public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { //bfs + hashtable // tc:O(node * edge); sc:O(n) if (node == null) { return(node); } Dictionary <UndirectedGraphNode, UndirectedGraphNode> dict = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); Queue <UndirectedGraphNode> queue = new Queue <UndirectedGraphNode>(); queue.Enqueue(node); dict[node] = new UndirectedGraphNode(node.label); while (queue.Count > 0) { var nd = queue.Dequeue(); foreach (var neigh in nd.neighbors) // for all neighbors of the current node { if (!dict.ContainsKey(neigh)) // clone node of current does not exist { dict[neigh] = new UndirectedGraphNode(neigh.label); // create new clone node queue.Enqueue(neigh); // add node has not been accessed } dict[nd].neighbors.Add(dict[neigh]); } } return(dict[node]); }
public UndirectedGraphNode SearchNode(List <UndirectedGraphNode> graph, Dictionary <UndirectedGraphNode, int> values, UndirectedGraphNode node, int target) { // write your code here Queue <UndirectedGraphNode> queue = new Queue <UndirectedGraphNode>(); queue.Enqueue(node); HashSet <UndirectedGraphNode> nodeSet = new HashSet <UndirectedGraphNode>(); while (queue.Count != 0) { UndirectedGraphNode root = queue.Dequeue(); int v = values[root]; nodeSet.Add(root); if (v == target) { return(root); } else { foreach (var n in root.neighbors) { if (!nodeSet.Contains(n)) { queue.Enqueue(n); } } } } return(null); }
private UndirectedGraphNode CloneLabel(UndirectedGraphNode node) { return new UndirectedGraphNode(node.label) { neighbors = new List<UndirectedGraphNode>(node.neighbors) }; }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(node); } Dictionary <UndirectedGraphNode, UndirectedGraphNode> map = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); UndirectedGraphNode root = new UndirectedGraphNode(node.label); map.Add(node, root); Queue <UndirectedGraphNode> queue = new Queue <UndirectedGraphNode>(); queue.Enqueue(node); while (queue.Count != 0) { UndirectedGraphNode cur = queue.Dequeue(); foreach (UndirectedGraphNode oldNeighbor in cur.neighbors) { if (!map.ContainsKey(oldNeighbor)) { map.Add(oldNeighbor, new UndirectedGraphNode(oldNeighbor.label)); queue.Enqueue(oldNeighbor); } map[cur].neighbors.Add(map[oldNeighbor]); } } return(root); }
public UndirectedGraphNode CloneGraph2(UndirectedGraphNode node) { if (node == null) { return(null); } var queue = new Queue <UndirectedGraphNode>(); queue.Enqueue(node); var newnode = new UndirectedGraphNode(node.label); dict2.Add(node, newnode); while (queue.Any()) { var top = queue.Dequeue(); foreach (var neighbor in top.neighbors) { if (dict2.ContainsKey(neighbor)) { dict2[top].neighbors.Add(dict2[neighbor]); } else { var newneighbor = new UndirectedGraphNode(neighbor.label); dict2.Add(neighbor, newneighbor); dict2[top].neighbors.Add(newneighbor); queue.Enqueue(neighbor); } } } return(newnode); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) return null; var dict = new Dictionary<int, UndirectedGraphNode>(); var queue = new Queue<UndirectedGraphNode>(); queue.Enqueue(CloneLabel(node)); dict.Add(node.label, queue.Peek()); while (queue.Count > 0) { var current = queue.Dequeue(); var newNeighbors = new List<UndirectedGraphNode>(current.neighbors.Count); foreach (var oldNeighbor in current.neighbors) { UndirectedGraphNode newNeighbor; if (!dict.TryGetValue(oldNeighbor.label, out newNeighbor)) { newNeighbor = CloneLabel(oldNeighbor); queue.Enqueue(newNeighbor); dict.Add(newNeighbor.label, newNeighbor); } newNeighbors.Add(newNeighbor); } current.neighbors = newNeighbors; } return dict[node.label]; }
//lable当key处理,为啥不用hashcode 或者md5一下 //queue里加入老数据,dic里加新数据. //考察图的遍历,这是bfs,一个个往队列里塞,关键不能塞重复了 public static UndirectedGraphNode Clone(UndirectedGraphNode node) { if (node == null) { return(null); } var graph = new UndirectedGraphNode(node.Label); var dic = new Dictionary <int, UndirectedGraphNode>(); dic.Add(graph.Label, graph); var queue = new Queue <UndirectedGraphNode>(); queue.Enqueue(node); while (queue.Count > 0) { var curr = queue.Dequeue(); foreach (var neighbour in curr.Neighbors) { if (!dic.ContainsKey(neighbour.Label)) { dic.Add(neighbour.Label, new UndirectedGraphNode(neighbour.Label)); queue.Enqueue(neighbour); } //新节点里的连接关系肯定要加 dic[curr.Label].Neighbors.Add(dic[neighbour.Label]); } } return(graph); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } var dict = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); var result = new UndirectedGraphNode(node.label); dict.Add(node, result); Queue <UndirectedGraphNode> q = new Queue <UndirectedGraphNode>(); q.Enqueue(node); while (q.Count > 0) { var toClone = q.Dequeue(); var clonedNode = dict[toClone]; foreach (var neighbor in toClone.neighbors) { if (!dict.ContainsKey(neighbor)) { dict.Add(neighbor, new UndirectedGraphNode(neighbor.label)); q.Enqueue(neighbor); } clonedNode.neighbors.Add(dict[neighbor]); } } return(result); }
public void TopSort() { var root = new UndirectedGraphNode(0); var one = new UndirectedGraphNode(1); var two = new UndirectedGraphNode(2); var three = new UndirectedGraphNode(3); var four = new UndirectedGraphNode(4); var five = new UndirectedGraphNode(5); root.neighbors.Add(one); root.neighbors.Add(two); root.neighbors.Add(three); one.neighbors.Add(four); two.neighbors.Add(four); two.neighbors.Add(five); three.neighbors.Add(four); three.neighbors.Add(five); var list = new List <UndirectedGraphNode> { root, one, two, three, four, five }; var r = TopSort(list); }
private UndirectedGraphNode CloneNode(UndirectedGraphNode node, Dictionary <UndirectedGraphNode, UndirectedGraphNode> map) { UndirectedGraphNode cloneNode = new UndirectedGraphNode(node.label); map.Add(node, cloneNode); return(cloneNode); }
private UndirectedGraphNode _CloneGraph(UndirectedGraphNode node, Dictionary <UndirectedGraphNode, UndirectedGraphNode> hashmap) { if (node == null) { return(null); } if (!hashmap.TryGetValue(node, out var clone)) { clone = new UndirectedGraphNode(node.label); hashmap.Add(node, clone); if (node.neighbors != null) { clone.neighbors = new List <UndirectedGraphNode>(); foreach (UndirectedGraphNode childNode in node.neighbors) { clone.neighbors.Add(_CloneGraph(childNode, hashmap)); } } } return(clone); }
// Using BFS // Tx = O(n) // Sx = O(n) public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(node); } Queue <UndirectedGraphNode> nodes = new Queue <UndirectedGraphNode>(); nodes.Enqueue(node); IDictionary <UndirectedGraphNode, UndirectedGraphNode> clone = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); clone.Add(node, new UndirectedGraphNode(node.label)); while (nodes.Count > 0) { var curr = nodes.Dequeue(); foreach (var neighbor in curr.neighbors) { if (!clone.ContainsKey(curr)) { clone.Add(neighbor, new UndirectedGraphNode(neighbor.label)); nodes.Enqueue(neighbor); } clone[curr].neighbors.Add(neighbor); } } return(clone[node]); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { var graphQueue = new Queue <UndirectedGraphNode>(); var oldNodeToNewNodeMap = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); graphQueue.Enqueue(node); oldNodeToNewNodeMap.Add(node, new UndirectedGraphNode(node.label)); while (graphQueue.Count != 0) { var graphNode = graphQueue.Dequeue(); foreach (var neighbour in graphNode.neighbours) { if (!oldNodeToNewNodeMap.ContainsKey(node)) { oldNodeToNewNodeMap.Add(neighbour, new UndirectedGraphNode(neighbour.label)); graphQueue.Enqueue(neighbour); } oldNodeToNewNodeMap[node].neighbours.Add(neighbour); } } return(oldNodeToNewNodeMap[node]); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } Dictionary <int, UndirectedGraphNode> cache = new Dictionary <int, UndirectedGraphNode>(); return(Clone(node, cache)); }
public void Tests() { var gr = new UndirectedGraphNode(0); gr.neighbors.Add(gr); gr.neighbors.Add(gr); var c = new CloneUndirectedGraph(); Assert.NotNull(c.CloneGraph(gr)); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } Dictionary <UndirectedGraphNode, UndirectedGraphNode> hashmap = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); return(_CloneGraph(node, hashmap)); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { //dfs + hashtable // tc:O(node * edge); sc:O(n) if (node == null) { return(node); } Dictionary <UndirectedGraphNode, UndirectedGraphNode> dict = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); return(CloneNode(node, dict)); }
private UndirectedGraphNode CloneNode(UndirectedGraphNode node, Dictionary <UndirectedGraphNode, UndirectedGraphNode> dict) { dict[node] = new UndirectedGraphNode(node.label); foreach (var nd in node.neighbors) { if (!dict.ContainsKey(nd)) { CloneNode(nd, dict); } dict[node].neighbors.Add(dict[nd]); } return(dict[node]); }
public UndirectedGraphNode BuildAGraph() { var g0 = new UndirectedGraphNode(0); var g1 = new UndirectedGraphNode(1); var g2 = new UndirectedGraphNode(2); g0.Neighbors.Add(g1); g0.Neighbors.Add(g2); g1.Neighbors.Add(g2); g2.Neighbors.Add(g2); return(g0); }
//https://leetcode.com/problems/clone-graph/ public void CloneGraphCre() { UndirectedGraphNode node1 = new UndirectedGraphNode(1); UndirectedGraphNode node2 = new UndirectedGraphNode(2); UndirectedGraphNode node3 = new UndirectedGraphNode(3); UndirectedGraphNode node4 = new UndirectedGraphNode(4); node1.neighbors.AddRange(new UndirectedGraphNode[] { node2, node4 }); node2.neighbors.AddRange(new UndirectedGraphNode[] { node1, node3 }); node3.neighbors.AddRange(new UndirectedGraphNode[] { node2, node4 }); node4.neighbors.AddRange(new UndirectedGraphNode[] { node1, node3 }); var res = CloneGraphCre(node1, new Dictionary <int, UndirectedGraphNode>()); }
public UndirectedGraphNode Clone(UndirectedGraphNode node, Dictionary <int, UndirectedGraphNode> cache) { if (cache.ContainsKey(node.label)) { return(cache[node.label]); } UndirectedGraphNode newNode = new UndirectedGraphNode(node.label); cache[node.label] = newNode; foreach (UndirectedGraphNode neig in node.neighbors) { newNode.neighbors.Add(Clone(neig, cache)); } return(newNode); }
//#5 //Finish the method below to do a depth-first search on an undirected graph. Depth-first search is //different compared breadth-first search.Depth-first will traverse as far into the graph as it can first whereas //breadth-first will traverse in a shallow, wide pattern. The starting graph node (class is defined on the last page) //is given, as well as the value(Data property of the node) you are searching for. The method should return true if //the goal is found and false otherwise.You may assume that all nodes of the graph have the Visited property //initialized to false. Your method should be recursive. bool DepthFirstSearch(UndirectedGraphNode <int> start, int goal) { if (start.Data == goal) { return(true); } else { foreach (UndirectedGraphNode <int> edge in start.Edges) { return(DepthFirstSearch(edge, goal)); } } return(false); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } Queue <UndirectedGraphNode> nodeQueue = new Queue <UndirectedGraphNode>(); nodeQueue.Enqueue(node); Dictionary <int, UndirectedGraphNode> nodeDic = new Dictionary <int, UndirectedGraphNode>(); Dictionary <int, UndirectedGraphNode> newGraphNodeDic = new Dictionary <int, UndirectedGraphNode>(); while (nodeQueue.Count != 0) { var root = nodeQueue.Dequeue(); UndirectedGraphNode newNode = new UndirectedGraphNode(root.label); if (!nodeDic.ContainsKey(root.label)) { nodeDic.Add(root.label, root); newGraphNodeDic.Add(root.label, newNode); //这个for循环一定要写在判断nodedic的里面 否则死循环 foreach (var n in root.neighbors) { if (n != null) { nodeQueue.Enqueue(n); } } } } foreach (var n in newGraphNodeDic) { var newNode = n.Value; var oldNode = nodeDic[n.Key]; foreach (var nb in oldNode.neighbors) { UndirectedGraphNode newNeightor = newGraphNodeDic[nb.label]; newNode.neighbors.Add(newNeightor); } } UndirectedGraphNode rootNode = newGraphNodeDic[node.label]; return(rootNode); // write your code here }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } Queue <UndirectedGraphNode> q = new Queue <UndirectedGraphNode>(); Dictionary <UndirectedGraphNode, UndirectedGraphNode> map = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); q.Enqueue(node); while (q.Count > 0) { UndirectedGraphNode currNode = q.Dequeue(); UndirectedGraphNode cloneNode; if (!map.ContainsKey(currNode)) { cloneNode = CloneNode(currNode, map); } else { cloneNode = map[currNode]; } IList <UndirectedGraphNode> neighborList = currNode.neighbors; for (int i = 0; i < neighborList.Count; i++) { UndirectedGraphNode neighborNode = neighborList[i]; UndirectedGraphNode clonedNeighborNode; if (!map.ContainsKey(neighborNode)) { q.Enqueue(neighborNode); clonedNeighborNode = CloneNode(neighborNode, map); } else { clonedNeighborNode = map[neighborNode]; } if (cloneNode.neighbors == null) { cloneNode.neighbors = new List <UndirectedGraphNode>(); } cloneNode.neighbors.Add(clonedNeighborNode); } } return(map[node]); }
public UndirectedGraphNode CopyList(UndirectedGraphNode node) { if (node == null) { return(null); } if (dictionary.ContainsKey(node)) { return(dictionary[node]); } var newNode = new UndirectedGraphNode(node.label); dictionary[node] = newNode; foreach (var neighbor in node.neighbors) { newNode.neighbors.Add(CopyList(neighbor)); } return(newNode); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } var queue = new Queue <UndirectedGraphNode>(); var map = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); UndirectedGraphNode retNode = new UndirectedGraphNode(node.Label); map[node] = retNode; queue.Enqueue(node); while (queue.Count() > 0) { UndirectedGraphNode current = queue.Dequeue(); int count = current.Neighbors.Count; for (int i = 0; i < count; i++) { UndirectedGraphNode neighbor = current.Neighbors[i]; if (map.ContainsKey(neighbor)) { map[current].Neighbors.Add(map[neighbor]); } else { UndirectedGraphNode n = new UndirectedGraphNode(neighbor.Label); map[current].Neighbors.Add(n); map[neighbor] = n; queue.Enqueue(neighbor); } } } return(retNode); }
// DFS solution public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } if (dict.ContainsKey(node.label)) { return(dict[node.label]); } var newnode = new UndirectedGraphNode(node.label); dict.Add(node.label, newnode); foreach (var neighbor in node.neighbors) { newnode.neighbors.Add(CloneGraph(neighbor)); } return(newnode); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } var dict = new Dictionary <int, UndirectedGraphNode>(); var list = new List <UndirectedGraphNode>(); list.Add(node); var newroot = new UndirectedGraphNode(node.label); dict[node.label] = newroot; while (list.Count > 0) { var newlist = new List <UndirectedGraphNode>(); foreach (var n in list) { var newneighbors = new List <UndirectedGraphNode>(); UndirectedGraphNode newnode; foreach (var nn in n.neighbors) { if (!dict.TryGetValue(nn.label, out newnode)) { newnode = new UndirectedGraphNode(nn.label); dict[nn.label] = newnode; newlist.Add(nn); } newneighbors.Add(newnode); } newnode = dict[n.label]; newnode.neighbors = newneighbors; } list = newlist; } return(newroot); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) return node; Stack<UndirectedGraphNode> st = new Stack<UndirectedGraphNode>(); st.Push(node); UndirectedGraphNode copy = new UndirectedGraphNode(node.label); Stack<UndirectedGraphNode> copyst = new Stack<UndirectedGraphNode>(); copyst.Push(copy); Dictionary<UndirectedGraphNode, UndirectedGraphNode> map = new Dictionary<UndirectedGraphNode, UndirectedGraphNode>(); map.Add(node, copy); while (st.Count > 0) { var curnode = st.Pop(); var curcopy = copyst.Pop(); foreach(var neigh in curnode.neighbors) { if (map.ContainsKey(neigh)) { curcopy.neighbors.Add(map[neigh]); } else { UndirectedGraphNode newneigh = new UndirectedGraphNode(neigh.label); curcopy.neighbors.Add(newneigh); map.Add(neigh, newneigh); st.Push(neigh); copyst.Push(newneigh); } } } return copy; }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } // Get all nodes UndirectedGraphNode result = null; var q = new Queue <UndirectedGraphNode>(); q.Enqueue(node); var map = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); map.Add(node, new UndirectedGraphNode(node.label)); while (q.Any()) { var curr = q.Dequeue(); foreach (var neighbor in curr.neighbors) { if (!map.ContainsKey(neighbor)) { q.Enqueue(neighbor); map.Add(neighbor, new UndirectedGraphNode(neighbor.label)); } } } foreach (var v in map.Keys) { var newNode = map[v]; foreach (var n in v.neighbors) { var newNeighbor = map[n]; newNode.neighbors.Add(newNeighbor); } } return(map[node]); }
private UndirectedGraphNode CloneGraph(UndirectedGraphNode node, Dictionary <int, UndirectedGraphNode> map) { if (node == null) { return(null); } if (map.ContainsKey(node.val)) { return(map[node.val]); } UndirectedGraphNode clone = new UndirectedGraphNode(node.val); foreach (UndirectedGraphNode neighbor in node.neighbors) { var cloneNeighbor = CloneGraph(neighbor, map); clone.neighbors.Add(cloneNeighbor); } return(clone); }
private UndirectedGraphNode Clone(UndirectedGraphNode node) { if (node == null) { return(node); } if (nodes.ContainsKey(node)) { return(nodes[node]); } UndirectedGraphNode clone = new UndirectedGraphNode(node.label); nodes.Add(node, clone); foreach (var curr in node.neighbors) { clone.neighbors.Add(Clone(curr)); } return(clone); }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) return null; var queue = new Queue<UndirectedGraphNode>(); var map = new Dictionary<UndirectedGraphNode, UndirectedGraphNode>(); UndirectedGraphNode retNode = new UndirectedGraphNode(node.Label); map[node] = retNode; queue.Enqueue(node); while (queue.Count() > 0) { UndirectedGraphNode current = queue.Dequeue(); int count = current.Neighbors.Count; for (int i = 0; i < count; i++) { UndirectedGraphNode neighbor = current.Neighbors[i]; if (map.ContainsKey(neighbor)) { map[current].Neighbors.Add(map[neighbor]); } else { UndirectedGraphNode n = new UndirectedGraphNode(neighbor.Label); map[current].Neighbors.Add(n); map[neighbor] = n; queue.Enqueue(neighbor); } } } return retNode; }
public UndirectedGraphNode CloneGraph(UndirectedGraphNode node) { if (node == null) { return(null); } Queue <UndirectedGraphNode> queue = new Queue <UndirectedGraphNode>(); Dictionary <UndirectedGraphNode, UndirectedGraphNode> map = new Dictionary <UndirectedGraphNode, UndirectedGraphNode>(); UndirectedGraphNode newHead = new UndirectedGraphNode(node.label); queue.Enqueue(node); map.Add(node, newHead); while (queue.Count != 0) { UndirectedGraphNode current = queue.Dequeue(); List <UndirectedGraphNode> currentNeighbors = (List <UndirectedGraphNode>)current.neighbors; foreach (UndirectedGraphNode aNeighbor in currentNeighbors) { if (!map.ContainsKey(aNeighbor)) { UndirectedGraphNode copy = new UndirectedGraphNode(aNeighbor.label); map.Add(aNeighbor, copy); map[current].neighbors.Add(copy); queue.Enqueue(aNeighbor); } else { map[current].neighbors.Add(map[aNeighbor]); } } } return(newHead); }
public static void Run() { var st = new Solution133(); Console.WriteLine("Start: {0}", DateTime.Now); UndirectedGraphNode tn = new UndirectedGraphNode(0); UndirectedGraphNode tn2 = new UndirectedGraphNode(1); UndirectedGraphNode tn3 = new UndirectedGraphNode(2); tn.neighbors.Add(tn2); tn.neighbors.Add(tn3); tn2.neighbors.Add(tn); tn2.neighbors.Add(tn3); tn3.neighbors.Add(tn); tn3.neighbors.Add(tn2); tn3.neighbors.Add(tn3); var ntn = st.CloneGraph(tn); Console.WriteLine("End: {0}", DateTime.Now); }