Sharing

#include<iostream>
#include<vector>

using namespace std;
typedef struct node{
	char data;
	int Next_Addr;               //下一个结点地址 
	int flag;                    //访问次数标记 
}Node;

int Get_Com(vector<Node> &Pre, int h1, int h2){
	int i,t1,t2;          
	i = h1;                        
	while(i != -1){
		Pre[i].flag += 1;
		i = Pre[i].Next_Addr;     //访问串1的下一个结点 
	}
	i = h2;
	while(i != -1){
		Pre[i].flag += 1;
		if(Pre[i].flag == 2)
			return i;
		i = Pre[i].Next_Addr;
	}
	return -1;                   //说明所有结点都只有被访问过一次，即无交汇结点，返回-1 
}

int main(){
	int N,Addr1,Addr2,temp_Addr;
	int Com;
	vector<Node> Pre;
	while(cin>>Addr1>>Addr2>>N){
		Pre.clear();
		Pre.resize(100000);
		for(int i=0; i<N; i++)
			Pre[i].flag = 0;
		for(int i=0; i<N; i++){
			cin>>temp_Addr;
			cin>>Pre[temp_Addr].data>>Pre[temp_Addr].Next_Addr;
		}
		Com = Get_Com(Pre,Addr1,Addr2);
		if(Com != -1){                   //-1前面不需要补充0 
			cout.width(5);
			cout.fill('0');
		}
		cout<<Com<<endl;
	}
	return 0;
}

#include<stdio.h>
#include<string.h>
using namespace std;

int list[100000];
int main(){
    
   int a,b,c;
    while(scanf("%d %d %d",&a,&b,&c)!=EOF){
        int temp=0;
     for(int i=0;i<100000;i++){
         list[i]=0;
     }
        int addr=-1;
        while(temp<c){
            int begin,next;
            char ch;
            scanf("%d %c %d",&begin,&ch,&next);

            list[next]++;
            if(list[next]==2){
                addr=next;
            }
  
            temp++;
        }
        
          printf("%d\n",addr);        
    }
    
    
}

#include <iostream>
#include <cstring>
using namespace std;

int main(){
    int firstStart,secondStart,n;
    while(cin>>firstStart>>secondStart>>n){
        int nextPosition[1000000];
        memset(nextPosition,0,sizeof(nextPosition));
        int count[1000000];
        memset(count,0,sizeof(count));
        char data[2];
        int startPosition=0,secondPosition=0;
        for(int i=0;i<n;i++){
            cin>>startPosition>>data>>secondPosition;
            nextPosition[startPosition]=secondPosition;
        }
        int position=firstStart;
        while(position!=-1){
            count[position]++;
            position=nextPosition[position];
        }
        int index=-1;
        position=secondStart;
        while(position!=-1){
            count[position]++;
            if(count[position]==2){
                index=position;
                break;
            }
            position=nextPosition[position];
        }
        cout<<index<<endl;
    }
}    

