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

int main(){
    int n=0,m=0;
    int terminal=0;
    vector<string> a;
    vector<string> b;
    string temp;
    while(cin>>n){//录入数据
    for(int i=0;i<n;i++){
     cin>>temp;
     a.push_back(temp);        
    }
    cin>>m;
    for(int i=0;i<m;i++){
    cin>>temp;
    b.push_back(temp);   
    }       
  if(n==1) {//只有1个***
      for(int i=0;i<m;i++){
       if(a[0]==b[i]){
       cout<<-1<<endl;
       break;
       }
       else if(i==m-1)cout<<0<<endl;
      }
     
  } 
  else{  //多个***
    int count=0;//目前访问到第几个服务器
    int countnei=0;
    int max=-1;
    int whichone=-1;//目前在用哪个***服务器线路
    while(count!=m){//访问服务器没到最后则持续执行
    for(int i=0;i<n;i++){//***服务器轮流判断最长不需换路步数
        if(i==whichone)continue;
    for(int j=count;j<m;j++){ //判断步数取最长   
    if(a[i]==b[j]){
     if(max<j-count){
        max=j-count;
        whichone=i;
        if(j>countnei)countnei=j;}
        break;
    }
    else if(j==m-1){
        count=m;
        break;
    }
    }
    }    
    if(count!=m){terminal++;
    count=countnei;            
    }
    max=-1;
    }  
    cout<<terminal<<endl;
    terminal=0;
  }
    a.clear();
    b.clear();
    }
    return 0;
} 
这个问题主要是每次哪个判断***服务器能持续走最长（局部最优），然后再从换路的地方再算哪个
持续走最长，依次下去。贪心即最优，可用数学证明。

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

const int maxn=1000;
const int maxm=5000;

string Start[maxn];
bool flag[maxn];
string Target[maxm];

int main(){
	int n,m;
	cin>>n;
	for(int i=0;i<n;++i){
		cin>>Start[i];
	}
	cin>>m;
	for(int i=0;i<m;++i){
		cin>>Target[i];
	}
	sort(Start,Start+n);
	for(int i=0;i<n;++i){
		flag[i]=false;
	}
	if(n==1){
		for(int i=0;i<m;++i){
			if(Start[0]==Target[i]){
				cout<<-1<<endl;
				return 0;
			}
		}
		cout<<0<<endl;
		return 0;
	}
	int count=0,result=0;
	for(int i=0;i<m;++i){
		int left=0,right=n-1;
		int mid;
		while(left<=right){
			mid=(left+right)/2;
			if(Start[mid]==Target[i]){
				if(flag[mid]==false){
					flag[mid]=true;
					count++;
				}
				break;
			}else if(Start[mid]<Target[i]){
				left=mid+1;
			}else{
				right=mid-1;
			}
		}
		if(count==n){
			result++;
			count=1;
			for(int j=0;j<n;++j){
				flag[j]=false;
			}
			flag[mid]=true;
		}
	}
	cout<<result<<endl;
	return 0;
}

解题思路

代码

#include <cstdio>
#include <vector>
#include <set>
#include <string>

using namespace std;

