图的遍历A1034 A1076 A1013

A1034
dfs

#include<iostream>
#include<map>
using namespace std;
map<string,int> stringtoint;
map<int,string> inttostring;
map<string,int> ans;
int idnumber,n,k;
int weight[2010];
int G[2010][2010];
bool vis[2010];//初始默认为false
int stoifunc(string s)
{
    if(stringtoint[s]==0)
    {
        stringtoint[s]=idnumber;
        inttostring[idnumber]=s;
        return idnumber++;
    }
    else return stringtoint[s];
}
void dfs(int u,int &head,int &nummember,int &totalweight)
{
    vis[u]=true;
    nummember++;
    if(weight[u]>weight[head])
        head=u;
    for(int v=1;v<idnumber;v++)
    {
        if(G[u][v]>0){
            totalweight+=G[u][v];
            G[u][v]=G[v][u]=0;
            if(vis[v]==false)
                dfs(v,head,nummember,totalweight);
        }
    }
}
void dfstravel()
{
    for(int i=1;i<idnumber;i++)
    {
        if(vis[i]==false)
        {
            int head=i;
            int nummember=0,totalweight=0;
            dfs(i,head,nummember,totalweight);
            if(nummember>2&&totalweight>k)
            {
                ans[inttostring[head]]=nummember;
            }
        }
    }
}
int main()
{
    int w;
    string s1,s2;
    cin>>n>>k;
    for(int i=0;i<n;i++)
    {
        cin>>s1>>s2>>w;
        int id1=stoifunc(s1);
        int id2=stoifunc(s2);
        weight[id1]+=w;
        weight[id2]+=w;
        G[id1][id2]+=w;
        G[id2][id1]+=w;
    }
    dfstravel();
    cout<<ans.size()<<endl;
    for(auto it=ans.begin();it!=ans.end();it++)
    {
        cout<<it->first<<" "<<it->second<<endl;
    }
    return 0;
}

A1076
bfs

#include<bits/stdc++.h>
using namespace std;
struct node{
	int id;
	int layer;
};
const int maxn=1010;
vector<node> adj[maxn];//邻接表
bool inq[maxn]={false};

int bfs(int s,int l)//用队列来求 
{
	int numforward=0;
    queue<node> q;
    node start;
    start.id=s;
    start.layer=0;
    q.push(start);
    inq[start.id]=true;
    while(!q.empty()){
        node topnode=q.front();
        q.pop();
        int u=topnode.id;
        for(int i=0;i<adj[u].size();i++)
        {
            node next=adj[u][i];
            next.layer=topnode.layer+1;
            if(inq[next.id]==false&&next.layer<=l)
            {
                q.push(next);
                inq[next.id]=true;
                numforward++;
            }
        }
    }
    return numforward;
}
int main()
{
	node user;
	int n,l,numfollower,idfollower;
	scanf("%d%d",&n,&l);
	for(int i=1;i<=n;i++)
	{
		user.id=i;
		scanf("%d",&numfollower);
		for(int j=0;j<numfollower;j++)
		{
			scanf("%d",&idfollower);
			adj[idfollower].push_back(user);
		}
	}
	int query,s;
	scanf("%d",&query);
	for(int i=0;i<query;i++){
		memset(inq,false,sizeof(inq));
		scanf("%d",&s);//结点 
		int numforward=bfs(s,l);//结点，层数
		printf("%d\n",numforward); 
	}
	return 0;
}

A1013 dfs

#include<bits/stdc++.h>
using namespace std;
const int N=1111;
vector<int> G[N];//邻接表
bool vis[N];//标记顶点i是否已被访问 

int currentpoint;//当前需要删除的顶点编号 
int n,m,k;
void dfs(int v){
	vis[v]=true;
	for(int i:G[v]){
		if(i!=currentpoint&&!vis[i])
			dfs(i);
	}
}
int main()
{
	scanf("%d%d%d",&n,&m,&k);//n是城市个数，m是高速公路个数，k是想要检查的城市个数
	for(int i=0;i<m;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		G[a].push_back(b);//边a->b，无向图 
		G[b].push_back(a);//边b->a 
	}
	for(int i=0;i<k;i++){
		scanf("%d",&currentpoint);//欲删除的顶点编号
		memset(vis,false,sizeof(vis));
		int block=0;
		for(int j=1;j<=n;j++)
		{
			if(j!=currentpoint&&!vis[j])
			{
				block++;
				dfs(j);
			}
		 } 
		 cout<<block-1<<endl; 
	}
	return 0;
 } 

A1021 dfs

#include<bits/stdc++.h>
using namespace std;

const int maxn=10010;
vector<int> G[maxn];
bool isroot[maxn];
int father[maxn];
//并查集初始化 
void init(int n){
	for(int i=1;i<=n;i++){
		father[i]=i;
	}
}
//查找x所在集合的根结点
int findfather(int x){
	int a=x;
	while(x!=father[x]){
		x=father[x];
	} 
	while(a!=father[a]){
		int z=a;
		a=father[a];
		father[z]=x;
	}
	return x;
}
//合并a和b所在的集合
void unionn(int a,int b){
	int faa=findfather(a);
	int fab=findfather(b);
	if(faa!=fab){
		father[faa]=fab;
	}
}
//计算连通块数目 
int calblock(int n){
	int block=0;
	for(int i=1;i<=n;i++){
		isroot[findfather(i)]=true;
	}
	for(int i=1;i<=n;i++){
		block+=isroot[i];
	}
	return block;
}
int maxh=0;
vector<int> temp,ans;
void dfs(int u,int height,int pre){
	if(height>maxh){
		temp.clear();
		temp.push_back(u);
		maxh=height;
	}else if(height==maxh){
		temp.push_back(u);
	}
	for(int i=0;i<G[u].size();i++){
		if(G[u][i]==pre) continue;
		dfs(G[u][i],height+1,u);
	}
}
int main()
{
	int a,b,n;
	scanf("%d",&n);
	init(n);
	for(int i=1;i<n;i++){
		scanf("%d%d",&a,&b);
		G[a].push_back(b);
		G[b].push_back(a);
		unionn(a,b);
	}
	int block=calblock(n);
	if(block!=1){
		printf("Error: %d components\n",block);
	}else{
		dfs(1,1,-1);
		ans=temp;
		dfs(ans[0],1,-1);
		for(int i=0;i<temp.size();i++){
			ans.push_back(temp[i]);
		}
		sort(ans.begin(),ans.end());
		printf("%d\n",ans[0]);
		for(int i=1;i<ans.size();i++){
			if(ans[i]!=ans[i-1]){
				printf("%d\n",ans[i]);
			}
		}
	}
	return 0;
}