#include <iostream>
#include <map>
using namespace std;
int main(){
    int first, start, n;
    while(cin >> first >> start >> n){
        int a, temp;
        char b;
        map<int, int> mymap;
        for(int i=0; i<n; ++i){
            cin >> a >> b >> temp;
            mymap[temp]++;
        }
        int taget = 0;
        for(auto it = mymap.begin(); it != mymap.end(); ++it){
            if(it->second == 2) taget = it->first;
        }
        if(taget) cout << taget << endl;
        else cout << "-1" << endl;
    }
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct Node {       //静态链表结点
    string data;    //数据
    int next;       //下一结点指针（地址）
};

vector<Node>nodes(1e5);     //静态链表存储区
//vector数组下标表示地址

int countNodes(int head) {  //统计静态链表结点个数，head为头指针
    int count = 0;
    for (; head != -1; head = nodes[head].next, count++);
    return count;
}

int main() {
    int head1, head2, n;
    while (cin >> head1 >> head2 >> n) {
        while (n--) {
            int address;    //地址
            cin >> address >> nodes[address].data >> nodes[address].next;
        }
        int n1 = countNodes(head1);
        int n2 = countNodes(head2);
        //两条链表长度找齐
        for (; n1 > n2; head1 = nodes[head1].next, n1--);
        for (; n2 > n1; head2 = nodes[head2].next, n2--);
        //两条链表同时向前遍历，地址相同或到达结尾时结束
        for (; head1 != -1 && head1 != head2;
                head1 = nodes[head1].next, head2 = nodes[head2].next);
        cout << head1 << endl;
    }
    return 0;
}

N<=100000不就是来直接寻址的吗？直接数组下标寻址了，不需要用map
#include <iostream>
using namespace std;
struct Node
{
    char c;
    int next;
} node[100001];
int main()
{
    int n, start1, start2, a, b;
    cin >> start1 >> start2 >> n;
    while (n--)
    {
        cin >> a >> node[a].c >> node[a].next;
    }
    int p = start1, q = start2;
    while (p != q)  //如果出现共同节点，那么退出循环
    {     
        p = (p == -1) ? start2 : node[p].next; //p到达末尾时，将其重新接到start2上
        q = (q == -1) ? start1 : node[q].next; //q到达末尾时，将其重新接到start1上

    }     //如果没有共同节点，那么两条链的最后一个节点的next都是-1，p=q=-1，也退出循环

    cout << p << endl;   //直接输出p即可，不需要判断
    system("pause");
    return 0;
}

#include<iostream>
(720)#include<map>

using namespace std;

struct Node{
    char letter;
    int next;
};

int main(){
    int address1,address2,n;
    while(cin>>address1>>address2>>n){
        map<int,Node> myMap;            //map映射，通过地址直接找到结点
        while(n--){                     //存入数据
            int myaddress,nextaddress;
            char data;
            cin>>myaddress>>data>>nextaddress;
            Node *current=new Node;
            current->letter=data;
            current->next=nextaddress;
            myMap[myaddress]=*current;
        }
        int len1=1,len2=1;             //统计两个单词长度
        int pos=address1;
        while(myMap[pos].next!=-1){
            len1++;
            pos=myMap[pos].next;
        }
        pos=address2;
        while(myMap[pos].next!=-1){
            len2++;
            pos=myMap[pos].next;
        }
        int pos1=address1,pos2=address2;   //设置位置标记指向两单词开头
        if(len1>len2){                     //对齐位置
            pos=len1-len2;
            while(pos>0){
                pos1=myMap[pos1].next;
                pos--;
            }
        }
        else{
            pos=len2-len1;
            while(pos>0){
                pos2=myMap[pos2].next;
                pos--;
            }
        }
        while(pos1!=pos2){               //同时后移，找到地址相同的结点，然后输出
            pos1=myMap[pos1].next;       //若无相同字母则最后位置都移动到-1，直接输出
            pos2=myMap[pos2].next;
        }
        cout<<pos1<<endl;
    }
    return 0;
}

#include<cstdio>
#include<vector>
using namespace std;
struct node{
    char ch;
    int next;
};
int main(){
   int r1,r2,k;
   int n1,n2,next;
   char ch;
   while(scanf("%d %d %d",&r1,&r2,&k)!=EOF){
   vector<node> v(100010);
   for(int i=0;i<k;++i){
       scanf("%d %c %d",&n1,&ch,&n2);
       v[n1].ch=ch;
       v[n1].next=n2;
   }
   int p=r1,len1=0,len2=0;
   while(p!=-1){
       len1++;
       p=v[p].next;
   }
   p=r2;
   while(p!=-1){
       len2++;
       p=v[p].next;
   }
   while(len1!=len2){
       if(len1>len2)
       {
           r1=v[r1].next;
           len1--;
       }
       else{
           r2=v[r2].next;
           len2--;
       }
   }
   while(r1!=-1){
       if(v[r1].ch==v[r2].ch&&r1==r2){
           printf("%05d\n",r1);
           break;
       }
       r1=v[r1].next;
       r2=v[r2].next;
   }
   if(r1==-1)
       printf("-1\n");
   }
    return 0;
}

/*她走丢了

运行时间较长，数据量还是比较大的，但是其他的应该会更长吧*/
#include <stdio.h>
#include <map>
using namespace std;

map<int, int> M;

int main() {
	int begin1, begin2, num;
	while (scanf("%d%d%d", &begin1, &begin2,&num) != EOF) {
        bool fag = true;
		M.clear();
		int s1, s2; char c;
		for (int i = 0; i < num; i++) {
			scanf("%d %c %d", &s1, &c, &s2);
			if(s2!=-1)
				M[s2]++;
			if (M[s2] == 2){
				printf("%d\n", s2);
                fag = false;
            }
		}
        if(fag)
            printf("-1\n");
	}
	return 0;
}