int main() {
    int n, m;
    set<string> ips;
    // read in
    scanf("%d", &n);
    char buf[50];
    for (int i = 0; i < n; i++) {
        scanf("%s", buf);
        ips.insert(string(buf));
    }
    // comp
    set<string> S;
    string temp;
    int ret = 0;
    scanf("%d", &m);
    for (int i = 0; i < m; i++) {
        scanf("%s", buf);
        temp = buf;
        if (ret < 0)
            continue;
        if (ips.count(temp) <= 0) // other ip
            continue;
        if (ips.size() <= 1) {
            ret = -1;
            continue;
        }
        S.insert(temp);
        if (S.size() >= n) {
            S.clear();
            S.insert(temp);
            ret++;
        }
    }
    printf("%d\n", ret);
    return 0;
}

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std; int main()
{
	vector<string> agent, visit;
	int n, m;
	string temp;
	while (cin >> n)
	{
		int i;
		for (i = 0; i < n; i++)//输入代理服务器
		{
			cin >> temp;
			agent.push_back(temp);
		}
		cin >> m;
		for (i = 0; i < m; i++)//输入访问服务器顺序
		{
			cin >> temp;
			visit.push_back(temp);
		}
		//pos:需要改变代理的服务器位置，count：改变次数
		int pos = 0, count = 0;
		//find函数查找的迭代器
		vector<string>::iterator it, start = visit.begin(), flag;
		//需要改变代理的服务器IP
		string current = "";

		//关键代码段
		//当只有一台代理，且要访问自己时，无论如何都要自己代理自己
		if (n == 1 && find(visit.begin(),visit.end(),agent[0]) != visit.end())
			count = -1;
		else
		{
			while (pos != visit.size())
			{//每一趟查找在服务器中最后访问的代理服务器位置
				for (i = 0; i < n; i++)
				{
					if (agent[i] != current)
					{
						it = find(start, visit.end(), agent[i]);
						int p = it - visit.begin();//用int型判断大小(前后位置)
						if (p > pos)
						{
							pos = p;
							flag = it;
						}
					}
					else
						continue;
				}
				//下一趟查找从当前下个位置开始；查找除了当前IP的所有代理服务器位置
				if (pos != visit.size())
				{
					start = ++flag;
					current = visit[pos];
					count++;
				}
			}
		}
		cout << count << endl;
		agent.clear();
		visit.clear();
	}
	return 0;
}

/*代理服务器用ipn[n]存储，要访问的服务器用ipm[m]存储，对于每一个要访问的服务器，将其与每一个代理服务器比较，
，设置judge[n]全为0，若相同则对应judge[]为1，judge全1时，代表这一轮在此之前都使用这一服务器，并且此时代理服务器
ip与要访问服务器ip相同，要切换服务器，因此切换次数count++，然后judge[]重置为0，但是judge[当前服务器位置]为1
（视为切换服务器后碰到的第一个服务器）。ps：注意只有一个代理服务器时情况*/
#include<stdio.h>
(737)#include<string.h>
#define N 20
int reset(int a[],int n)
{
    for(int i=0;i<n;i++)
    a[i]=0;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
	char ipn[n][N];
	for(int i=0;i<n;i++)
	{
            scanf("%s",ipn[i]);
	 }
	int m;
	scanf("%d",&m);
	char ipm[m][N];
	for(int i=0;i<m;i++)
	{
	    scanf("%s",ipm[i]);
	 }
		
	int judge[n];
	reset(judge,n);
	int flag=0;					//判断judge是否变化 
	int count =0;					//转换服务器次数 
	int flag_n=0;					//n=1时发生匹配则跳出循环，输出-1 
	for(int i=0;i<m;i++)
	{
	    for(int j=0;j<n;j++)
	    {
		if(!strcmp(ipm[i],ipn[j])) 	//ipm[]与ipn[]匹配 ,则judge[]置1 
		{
		    judge[j]=1;					
		    flag=1;					
		 }
		if(flag==1)			//judge[]位变动则判断是否全为1（即是否全部轮过一遍） 
		{
		    if(n==1)
		    {
			printf("-1\n");
			flag_n=1; 
			break;
		     }
		    int flag2=0;				//有0说明还有未轮过，跳出 
	   	    for(int k=0;k<n;k++)
		    {
			if(judge[k]==0)
			{
			    flag2=1;
			    break;
			 } 
		     }
		    if(flag2==0)
		    {
			count++;
			reset(judge,n);
			judge[j]=1;
			flag=0; 
			break;				//有重复就对下一个ipm进行匹配，因为ipn各不相同，只可能匹配成功一个 
		     }
		    else flag=0; 					
		}
	    }
	    if(flag_n==1) break;	
	}
	if(flag_n==0) printf("%d\n",count);
	flag_n=0;
    }
    return 0;
}

