diff --git a/README.md b/README.md
index c7dc5aa5bba1afbc05a618946e230510e5bfd2c2..7c746b86f53960d3119d671558e6b29633ff82a6 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 
 ### 截止日期
 
-2021.1.6
+2021.1.13
 
 ### 基础
 
diff --git "a/\344\275\234\344\270\232/\345\233\276\351\201\215\345\216\206/Graphmatrix.java" "b/\344\275\234\344\270\232/\345\233\276\351\201\215\345\216\206/Graphmatrix.java"
new file mode 100644
index 0000000000000000000000000000000000000000..0ba40c812a0c46e0bd1ab32eaed162641799637c
--- /dev/null
+++ "b/\344\275\234\344\270\232/\345\233\276\351\201\215\345\216\206/Graphmatrix.java"
@@ -0,0 +1,168 @@
+package Graph;
+
+        //用邻接矩阵表示一个图，并求深度优先搜索遍历和广度优先搜索遍历    20200340911 何灿烽
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+
+class Varr<AnyType>
+{
+	char data;
+	int du;
+	boolean visit;
+	public Varr(char data){
+		this.data=data;
+		this.du=0;
+		this.visit=false;
+	}
+}
+
+
+public class Graphmatrix<AnyType> { 
+	Varr varr[];
+	int arcs[][];
+	int num;
+	Scanner sc=new Scanner(System.in);
+	
+	public void creatGraph(){
+		System.out.println("模拟一个矩阵表示图");
+		
+		System.out.println("请输入顶点的个数：");
+		num=sc.nextInt();
+		varr=new Varr[num];
+		arcs=new int[num][num];
+		for(int i=0;i<num;i++){
+			for(int j=0;j<num;j++){
+				arcs[i][j]=0;
+			}
+		}
+		
+		System.out.println("请输入顶点数据");
+		String point=sc.next();
+		char p[]=point.toCharArray();
+		for(int i=0;i<p.length;i++){
+			varr[i]=new Varr(p[i]);
+		}
+		System.out.println("请输入边的条数，（数字）");
+		int d=sc.nextInt();
+		System.out.println("请输入各边");
+		int i;
+		String[] f=new String[d];
+		for(i=0;i<d;i++)
+		{
+		  f[i]=sc.next();          //a:ac ab; b:bc ba c:ca:cb;
+		}
+		
+		for(int u=0;u<num;u++)
+		{
+			int h=0;
+			char ap[]=new char[1000];
+			for(i=0;i<d;i++)
+			{
+				char b[]=f[i].toCharArray();
+				if(b[0]==varr[u].data)
+				{
+					ap[h]=b[1];
+					h++;
+				}
+			}
+			if(h==0)
+				continue;
+			varr[u].du=varr[u].du+h;
+			int j;
+			for(i=0;i<num;i++)
+			{
+				for(int r=0;r<h;r++)
+				{
+					if((varr[i].data==ap[r]))
+					{
+						
+						varr[i].du++;
+						//System.out.println(varr[i].data+"度 "+varr[i].du+"now"+varr[u].data);
+						break;
+					}
+				}
+			}
+		
+			int y;
+			int ap_int[]=new int[1000];       //存放邻接点下标
+			if(h==0)
+				continue;//ap_int[0]=-1;
+			else{
+			  for(int t=0;t<h;t++){          //获取邻接点下标
+				   y=0;
+				  while(varr[y].data!=ap[t]&&y<varr.length){
+					 y++;
+				  }
+				  ap_int[t]=y;
+			  }
+			}	
+			for(int r=0;r<h;r++)
+			arcs[u][ap_int[r]]=1;
+		}	
+	}
+	
+	public void DFS(int v){
+		varr[v].visit=true;
+		System.out.println(varr[v].data);
+		for(int i=0;i<varr.length;i++){
+			if(arcs[v][i]==1&&varr[i].visit==false)
+				DFS(i);
+		}
+	}
+	
+	
+	public void BFS(){
+		int v=0;	
+		Queue<Integer> q=new LinkedList<Integer>();
+		
+		for(int i=0;i<varr.length;i++){
+			varr[i].visit=false;
+		}	
+		q.add(v);
+		while(!q.isEmpty()){
+			v=q.poll();
+			if(varr[v].visit==false){
+				varr[v].visit=true;
+				System.out.println(varr[v].data);
+			}
+			
+		for(int i=0;i<varr.length;i++){
+			if(arcs[v][i]==1&&varr[i].visit==false){
+				q.add(i);
+				}
+			}
+		}
+	}
+	
+	//求度
+	public void du(){
+		/*int count=0;
+		for(int i=0;i<varr.length;i++){
+			for(int j=0;j<varr.length;j++){
+				if(arcs[i][j]==1)
+					count++;
+			}
+			System.out.println(varr[i].data+"的度为： "+count);
+			count=0;
+		}*/
+		for(int i=0;i<num;i++)
+		{
+			System.out.println(varr[i].data+"的度为："+varr[i].du);
+		}
+	}
+	
+	public static void main(String[] args) {
+		 Graphmatrix g=new  Graphmatrix();
+	     g.creatGraph();
+	     //g.du();
+	     
+	 	 System.out.println("深度优先遍历DFS的遍历结果是");
+	     g.DFS(0);
+	     g.DFS(1);
+	     System.out.println("广度优先遍历BFS的遍历结果是");
+	     g.BFS();
+	}
+	
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/Graphmatrix.java" "b/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/Graphmatrix.java"
new file mode 100644
index 0000000000000000000000000000000000000000..0ba40c812a0c46e0bd1ab32eaed162641799637c
--- /dev/null
+++ "b/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/Graphmatrix.java"
@@ -0,0 +1,168 @@
+package Graph;
+
+        //用邻接矩阵表示一个图，并求深度优先搜索遍历和广度优先搜索遍历    20200340911 何灿烽
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Scanner;
+
+
+class Varr<AnyType>
+{
+	char data;
+	int du;
+	boolean visit;
+	public Varr(char data){
+		this.data=data;
+		this.du=0;
+		this.visit=false;
+	}
+}
+
+
+public class Graphmatrix<AnyType> { 
+	Varr varr[];
+	int arcs[][];
+	int num;
+	Scanner sc=new Scanner(System.in);
+	
+	public void creatGraph(){
+		System.out.println("模拟一个矩阵表示图");
+		
+		System.out.println("请输入顶点的个数：");
+		num=sc.nextInt();
+		varr=new Varr[num];
+		arcs=new int[num][num];
+		for(int i=0;i<num;i++){
+			for(int j=0;j<num;j++){
+				arcs[i][j]=0;
+			}
+		}
+		
+		System.out.println("请输入顶点数据");
+		String point=sc.next();
+		char p[]=point.toCharArray();
+		for(int i=0;i<p.length;i++){
+			varr[i]=new Varr(p[i]);
+		}
+		System.out.println("请输入边的条数，（数字）");
+		int d=sc.nextInt();
+		System.out.println("请输入各边");
+		int i;
+		String[] f=new String[d];
+		for(i=0;i<d;i++)
+		{
+		  f[i]=sc.next();          //a:ac ab; b:bc ba c:ca:cb;
+		}
+		
+		for(int u=0;u<num;u++)
+		{
+			int h=0;
+			char ap[]=new char[1000];
+			for(i=0;i<d;i++)
+			{
+				char b[]=f[i].toCharArray();
+				if(b[0]==varr[u].data)
+				{
+					ap[h]=b[1];
+					h++;
+				}
+			}
+			if(h==0)
+				continue;
+			varr[u].du=varr[u].du+h;
+			int j;
+			for(i=0;i<num;i++)
+			{
+				for(int r=0;r<h;r++)
+				{
+					if((varr[i].data==ap[r]))
+					{
+						
+						varr[i].du++;
+						//System.out.println(varr[i].data+"度 "+varr[i].du+"now"+varr[u].data);
+						break;
+					}
+				}
+			}
+		
+			int y;
+			int ap_int[]=new int[1000];       //存放邻接点下标
+			if(h==0)
+				continue;//ap_int[0]=-1;
+			else{
+			  for(int t=0;t<h;t++){          //获取邻接点下标
+				   y=0;
+				  while(varr[y].data!=ap[t]&&y<varr.length){
+					 y++;
+				  }
+				  ap_int[t]=y;
+			  }
+			}	
+			for(int r=0;r<h;r++)
+			arcs[u][ap_int[r]]=1;
+		}	
+	}
+	
+	public void DFS(int v){
+		varr[v].visit=true;
+		System.out.println(varr[v].data);
+		for(int i=0;i<varr.length;i++){
+			if(arcs[v][i]==1&&varr[i].visit==false)
+				DFS(i);
+		}
+	}
+	
+	
+	public void BFS(){
+		int v=0;	
+		Queue<Integer> q=new LinkedList<Integer>();
+		
+		for(int i=0;i<varr.length;i++){
+			varr[i].visit=false;
+		}	
+		q.add(v);
+		while(!q.isEmpty()){
+			v=q.poll();
+			if(varr[v].visit==false){
+				varr[v].visit=true;
+				System.out.println(varr[v].data);
+			}
+			
+		for(int i=0;i<varr.length;i++){
+			if(arcs[v][i]==1&&varr[i].visit==false){
+				q.add(i);
+				}
+			}
+		}
+	}
+	
+	//求度
+	public void du(){
+		/*int count=0;
+		for(int i=0;i<varr.length;i++){
+			for(int j=0;j<varr.length;j++){
+				if(arcs[i][j]==1)
+					count++;
+			}
+			System.out.println(varr[i].data+"的度为： "+count);
+			count=0;
+		}*/
+		for(int i=0;i<num;i++)
+		{
+			System.out.println(varr[i].data+"的度为："+varr[i].du);
+		}
+	}
+	
+	public static void main(String[] args) {
+		 Graphmatrix g=new  Graphmatrix();
+	     g.creatGraph();
+	     //g.du();
+	     
+	 	 System.out.println("深度优先遍历DFS的遍历结果是");
+	     g.DFS(0);
+	     g.DFS(1);
+	     System.out.println("广度优先遍历BFS的遍历结果是");
+	     g.BFS();
+	}
+	
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/\351\202\273\346\216\245\350\241\250/Graph.java" "b/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/\351\202\273\346\216\245\350\241\250/Graph.java"
new file mode 100644
index 0000000000000000000000000000000000000000..1c6ddbd6b09327dc313ad86b84c5a886502472e7
--- /dev/null
+++ "b/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/\351\202\273\346\216\245\350\241\250/Graph.java"
@@ -0,0 +1,212 @@
+package Graph1;
+            //邻接表表示加权有向图，并利用了dijkstra求最短路径   20200340911 何灿烽
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+ 
+public class Graph{
+    private List<Vertex> vertexList;   //图的顶点集
+    private Map<Vertex, List<Edge>> ver_edgeList_map;  //图的每个顶点对应的有向边
+    
+    public Graph(List<Vertex> vertexList, Map<Vertex, List<Edge>> ver_edgeList_map) {
+        super();
+        this.vertexList = vertexList;
+        this.ver_edgeList_map = ver_edgeList_map;
+    }
+ 
+    public List<Vertex> getVertexList() {
+        return vertexList;
+    }
+ 
+    public void setVertexList(List<Vertex> vertexList) {
+        this.vertexList = vertexList;
+    }
+ 
+    
+    public Map<Vertex, List<Edge>> getVer_edgeList_map() {
+        return ver_edgeList_map;
+    }
+ 
+    public void setVer_edgeList_map(Map<Vertex, List<Edge>> ver_edgeList_map) {
+        this.ver_edgeList_map = ver_edgeList_map;
+    }
+ 
+ 
+    static class Edge{
+        private Vertex startVertex;  //此有向边的起始点
+        private Vertex endVertex;    //此有向边的终点
+        private int weight;          //此有向边的权值
+        
+        public Edge(Vertex startVertex, Vertex endVertex, int weight) {
+            super();
+            this.startVertex = startVertex;
+            this.endVertex = endVertex;
+            this.weight = weight;
+        }
+        
+        public Edge()
+        {}
+        
+        public Vertex getStartVertex() {
+            return startVertex;
+        }
+        public void setStartVertex(Vertex startVertex) {
+            this.startVertex = startVertex;
+        }
+        public Vertex getEndVertex() {
+            return endVertex;
+        }
+        public void setEndVertex(Vertex endVertex) {
+            this.endVertex = endVertex;
+        }
+        public int getWeight() {
+            return weight;
+        }
+        public void setWeight(int weight) {
+            this.weight = weight;
+        }
+    }
+    
+     static class Vertex {
+        private final static int infinite_dis = Integer.MAX_VALUE;
+        
+        private String name;  //节点名字
+        private boolean known; //此节点之前是否已知
+        private int adjuDist; //此节点距离
+        private Vertex parent; //当前从初始节点到此节点的最短路径下，的父节点。
+        
+        public Vertex()
+        {
+            this.known = false;
+            this.adjuDist = infinite_dis;
+            this.parent = null;
+        }
+        
+        public Vertex(String name)
+        {
+            this.known = false;
+            this.adjuDist = infinite_dis;
+            this.parent = null;
+            this.name = name;
+        }
+        
+        public String getName() {
+            return name;
+        }
+        public void setName(String name) {
+            this.name = name;
+        }
+        public boolean isKnown() {
+            return known;
+        }
+        public void setKnown(boolean known) {
+            this.known = known;
+        }
+        public int getAdjuDist() {
+            return adjuDist;
+        }
+        public void setAdjuDist(int adjuDist) {
+            this.adjuDist = adjuDist;
+        }
+        
+        public Vertex getParent() {
+            return parent;
+        }
+ 
+        public void setParent(Vertex parent) {
+            this.parent = parent;
+        }
+        
+        /*重新Object父类的equals方法*/
+        public boolean equals(Object obj) {
+            if (!(obj instanceof Vertex)) {
+                throw new ClassCastException("要与Vertext进行比较的对象必须是Vertex");
+            }
+            
+            if (this.name==null) {
+                throw new NullPointerException("要比较的顶点的名称不能为空");
+            }
+            
+            return this.name.equals(obj);
+        }
+    }
+    
+    public void setRoot(Vertex v)
+    {
+        v.setParent(null);
+        v.setAdjuDist(0);
+    }
+    
+    
+    /**startIndex dijkstra遍历的起点节点下标
+     * destIndex dijkstra遍历的终点节点下标
+     */
+    public void dijkstraTravasal(int startIndex,int destIndex)
+    {
+        Vertex start = vertexList.get(startIndex);
+        Vertex dest = vertexList.get(destIndex);
+        String path = "["+dest.getName()+"]";
+        
+        setRoot(start);
+        updateChildren(vertexList.get(startIndex));
+        
+        int shortest_length = dest.getAdjuDist(); 
+        
+        while((dest.getParent()!=null)&&(!dest.equals(start)))
+        {
+            path = "["+dest.getParent().getName()+"] --> "+path;
+            dest = dest.getParent();
+        }
+        
+        System.out.println("["+vertexList.get(startIndex).getName() +"] to ["+
+                vertexList.get(destIndex).getName()+"] dijkstra shortest path :: "+path);
+        System.out.println("shortest length::"+shortest_length);
+    }
+    
+    //从初始节点开始递归更新邻接表
+    private void updateChildren(Vertex v)
+    {
+        if (v==null) {
+            return;
+        }
+        
+        if (ver_edgeList_map.get(v)==null||ver_edgeList_map.get(v).size()==0) {
+            return;
+        }
+        //用来保存每个可达的节点
+        List<Vertex> childrenList = new LinkedList<Graph.Vertex>();
+        for(Edge e:ver_edgeList_map.get(v))
+        {
+            Vertex childVertex = e.getEndVertex();
+            
+            //如果子节点之前未知，则进行初始化，
+            //把当前边的开始点默认为子节点的父节点，长度默认为边长加边的起始节点的长度，并修改该点为已经添加过，表示不用初始化
+            if(!childVertex.isKnown())
+            {
+                childVertex.setKnown(true);
+                childVertex.setAdjuDist(v.getAdjuDist()+e.getWeight());
+                childVertex.setParent(v);
+                childrenList.add(childVertex);
+            }
+            
+            //此时该子节点的父节点和之前到该节点的最小长度已经知道了，则比较该边起始节点到该点的距离是否小于子节点的长度，
+            //只有小于的情况下，才更新该点为该子节点父节点,并且更新长度。
+            int nowDist = v.getAdjuDist()+e.getWeight();
+            if(nowDist>=childVertex.getAdjuDist())
+            {
+                continue;
+            }
+            else {
+                childVertex.setAdjuDist(nowDist);
+                childVertex.setParent(v);
+            }
+        }
+        
+        //更新每一个子节点
+        for(Vertex vc:childrenList)
+        {
+            updateChildren(vc);
+        }
+    }
+    
+}
\ No newline at end of file
diff --git "a/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/\351\202\273\346\216\245\350\241\250/TestGraph.java" "b/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/\351\202\273\346\216\245\350\241\250/TestGraph.java"
new file mode 100644
index 0000000000000000000000000000000000000000..c7e00b19144cea88ba729ef490caffaeb573d1d7
--- /dev/null
+++ "b/\344\275\234\344\270\232/\345\256\232\344\271\211\345\233\276/\351\202\273\346\216\245\350\241\250/TestGraph.java"
@@ -0,0 +1,77 @@
+package Graph1;
+             //邻接表表示加权有向图，并利用了dijkstra求最短路径   20200340911 何灿烽
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import Graph1.Graph.Edge;
+import Graph1.Graph.Vertex;
+      /*测试用main方法*/
+public class TestGraph {
+    public static void main(String[] args) {
+        Vertex v1= new Vertex("v1");
+        Vertex v2= new Vertex("v2");
+        Vertex v3= new Vertex("v3");
+        Vertex v4= new Vertex("v4");
+        Vertex v5= new Vertex("v5");
+        Vertex v6= new Vertex("v6");
+        Vertex v7= new Vertex("v7");
+        Vertex v8= new Vertex("v8");
+        
+        List<Vertex> verList = new LinkedList<Graph.Vertex>();
+        verList.add(v1);
+        verList.add(v2);
+        verList.add(v3);
+        verList.add(v4);
+        verList.add(v5);
+        verList.add(v6);
+        verList.add(v7);
+        verList.add(v8);
+        
+        Map<Vertex, List<Edge>> vertex_edgeList_map = new HashMap<Graph.Vertex, List<Edge>>();
+        
+        List<Edge> v1List = new LinkedList<Graph.Edge>();
+        v1List.add(new Edge(v1,v2,6));
+        v1List.add(new Edge(v1,v4,1));
+        v1List.add(new Edge(v1,v4,1));
+        
+        List<Edge> v2List = new LinkedList<Graph.Edge>();
+        v2List.add(new Edge(v2,v3,43));
+        v2List.add(new Edge(v2,v4,11));
+        v2List.add(new Edge(v2,v5,6));
+        
+        List<Edge> v3List = new LinkedList<Graph.Edge>();
+        v3List.add(new Edge(v3,v8,8));
+        
+        List<Edge> v4List = new LinkedList<Graph.Edge>();
+        v4List.add(new Edge(v4,v3,15));
+        v4List.add(new Edge(v4,v5,12));
+        
+        List<Edge> v5List = new LinkedList<Graph.Edge>();
+        v5List.add(new Edge(v5,v3,38));
+        v5List.add(new Edge(v5,v8,13));
+        v5List.add(new Edge(v5,v7,24));
+        
+        List<Edge> v6List = new LinkedList<Graph.Edge>();
+        v6List.add(new Edge(v6,v5,1));
+        v6List.add(new Edge(v6,v7,12));
+        
+        List<Edge> v7List = new LinkedList<Graph.Edge>();
+        v7List.add(new Edge(v7,v8,20));
+        
+        vertex_edgeList_map.put(v1, v1List);
+        vertex_edgeList_map.put(v2, v2List);
+        vertex_edgeList_map.put(v3, v3List);
+        vertex_edgeList_map.put(v4, v4List);
+        vertex_edgeList_map.put(v5, v5List);
+        vertex_edgeList_map.put(v6, v6List);
+        vertex_edgeList_map.put(v7, v7List);
+        
+        
+        Graph g = new Graph(verList, vertex_edgeList_map);
+      g.dijkstraTravasal(0, 7);
+      
+    }
+}
\ No newline at end of file