【2019暑期】【PAT甲级】图论专练总结

发现了一个大佬总结的好文章,准备按照她的路线进行学习

DFS/BFS

1106

统计层数和次数的时候,在判断里统计,不要在递归里
不然会很麻烦也会导致结果错误
注意更新最小层数时也要把次数还原

int n;
double p,r,sum;
int cnt=1,minl=999999;
vector node[110000];

void dfs(int root,int level){
	if(node[root].size()==0){	
		if(level> n >> p >> r;
 	for(int i=0; i> k;
 		for(int j=0; j> h;
 			node[i].push_back(h);
		}
	 } 	
 	dfs(0,0);
 	sum = p * pow((1+r*0.01),minl); 	
 	printf("%.04f %d\n",sum,cnt);
    return 0;
}

1103

写递归,先写退出条件,然后根据推出条件看自己需要什么变量然后就传什么变量

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

vector pa,ans;
int msum = -1;
int n,k,p;
void dfs(int last,int sum,int size){
	if(size>k) return ;
	if(size==k&&last!=0) return ;
	if(size==k&&last==0){
		if(sum>msum){
			msum = sum;
			ans = pa;
		}
		if(sumpa[i]) return ;
				else if(ans[i] =1; i--){
		if(size==0||i<=pa.back()){
			pa.push_back(i);
			dfs(last-pow(i,p),sum+i,size+1);
			pa.pop_back();
		}
	}
}


int main()
{
	cin >> n >> k >> p;
	dfs(n,0,0);
 	if(ans.size()==0) cout << "Impossible" << endl;
 	else {
 		cout << n << " = ";
 		for(int i=0; i

1013

连通分量,不要想的太麻烦,自己总把简单题复杂化

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int n,m,k;

int edge[1100][1100];
int sum;
int go[1100];

void dfs(int root){
	
	go[root] = 1;
	//int flag = 0;
	for(int i=1; i<=n; i++){
		if(go[i]!=1&&edge[root][i]==1){
			dfs(i);
			//flag = 1;
		}
	}
	//if(flag==0) return ;
}

int main()
{
	cin >> n >> m >> k;
	for(int i=0; i> a >> b;
		edge[a][b] = edge[b][a] = 1;
	}
 	
 	for(int i=0; i> no;
 		memset(go,0,sizeof(go));
 		go[no] = 1; 		
		for(int j=1; j<=n; j++){
			if(go[j]==0){
				dfs(j);
				sum++;
			}
		}
		cout << sum-1 << endl;
		sum = 0;
	}
 	
    return 0;
}


最短路径(迪杰斯特拉)

1003

大佬的写法更简洁,多多理解

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int n,m,start,en;
int weight[510]; //点权 
int edge[510][510]; //边权 
int visit[510]; 
int inf = 99999999;
int dis[510]; //每个点到起点的最短距离 
int num[510]; //多少个最短路径
int minw[510]; //最小点权和 

int main()
{
	cin >> n >> m >> start >> en;
	for(int i=0; i> a;
		weight[i] = a;
	}
	fill(edge[0],edge[0]+510*510,inf); 
	for(int i=0; i> a >> b >> c;
		edge[a][b] = edge[b][a] = c;
	}
 	fill(dis,dis+510,inf);
 	dis[start] = 0;
 	num[start] = 1;
 	minw[start] = weight[start];
 	for(int i=0; i

1030

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int n,m,s,d;
int edge[510][510];
int cost[510][510];
int visit[510];
int dis[510];
int inf = 99999999;
int now[510];
int pre[510];

void dfs(int c){
	if(c==s){
		cout << c;
		return ;
	}
	dfs(pre[c]);
	cout << " "<< c ;	
}


int main()
{
	cin >> n >> m >> s >> d;
	fill(cost[0],cost[0]+510*510,inf);
	fill(edge[0],edge[0]+510*510,inf);
	fill(dis,dis+510,inf);
	fill(now,now+510,inf);
	for(int i=0; i> a >> b >> c >>d;
		edge[a][b] = edge[b][a] = c;
		cost[a][b] = cost[b][a] = d;
	}
	dis[s] = 0;
	now[s] = 0;
	pre[s] = s;
	for(int i=0; idis[u]+edge[u][v]){
					dis[v] = dis[u] + edge[u][v];
					now[v] = now[u] + cost[u][v];
					pre[v] = u;
				}
				else if(dis[v]==dis[u]+edge[u][v]){
					if(now[v]>now[u]+cost[u][v]){
						now[v] = now[u] + cost[u][v]; 					
						pre[v] = u;
					}
				}
			}
		}
	}
	//for(int i=0; i

欧拉图

1126

欧拉路径:所有路径都走且只走一遍,只有两个点的度数是奇数,其他都是偶数
欧拉回路:所有路径都走且只走一遍,所有点的度数都是偶数
欧拉图:含有欧拉回路的图
半欧拉图:含有欧拉路径的图
非欧拉图:除了不满足以上情况外,还可能所有点不在一个图上

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int n,m; 
int degree[510];
int edge[510][510];
int inf = 99999999;
int have[510];
int visit[510];
int num,sum;

void dfs(int node){
	if(have[node] == inf){
		return ;
	}
	visit[node] = 1;
	for(int i=1; i<=n; i++){
		if(visit[i]==0&&edge[node][i]!=inf){
			dfs(i);
		}
	}
}


int main()
{
	cin >> n >> m;
	fill(edge[0],edge[0]+510*510,inf);
	fill(have,have+510,inf);
	for(int i=0; i> a >> b;
		have[a] = a;
		have[b] = b;
		edge[a][b] = edge[b][a] = 1;
		degree[a]++;
		degree[b]++;
	}
	for(int i=1; i<=n; i++){
		if(visit[i]==0){
			dfs(i);
			num++;
		}
	}
	//cout << num << endl;
	for(int i=1; i<=n; i++){
		if(degree[i]%2!=0){
			sum++;
		}
		if(i==1) cout << degree[i];
		else cout << " " << degree[i];
	}
	cout << endl;
	if(num>1||sum!=2&&sum!=0){
		cout << "Non-Eulerian"<< endl;
	}
	else if(sum==2){
		cout << "Semi-Eulerian" << endl; 
	}
	else if(sum==0){
		cout << "Eulerian" << endl;
	}
    return 0;
}

哈密顿图

1122

哈密顿路径也称作哈密顿链,指在一个图中沿边访问每个顶点恰好一次的路径。
欧拉回路是指不重复的走过所有路径的回路
哈密尔顿环是指不重复地走过所有的点,并且最后还能回到起点的回路。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int n,m,k,p;
int node[210][210];

int main()
{
 	cin >> n >> m;
 	for(int i=1; i<=m; i++){
 		int a,b;
 		cin >> a >> b;
 		node[a][b] = node[b][a] = 1;
	}
	
	cin >> k;
 	for(int i=0; i> p;
 		vector jud;
 		set ans;
 		int key1 = 1,key2 = 1;
 		for(int j=0; j> a;
 			ans.insert(a);
 			jud.push_back(a);
		}
		if(ans.size()n) key1 = 0;
		for(int j=0; j

并查集

1107

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

int n; 
int fa[1100];
int ans[1100];
int ch[1100];

int find(int r){
	return fa[r] == r?r:fa[r]=find(fa[r]);
}

void join (int x,int y){
	int a = find(x);
	int b = find(y);
	if(a!=b) fa[b] = a;
}

bool my(int a,int b){
	return a>b;
}

int main()
{
 	cin >> n;
 	for(int i=0; i<1100; i++) 
 		fa[i] = i;
 	for(int i=1; i<=n; i++){
 		int k;
 		scanf("%d:",&k);
 		for(int j=0; j> m;
 			if(ch[m]==0){
 				ch[m] = i;
			}
			else join(ch[m],i);
		}
	 }
 
 	for(int i=1; i<=n; i++){
 		ans[find(i)]++;
	}
	int sum = 0;
	for(int i=1; i<=n; i++){
		if(ans[i]!=0) sum++;
	}
	cout << sum << endl;
	sort(ans,ans+n+1,my);
	for(int i=0; i

拓扑排序

1146

你可能感兴趣的:(pat,2019暑期)