#include <iostream>
#include <algorithm>
#include <map>

// AC in Mar 11th, 2020.
// Time: 4mm
using namespace std;
int main() {
    int n, m, answer = 0;
    cin>> n;
    string proxy[n];
    map<string, int> pair;
    int left = n;
    for (int i = 0; i < n; ++i) {
        cin>> proxy[i];
        pair.insert({proxy[i], 0}); // set to the  NOT FOUND state.
    }
    cin>> m;
    string server[m];
    for (int j = 0; j < m; ++j) {
        cin>> server[j];
    } // end of input

    for (int k = 0; k < m; ++k) {
        if (!binary_search(proxy, proxy + n, server[k])) { // not in the proxy list.
            continue;
        } else if (pair[server[k]] == 1) { // in the proxy list but value of pair is 1.
            continue;
        } else { // in the proxy list and value of pair is 0.
            pair[server[k]] = 1; // set to the FOUND state.
            left--;
        }

        if(left == 0) { // a circle.
            left = n - 1; // not including the current one.
            for (int i = 0; i < n; ++i) {
                pair[proxy[i]] = 0; // reset to the initial state.
            }
            pair[server[k]] = 1; // not including the current one.
            answer++; // all the proxy were found, so plus 1.
        }
    }

    if(n == 1 && binary_search(server, server + m, proxy[0])) {
        answer = -1; // special answer
    }
    cout<< answer;
    return 0;
}

#include <cstdio>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
    int n, m, cnt = 0;
    char buf[16];
    unordered_map<string, bool> proxy; //代理服务器列表及其是否出现记录表
    vector<string> server; //服务器队列
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s", buf);
        proxy[string(buf)] = false;
    }
    scanf("%d", &m);
    for (int i = 0; i < m; i++) {
        scanf("%s", buf);
        server.push_back(string(buf));
    }
    //代理服务器只有一台的情况下，查找服务器列表里边有没有代理服务器，有就无解返回
    if (n == 1) {
        string only_proxy = proxy.begin()->first;
        for (const auto& s : server) {
            if (s == only_proxy) {
                printf("-1\n");
                return 0;
            }
        }
    }
    //遍历请求服务器队列
    for(const auto& s: server){
        //此服务器为代理服务器之一时，开始对比服务器出现记录表
        if (proxy.find(s) != proxy.end()) {
            proxy[s] = true;
            bool all_true_flag = true;
            for (const auto& x : proxy) {
                if (!x.second) {
                    all_true_flag = false;
                    break;
                }
            }
            //所有服务器都出现过时，切换次数加一，当前遍历到的服务器为上一次切过来的代理服务器，此时应切出此服务器到另外一个代理服务器上
            if (all_true_flag) {
                cnt++;
                for (auto& i : proxy)
                    i.second = false;
                //因为是从当前服务器切出的，切入的下一个服务器不应为当前服务器，当前服务器出现计为true，其余计为false
                proxy[s]=true;
            }
        }
    }
    printf("%d\n", cnt);
    return 0;
}

/*
`    这是一道考察贪心策略的问题，每次遍历一遍proxy服务器数组，计算他们在当前的服务器序列中可以访问的最大服务数量
    下次继续遍历所有proxy服务器的话就直接从上次记录的最大可访问的服务器数下标开始再次遍历就行了
    注释写得比较详细，大家可以看看
*/
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int MAXM = 5010;
string proxy[MAXN];
string server[MAXM];
int main(){
	int n,m;
	while(cin>>n){
		for(int i=0;i<n;i++){
			cin>>proxy[i];
		}
		cin>>m;
		for(int i=0;i<m;i++){
			cin>>server[i];
		}
		int index = 0; //用来记录当前要从服务器数组访问的下标
		int count = -1;// 记录切换次数
		int flag = 1; // 记录proxy服务器访问服务器的成功标志
		while(flag==1&&index!=m){
			int max = 0; // 记录遍历从index位置开始遍历一遍proxy服务器后可访问的服务器数量
			for(int i = 0 ;i<n;i++){
				int j = index; // 服务器的位置从上次可以访问的最大数量的下标开始
				while(proxy[i]!=server[j]&&j<m){
					j++;
				}
				if(j-index>max){
					max = j-index;
				}
			} 
			count++; // 切换次数增加
			if(max == 0){ //如果遍历一遍proxy服务器但是最大可访问数量为0，则认为无解 
				flag = 0;
			}else{
				index+=max;
			}
		}
		if(flag){ 
			cout<<count<<endl;
		}else{ 
			cout<<-1<<endl;
		}
	}
    return 0;
}

