pat-树剩余图部分03 04

最新推荐文章于 2024-06-02 01:22:58 发布

江船夜雨听笛

最新推荐文章于 2024-06-02 01:22:58 发布

阅读量163

点赞数

分类专栏： pat-复习文章标签：队列算法 pivot

本文链接：https://blog.csdn.net/m0_45359314/article/details/113786788

版权

pat-复习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文探讨了深度优先搜索（DFS）和广度优先搜索（BFS）在解决图和树结构问题中的核心策略。通过多个实例展示了它们在构建二叉树、最小生成树、最短路径、查找最大/最小堆等问题中的应用。同时，还讨论了如何结合这些算法进行剪枝操作以优化解决方案。

摘要由CSDN通过智能技术生成

//1009
#include<bits/stdc++.h>
using namespace std;
struct node{
int key,le,index; 	
 };
 vector<int> in,post;
 vector<node> pre,lev[35];
 int maxle=0;
 void dfs(int root,int inll,int inrr,int index,int le){
 	//end
 	if(inll>inrr) return;
 	if(le>maxle) maxle=le;
 	int i=inll;
 	while(in[i]!=post[root]&&i<=inrr)i++;
 	pre.push_back({post[root],le,index});
 	dfs(root-(inrr-i)-1,inll,i-1,2*index+1,le+1 );
 	dfs(root-1,i+1,inrr,2*index+2,le+1);
 }
 bool cmp1(node&a,node&b){
 	return a.index<b.index;
 }
 bool cmp2(node&a,node&b){
 	return a.index>b.index;
 }
 int main(){
 	int n,_1;
 	scanf("%d",&n);
 	for(int i=0;i<n;i++){
 		scanf("%d",&_1);
 		in.push_back(_1);
	 }
	 	for(int i=0;i<n;i++){
 		scanf("%d",&_1);
 		post.push_back(_1);
	 }
	 dfs(post.size()-1,0,in.size()-1,0,0);
	 for(int i=0;i<pre.size();i++){
	 	lev[pre[i].le].push_back(pre[i]);
	 }
	 for(int i=0;i<=maxle;i++){
	 	if(i%2==0){
	 		sort(lev[i].begin(),lev[i].end(),cmp2);
		 }else{
		 	sort(lev[i].begin(),lev[i].end(),cmp1);
		 }
	 }
	 int flag=1;
	 for(int i=0;i<=maxle;i++){
	 	for(int j=0;j<lev[i].size();j++){
	 		if(flag!=1) {
			 printf(" ");
			 //根本就没有进去的机会你要先让他进去 钥匙放里边门锁上了永远也进不， 先锁型钥匙放外面 
			 }
			 printf("%d",lev[i][j].key);
			 flag=0;
		 }
	 }
	 return 0;
 }

//1030
#include<bits/stdc++.h>
using namespace std;
int v[600][600],a[600][600];
const int inf=1000000000;
vector<int> pre[600],temp,ans;
int ss,dd,maxd=100000000000,maxa=10000000000,dist[600],visit[600];
void dfs(int d){
	//end
	if(d==ss){
		temp.push_back(d);int sumd=0,suma=0;
		for(int i=1;i<temp.size();i++){
			sumd+=v[temp[i-1]][temp[i]];//双索引 1
			suma+=a[temp[i-1]][temp[i]];
		}
		if(sumd<maxd){
			maxd=sumd;
			ans=temp;
			maxa=suma;
		}else if(sumd==maxd&&suma<maxa){//else biyk uhmmyyxdxymm 3
			maxa=suma;
			ans=temp;
		}
		temp.pop_back();//忘写 2
		return; 
	}
	temp.push_back(d);
	for(int i=0;i<pre[d].size();i++){
		dfs(pre[d][i]);
	}
	temp.pop_back();//忘写 
}
int main(){
	fill(v[0],v[0]+600*600,inf);
	fill(a[0],a[0]+600*600,inf);
	fill(dist,dist+600,inf);//600*600 bu xu 0
	int n,m,_1,_2,_3,_4;
	scanf("%d%d%d%d",&n,&m,&ss,&dd);
	for(int i=0;i<m;i++){
		scanf("%d%d%d%d",&_1,&_2,&_3,&_4);
		a[_1][_2]=a[_2][_1]=_4;
		v[_1][_2]=v[_2][_1]=_3;
	}
	dist[ss]=0;
	for(int i=0;i<n;i++){
		int u=-1,min=inf;
		for(int j=0;j<n;j++){
			if(visit[j]==0&&dist[j]<min){
				min=dist[j];
				u=j;
			}
		}
		if(u==-1) break;
		visit[u]=1;
		for(int vv=0;vv<n;vv++){
			if(visit[vv]==0&&v[u][vv]!=inf){
				if(dist[vv]>dist[u]+v[u][vv]){
					dist[vv]=dist[u]+v[u][vv];
					pre[vv].clear();//5
					pre[vv].push_back(u);
				}else if(dist[vv]==dist[u]+v[u][vv]){ //4
					pre[vv].push_back(u);
				}
			}
		}
	}
	dfs(dd);
	for(int i=ans.size()-1;i>=0;i--){
		if(i!=ans.size()-1) printf(" ");
		printf("%d",ans[i]);
	}
	printf(" %d",maxd);
	printf(" %d",maxa);
	return 0;
	
}

