题目

To store English words, one method is to use linked lists and store a word letter by letter. To save some space, we may let the words share the same sublist if they share the same sufix. For example, “loading” and “being” are stored as showed in Figure 1.
Input Specification:
Each input file contains one test case. For each case, the first line contains two addresses of nodes and a positive N (<= 105), where the two addresses are the addresses of the first nodes of the two words, and N is the total number of nodes. The address of a node is a 5-digit positive integer, and NULL is represented
by -1.
Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is the letter contained by this node which is an English letter chosen from {a-z, A-Z}, and Next is the position of the next node.
Output Specification:
For each case, simply output the 5-digit starting position of the common sufix. If the two words have no common sufix, output “-1” instead.
Sample Input 1:
11111 22222 9
67890 i 00002
00010 a 12345
00003 g -1
12345 D 67890
00002 n 00003
22222 B 23456
11111 L 00001
23456 e 67890
00001 o 00010
Sample Output 1:
67890
Sample Input 2:
00001 00002 4
00001 a 10001
10001 s -1
00002 a 10002
10002 t -1
Sample Output 2:
-1

题目分析

两个链表，有共同后缀，找出共同后缀的第一个节点的地址

解题思路

思路01（最优）

1. 定义Node结构体，记录每个节点信息（地址，data，next指针），用map记录映射关系<地址，节点>方便O(1)查找（可以使用大数组代替，下标及地址，元素值记录next）
2. 遍历第一个链表，出现过的元素标记为1
3. 遍历第二个链表，若其节点在第一个链表中出现过（即：标记=1），则打印，若链表2中没有在链表1中出现过的节点，打印-1

思路02

1. 定义Node结构体，记录每个节点信息（地址，data，next指针），用map记录映射关系<地址，节点>方便O(1)查找（可以使用大数组代替，下标及地址，元素值记录next）
2. 分别计算两个链表的长度
3. 先遍历长链表到其长度跟短链表长度相等
4. 同时遍历两个链表，找出相同节点，若有相同节点，打印其地址，若无相同节点，打印-1；

思路03（该思路错误，列出来为了下次不再这样思考）

1. 记录输入的每个样例的next，如果有next出现两次，即为相同节点（×）；如果其中一个链表的起点是另一个链表的节点（即任意一个链表的起点在另外一个链表中出现过）（测试点2,4,5错误）
注：网上其他朋友有说 一个错误情况为格式，必须为5个字符

Code

Code 01

#include <iostream>
#include <list>
#include <unordered_map>
using namespace std;
struct node {
    string adr;
    char data;
    string next;
    bool flag=false;
};
int main(int argc,char * argv[]) {
    string s1,s2;
    int d;
    char c;
    node n;
    cin>>s1>>s2>>d;
    unordered_map<string,node> m; //用map最后一个点会超时
    for(int i=0; i<d; i++) {
        cin>>n.adr>>n.data>>n.next;
        m[n.adr]=n;
    }

    string n1=s1;
    while(n1!="-1") {
        m[n1].flag=true;
        n1=m[n1].next;
    }

    string n2=s2;
    while(n2!="-1") {
        if(m[n2].flag) {
            break;
        }
        n2=m[n2].next;
    }
    printf("%s",n2.c_str());
    return 0;
}

Code 02

#include <iostream>
#include <list>
#include <unordered_map>
using namespace std;
struct node {
    string adr;
    char data;
    string next;
    bool flag=false;
};
int main(int argc,char * argv[]) {
    string s1,s2;
    int d;
    char c;
    node n;
    cin>>s1>>s2>>d;
    unordered_map<string,node> m; //用map最后一个点会超时
    for(int i=0; i<d; i++) {
        cin>>n.adr>>n.data>>n.next;
        m[n.adr]=n;
    }

    int len1=0,len2=0;
    string n1=s1;
    while(n1!="-1") {
        n1=m[n1].next;
        len1++;
    }
    string n2=s2;
    while(n2!="-1") {
        n2=m[n2].next;
        len2++;
    }

    n1=s1,n2=s2;
    while(len1>len2) {
        len1--;
        n1=m[n1].next;
    }
    while(len1<len2) {
        len2--;
        n2=m[n2].next;
    }
    while(n1!=n2){
        n1=m[n1].next;
        n2=m[n2].next;
    }
    printf("%s",n1.c_str());
    return 0;
}

原文地址：https://www.cnblogs.com/houzm/p/12283993.html