#include <stdio.h>
int main() {
    int n;
    while(scanf("%d",&n)!=EOF) {
        int m;
        unsigned proxy[1000];
        unsigned server[5000];
        unsigned a,b,c,d;
        for(int i=0; i<n; i++) {
            scanf("%d.%d.%d.%d",&a,&b,&c,&d);
            proxy[i]=a*256*256*256+b*256*256+c*256+d;
        }
        scanf("%d",&m);
        for(int i=0; i<m; i++) {
            scanf("%d.%d.%d.%d",&a,&b,&c,&d);
            server[i]=a*256*256*256+b*256*256+c*256+d;
        }
        int count=0;
        if(n==1) {
            for(int i=0; i<m; i++) {
                if(server[i]==proxy[0]) {
                    count=-1;
                    break;
                }
            }
        } else {
            int mark_proxy[1000]= {0};
            int mark=0;
            for(int i=0; i<m; i++) {
                for(int j=0; j<n; j++) {
                    if(proxy[j]==server[i]) {
                        if(mark_proxy[j]==0) {
                            if(mark==n-1) {
                                count++;
                                for(int k=0; k<n; k++) {
                                    mark_proxy[k]=0;
                                }
                                mark=0;
                            }
                            mark_proxy[j]=1;
                            mark++;
                        }
                        break;
                    }
                }
            }
        }
        printf("%d\n",count);
    }
    return 0;
}

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

int main(){
	int m,n;
	unsigned int a,b,c,d;
	unsigned int vec[1001];
	unsigned int exm[2000];
	map<unsigned int,bool> ma;//标记代理ip是否被统计

	while(scanf("%d",&n)!=EOF && n!=0){
		memset(vec,0,sizeof(vec));
		memset(exm,0,sizeof(exm));
		for(int i=0;i<n;i++){
			scanf("%d.%d.%d.%d",&a,&b,&c,&d);
			vec[i] = ((a<<8|b)<<8|c)<<8|d;   //转化为unsigned int类型整数表示ip
		}
		sort(vec,vec+n);

		scanf("%d",&m);
		for(int i=0;i<m;i++){
			scanf("%d.%d.%d.%d",&a,&b,&c,&d);
			exm[i] = ((a<<8|b)<<8|c)<<8|d;   //转化为unsigned int类型整数表示ip
		}
		//输入结束

		//贪心算法
		ma.clear();
		int temp=n;
		int ans =0;
		for(int i=0;i<m;i++){   //逐一考察每个服务器
			if(binary_search(vec,vec+n,exm[i])){  //如果该服务器ip是代理ip之一

				//贪心找到能访问最多服务器的代理ip
				if(!ma[exm[i]]){      //该代理ip未被统计
					if(temp==1){          //且其他代理ip都以被统计，那么该代理IP为目前选定的代理ip地址
						ans++;
						ma.clear();
						temp=n;
					}
					ma[exm[i]]=true;
					temp--;
				}
			}
		}

		//返回-1情况
		if(n==1 && ans > 0) {
			cout<<-1<<endl;
			continue;
		}
		cout<<ans<<endl;
	}

	return 0;
}

