《Cracking the Coding Interview》——第4章：树和图——题目7

2014-03-19 04:48

题目：最近公共父节点问题。

解法1：Naive算法，先对其高度，然后一层一层往上直到找到结果。

代码：

 // 4.7 Least Common Ancestor
 // This solution is Naive Algorithm, may timeout on very large and skewed trees.
 #include <cstdio>
 #include <cstring>
 using namespace std;

 const int MAXN = ;
 // tree[x][0]: parent of node x
 // tree[x][1]: left child of node x
 // tree[x][2]: right child of node x
 // tree[x][3]: value of node x
 int tree[MAXN][];
 // number of nodes
 int e;

 void build(int a)
 {
     int tmp;

     scanf("%d", &tmp);
     if(tmp)
     {
         tree[a][] = e;
         tree[e][] = tmp;
         tree[e][] = a;
         ++e;
         // build the left subtree
         build(e - );
     }

     scanf("%d", &tmp);
     if(tmp)
     {
         tree[a][] = e;
         tree[e][] = tmp;
         tree[e][] = a;
         ++e;
         // build the right subtree
         build(e - );
     }
 }

 int main()
 {
     int n, ni;
     int i;
     // the value to be queried
     int m1, m2;
     // the corresponding node indices of m1 and m2
     int s1, s2;
     int t1, t2;
     int c1, c2, c;

     while (scanf("%d", &n)  == ) {
         for (ni = ; ni < n; ++ni) {
             // get value for root node
             e = ;
             scanf("%d", &tree[][]);

             // root has no parent node
             tree[][] = -;
             build();

             while (scanf("%d%d", &m1, &m2) ==  && (m1 && m2)) {
                 s1 = s2 = -;
                 for (i = ;i <= e; ++i) {
                     if (tree[i][] == m1) {
                         s1 = i;
                         // there're duplicate values
                         break;
                     }
                 }
                 for (i = ;i <= e; ++i) {
                     if (tree[i][] == m2) {
                         s2 = i;
                         // there're duplicate values
                         break;
                     }
                 }

                 if (s1 != - && s2 != -) {
                     t1 = s1;
                     t2 = s2;
                     c1 = c2 = ;

                     // c1 is the depth of t1
                     while (tree[t1][] != -) {
                         ++c1;
                         t1 = tree[t1][];
                     }
                     // c2 is the depth of t2
                     while (tree[t2][] != -) {
                         ++c2;
                         t2 = tree[t2][];
                     }

                     // move'em to the same height level
                     if (c1 > c2) {
                         c = c1 - c2;
                         while(c--) {
                             s1 = tree[s1][];
                         }
                     } else {
                         c = c2 - c1;
                         while(c--) {
                             s2 = tree[s2][];
                         }
                     }

                     while(s1 != s2)
                     {
                         s1 = tree[s1][];
                         s2 = tree[s2][];
                     }
                     printf("%d\n", tree[s1][]);
                 } else {
                     // At least one value is not found in the tree.
                     printf("Not found in the tree.\n");
                 }
             }
         }
     }

     return ;
 }

解法2：Naive算法的倍增优化。