//1130
#include<bits/stdc++.h>
using namespace std;
struct node{
	string a;
	int ll,rr;
}v[100];
int flag=1,flag1=1;
void dfs(int root){
	//end
	if(v[root].ll!=-1&&v[root].rr!=-1){
		if(flag==0){
	 printf("(");dfs(v[root].ll);cout<<v[root].a;dfs(v[root].rr) ;printf(")");}
	 else {
	 	flag=0; flag1=0;
	//dfs(v[root].ll);printf("%s",v[root].a.c_str());dfs(v[root].rr) ;
	dfs(v[root].ll);cout<<v[root].a;dfs(v[root].rr) ;
	//flag=0;注意如果有递归他会先执行递归如果后面要用钥匙要放在递归上面 
    }
	 }
	 //如果你是老师你会增么出测试点（坑点） 
	else if(v[root].rr!=-1) {//单链时这里也会错   也要把括号去掉所以不如直接string 然后最后判断
	 if(flag1==0){
	printf("(");cout<<v[root].a;dfs(v[root].rr);printf(")");}
	else{
		flag1=0;
		flag=0;//两把钥匙都要开 
		cout<<v[root].a;dfs(v[root].rr);
	}
	}//需要输入内容 
	else if(v[root].ll==-1&&v[root].rr==-1) cout<<v[root].a;
}
int have[100];
int main(){
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		cin>>v[i].a;
		scanf("%d",&v[i].ll);
		scanf("%d",&v[i].rr);
		if(v[i].ll!=-1)
		have[v[i].ll]=1;//-1居然用标记上
		 if(v[i].rr!=-1)
		have[v[i].rr]=1;
	}
	int j=1;//编号是从一开始 
	while(have[j]==1) j++;
	dfs(j);
	return 0;
/*	4
	- -1 2
	2 -1 3
	* -1 4
	3 -1-1 */
}

//1138
#include<bits/stdc++.h>
using namespace std;
vector<int> pre,in;
map<int,int> pos;
int flag=0;
void dfs(int root,int inll,int inrr){
	//end
	if(inll>inrr) return;
	if(flag==1) return;
    int i=pos[pre[root]];//中序中的位置 
    if(flag==1) return;
	dfs(root+1,inll,i-1);
	if(flag==1) return;
	dfs(root+i-inll+1,i+1,inrr);
	if(flag==1) return;
	printf("%d",pre[root]);
	flag=1;
}
int main(){
	int n,_1;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&_1);
		pre.push_back(_1);
	}
	for(int i=0;i<n;i++){
		scanf("%d",&_1);
		in.push_back(_1);
		pos[_1]=i;
	}
	dfs(0,0,n-1);
	return 0;
}