//典型贪心算法
//要找到访问服务器地址中最后出现的***服务器
#include<iostream>
#include<string>
#include<string.h>
#include<vector>
using namespace std;
int main(){
    int n1,n2,num=0,count=0,a[9000];
    memset(a,0,sizeof(a));
    while(cin>>n1){
        string str;
        vector<string> vi;
        vector<string> v;
//存***服务器
        for(int i=0;i<n1;i++){
            cin>>str;
            vi.push_back(str);
        }
//存访问服务器
        cin>>n2;
        for(int i=0;i<n2;i++){
            cin>>str;
            v.push_back(str);
        }
        int num;
//遍历访问服务器
        for(vector<string>::iterator it=v.begin();it!=v.end();it++){
//a[i]用来记录***服务器是否出现过
            for(int i=0;i<vi.size();i++){
                if(*it==vi[i]){
                    a[i]=1;
                    num=i;
                }
            }
            int j=0;
//找到最远的***服务器，此时更换***服务器
            if(vi.size()>1){
                for(;j<n1;j++){
                    if(!a[j])
                        break;
                }
                if(j==n1){
                    memset(a,0,sizeof(a));
                    a[num]=1;
                    count++;
                }
            }
//如果只有一个***服务器并出现在访问服务器里，则没有办法
            else if(a[0]==1&&vi.size()==1)
                count=-1;        
        }
        cout<<count;
    }
    return 0;
}

#include <iostream>
#include <string>

//此题的思路是贪心算法，先遍历每个***服务器，看***服务器能访问到的最大步长，记录下来，
//下个***继续从该位置访问，直到所有的服务器都访问完
using namespace std;
int main() 
{
    int n, m, count = 0;//count代表转换次数
    cin >> n;
    string pro[5000], ser[5000];//pro为***服务器，ser为待访问服务器
    for (int i = 0; i<n; i++) 
    {
        cin >> pro[i];
    }
    cin >> m;
    for (int j = 0; j<m; j++) 
    {
        cin >> ser[j];
    }
    int index = 0, flag = 1;//index为当前访问到的服务器，flag为是否遍历成功
    while (flag&&index != m) 
    { 
        //当游标index遍历到m时表示遍历结束
        int max = 0;//代表一个***服务器能访问到的最远步长
        for (int i = 0; i<n; i++) 
        {
            int j = index;//从游标位置开始遍历 
            while((pro[i]!=ser[j])&&(j<m)) 
                j++;//条件不满足之前一直遍历服务器 
            if(j-index>max)//寻找当前更换***点能到达的最大步长
                max=j-index; //j-index为步长
        }
        if (max == 0) 
            flag = 0;//代表遍历失败
        count++;
        index += max;//下个***从此处开始遍历 ，index每加一次max代表一个***走到了最大步长 ，count+1，直到index=m
    }
    if (flag) 
        cout << count - 1 << endl;//第一次不算转换
    else 
        cout << -1 << endl;
    return 0;
}

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
    string s[1000];
    string s1[5000];
    int n,m;
    cin>>n;
    for(int i=0;i<n;i++)    cin>>s[i];
    cin>>m;
    for(int i=0;i<m;i++)    cin>>s1[i];
    int flag=0,change=0,count=0,j,max;
    while(flag<m)
    {
         max=0;
        for(int i=0;i<n;i++)
        {
            j=flag;
            count=0;
            while(j<m&& s[i]!=s1[j])
            {
                count++;
                j++;
            }    
            if(count>max)    max=count;
        }
        if(max==0)    break;
        flag+=max;
        change++;
    }
    if(max==0)    cout<<"-1";
    else cout<<change-1;    
}
 