代码：

 // 4.7 Least Common Ancestor
 // O(log(n)) solution with binary decomposition.
 #include <cstdio>
 #include <cstring>
 using namespace std;

 typedef struct st{
 public:
     int key;
     st *ll;
     st *rr;
     st(int _key = ): key(_key), ll(NULL), rr(NULL) {}
 }st;

 // maximal number of nodes
 const int MAXN = ;
 // key -> node_index mapping
 int hash_key[MAXN];
 // node_index -> key mapping
 int key_hash[MAXN];
 // depth of each node
 int depth[MAXN];
 // array recording ancestors
 int anc[MAXN][];
 // total number of nodes, index starting from 1
 int nc;

 // recursively calculate depths of nodes
 void getDepth(st *root, int dep)
 {
     if (root == NULL) {
         return;
     }
     depth[hash_key[root->key]] = dep;
     if (root->ll != NULL) {
         getDepth(root->ll, dep + );
     }
     if (root->rr != NULL) {
         getDepth(root->rr, dep + );
     }
 }

 // recursively construct a binary tree
 void constructBinaryTree(st *&root)
 {
     int tmp;

     scanf("%d", &tmp);
     if (tmp == ) {
         root = NULL;
     } else {
         root = new st(tmp);
         ++nc;
         if (hash_key[tmp] == ) {
             hash_key[tmp] = nc;
         }
         key_hash[nc] = tmp;
         constructBinaryTree(root->ll);
         constructBinaryTree(root->rr);
     }
 }

 // recursively initialize ancestor array
 void getParent(st *root)
 {
     if (root == NULL) {
         return;
     }

     // anc[x][0] is the direct parent of x.
     if (root->ll != NULL) {
         anc[hash_key[root->ll->key]][] = hash_key[root->key];
         getParent(root->ll);
     }
     if (root->rr != NULL) {
         anc[hash_key[root->rr->key]][] = hash_key[root->key];
         getParent(root->rr);
     }
 }

 // calculate LCA in O(log(n)) time
 int leastCommonAncestor(int x, int y)
 {
     int i;

     if (depth[x] < depth[y]) {
         return leastCommonAncestor(y, x);
     }
     for (i = ; i >= ; --i) {
         if (depth[anc[x][i]] >= depth[y]) {
             x = anc[x][i];
             if (depth[x] == depth[y]) {
                 break;
             }
         }
     }
     if (x == y) {
         return x;
     }

     for (i = ; i >= ; --i) {
         if (anc[x][i] != anc[y][i]) {
             // they'll finally be equal, think about the reason.
             x = anc[x][i];
             y = anc[y][i];
         }
     }

     // this is the direct parent of x
     return anc[x][];
 }

 st *deleteTree(st *root)
 {
     if (NULL == root) {
         return NULL;
     }

     if (root->ll != NULL) {
         root->ll = deleteTree(root->ll);
     }
     if (root->rr != NULL) {
         root->rr = deleteTree(root->rr);
     }
     delete root;
     root = NULL;

     return NULL;
 }

 int main()
 {
     int ci, cc;
     int i, j;
     int x, y;
     st *root;

     while (scanf("%d", &cc) == ) {
         for (ci = ; ci < cc; ++ci) {
             // data initialization
             memset(hash_key, , MAXN * sizeof(int));
             memset(key_hash, , MAXN * sizeof(int));
             memset(depth, , MAXN * sizeof(int));
             memset(anc, , MAXN *  * sizeof(int));
             nc = ;
             root = NULL;

             constructBinaryTree(root);
             getParent(root);
             getDepth(root, );
             for (j = ; j < ; ++j) {
                 for (i = ; i <= nc; ++i) {
                     anc[i][j] = anc[anc[i][j - ]][j - ];
                 }
             }
             while (scanf("%d%d", &x, &y) ==  && (x && y)) {
                 if (hash_key[x] ==  || hash_key[y] == ) {
                     printf("Not found in the tree.\n");
                 } else {
                     printf("%d\n", key_hash[leastCommonAncestor(hash_key[x], hash_key[y])]);
                 }
             }

             root = deleteTree(root);
         }
     }

     return ;
 }

解法3：Tarjan离线算法，并查集的妙用。

