PAT 1032 Sharing[hash][链表][一般上]

1032 Sharing (25)（25 分）

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 suffix. For example, "loading" and "being" are stored as showed in Figure 1.

\ Figure 1

You are supposed to find the starting position of the common suffix (e.g. the position of "i" 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 (<= 10^5^), 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 suffix. If the two words have no common suffix, 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

//这个代码可以在牛客网上AC，但是在pat上有最后两个测试点通不过，只得了20分，问题在哪里呢？

#include <iostream>
#include <vector>
#include<stdio.h>
#include <algorithm>
using namespace std;
int node[];

int main()
{
    int f,t,no;
    int addr,next,outs;
    char ch;
    bool flag=false;
    while(scanf("%d%d%d",&f,&t,&no)!=-)
    {
        for(int i=; i<no; i++)
        {
            scanf("%d %c %d",&addr,&ch,&next);
            if(next!=-)
            {
            if(node[next]==)
                node[next]=;
            else
            {
                outs=next;
                flag=true;
            }
        }
    }
     if(!flag)
            printf("-1\n");
        else{
            printf("%5d\n",outs);
            flag=false;
        }
}

return ;
}

//这个我甚至都没存储什么信息，因为一个节点如果在next的位置出现了2次，那么肯定就是那个公共的呀，还有什么异议吗?这可能就是我在pat上通不过的原因，找一下。

#include <iostream>
#include <vector>
#include<stdio.h>
#include <algorithm>
using namespace std;
int node[];

int main()
{
    int f,t,no;
    int addr,next,outs=-;
    char ch;
    bool flag=false;
    while(scanf("%d%d%d",&f,&t,&no)!=-){
        node[f]=;
        node[t]=;
        for(int i=; i<no; i++)
        {
            scanf("%d %c %d",&addr,&ch,&next);
            if(next!=-)
            {
            if(node[next]==)
                node[next]=;
            else if(outs==-)
            {
                outs=next;
                flag=true;
            }
            }
        }
        if(f==t){
            printf("%05d",f);continue;//这个是针对测试点4，
            //当起始地址一样时。
        }
        if(!flag)
            printf("-1");
        else{
            printf("%05d",outs);
            outs=-;
            flag=false;
        }
    }
return ;
}

//应该是不行了，如果用只存next来做，没找到为什么测试点2和测试点5过不去，好绝望。先就这样吧。（有一个博客里是说，如果只判断next就不能判断出干扰点，而我想不出来干扰点是什么。）

大佬们的代码都是hash+模拟链表，先都把所有的点读入， 在第一条链表中出现的进行标记，第二条中出现的如果在第一条中已经出现了，那么就是这个点，

代码来自：https://www.liuchuo.net/archives/2113

#include <cstdio>
using namespace std;
struct NODE {
    char key;
    int next;
    bool flag;
}node[];
int main() {
    int s1, s2, n, a, b;
    scanf("%d%d%d", &s1, &s2, &n);
    char data;
    for(int i = ; i < n; i++) {
        scanf("%d %c %d", &a, &data, &b);
        node[a] = {data, b, false};//结构体居然可以这么初始化。
    }
    for(int i = s1; i != -; i = node[i].next)
        node[i].flag = true;//这样就可以模拟单链表的遍历
    for(int i = s2; i != -; i = node[i].next) {
        if(node[i].flag == true) {
            printf("%05d", i);
            return ;
        }
    }
    printf("-1");
    return ;
}