/*
贪心算法，每次选择***服务器能访问的最大深度，转换次数加一，下次迭代从最大深度开始
*/
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
//    freopen("input.txt","r",stdin);
    vector<string> nn,mm;
    vector<string>::iterator it,index,start,max;
    int n,m; 
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++)
        {
            string s;cin>>s;
            nn.push_back(s);
        }
    scanf("%d",&m);
    for(int i=0;i<m;i++)
       {
           string s;cin >> s;
           mm.push_back(s);
       }
       max = start = mm.begin();
    int res = 0,flag = 0;
    while(res<=m)
    {
        for(int i=0;i<n;i++)
        {
            index=find(start,mm.end(),nn[i]);
            if(index==mm.end())
            {
                cout << res << endl;
                flag = 1;
                break;
            }
             if(max<index)
                 max = index;
        }
        if(index==mm.end())
            break;
        start = max;
        res++;
    }
    if(flag==0)
    cout << -1 << endl;
    flag = 0;
    }
    
    return 0;
}

这道题花了好多时间,来看大家讨论才发现自己之前把题目理解错了,一开始以为***服务器每个只能使用一次的,所以觉得贪心好像不太对.如果***服务器可以重复使用的话,贪心就是对的咯,因为假设x1,x2,...xn这个访问序列是最优的(n最小)且y1放在第一个访问可以pass掉的服务器比x1多,那么用y1代替掉x1后,会比x1pass掉更多的服务器,所以结果至少不会差.

include <iostream>

include <string>

include <vector>

include <map>

include <queue>

include <stack>

include <algorithm>

include <cstdio>

include <cstring>

include <cstdlib>

include <cmath>

using namespace std;

int n, m;

void solve_04 ( vector<string> & pxy, vector<string> & ser )
{
int i, j = 0, k = 0, ans = 0;
while ( true )
{
int t = k;
for ( i = 0; i < pxy.size ( ); i ++ )
{
j = t;
while ( j < m && pxy[i] != ser[j] ) j ++;
if ( j == m )
{
cout << ans << endl;
return ;
}
k = max ( k, j );
}
ans ++;
///如果某轮循环k没有前进,说明只有一个***服务器,且服务器中也有它
if ( t == k )
{
cout << -1 << endl;
return ;
}
}
return ;
}

int main ( )
{
while ( cin >> n )
{
int i;
vector< string > pxy( n, "" );
for ( i = 0; i < n; i ++ )
cin >> pxy[i];
cin >> m;
vector< string > ser( m, "" );
for ( i = 0; i < m; i ++ )
cin >> ser[i];
solve_04 ( pxy, ser );
}
return 0;
}