//1147
#include<bits/stdc++.h>
using namespace std;
vector<int> lev,post;
void dfs(int index){
	//end
	if(index>lev.size()-1) return;
	dfs(2*index+1);
	dfs(2*index+2);
	post.push_back(lev[index]);
}
int main(){
	int m,n,_1;
	scanf("%d%d",&m,&n);
	for(int i=0;i<m;i++){
		lev.clear();
		post.clear();
		for(int j=0;j<n;j++){
			scanf("%d",&_1);
			lev.push_back(_1);
		}
		dfs(0);
		int min=1,max=1;
		for(int q=1;q<lev.size();q++){
			if(lev[(q-1)/2]>lev[q]) min=0;
			if(lev[(q-1)/2]<lev[q]) max=0;
		} 
		if(min==0&&max==0) printf("Not Heap\n");
		else if(min==1) printf("Min Heap\n");
		else printf("Max Heap\n");
		for(int k=0;k<post.size();k++){
			if(k!=0) printf(" ");
			printf("%d",post[k]);
		}
		printf("\n");
	}
	return 0;
}

//最后与dfs剪枝合在一起做一个总结 
//1155
#include<bits/stdc++.h>
using namespace std;
vector<int>lev,ans[2050],temp;
int cnt=0;
int flag=0;
void dfs(int index){
	//end
	if(2*index+1>lev.size()-1&&2*index+2>lev.size()-1){//不应该用或，应该是且，左右都没有元素了才能这么干，如果左边有元素就停了不行 
			if(index>=lev.size())  flag=1;//有封就有有解，他是从右到左否则后面就进不来了 
			//if(index>=lev.size()) return;//终点不确定所以当不是终点时也会popback导致错误，他是先判断右面有没有在判断左面有没有，特殊情况就是右面没有时有这个条件也会进来导致错误 
			if(index<lev.size()){//终点已经确定时无所谓 
			temp.push_back(lev[index]);
			ans[cnt++]=temp;
			//temp.pop_back();//只有确定终点后才pop——back终点不确定是最好用两个pop——back 
			flag=0;
		     }
			return; 
	}
	/*if(index>lev.size()-1){
		ans[cnt++]=temp;//左边超了以后右边也会超入了两次 
		return;
	}*/
	temp.push_back(lev[index]);
	dfs(2*index+2);
	if(flag==0)
	temp.pop_back();
	dfs(2*index+1);
	temp.pop_back();
	

}
int main(){
	int n,_1;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&_1);
		lev.push_back(_1);
	}
	dfs(0);
	for(int i=0;i<cnt;i++){
		for(int j=0;j<ans[i].size();j++){
			if(j!=0) printf(" ");
			printf("%d",ans[i][j]);
		}
		printf("\n");
	}
	int max=1,min=1;
	for(int i=1;i<lev.size();i++){
		if(lev[(i-1)/2]>lev[i])min=0;
		if(lev[(i-1)/2]<lev[i])max=0;
	}
	if(max==0&&min==0)
	printf("Not Heap");
	else if(min==1) printf("Min Heap");
	else printf("Max Heap");
	return 0;
}

