圖與連結串列的深拷貝

都用到了unordered_map：原節點->拷貝節點，在遍歷的過程中完成複製。

圖：leetcode 133.克隆圖

給你無向 連通 圖中一個節點的引用，請你返回該圖的 深拷貝（克隆）。圖中的每個節點都包含它的值 val（int） 和其鄰居的列表（list[Node]）。

class Node {
public int val;
public List neighbors;
}

DFS

維護一個unordered_map<Node*, Node*> vis，如果已經拷貝過該節點，直接返回拷貝節點；如果未拷貝過，就建立該節點的副本，遍歷該節點的鄰居，給副本的鄰接連結串列新增鄰居對應的副本。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    unordered_map<Node*, Node*> vis;
    Node* cloneGraph(Node* node) {
        if(!node) return node;
        if(vis.count(node)) return vis[node];
        auto cp = new Node(node->val);
        vis[node] = cp;
        for(auto x : node->neighbors)
        {
            vis[node]->neighbors.push_back(cloneGraph(x));
        }
        return cp;
    }
};
 

BFS

class Solution {
public:
    Node* cloneGraph(Node* node) {
        if(!node) return node;
        queue<Node*> Q;
        unordered_map<Node*, Node*> mp;
        mp[node] = new Node(node->val);
        Q.push(node);
        while(Q.size())
        {
            auto t = Q.front();
            Q.pop();
            for(auto x : t->neighbors)
            {
                if(mp.count(x))
                {
                    mp[t]->neighbors.push_back(mp[x]);
                    continue;
                }
                Q.push(x);
                mp[x] = new Node(x->val);
                mp[t]->neighbors.push_back(mp[x]);
            }
        }
        return mp[node];
    }
};
 

連結串列：leetcode 138. 複製帶隨機指標的連結串列

維護一個unordered_map<Node*, Node*> mp，如果該節點的拷貝已經存在，就返回它的拷貝節點，否則建立拷貝節點更新mp，緊接著設定拷貝節點的next和random。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    unordered_map<Node*, Node*> mp;
    Node* copyRandomList(Node* head) {
        if(!head) return head;
        if(mp.count(head)) return mp[head];
        auto cp = new Node(head->val);
        mp[head] = cp;
        mp[head]->next = copyRandomList(head->next);
        mp[head]->random = copyRandomList(head->random);
        return mp[head];
    }
};