PAT 1032 （未完成）

　　斗智斗勇系列，这个时间限制太变态了，10^5的数据读进去100ms就完蛋，buffer又不能太多开，但是8M buffer开出来其实也没啥用，还是超时

　　除去超时数据点，还有一个数据点没有过，不知道是什么边界条件，不管了

　　判断两条链表是否相交，首先两条链表都走到最后一个节点，如果节点相同，则说明这两条链表是相交的。算出两条链表的长度，len1，len2，max(len1, len2) - min(len1, len2)，长的链表先走diff step，再和短的链表一起走，相遇的节点即为共同节点的起始节点。

　　另外学到了，PAT中的JAVA如果是返回非零，则说明存在着异常。前面有数据点返回非零是因为没有判断null。

　　

　　

import java.util.*;
import java.io.*;

class FastReader{
    BufferedReader reader;
    StringTokenizer tokenizer;
    
    public FastReader(InputStream stream){
        reader = new BufferedReader(new InputStreamReader(stream), 1 << 22);
        tokenizer = null;
    }
    
    public String next(){
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try { 
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (Exception e){
                //System.out.println(-1);
                throw new RuntimeException(e);
            }
        }
        
        return tokenizer.nextToken();
    }
    
    public int next_int(){
        return Integer.parseInt(next());
    }
}

class Node{
    int address;
    int next_address;
    Node next;
    
    public Node(){
        next = null;
    }
}

public class Main {
    public static void main(String[] args){
        FastReader reader = new FastReader(System.in);
        int first_start, second_start;
        int N;
        
        first_start = reader.next_int();
        second_start = reader.next_int();
        N = reader.next_int();
        
        Node[] nodes = new Node[N];
        
        for (int i = 0; i < N; i++){
            int cur_address = reader.next_int();
            reader.next();
            int next_address = reader.next_int();
            
            Node node = new Node();
            node.address = cur_address;
            node.next_address = next_address;
            nodes[i] = node;
        }
        
        Node first_word = null, second_word = null;
        for (int i = 0; i < N; i++){
            Node cur_node = nodes[i];
            if (cur_node.address == first_start)
                first_word = cur_node;
            else if (cur_node.address == second_start)
                second_word = cur_node;
            for (int j = 0; j < N; j++){
                Node candidate_node = nodes[j];
                
                if (cur_node.next_address == candidate_node.address){
                    cur_node.next = candidate_node;
                    break;
                }
            }
        }
        
        int len1 = 0, len2 = 0;
        Node first_ptr = first_word, second_ptr = second_word;
        
        if (first_ptr == null || second_ptr == null){
            System.out.println(-1);
            return;
        }
        
        while (first_ptr.next != null){
            first_ptr = first_ptr.next;
            len1++;
        }
        while (second_ptr.next != null){
            second_ptr = second_ptr.next;
            len2++;
        }
        
        if (first_ptr != second_ptr){
            System.out.println(-1);
            return;
        }
        
        int diff_step = Math.max(len1, len2) - Math.min(len1, len2);
        if (len1 < len2){
            first_ptr = second_word;
            second_ptr = first_word;
        } else {
            first_ptr = first_word;
            second_ptr = second_word;
        }
        
        for (int i = 0; i < diff_step; i++)
            first_ptr = first_ptr.next;
        while (first_ptr != second_ptr){
            first_ptr = first_ptr.next;
            second_ptr = second_ptr.next;
        }
        
        System.out.println(first_ptr.address);
    }
}