PAT Advanced A1021 Deepest Root (25) [图的遍历,DFS,计算连通分量的个数,BFS,并查集]
作者:互联网
题目
题目分析
已知图的顶点N和边N-1,判断所给图是否是一棵树,如果是,查找并打印最高树的所有根节点(从小到大)
- 判断图为树有两个条件:只有一个连通分量(否则为森林);无环(已知顶点数为N,边为N-1的连通图一定是树)
- 最高树的所有根节点,其含义可以从样例中推导得出(起始顶点不同,寻找出的最高树不同)
解题思路
1. 存储顶点和边
- 邻接表
- 邻接矩阵
2. 计算连通分量个数
连通分量等于1时,满足条件
- DFS
- BFS
- 并查集
3. 查找最大高度树的根节点
- 任意取一个顶点,求其能到达的最远的节点集合A,如测试样例1中:取1,可以得到5,3,4
- 任取取A集合中一个顶点,求其能到达的最远的节点集合B,如取A集合中3,可以得到4,5
- 集合A和集合B的并集去重排序,即为答案
Code
Code 01(邻接矩阵 并查集)
#include <iostream>
#include <vector>
#include <set>
using namespace std;
const int maxn=10010;
vector<int> g[maxn],temp; //邻接表 存储边
set<int> vs; // 存储所有满足条件的 the deepest roots
int maxh,n,father[maxn],vis[maxn];
/*
并查集判断连通分量树
两次dfs求the deepest root
*/
int init() { /* 并查集 初始化 */
for(int i=1; i<=n; i++)father[i]=i;
}
int find(int x) { /* 并查集 查 */
int a = x;
while(x!=father[x]) {
x=father[x];
}
while(a!=father[a]) { // 路径压缩
int temp=a;
a=father[a];
father[a]=x;
}
return x;
}
void Union(int a,int b) { /* 并查集 并 */
int fa=find(a);
int fb=find(b);
if(fa<fb)father[fb]=fa;
else father[fa]=fb;
}
void dfs(int a, int h) { /* dfs */
vis[a]=1;
if(h>maxh) {
temp.clear();
temp.push_back(a); // the deepest root
maxh=h;
} else if(h==maxh)
temp.push_back(a);
for(int i=0; i<g[a].size(); i++) {
if(vis[g[a][i]]==0)
dfs(g[a][i],h+1);
}
}
void pts() {
for(int i=0; i<temp.size(); i++)
vs.insert(temp[i]);
}
int main(int argc,char * argv[]) {
int a,b;
scanf("%d",&n);
init();
for(int i=1; i<=n-1; i++) {
scanf("%d %d",&a,&b);
g[a].push_back(b);
g[b].push_back(a);
Union(a,b);
}
// 统计连通分量数
for(int i=1; i<=n; i++) {
vs.insert(find(i));
}
if(vs.size()>1) {
printf("Error: %d components",vs.size());
return 0;
}
vs.clear(); //vs重置,方便下面使用
dfs(1,1); // 第一次dfs,任意取一个顶点,获取最深根集合A
pts(); //将集合A存入set
fill(vis,vis+maxn,0); //重置vis访问标记数组
//maxh=0; //无需重置maxh,因为第一轮得到的maxh即为最高树高度,第二轮中h==maxh时添加剩余的the deepest root
dfs(temp[0],1);// 第二次dfs,从集合A中任取一个顶点,获取最深根集合B
pts(); //将集合B存入set
for(set<int>::iterator it=vs.begin(); it!=vs.end(); it++) { //set默认从小到大,A+B去重即为结果
printf("%d\n",*it);
}
return 0;
}
Code 02(邻接矩阵 DFS)
#include <iostream>
#include <vector>
#include <set>
using namespace std;
const int maxn=10010;
vector<int> g[maxn],temp; //邻接表 存储边
set<int> vs; // 存储所有满足条件的 the deepest roots
int n,maxh,vis[maxn];
/*
第一次dfs 求连通分量,求the deepest root集合A
第二次dfs 求the deepest root集合B
集合A+B,去重排序 即为答案
*/
void dfs(int a, int h) { /* dfs */
vis[a]=1;
if(h>maxh) {
temp.clear();
temp.push_back(a); // the deepest root
maxh=h;
} else if(h==maxh)
temp.push_back(a);
for(int i=0; i<g[a].size(); i++) {
if(vis[g[a][i]]==0)
dfs(g[a][i],h+1);
}
}
void pts() {
for(int i=0; i<temp.size(); i++)
vs.insert(temp[i]);
}
int main(int argc,char * argv[]) {
int a,b;
scanf("%d",&n);
for(int i=1; i<=n-1; i++) {
scanf("%d %d",&a,&b);
g[a].push_back(b);
g[b].push_back(a);
}
// 统计连通分量数
int cnt=0;
for(int i=1; i<=n; i++) {
if(vis[i]==0){
dfs(i,0);
pts(); //将集合A存入set
cnt++;
}
}
if(cnt>1) {
printf("Error: %d components",cnt);
return 0;
}
fill(vis,vis+maxn,0); //重置vis访问标记数组
//maxh=0; //无需重置maxh,因为第一轮得到的maxh即为最高树高度,第二轮中h==maxh时添加剩余的the deepest root
dfs(temp[0],1);// 第二次dfs,从集合A中任取一个顶点,获取最深根集合B
pts(); //将集合B存入set
for(set<int>::iterator it=vs.begin(); it!=vs.end(); it++) { //set默认从小到大,A+B去重即为结果
printf("%d\n",*it);
}
return 0;
}
Code 03(邻接矩阵 BFS)
#include <iostream>
#include <vector>
#include <set>
#include <queue>
using namespace std;
const int maxn=10010;
vector<int> g[maxn],temp; //邻接表 存储边
set<int> vs; // 存储所有满足条件的 the deepest roots
int n,maxh,vis[maxn];
struct node {
int v;
int h;
};
/*
第一次bfs 求连通分量,求the deepest root集合A
第二次bfs 求the deepest root集合B
集合A+B,去重排序 即为答案
*/
void bfs(int a) { /* dfs */
vis[a]=1;
queue<node> q;
q.push({a,0});
while(!q.empty()) {
node now = q.front();
q.pop();
if(now.h>maxh) {
temp.clear();
temp.push_back(now.v); // the deepest root
maxh=now.h;
} else if(now.h==maxh)
temp.push_back(now.v);
for(int i=0; i<g[now.v].size(); i++)
if(vis[g[now.v][i]]==0){
q.push({g[now.v][i],now.h+1});
vis[g[now.v][i]]=1;
}
}
}
void pts() {
for(int i=0; i<temp.size(); i++)
vs.insert(temp[i]);
}
int main(int argc,char * argv[]) {
int a,b;
scanf("%d",&n);
for(int i=1; i<=n-1; i++) {
scanf("%d %d",&a,&b);
g[a].push_back(b);
g[b].push_back(a);
}
// 统计连通分量数
int cnt=0;
for(int i=1; i<=n; i++) {
if(vis[i]==0) {
bfs(i);
pts(); //将集合A存入set
cnt++;
}
}
if(cnt>1) {
printf("Error: %d components",cnt);
return 0;
}
fill(vis,vis+maxn,0); //重置vis访问标记数组
//maxh=0; //无需重置maxh,因为第一轮得到的maxh即为最高树高度,第二轮中h==maxh时添加剩余的the deepest root
bfs(temp[0]);// 第二次dfs,从集合A中任取一个顶点,获取最深根集合B
pts(); //将集合B存入set
for(set<int>::iterator it=vs.begin(); it!=vs.end(); it++) //set默认从小到大,A+B去重即为结果
printf("%d\n",*it);
return 0;
}
Code 04(邻接表 DFS)
#include <iostream>
#include <vector>
#include <set>
using namespace std;
const int maxn=10010;
vector<int> temp; //邻接表 存储边
set<int> vs; // 存储所有满足条件的 the deepest roots
int n,maxh,vis[maxn],g[maxn][maxn];
/*
第一次dfs 求连通分量,求the deepest root集合A
第二次dfs 求the deepest root集合B
集合A+B,去重排序 即为答案
*/
void dfs(int a, int h) { /* dfs */
vis[a]=1;
if(h>maxh) {
temp.clear();
temp.push_back(a); // the deepest root
maxh=h;
} else if(h==maxh)
temp.push_back(a);
for(int i=1; i<maxn; i++)
if(g[a][i]==1 && vis[i]==0)
dfs(i,h+1);
}
void pts() {
for(int i=0; i<temp.size(); i++)
vs.insert(temp[i]);
}
int main(int argc,char * argv[]) {
int a,b;
scanf("%d",&n);
for(int i=1; i<=n-1; i++) {
scanf("%d %d",&a,&b);
g[a][b]=1;
g[b][a]=1;
}
// 统计连通分量数
int cnt=0;
for(int i=1; i<=n; i++) {
if(vis[i]==0) {
dfs(i,0);
pts(); //将集合A存入set
cnt++;
}
}
if(cnt>1) {
printf("Error: %d components",cnt);
return 0;
}
fill(vis,vis+maxn,0); //重置vis访问标记数组
//maxh=0; //无需重置maxh,因为第一轮得到的maxh即为最高树高度,第二轮中h==maxh时添加剩余的the deepest root
dfs(temp[0],1);// 第二次dfs,从集合A中任取一个顶点,获取最深根集合B
pts(); //将集合B存入set
for(set<int>::iterator it=vs.begin(); it!=vs.end(); it++) { //set默认从小到大,A+B去重即为结果
printf("%d\n",*it);
}
return 0;
}
Code 05(邻接表 BFS)
#include <iostream>
#include <vector>
#include <set>
#include <queue>
using namespace std;
const int maxn=10010;
vector<int> temp; //邻接表 存储边
set<int> vs; // 存储所有满足条件的 the deepest roots
int n,maxh,vis[maxn],g[maxn][maxn];
struct node {
int v;
int h;
};
/*
第一次bfs 求连通分量,求the deepest root集合A
第二次bfs 求the deepest root集合B
集合A+B,去重排序 即为答案
*/
void bfs(int a) { /* dfs */
vis[a]=1;
queue<node> q;
q.push({a,0});
while(!q.empty()) {
node now = q.front();
q.pop();
if(now.h>maxh) {
temp.clear();
temp.push_back(now.v); // the deepest root
maxh=now.h;
} else if(now.h==maxh)
temp.push_back(now.v);
for(int i=1; i<maxn; i++)
if(g[now.v][i]==1 && vis[i]==0){
q.push({i,now.h+1});
vis[i]=1;
}
}
}
void pts() {
for(int i=0; i<temp.size(); i++)
vs.insert(temp[i]);
}
int main(int argc,char * argv[]) {
int a,b;
scanf("%d",&n);
for(int i=1; i<=n-1; i++) {
scanf("%d %d",&a,&b);
g[a][b]=1;
g[b][a]=1;
}
// 统计连通分量数
int cnt=0;
for(int i=1; i<=n; i++) {
if(vis[i]==0) {
bfs(i);
pts(); //将集合A存入set
cnt++;
}
}
if(cnt>1) {
printf("Error: %d components",cnt);
return 0;
}
fill(vis,vis+maxn,0); //重置vis访问标记数组
//maxh=0; //无需重置maxh,因为第一轮得到的maxh即为最高树高度,第二轮中h==maxh时添加剩余的the deepest root
bfs(temp[0]);// 第二次dfs,从集合A中任取一个顶点,获取最深根集合B
pts(); //将集合B存入set
for(set<int>::iterator it=vs.begin(); it!=vs.end(); it++) //set默认从小到大,A+B去重即为结果
printf("%d\n",*it);
return 0;
}
标签:25,PAT,temp,int,查集,vis,maxh,maxn,deepest 来源: https://www.cnblogs.com/houzm/p/12359104.html