hihoCoder 1062 最近公共祖先·一 最详细的解题报告

题目来源：最近公共祖先·一

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

题目描述

小Ho最近发现了一个神奇的网站！虽然还不够像58同城那样神奇，但这个网站仍然让小Ho乐在其中，但这是为什么呢？

“为什么呢？”小Hi如是问道，在他的观察中小Ho已经沉迷这个网站一周之久了，甚至连他心爱的树玩具都弃置一边。

“嘿嘿，小Hi，你快过来看！”小Ho招呼道。

“你看，在这个对话框里输入我的名字，在另一个对话框里，输入你的名字，再点这个查询按钮，就可以查出来……什么！我们居然有同一个祖祖祖祖祖爷爷？”

“诶，真是诶……这个网站有点厉害啊。”小Hi不由感叹道。

“是啊，这是什么算法啊，这么厉害！”小Ho也附和道。

“别2，我说的是他能弄到这些数据很厉害，而人类的繁殖树这种层数比较浅的树对这类算法的要求可是简单的不得了，你都能写出来呢！”小Hi道。

“啊？我也能写出来？可是……该从哪开始呢？”小Ho困惑了。

小Ho要面临的问题是这样的，假设现在他知道了N个人的信息——他们的父亲是谁，他需要对于小Hi的每一次提问——两个人的名字，告诉小Hi这两个人的是否存在同一个祖先，如果存在，那么他们的所有共同祖先中辈分最低的一个是谁？

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为一个整数N，意义如前文所述。

每组测试数据的第2~N+1行，每行分别描述一对父子关系，其中第i+1行为两个由大小写字母组成的字符串Father_i, Son_i，分别表示父亲的名字和儿子的名字。

每组测试数据的第N+2行为一个整数M，表示小Hi总共询问的次数。

每组测试数据的第N+3~N+M+2行，每行分别描述一个询问，其中第N+i+2行为两个由大小写字母组成的字符串Name1_i, Name2_i，分别表示小Hi询问中的两个名字。

对于100%的数据，满足N<=10^2，M<=10^2, 且数据中所有涉及的人物中不存在两个名字相同的人（即姓名唯一的确定了一个人）。

输出

对于每组测试数据，对于每个小Hi的询问，输出一行，表示查询的结果：如果根据已知信息，可以判定询问中的两个人存在共同的祖先，则输出他们的所有共同祖先中辈分最低的一个人的名字，否则输出-1。

样例输入

11
JiaYan JiaDaihua
JiaDaihua JiaFu
JiaDaihua JiaJing
JiaJing JiaZhen
JiaZhen JiaRong
JiaYuan JiaDaishan
JiaDaishan JiaShe
JiaDaishan JiaZheng
JiaShe JiaLian
JiaZheng JiaZhu
JiaZheng JiaBaoyu
3
JiaBaoyu JiaLian
JiaBaoyu JiaZheng
JiaBaoyu LinDaiyu

样例输出

JiaDaishan
JiaZheng
-1

解题思路：首先定义一个Node类，其中name表示节点的名字，isVisited表示该节点是否被访问过，parentIndex表示其父节点在数组中的下标，每当接受一组输入数据（parent，child）时，就在数组中查找该parent节点和child节点是否创建，然后再建立关系，最后整个数组中的数据全部建立了关系。当接收到一对询问（first，second）时，首先将first以及first的祖先节点isVisited设置为true，second也是一样，如果发现当前节点的isVisited已经为true，说明first已经访问过该节点，并且该节点为（first，second）的最近公共子节点。为了加速查找，采用hashmap来记录节点信息。

具体算法（java版，可以直接AC）

import java.util.HashMap;
import java.util.Scanner;

public class Main {

    private HashMap<String,Integer>nodeMap;
    private Node[]nodes;
    private int index;
    private int ancestorIndex;
    
    public Main(){
        this.nodeMap=new HashMap<String,Integer>();
        this.nodes=new Node[1001];
        this.index=0;
        this.ancestorIndex=-1;
    }
    
    private void reset(){
        for(int i=0;i<this.index;i++){
            this.nodes[i].isVisited=false;
        }
        this.ancestorIndex=-1;
    }
    
    private int getNode(String nodeName){        
        if(!this.nodeMap.containsKey(nodeName)){
            this.nodes[this.index]=new Node(nodeName);
            this.nodeMap.put(nodeName, this.index);
            this.index++;
        }
        return this.nodeMap.get(nodeName);
    }
    
    private void visit(int nodeIndex){
        if(nodeIndex>=0&&nodeIndex<this.index){
            if(this.nodes[nodeIndex].isVisited){
                this.ancestorIndex= nodeIndex;
                return;
            }else{
                this.nodes[nodeIndex].isVisited=true;
                int parentIndex=this.nodes[nodeIndex].parentIndex;
                this.visit(parentIndex);
            }            
        }
    }
    
    public void addNode(String parent,String child){
        int parentIndex=this.getNode(parent);
        int childIndex=this.getNode(child);
        if(parentIndex>=0&&parentIndex<this.index
                &&childIndex>=0&&childIndex<this.index){
            this.nodes[childIndex].parentIndex=parentIndex;
        }
    }
    
    public void getAncestor(String first,String second){
        int firstIndex=this.getNode(first);
        int secondIndex=this.getNode(second);
        this.visit(firstIndex);
        this.visit(secondIndex);
        if(this.ancestorIndex>=0&&this.ancestorIndex<this.index){
            this.nodes[this.ancestorIndex].print();
        }else{
            System.out.println("-1");
        }
        this.reset();
    }
    
    public static void main(String[] args) {
        
        Scanner scanner=new Scanner(System.in);
        Main ancestor=new Main();
        int n=scanner.nextInt();
        for(int i=0;i<n;i++){
            String first=scanner.next();
            String second=scanner.next();
            ancestor.addNode(first, second);
        }
        int m=scanner.nextInt();
        for(int i=0;i<m;i++){
            String first=scanner.next();
            String second=scanner.next();
            ancestor.getAncestor(first, second);
        }
    }

}

class Node{
    public String name;
    public int parentIndex;
    public boolean isVisited;
    public Node(String name){
        this.name=name;
        this.parentIndex=-1;
        this.isVisited=false;
    }
    public void print(){
        System.out.println(this.name);
    }
}

算法效率不是很好，如果有好的算法可以留言，谢谢！