算法基础 - 树的最近公共祖先

最近公共祖先

树的公共祖先很容易理解：就是到两个点的路径(A,B)上的公共点。
那么最近公共祖先就是公共路径（A, B）上深度最高的公共点。

二叉树的最近公共祖先

---

二叉树的公共祖先很简单，就是在先序遍历也就是DFS过程中，记录当前的祖先，放到栈里，在遍历的过程中，不断对栈进行监控，当前遍历的最近公共祖先发生变化之后，对栈进行弹栈操作。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //上面是TreeNode的定义
 vector<TreeNode*> treeStack;
 TreeNode* ancestor;
 int flag;
 //以上是全局变量
void findAncestor(TreeNode* node, TreeNode* p, TreeNode* q){
        if(p == q){
            ancestor = p;
            return;
        }
        if(node == NULL){
            return;
        }
        if((node == p || node == q) && flag == 0){
            flag = 1;
            treeStack.push_back(node);
        }else if((node == p || node == q) && flag == 1){
            int length = treeStack.size();
            ancestor = treeStack[length-1];
            return;
        }
        if(flag == 0){
            treeStack.push_back(node);
        }
        findAncestor(node->left, p, q);
        findAncestor(node->right, p, q);
        if(node == treeStack.back()){
            treeStack.pop_back();
        }
    }

普通树的最近公共祖先

普通树和二叉树在算法上并没有太多区别，只是在遍历的时候稍有不同，因为每个节点的孩子节点最多的时候不是两个了，所以用个for循环来进行遍历。

代码实现：

//
//  main.cpp
//  HiHocoder
//
//  Created by Alps on 16/5/9.
//  Copyright © 2016年 chen. All rights reserved.
//
#include<iostream>
#include<cstring>
#include<string>
#include<unordered_map>
#include<vector>

using namespace std;

vector<int> tree[100005];
unordered_map<int, int> nameSet;
unordered_map<string, int> names;
string strs[100005];
vector<int> path;
int ance;
int flag = 0;
static int id = 0;

int getId(string name){
    if(names.count(name) == 0){
        names[name] = id;
        strs[id] = name;
        id++;
    }
    return names[name];
}

void findAnces(int node, int id_1, int id_2){
    if (id_1 == id_2) {
        ance = id_1;
        flag = 2;
        return;
    }
    if(flag == 0){
        path.push_back(node);
    }
    if(node == id_1){
        flag += 1;
    }
    if(node == id_2){
        flag += 1;
    }
    if(flag == 2){
        ance = path.back();
        return;
    }
    for(int i = 0; i < tree[node].size(); i++){
        findAnces(tree[node][i], id_1, id_2);
        if (flag == 2) {
            return;
        }
    }
    if(node == path.back()){
        path.pop_back();
    }
}

int main(){
    int M,N;
    cin>>M;
    string name_1, name_2;
    int id_1, id_2;
    for(int i = 0; i < M; i++){
        cin>>name_1>>name_2;
        id_1 = getId(name_1);
        id_2 = getId(name_2);
        tree[id_1].push_back(id_2);
        nameSet[id_2] = id_1;
        if(nameSet.count(id_1) == 0){
            nameSet[id_1] = id_1;
        }
    }
    int root = 0;
    while(nameSet[root] != root){
        root = nameSet[root];
    }
    cin>>N;
    for(int i = 0; i < N; i++){
        cin>>name_1>>name_2;
        id_1 = getId(name_1);
        id_2 = getId(name_2);
        findAnces(root, id_1, id_2);
        cout<<strs[ance]<<endl;
        path.clear();
        ance = 0;
        flag = 0;
    }
    return 0;
}

这个是最简单的办法，下篇博客我会写LCA的在线和离线算法。
算法的复杂度会有一个质的变化。