#include <stdio.h>
#include <string.h>
#define MAX_SIZE 5000
#define MAX_IP 1000
#define IP_LENGTH 16
int main(int argc, char *argv[])
{
    int N,M,i = 0,j = 0,s = 0;
    char proxy_ip[MAX_IP][IP_LENGTH],server_ip[MAX_SIZE][IP_LENGTH];
    int proxy_sign[MAX_IP] = {0},server_sign[MAX_SIZE] = {-1};
    while(scanf("%d",&N) != EOF)
    {
        s = 0;
        for(i = 0;i < N;i++)
        {
            scanf("%s",proxy_ip[i]);proxy_sign[i] = MAX_SIZE;
        }
        scanf("%d",&M);
        for(i = 0;i < M;i++)
        {
            scanf("%s",server_ip[i]);server_sign[i] = -1;
            for(j = 0;j < N;j++)
                if(server_ip[i][0] == proxy_ip[j][0] && server_ip[i][1] == proxy_ip[j][1] 
                    && strcmp(server_ip[i],proxy_ip[j]) == 0)
                {
                    if(N == 1)
                        s = 1;
                    proxy_sign[j] = proxy_sign[j] > i ? i : proxy_sign[j];
                    server_sign[i] = j;break;    
                }
        }
        int flag = 0,count = -1,k = 0,max_site = 0;
        while(flag == 0 && s == 0)
        {
            flag = 1;max_site = proxy_sign[0];
            for(i = 1;i < N;i++)
            {
                if(max_site < proxy_sign[i])
                    max_site = proxy_sign[i];
                if(max_site == MAX_SIZE)
                    break;
            }
            int p = max_site;
            for(k = 0;k < N;k++)
            {
                for(j = p;j < M;j++)
                    if(server_sign[j] == k)
                    {
                        proxy_sign[k] = j; break;
                    }
                if(j == M)
                    proxy_sign[k] = MAX_SIZE;
            }
            if(max_site != MAX_SIZE)
                flag = 0;
            count++;
            //for(i = 0;i < N;i++)
            //    printf("%d ",proxy_sign[i]);
            //printf("\n");
        }
        printf("%d\n",count);
    }
    return 0;
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		while(in.hasNext()){
			/*执行数据输入
			 * n:***服务器个数
			 * arr1:***服务器地址数组
			 * m:要访问的服务器个数
			 * arr2:要访问的服务器地址数组
			 */
			int n=in.nextInt();
			String[] arr1=new String[n];
			for (int i=0;i<n;i++){
				arr1[i]=in.next();
			}
			int m=in.nextInt();
			String[] arr2=new String[m];
			for (int i=0;i<m;i++){
				arr2[i]=in.next();
			}
			//设置一个二维集合用于存放n*m的比较结果
			List<ArrayList<Integer>> list=new ArrayList<ArrayList<Integer>>();
			for (int i=0;i<n;i++){//对于每一个***地址而言
				ArrayList<Integer> list2=new ArrayList<Integer>();//代表着第i***地址无法通过的访问地址的索引集合
				for (int j=0;j<m;j++){//和即将访问的地址进行一一比较
					if (arr1[i].equals(arr2[j])){//如果两者相同，即代表不能通过，需要换一个***地址
						list2.add(j);//将不能通过的访问地址的索引加入到集合中
					}
				}
				list.add(list2);//将索引集合加入到总集合中
			}
			//输出结果
			System.out.println(goFurther(list, arr2.length));
		}
	}
	//用于处理数据，得出最少更换次数
	public static int goFurther(List<ArrayList<Integer>> list,int len){
		int p=0;//代表已经访问到了arr2的具体某个位置
		int times=0;//代表已经更换了***地址的次数
		while(p!=len){//设置一个循环条件，实则用不到该条件，可以设置成true
			times++;//进行一次更换
			int max=0;//设置max为0，即第times次之前所能访问的最多的arr2中的地址长度
			//找出所有的***地址中，谁能在目前的情况下访问的最多
			for (int i=0;i<list.size();++i){//对于list中的每一个子list2的第一个元素，都代表着第i个***地址一开始所能访问的最远距离
				ArrayList<Integer> list2=list.get(i);//得到这个子list2
				if (list2.size()!=0){//如果该集合不为空
					int k=list2.get(0);//得到该集合的第一个元素
					if (k>max){
						max=k;
					}
				}
			}
			if (max==p){//如果访问的最远距离恰好就是目前已经达到的最远距离，即已经无法继续向后面访问了，代表没有符合要求的安排方式
				return -1;
			}
			p=max;//否则则将已经达到的最远距离赋值给p
			//用于清除集合中所有在已经达到的最远距离之前的无用数据，即二维集合中所有小于max的数据给予清除
			for (int i=0;i<list.size();++i){
				int size=list.get(i).size();//这里之所以将size赋值给一个变量，是因为后面对子list2进行处理的时候会改变它原有的长度
				for (int j=0;j<size;j++){
					if (list.get(i).get(0)<max){//每一次都会导致remove掉索引为0的数据，所以只要重复get(0)即可
						list.get(i).remove(0);
					}else{
						//如果能达到的最远距离不在是已经达到的距离，那么remove就可以结束了，因为子集合list2必然是从小到大排序的
						break;
					}
					if (list.get(i).size()==0){//如果一个子集合list2为空了，说明它可以一路畅通无阻地访问到最后，此时的更换次数time即为符合要求的times
						return times;
					}
				}
			}
		}
		//该return实则没有意义，因为返回值必然会在while中已经得到。
		return times;
	}
}