代码：

 // 4.7 Least Common Ancestor
 // Tarjan Offline Algorithm
 #include <cstdio>
 #include <cstdlib>
 #include <unordered_map>
 #include <unordered_set>
 using namespace std;

 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;

     TreeNode(int _val = ): val(_val), left(nullptr), right(nullptr) {};
 };

 void constructTree(vector<TreeNode *> &nodes,
                    unordered_set<TreeNode *> &checked)
 {
     int ll, rr;
     int i;

     for (i = ; i < (int)nodes.size(); ++i) {
         checked.insert(nodes[i]);
     }
     for (i = ; i < (int)nodes.size(); ++i) {
         scanf("%d%d", &ll, &rr);
         if (ll > ) {
             nodes[i]->left = nodes[ll - ];
             checked.erase(nodes[ll - ]);
         }
         if (rr > ) {
             nodes[i]->right = nodes[rr - ];
             checked.erase(nodes[rr - ]);
         }
     }
 }

 TreeNode *findRoot(TreeNode *node, unordered_map<TreeNode *, TreeNode *> &disjoint_set)
 {
     if (node != disjoint_set[node]) {
         disjoint_set[node] = findRoot(disjoint_set[node], disjoint_set);
     }

     return disjoint_set[node];
 }

 void tarjanLCA(TreeNode *root, unordered_map<TreeNode *, TreeNode *> &disjoint_set,
                unordered_map<TreeNode *, unordered_map<TreeNode *, TreeNode *> > &query,
                unordered_set<TreeNode *> &checked)
 {
     if (root == nullptr) {
         return;
     }

     disjoint_set[root] = root;
     if (root->left != nullptr) {
         tarjanLCA(root->left, disjoint_set, query, checked);
         disjoint_set[root->left] = root;
     }
     if (root->right != nullptr) {
         tarjanLCA(root->right, disjoint_set, query, checked);
         disjoint_set[root->right] = root;
     }
     checked.insert(root);

     if (query.find(root) == query.end()) {
         return;
     }

     unordered_map<TreeNode *, TreeNode *>::iterator it;
     for (it = query[root].begin(); it != query[root].end(); ++it) {
         if (it->second != nullptr) {
             // already solved, skip it
             continue;
         }
         if (checked.find(it->first) != checked.end()) {
             query[root][it->first] = query[it->first][root] = findRoot(it->first, disjoint_set);
         }
     }
 }

 int main()
 {
     int n;
     int i;
     int val;
     vector<TreeNode *> nodes;
     TreeNode *root;
     unordered_map<TreeNode *, TreeNode *> disjoint_set;
     unordered_map<TreeNode *, unordered_map<TreeNode *, TreeNode *> > query;
     unordered_map<TreeNode *, unordered_map<TreeNode *, TreeNode *> >::iterator it1;
     unordered_set<TreeNode *> checked;
     unordered_map<TreeNode *, TreeNode *>::iterator it2;
     int idx1, idx2;

     while (scanf("%d", &n) ==  && n > ) {
         nodes.resize(n);
         for (i = ; i < n; ++i) {
             scanf("%d", &val);
             nodes[i] = new TreeNode(val);
         }
         constructTree(nodes, checked);
         root = *(checked.begin());
         checked.clear();

         while (scanf("%d%d", &idx1, &idx2) ==  && (idx1 >=  && idx2 >= )) {
             if (idx1 > idx2) {
                 i = idx1;
                 idx1 = idx2;
                 idx2 = i;
             }
             query[nodes[idx1]][nodes[idx2]] = nullptr;
             query[nodes[idx2]][nodes[idx1]] = nullptr;
         }
         // Tarjan Offline Algorithm
         tarjanLCA(root, disjoint_set, query, checked);

         // print the results
         for (it1 = query.begin(); it1 != query.end(); ++it1) {
             for (it2 = (it1->second).begin(); it2 != (it1->second).end(); ++it2) {
                 if (it1->first->val > it2->first->val) {
                     continue;
                 }
                 printf("The least common ancestor of %d and %d is %d.\n",
                        it1->first->val, it2->first->val, it2->second->val);
             }
         }

         // clear up
         disjoint_set.clear();
         checked.clear();
         for (it1 = query.begin(); it1 != query.end(); ++it1) {
             (it1->second).clear();
         }
         query.clear();
     }

     return ;
 }