//1003
#include<bits/stdc++.h>
using namespace std;
int d[600][600],a[600],dist[600],visit[600];//a--0 
vector<int> pre[600],temp,ans;
int ss,ee,cnt=0,maxb=0;
const int inf =1000000000;
void dfs(int dd){
	//end
	if(dd==ss){
		temp.push_back(dd);
		cnt++;
		int tempb=0;
		for(int i=0;i<temp.size();i++){
			tempb+=a[temp[i]];
		}
		if(tempb>maxb){
			maxb=tempb;
		}
		temp.pop_back();
		return;
	}
	temp.push_back(dd);
	for(int i=0;i<pre[dd].size();i++){
		dfs(pre[dd][i]);
	}
	temp.pop_back();
}
int main(){
	fill(d[0],d[0]+600*600,inf);
	fill(dist,dist+600,inf);
	int n,m,_1,_2,_3;
	scanf("%d%d%d%d",&n,&m,&ss,&ee);
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	for(int i=0;i<m;i++){
		scanf("%d%d%d",&_1,&_2,&_3);
		d[_1][_2]=d[_2][_1]=_3;
	}
	dist[ss]=0;
	for(int i=0;i<n;i++){
		int u=-1,min=inf;
		for(int j=0;j<n;j++){
			if(visit[j]==0&&dist[j]<min){
				u=j;
				min=dist[j];
			}
		}
		if(u==-1) break;
		visit[u]=1;
		for(int v=0;v<n;v++){
			if(visit[v]==0&&d[u][v]!=inf){
				if(dist[v]>dist[u]+d[u][v]){
					dist[v]=dist[u]+d[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}else if(dist[v]==dist[u]+d[u][v]){
					pre[v].push_back(u);
				}
			}
		}
	}
	dfs(ee);
	printf("%d %d",cnt,maxb);
	return 0;
}

//1021
#include<bits/stdc++.h>
using namespace std;
int visit[10010],maxle=0;//crt
vector<int> a[10010],b1,b2;
set<int> ans;
void dfs(int root,int le,vector<int> &b11){//若想存储在传入参数里需要引用 
	//end
	if(le>maxle){
		maxle=le;
		b11.clear();
		b11.push_back(root);
	}else if(maxle==le){
		b11.push_back(root);
	}
	visit[root]=1;//需不需要标记需不需要撤标记 
	for(int i=0;i<a[root].size();i++){
		if(visit[a[root][i]]==0){
			dfs(a[root][i],le+1,b11);
		}
	}
	
}
int main(){
	int n,_1,_2;
	scanf("%d",&n);
	for(int i=0;i<n-1;i++){
		scanf("%d%d",&_1,&_2);
		a[_1].push_back(_2);
		a[_2].push_back(_1);
	}
	int cnt=0;
	for(int i=1;i<=n;i++){
		if(visit[i]==0){
			dfs(i,0,b1);
		cnt++;
		}
	}
	if(cnt!=1){
		printf("Error: %d components",cnt);
	}else {
		fill(visit,visit+10010,0);
		dfs(b1[0],0,b2);
	
	for(int i=0;i<b2.size();i++){
		ans.insert(b2[i]);
	}
	for(int i=0;i<b1.size();i++){
		ans.insert(b1[i]);
	}
	for(auto it=ans.begin();it!=ans.end();it++){
		printf("%d\n",*it);
	}
    }
    return  0;
}

//1034
#include<bits/stdc++.h>
using namespace std;
int a[2010][2010],visit[2010],w[2010];//要乘以2，n是边数 
map<string,int> si;
map<int,string> is;
int cnt=1,n;//1--
int ff(string k){
	if(si[k]==0){
		si[k]=cnt;
		is[cnt]=k;
		cnt++;
	}
		return si[k];
}
struct node{
	int he;
	int num;
};
int tempnum=0,tempw=0,k;
vector<node> ans;//应该是一维大小 
int nc=0;
bool cmp(node&a,node&b){
	return is[a.he]<is[b.he];
}
void dfs(int root,int &head){
	//end
	if(w[root]>w[head]){//终点不明确放外面判断比放里面容易判断 
		head=root;
	}
	tempnum++;
/*	if(tempnum>2&&tempw>k){
		ans[nc].he=head;
		ans[nc].num=tempnum;//重复赋值最终得正确答案 
	}*/ //在这里面收集这个信息不知道什么时候是终点不如等它结束最后收集 
	visit[root]=1;
	for(int i=1;i<=si.size();i++){
		if(a[root][i]>0){//首先要有权   边标记 
		tempw+=a[root][i];
			a[root][i]=a[i][root]=0;//即时标记 //两条边都要去无向图有两个标记 //位置不对加完就要去标记，非0即标记 
		if(visit[i]==0){//点标记 
			//a[root][i]=a[i][root]=0;//即时标记 //两条边都要去无向图有两个标记 
			dfs(i,head);
		}
	    }
	}
}
int main(){
	scanf("%d%d",&n,&k);
	string _1,_2;
	int _3;
	for(int i=0;i<n;i++){
		cin>>_1>>_2>>_3;
		a[ff(_1)][ff(_2)]+=_3;
		a[ff(_2)][ff(_1)]+=_3;
		w[ff(_1) ]+=_3;
		w[ff(_2) ]+=_3;
	}
	int g=0;
	for(int i=1;i<=si.size();i++){
		tempnum=0;tempw=0;int head=0;//dfs里面没有crt 
	if(visit[i]==0){
	dfs(i,head);
	if(tempnum>2&&tempw>k){
		/*ans[nc].he=head;
		ans[nc].num=tempnum;//重复赋值最终得正确答案 */
		ans.push_back({head,tempnum});
	}
	}
	}
	sort(ans.begin(),ans.end(),cmp);
	printf("%d\n",ans.size());
	for(int i=0;i<ans.size();i++){
		printf("%s %d\n",is[ans[i].he].c_str(),ans[i].num );
	}
	return 0;
	
	
}

//1072
#include<bits/stdc++.h>
using namespace std;
int a[1019][1019],dist[1019],visit[1019];//crt
const int inf=1000000000;
int n;
int gswit(string a){
	if(!isdigit(a[0])){
	string b=a.substr(1);
	return n+stoi(b);
    }else{
    	return stoi(a);
	}
}
int main(){
	fill(a[0],a[0]+1019*1019,inf);
	int m,k,ds,maxg,flag=0;
	double av=inf,maxav,maxmind=0;//maxmin输出应该是double型它的真正类型还要关注输出是什么 
	string _1,_2;
	int _3;
	scanf("%d%d%d%d",&n,&m,&k,&ds);
	for(int i=0;i<k;i++){
		cin>>_1>>_2;
		scanf("%d",&_3);
		a[gswit(_1)][gswit(_2)]=a[gswit(_2)][gswit(_1)]=_3;
	}
	for(int i=1;i<=m;i++){
		fill(dist,dist+1019,inf);
		//fill(visit,visit+1019,inf);
		fill(visit,visit+1019,0);//visit应该用0填充 
		dist[n+i]=0;
		//路径都不用记录只要个距离
		for(int p=1;p<=n+m;p++){//需要加入其他几个后选点 
			int u=-1,min=inf;
			for(int j=1;j<=n+m;j++){
				if(visit[j]==0&&dist[j]<min){
					min=dist[j];
					u=j;
				}
			}
			if(u==-1) break;
			visit[u]=1;
			for(int v=1;v<=n+m;v++){
				if(visit[v]==0&&a[u][v]!=inf){
					if(dist[v]>dist[u]+a[u][v]){
						dist[v]=dist[u]+a[u][v];
					}
				}
			}
		}
		int mind=inf,maxd=0,sum=0;
		for(int q=1;q<=n;q++){
			sum+=dist[q];
			if(dist[q]<mind){
				mind=dist[q];
			}
			if(dist[q]>maxd){
				maxd=dist[q];
			}
		}
		double tempav=sum*1.0/n;
		if(maxd>ds){
		continue;	
		}
		if(mind>maxmind){
			maxmind=mind;
			maxg=i;
			maxav=tempav;
			av=maxav;
			flag=1;
		}else if(maxmind==mind&&tempav<av){
			maxmind=mind;
			maxg=i;
			maxav=tempav;
			av=maxav;
			flag=1;
		}
		
	}
	if(flag==0)
	printf("No Solution");
	else {
		printf("G%d\n",maxg);
		printf("%.1lf %.1lf",maxmind,maxav);//注意格式中间没加空格 
	}
	return 0;
}

//1013
#include<bits/stdc++.h>
using namespace std;
int a[1010][1010],visit[1010],n;
void dfs(int ss){//yk bikl  ce ui uu ju
	//end
	visit[ss]=1;
	for(int i=1;i<=n;i++){
		if(visit[i]==0&&a[ss][i]>0){
			dfs(i);
		}
	}
}
int main(){//没加() 
int m,k,_1,_2,_3;
scanf("%d%d%d",&n,&m,&k);
for(int i=0;i<m;i++){
	scanf("%d%d",&_1,&_2);
	a[_1][_2]=a[_2][_1]=1;
}

for(int i=1;i<=k;i++){
	fill(visit,visit+1010,0);
	int cnt=0;
	scanf("%d",&_3);
	visit[_3]=1;
	for(int i=1;i<=n;i++){
		if(visit[i]==0){//从没被访问的开始 
         dfs(i);
        cnt++;
		}
    }
	printf("%d\n",cnt-1);	
}
return 0;
}

//1076
#include<bits/stdc++.h>
using namespace std;
int a[1010][1010],visit[1010];//visit crt
struct node{
	int index,le;
};
int n,ll,cnttt;
void bfs(int ss){//bfs 不是递归实现的 
    queue<node> grxi;
	grxi.push({ss,0});
	visit[ss]=1;//int cnt=0;
	cnttt=0;
	while(!grxi.empty()){//队列必须用结构体控制层数，因为统一控制会因为一度关系的的节点数没有pop遍历完就导致层数错误相加而错误 
		node temp=grxi.front();
		grxi.pop();
		for(int i=1;i<=n;i++){ 
			if(visit[i]==0&&a[temp.index][i]>0&&temp.le<ll){//不能大于1本身就是1 大于0 
				visit[i]=1;//标记所有一度关系避免影响二度关系回来的问题 
				cnttt++;
				grxi.push({i,temp.le+1});
			}
			
		}
		//cnt++;
		
	}
	
}
int main(){
	int _1,_2;
	scanf("%d%d",&n,&ll);
	for(int i=1;i<=n;i++){
		scanf("%d",&_1);
		for(int j=0;j<_1;j++){
			scanf("%d",&_2);//有向图 正反反正意义不同 
			a[_2][i]=1;
		}
	}
	scanf("%d",&_1);
	for(int i=0;i<_1;i++){
		scanf("%d",&_2);
		fill(visit,visit+1010,0);
		bfs(_2);
		printf("%d\n",cnttt);
	}
	return 0;
}

//1087
#include<bits/stdc++.h>
using namespace std;
int a[250][250],visit[250],dist[250];
map<string,int> si;
map<int,string> is;
const int inf=1000000000;
vector<int> pre[250],temp,ans;
int ss,cnt=0,maxsum=0,maxav=0,happy[250];//需赋值 
void dfs(int ee){//重名与函数参数 
	//end
	if(ee==ss){
		temp.push_back(ee);
		cnt++;
		int sum=0,av;
		for(int i=temp.size()-2;i>=0;i--){
		sum+=happy[temp[i]];//花费用不着第一指标就能解决 
		av=sum/(temp.size()-1) ;
		}if(sum>maxsum){
			ans=temp;
			maxsum=sum;
			maxav=av;//最大快乐的改变，av也要变他的优先级高于av 
		}else if(maxsum==sum&&av>maxav){
			ans=temp;
			maxav=av;
		} 
		//temp.pop_back();
		return;	
	}
	temp.push_back(ee);
	for(int i=0;i<pre[ee].size();i++){
		dfs(pre[ee][i]);
		temp.pop_back();
	}
	//temp.pop_back();
}
int main(){
	fill(a[0],a[0]+250*250,inf);
	fill(dist,dist+250,inf);
	int n,k,_1;
	string ssq;
	scanf("%d%d",&n,&k);
	cin>>ssq;
	si[ssq]=1;
	ss=1;
	is[1]=ssq;
	for(int i=0;i<n-1;i++){
		cin>>ssq;
		si[ssq]=i+2;
		is[i+2]=ssq;//只建了si未建is 
		scanf("%d",&_1);
		happy[si[ssq]]=_1;	
	}
	string _3,_4;
	int _5;
	for(int i=0;i<k;i++){
		cin>>_3>>_4>>_5;
		a[si[_3] ][si[_4] ]=a[ si[_4] ][si[_3] ]=_5;
	}
	dist[1]=0;
	for(int i=1;i<=n;i++){
		int u=-1,min=inf;
		for(int j=1;j<=n;j++){
			if(visit[j]==0&&dist[j]<min){
				min=dist[j];
				u=j;
			}
		}
		if(u==-1) break;
		visit[u]=1;
		for(int v=1;v<=n;v++){
			if(visit[v]==0&&a[u][v]!=inf){
				if(dist[v]>dist[u]+a[u][v]){
					dist[v]=dist[u]+a[u][v];//直接复制过来>于号都没改？？？ 不要弄着那边 突然想起来前面有部分没弄就结束去弄前面，先记下来，弄好这边再去弄那边 
					pre[v].clear();
					pre[v].push_back(u);
				}else if(dist[v]==dist[u]+a[u][v]){
					pre[v].push_back(u);
				}
			}
		}
	}
	//debug
	//printf("%d*******",si["ROM"]);
	dfs(si["ROM"]);
	printf("%d %d %d %d\n",cnt,dist[si["ROM"]],maxsum,maxav);
	for(int i=ans.size()-1;i>=0;i--){
		if(i!=ans.size()-1)printf("->");
		printf("%s",is[ans[i]].c_str());
	}
	return 0;
}

树部分1130 1155需再熟悉

图部分1034 1076

棒棒哒加油