想象一下,代理服务器是一个漏筛,漏筛的每一个洞代表一个代理服务器地址,而待访问的服务器序列要经过这个漏筛,每一次待访问的服务器如果和其中的一个洞相同,则堵上该洞。这样就保证了每一段都选择尽可能多重复使用的地址,降低跳转次数。
当洞被堵满,有两种情况:
1.当前待访问的服务器地址和所有代理服务器地址全部相同,即没有可用的代理服务器,应该返回-1。(其实本题明确告知代理服务器地址两两不同,故只有一种可能,那就是只有一个代理服务器地址,并且这个地址中枪了)
2.历史沉淀,一层一层筛选之后,某一个地址将最后一个可用的代理服务器地址给重合了。这个时候需要跳转一次,将之前所有堵上的洞重新释放,进入新一段的过筛。但是这个洞要堵上,成为历史遗留。

//试题:https://www.nowcoder.com/questionTerminal/1284469ee94a4762848816a42281a9e0

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

int func(string agentip[],string realip[],int agentnum,int realnum,int avoid0[],int realnow){
    if(realnow >= realnum) return 0;
    int avoidnow[agentnum];//标记数组,当前待访问服务器与代理服务器组之间的映射关系
    int rowsum_n = 0;//标记值,如果rowsum_n = agentnum,则说明无可用的代理服务器
    int rowsum = 0;//标记值,如果rowsum = agentnum,则说明需要进行一次跳转
    for(int i = 0;i < agentnum;i++){
        if(agentip[i] == realip[realnow]){
            rowsum_n++;
            avoidnow[i] = 1;
        }
        else avoidnow[i] = 0;
        
        if(avoid0[i] != avoidnow[i]) avoid0[i] = 1;
        if(avoid0[i]) rowsum++;
    }
    if(rowsum_n == agentnum) return -1;
    
    int change = 0;
    if(rowsum != agentnum) change =func(agentip,realip,agentnum,realnum,avoid0,realnow+1);
    else{
    change = func(agentip,realip,agentnum,realnum,avoidnow,realnow+1);
    if(change != -1) change++;
    }
    return change;
}



int main(){
    int agentnum;
    int realnum;
    int i,j;
    while(scanf("%d",&agentnum) != EOF){
        
        string agentip[agentnum];
        for(i = 0; i < agentnum; i++)
            cin >> agentip[i];
        
        int avoid0[agentnum];
        for(i = 0; i< agentnum;i++) avoid0[i] = 0;
        
        scanf("%d",&realnum);
        string realip[realnum];
        for(i = 0; i < realnum; i++){
            cin >> realip[i];
        }
        
        int change = func(agentip,realip,agentnum,realnum,avoid0,0);
        printf("%d",change);
    }
    return 0;
}