Merge pull request #12 from algorithmzuo/master

update

src/class10/Code03_TopologicalOrderDFS1.java

@@ -5,7 +5,7 @@ import java.util.Comparator;
 import java.util.HashMap;
 
 // OJ链接：https://www.lintcode.com/problem/topological-sorting
-public class Code03_TopologicalOrderDFS {
+public class Code03_TopologicalOrderDFS1 {
 
 	// 不要提交这个类
 	public static class DirectedGraphNode {

src/class10/Code03_TopologicalOrderDFS2.java

@@ -0,0 +1,70 @@
+package class10;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+
+// OJ链接：https://www.lintcode.com/problem/topological-sorting
+public class Code03_TopologicalOrderDFS2 {
+
+	// 不要提交这个类
+	public static class DirectedGraphNode {
+		public int label;
+		public ArrayList<DirectedGraphNode> neighbors;
+
+		public DirectedGraphNode(int x) {
+			label = x;
+			neighbors = new ArrayList<DirectedGraphNode>();
+		}
+	}
+
+	// 提交下面的
+	public static class Record {
+		public DirectedGraphNode node;
+		public long nodes;
+
+		public Record(DirectedGraphNode n, long o) {
+			node = n;
+			nodes = o;
+		}
+	}
+
+	public static class MyComparator implements Comparator<Record> {
+
+		@Override
+		public int compare(Record o1, Record o2) {
+			return o1.nodes == o2.nodes ? 0 : (o1.nodes > o2.nodes ? -1 : 1);
+		}
+	}
+
+	public static ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
+		HashMap<DirectedGraphNode, Record> order = new HashMap<>();
+		for (DirectedGraphNode cur : graph) {
+			f(cur, order);
+		}
+		ArrayList<Record> recordArr = new ArrayList<>();
+		for (Record r : order.values()) {
+			recordArr.add(r);
+		}
+		recordArr.sort(new MyComparator());
+		ArrayList<DirectedGraphNode> ans = new ArrayList<DirectedGraphNode>();
+		for (Record r : recordArr) {
+			ans.add(r.node);
+		}
+		return ans;
+	}
+
+	public static Record f(DirectedGraphNode cur, HashMap<DirectedGraphNode, Record> order) {
+		if (order.containsKey(cur)) {
+			return order.get(cur);
+		}
+		long nodes = 0;
+		for (DirectedGraphNode next : cur.neighbors) {
+			nodes += f(next, order).nodes;
+		}
+		Record ans = new Record(cur, nodes + 1);
+		order.put(cur, ans);
+		return ans;
+	}
+
+}

src/class10/Code03_TopologySort.java

@@ -10,20 +10,14 @@ public class Code03_TopologySort {
 
 	// directed graph and no loop
 	public static List<Node> sortedTopology(Graph graph) {
-		// key：某一个node
-		// value：剩余的入度
 		HashMap<Node, Integer> inMap = new HashMap<>();
-		// 剩余入度为0的点，才能进这个队列
 		Queue<Node> zeroInQueue = new LinkedList<>();
-		
-		
 		for (Node node : graph.nodes.values()) {
 			inMap.put(node, node.in);
 			if (node.in == 0) {
 				zeroInQueue.add(node);
 			}
 		}
-		// 拓扑排序的结果，依次加入result
 		List<Node> result = new ArrayList<>();
 		while (!zeroInQueue.isEmpty()) {
 			Node cur = zeroInQueue.poll();

src/class10/Code06_Dijkstra.java

@@ -8,15 +8,9 @@ import java.util.Map.Entry;
 public class Code06_Dijkstra {
 
 	public static HashMap<Node, Integer> dijkstra1(Node from) {
-		// 从head出发到所有点的最小距离
-		// key : 从head出发到达key
-		// value : 从head出发到达key的最小距离
-		// 如果在表中，没有T的记录，含义是从head出发到T这个点的距离为正无穷
 		HashMap<Node, Integer> distanceMap = new HashMap<>();
 		distanceMap.put(from, 0);
-		// 已经求过距离的节点，存在selectedNodes中，以后再也不碰
 		HashSet<Node> selectedNodes = new HashSet<>();
-		// from 0
 		Node minNode = getMinDistanceAndUnselectedNode(distanceMap, selectedNodes);
 		while (minNode != null) {
 			int distance = distanceMap.get(minNode);
@@ -25,8 +19,7 @@ public class Code06_Dijkstra {
 				if (!distanceMap.containsKey(toNode)) {
 					distanceMap.put(toNode, distance + edge.weight);
 				} else {
-					distanceMap.put(edge.to, 
-							Math.min(distanceMap.get(toNode), distance + edge.weight));
+					distanceMap.put(edge.to, Math.min(distanceMap.get(toNode), distance + edge.weight));
 				}
 			}
 			selectedNodes.add(minNode);
@@ -35,9 +28,7 @@ public class Code06_Dijkstra {
 		return distanceMap;
 	}
 
-	public static Node getMinDistanceAndUnselectedNode(
-			HashMap<Node, Integer> distanceMap, 
-			HashSet<Node> touchedNodes) {
+	public static Node getMinDistanceAndUnselectedNode(HashMap<Node, Integer> distanceMap, HashSet<Node> touchedNodes) {
 		Node minNode = null;
 		int minDistance = Integer.MAX_VALUE;
 		for (Entry<Node, Integer> entry : distanceMap.entrySet()) {
@@ -107,8 +98,7 @@ public class Code06_Dijkstra {
 		}
 
 		private void insertHeapify(Node node, int index) {
-			while (distanceMap.get(nodes[index]) 
-					< distanceMap.get(nodes[(index - 1) / 2])) {
+			while (distanceMap.get(nodes[index]) < distanceMap.get(nodes[(index - 1) / 2])) {
 				swap(index, (index - 1) / 2);
 				index = (index - 1) / 2;
 			}
@@ -120,8 +110,7 @@ public class Code06_Dijkstra {
 				int smallest = left + 1 < size && distanceMap.get(nodes[left + 1]) < distanceMap.get(nodes[left])
 						? left + 1
 						: left;
-				smallest = distanceMap.get(nodes[smallest]) 
-						< distanceMap.get(nodes[index]) ? smallest : index;
+				smallest = distanceMap.get(nodes[smallest]) < distanceMap.get(nodes[index]) ? smallest : index;
 				if (smallest == index) {
 					break;
 				}

src/class10/Code07_MergeUsers.java

@@ -1,118 +0,0 @@
-package class10;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Stack;
-
-public class Code07_MergeUsers {
-
-	public static class Node<V> {
-		V value;
-
-		public Node(V v) {
-			value = v;
-		}
-	}
-
-	public static class UnionSet<V> {
-		public HashMap<V, Node<V>> nodes;
-		public HashMap<Node<V>, Node<V>> parents;
-		public HashMap<Node<V>, Integer> sizeMap;
-
-		public UnionSet(List<V> values) {
-			for (V cur : values) {
-				Node<V> node = new Node<>(cur);
-				nodes.put(cur, node);
-				parents.put(node, node);
-				sizeMap.put(node, 1);
-			}
-		}
-
-		// 从点cur开始，一直往上找，找到不能再往上的代表点，返回
-		public Node<V> findFather(Node<V> cur) {
-			Stack<Node<V>> path = new Stack<>();
-			while (cur != parents.get(cur)) {
-				path.push(cur);
-				cur = parents.get(cur);
-			}
-			// cur头节点
-			while (!path.isEmpty()) {
-				parents.put(path.pop(), cur);
-			}
-			return cur;
-		}
-
-		public boolean isSameSet(V a, V b) {
-			if (!nodes.containsKey(a) || !nodes.containsKey(b)) {
-				return false;
-			}
-			return findFather(nodes.get(a)) == findFather(nodes.get(b));
-		}
-
-		public void union(V a, V b) {
-			if (!nodes.containsKey(a) || !nodes.containsKey(b)) {
-				return;
-			}
-			Node<V> aHead = findFather(nodes.get(a));
-			Node<V> bHead = findFather(nodes.get(b));
-			if (aHead != bHead) {
-				int aSetSize = sizeMap.get(aHead);
-				int bSetSize = sizeMap.get(bHead);
-				Node<V> big = aSetSize >= bSetSize ? aHead : bHead;
-				Node<V> small = big == aHead ? bHead : aHead;
-				parents.put(small, big);
-				sizeMap.put(big, aSetSize + bSetSize);
-				sizeMap.remove(small);
-			}
-		}
-		
-		
-		public int getSetNum() {
-			return sizeMap.size();
-		}
-		
-	}
-
-	public static class User {
-		public String a;
-		public String b;
-		public String c;
-
-		public User(String a, String b, String c) {
-			this.a = a;
-			this.b = b;
-			this.c = c;
-		}
-
-	}
-
-	// (1,10,13) (2,10,37) (400,500,37)
-	// 如果两个user，a字段一样、或者b字段一样、或者c字段一样，就认为是一个人
-	// 请合并users，返回合并之后的用户数量
-	public static int mergeUsers(List<User> users) {
-		UnionSet<User> unionFind = new UnionSet<>(users);
-		HashMap<String, User> mapA = new HashMap<>();
-		HashMap<String, User> mapB = new HashMap<>();
-		HashMap<String, User> mapC = new HashMap<>();
-		for(User user : users) {
-			if(mapA.containsKey(user.a)) {
-				unionFind.union(user, mapA.get(user.a));
-			}else {
-				mapA.put(user.a, user);
-			}
-			if(mapB.containsKey(user.b)) {
-				unionFind.union(user, mapB.get(user.b));
-			}else {
-				mapB.put(user.b, user);
-			}
-			if(mapC.containsKey(user.c)) {
-				unionFind.union(user, mapC.get(user.c));
-			}else {
-				mapC.put(user.c, user);
-			}
-		}
-		// 向并查集询问，合并之后，还有多少个集合？
-		return unionFind.getSetNum();
-	}
-
-}