#include "Tree.h"
using namespace std;
//並查集結構
class DisjoinSets
{
public:
    DisjoinSets() {}
    void makeSets(Node* head)
    {
        fatherMap.clear();
        rankMap.clear();
        preOrderMake(head);
    }
    void setUnion(Node* a, Node* b);
    Node* findFather(Node* n);
private:
    map
 
<Node*, Node*> fatherMap;
    map<Node*, int>   rankMap;
    void preOrderMake(Node* head);
};
void DisjoinSets::preOrderMake(Node* head)
{
    if(head == nullptr)
        return;
    fatherMap[head] = head;
    rankMap[head]   = 0;
    preOrderMake(head->left);
    preOrderMake(head->right);
}
Node* DisjoinSets::findFather(Node* n)
{
    Node* father = fatherMap[n];
    if
 
(father != n)
        father = findFather(father);
    fatherMap[n] = father;
    return father;
}
void DisjoinSets::setUnion(Node* a, Node* b)
{
    if(a == nullptr || b == nullptr)
        return;
    Node* aFather = findFather(a);
    Node* bFather = findFather(b);
    if(aFather != bFather)
    {
        int
 
 aRank = rankMap[aFather];
        int bRank = rankMap[bFather];
        if(aRank < bRank)
        {
            fatherMap[aFather] = bFather;
        } else if(aRank > bRank) {
            fatherMap[bFather] = aFather;
        } else {
            fatherMap[bFather] = aFather;
            rankMap[aFather] = aRank + 1;
        }
    }
}
struct Query
{
    Node* o1;
    Node* o2;
    Query(Node* data1, Node* data2) : o1(data1), o2(data2) {}
    Query() : o1(nullptr), o2(nullptr) {}
};
class Tarjan
{
public:
    Tarjan() {
        sets = new DisjoinSets();
    }
    vector<Node*> query(Node* head , vector<Query*>& ques);
private:
    map<Node*, list<Node*> > queryMap;
    map<Node*, list<int> >   indexMap;
    map<Node*, Node*>        ancestorMap;
    DisjoinSets* sets;
    void setQueries(vector<Query*> & ques, vector<Node*> & ans);
    void setAnswers(Node* head, vector<Node*> & ans);
};
void Tarjan::setQueries(vector<Query*> & ques, vector<Node*> &ans)
{
    Node* o1 = nullptr;
    Node* o2 = nullptr;
    for(int i = 0; i < ques.size(); ++i)
    {
        o1 = ques[i]->o1;
        o2 = ques[i]->o2;
        if(o1 == o2 || o1 == nullptr || o2 == nullptr)
            ans[i] = (o1 != nullptr ? o1 : o2);
        else {
            if(queryMap.find(o1) == queryMap.end())
            {
                list<Node*> nlist;
                queryMap[o1] = nlist;
                list<int> ilist;
                indexMap[o1] = ilist;
            }
            if(queryMap.find(o2) == queryMap.end())
            {
                list<Node*> nlist;
                queryMap[o2] = nlist;
                list<int> ilist;
                indexMap[o2] = ilist;
            }
            queryMap[o1].push_back(o2);
            indexMap[o1].push_back(i);
            queryMap[o2].push_back(o1);
            indexMap[o2].push_back(i);
        }
    }
}
void Tarjan::setAnswers(Node* head, vector<Node*> & ans)
{
    if(head == nullptr)
        return;
    setAnswers(head->left, ans);
    sets->setUnion(head->left, head);
    ancestorMap[sets->findFather(head)] = head;
    setAnswers(head->right, ans);
    sets->setUnion(head->right, head);
    ancestorMap[sets->findFather(head)] = head;

    list<Node*> nList = queryMap[head];
    list<int>   iList = indexMap[head];

    Node* node = nullptr;
    Node* nodefather = nullptr;
    int index = 0;
    while(!nList.empty())
    {
        node = nList.front();
        nList.pop_front();
        index = iList.front();
        iList.pop_front();
        nodefather = sets->findFather(node);
        if(ancestorMap.find(nodefather) != ancestorMap.end())
            ans[index] = ancestorMap[nodefather];
    }
}
vector<Node*> Tarjan::query(Node* head, vector<Query*>& ques)
{
    vector<Node*> ans(ques.size());
    setQueries(ques, ans);
    sets->makeSets(head);
    setAnswers(head, ans);
    return ans;
}
int main()
{
     Node* pNode0 = new Node(5);
    Node* pNode1 = new Node(3);
    Node* pNode2 = new Node(7);
    Node* pNode3 = new Node(2);
    Node* pNode4 = new Node(5);
    Node* pNode5 = new Node(6);
    Node* pNode6 = new Node(8);

    connectTree(pNode0, pNode1, pNode2);
    connectTree(pNode1, pNode3, pNode4);
    connectTree(pNode2, pNode5, pNode6);

    vector<Node*> ans;
    vector<Query*> ques;
    Query* q1 = new Query(pNode1, pNode3);
    Query* q2 = new Query(pNode3, pNode6);
    Query* q3 = new Query(pNode5, pNode6);
    ques.push_back(q1);
    ques.push_back(q2);
    ques.push_back(q3);

    Tarjan* tr = new Tarjan();
    ans = tr->query(pNode0, ques);
    for(int i = 0; i < ans.size(); ++i)
        cout << ans[i]->value << endl;
}