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);
}
