图的遍历(PAT : A1013,A1021,A1034,A1076,Interstellar Love)

Battle Over Cities

1013 Battle Over Cities (25 分)

思路:

dfs或并查集判连通就好

代码1(邻接矩阵+dfs):

#include <cstdio>
#include <algorithm>
using namespace std;
int v[1010][1010];
bool vis[1010];
int n;
void dfs(int node) {
    vis[node] = true;
    for(int i = 1; i <= n; i++) {
        if(!vis[i] && v[node][i] == 1)
            dfs(i);
    }
}
int main() {
    int m, k, a, b;
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 0; i < m; i++) {
        scanf("%d%d", &a, &b);
        v[a][b] = v[b][a] = 1;
    }
    for(int i = 0; i < k; i++) {
        fill(vis, vis + 1010, 0);
        scanf("%d", &a);
        int cnt = 0;
        vis[a] = true;//刨掉这个点
        for(int j = 1; j <= n; j++) {
            if(!vis[j]) {
                dfs(j);
                cnt++;
            }
        }
        printf("%d\n", cnt - 1);
    }
    return 0;
}

代码2(vector+dfs):

#include<bits/stdc++.h>
using namespace std;
const int N=1e5;
vector<int> v[N];
bool vis[N];
void dfs(int x,int t){
    if(vis[x]||x==t){
        return;
    }
    vis[x]=1;
    for(int i=0;i<v[x].size();i++){
        dfs(v[x][i],t);
    }
}
int main(){
    int n,m,a,b,k,t,ans=0;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        v[a].push_back(b);
        v[b].push_back(a);
    }
    for(int i=0;i<k;i++){
        ans=0;
        memset(vis,0,sizeof(vis));
        scanf("%d",&t);
        for(int j=1;j<=n;j++){
            if(j==t)
                continue;
            if(!vis[j]){
                dfs(j,t);
                ans++;
            }
        }
        printf("%d\n",ans-1);
    }
    return 0;
}

另一种写法:

#include<bits/stdc++.h>
using namespace std;
const int N=1e5;
vector<int> v[N];
bool vis[N];
void dfs(int x){
    if(vis[x])
        return;
    vis[x]=1;
    for(int i=0;i<v[x].size();i++)
        dfs(v[x][i]);
}
int main(){
    int n,m,a,b,k,t,ans=0;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<m;i++){
        scanf("%d%d",&a,&b);
        v[a].push_back(b);
        v[b].push_back(a);
    }
    for(int i=0;i<k;i++){
        ans=0;
        memset(vis,0,sizeof(vis));
        scanf("%d",&t);
        vis[t]=1;
        for(int j=1;j<=n;j++){
            if(!vis[j]){
                dfs(j);
                ans++;
            }
        }
        printf("%d\n",ans-1);
    }
    return 0;
}

代码3(并查集):

#include<stdio.h>

const int N=1010;
const int M=1000100;
int fa[N];
int a[M],b[M],c;
int n,m,k;

int find(int v){
    if(fa[v] == v)return v;
    else return fa[v]= find(fa[v]);
}

void merge(int u,int v){
    int t1= find(u);
    int t2= find(v);
    if(t1!=t2)
        fa[t2]=t1;
}

void init(){
    for(int i=1;i<=n;i++)
        fa[i]=i;
}

int get(){
    int sum=0;
    for(int i=1;i<=m;i++){
        if(a[i] != c && b[i] != c)
            merge(a[i],b[i]);
    }
    for(int i=1;i<=n;i++){
        if(fa[i] == i)
            sum++;
    }
    return sum-2;
}

int main(){
    while(~scanf("%d%d%d",&n,&m,&k)){
        for(int i=1; i<=m; i++)
            scanf("%d%d",&a[i],&b[i]);

        for(int i=1; i<=k; i++){
            scanf("%d",&c);
            init();
            printf("%d\n", get());
        }
    }
    return 0;
}

Deepest Root

1021 Deepest Root (25 分)

$引理$

先从树中任选一个结点,以它为起点dfs找到最深的结点(可能有多个),放入集合A，然后从A中任意选一个结点,以它为起点dfs找到最深的结点(可能有多个),这次放入集合B，A和B的并集就是所求的使树高最大的结点

代码:

#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int n, mx_h = 0;
vector<int> v[10010];
bool visit[10010];
set<int> s;
vector<int> t;
void dfs(int node, int h) {
    if(h > mx_h) {
        t.clear();
        t.push_back(node);
        mx_h = h;
    }
    else if(h == mx_h){
        t.push_back(node);
    }
    visit[node] = true;
    for(int i = 0; i < v[node].size(); i++) {
        if(!visit[v[node][i]])
            dfs(v[node][i], h + 1);
    }
}
int main() {
    scanf("%d", &n);
    int a, b, cnt = 0;
    for(int i = 0; i < n - 1; i++) {
        scanf("%d%d", &a, &b);
        v[a].push_back(b);
        v[b].push_back(a);
    }
    for(int i = 1; i <= n; i++) {
        if(!visit[i]) {
            dfs(i, 1);
            cnt++;
        }
    }
    if(cnt >= 2) {
        printf("Error: %d components", cnt);
        return 0;
    }
    int s1=t[0];
    for(int i = 0; i < t.size(); i++)
        s.insert(t[i]);
    t.clear();
    mx_h = 0;
    fill(visit, visit + 10010, false);
    dfs(s1, 1);
    for(int i = 0; i < t.size(); i++)
        s.insert(t[i]);
    for(set<int>::iterator it = s.begin(); it != s.end(); it++)
        printf("%d\n", *it);
    return 0;
}

Head of a Gang

1034 Head of a Gang (30 分)

思路:

在图的连通分量里搜集信息，用图的dfs遍历解决就好

注意遍历过一条边之后就把这条边的权值设为0$（G[u][v]=G[v][u]=0）$防止出现回路遍历死循环

代码:

#include <iostream>
#include <map>
using namespace std;
map<string, int> stringToInt;
map<int, string> intToString;
map<string, int> ans;
int id = 1, k;
int stoifunc(string s) {
    if(stringToInt[s] == 0) {
        stringToInt[s] = id;
        intToString[id] = s;
        return id++;
    }
    else{
        return stringToInt[s];
    }
}
int G[2010][2010], weight[2010];
bool vis[2010];
void dfs(int u, int &head, int &num, int &sum) {
    vis[u] = true;
    num++;
    if(weight[u] > weight[head])
        head = u;
    for(int v = 1; v < id; v++) {
        if(G[u][v] > 0) {
            sum += G[u][v];
            G[u][v] = G[v][u] = 0;
            if(!vis[v])
                dfs(v, head, num, sum);
        }
    }
}
void dfsTrave() {
    for(int i = 1; i < id; i++) {
        if(!vis[i]) {
            int head = i, num = 0, sum = 0;
            dfs(i, head, num, sum);
            if(num > 2 && sum > k)
                ans[intToString[head]] = num;
        }
    }
}
int main() {
    int n, w;
    cin >> n >> k;
    string s1, s2;
    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;
    }
    dfsTrave();
    cout << ans.size() << endl;
    for(auto it = ans.begin(); it != ans.end(); it++)
        cout << it->first << " " << it->second << endl;
    return 0;
}

Forwards on Weibo

1076 Forwards on Weibo (30 分)

思路:

带层数的bfs，因为一个用户不能重复转发消息，所以用vis判断当前结点是否入队过了，如果入队过了就不能重复入队

代码:

#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
int n, l, m, k;
struct node {
    int id, layer;
};
vector<int> v[1010];
int bfs(node no) {
    bool vis[1010];
    memset(vis, 0, sizeof vis);
    queue<node> q;
    q.push(no);
    vis[no.id] = true;
    int cnt = 0;
    while(!q.empty()) {
        node top = q.front();
        q.pop();
        int no2 = top.id;
        for(int i = 0; i < v[no2].size(); i++) {
            int nextid = v[no2][i];
            if(!vis[nextid] && top.layer < l) {
                node next = {nextid, top.layer + 1};
                q.push(next);
                vis[next.id] = true;
                cnt++;
            }
        }
    }
    return cnt;
}

int main() {
    scanf("%d %d", &n, &l);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &m);
        for(int j = 0,t; j < m; j++) {
            scanf("%d", &t);
            v[t].push_back(i);
        }
    }
    scanf("%d", &k);
    for(int i = 0,t; i < k; i++) {
        scanf("%d", &t);
        node tnode = {t, 0};
        printf("%d\n", bfs(tnode));
    }
    return 0;
}

Interstellar Love

Interstellar Love

题意:

给一个图,求出有多少个含多于一个元素的连通块,并从这些连通块找出哪内部些是存在环的

思路1:

并查集判断存在环的连通块

代码1:

#include<bits/stdc++.h>
using namespace std;
int f[1005];
int vis[1005];
int d[1005];
int t,n,m,a,b;
int find(int x){
    if(f[x]==x) return x;
    else return f[x]=find(f[x]);
}
int main(){
    scanf("%d",&t);
    for(int k=1;k<=t;k++){
        scanf("%d %d",&n,&m);
        memset(vis, 0, sizeof(vis));
        memset(d,0,sizeof(d));
        for(int i=1;i<=n;i++) f[i]=i;
        int c1=0,c2=0;
        for(int i=0;i<m;i++){
            scanf("%d%d",&a,&b);
            vis[a]=vis[b]=1;
            int x=find(a),y=find(b);
            //要连通2个块了
            if(x!=y){
                //把x的状态移到y上
                d[y]=max(d[x],d[y]);
                d[x]=0;
                f[x]=y;//把a的所在的树接到b所在的树上
            }
            //如果连通块有环,不影响,无环,就给根一个环标记
            else d[x]=1;
        }
        for(int i=1;i<=n;i++){
            if(f[i]==i && vis[i] == 1) c1++;
            if(d[i]) c2++;
        }
        printf("Night sky #%d: %d constellations, of which %d need to be fixed.\n\n",k,c1,c2);
    }
    return 0;
}

对每一个连通块，如果块内的边数大于等于这个树的点数，那么它就不是一棵树了，里面一定有环

代码2:

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const ll N = 1 << 20;
const ll N2 = 5005;
const ll mod = 1e9 + 7;
const double dinf = 1e99;
const double PI = cos(-1.0);
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;

ll pa[N], siz[N];

void init(int n) {
    for (int i = 0; i <= n; i++) {
        pa[i] = i;
        siz[i] = 1;
    }
}

int find(int a) {
    return pa[a] == a ? a : pa[a] = find(pa[a]);
}
//启发式合并
void merge(int a, int b) {
    a = find(a);
    b = find(b);
    // 保证小的合到大的里
    if (siz[a] > siz[b]) swap(a, b);
    siz[b] += siz[a];
    pa[a] = b;
}

vector<pair<int, int> > v;
int tot[N];
int cir[N];

int main() {
    ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int T;
    cin >> T;
    for (int t = 1; t <= T; t++) {
        v.clear();
        int n, m;
        cin >> n >> m;
        init(n);
        for (int i = 1; i <= m; i++) {
            int a, b;
            cin >> a >> b;
            v.push_back({a, b});
            merge(a, b);
        }

        map<int, int> mp2;
        for (int i = 1; i <= n; i++) tot[i] = cir[i] = 0;
        for (int i = 1; i <= n; i++) {
            tot[find(i)]++;
        }
        for (auto x:v) {
            cir[find(x.first)]++;
        }
        int cnt1 = 0;
        for (int i = 1; i <= n; i++) if (tot[i] > 1) cnt1++;
        int cnt2 = 0;
        for (int i = 1; i <= n; i++) {
            if (tot[i] <= 1) continue;
            if (cir[i] >= tot[i]) cnt2++;
        }
        cout << "Night sky #" << t << ": " << cnt1 << " constellations, of which " << cnt2 << " need to be fixed. "<< endl << endl;
    }
}

当然dfs判断连通块是否含环也很方便

代码3:

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 1e3 + 10;
int g[N][N],vis[N];
int ans,n,flag,res[N];
void dfs(int st,int lst){
    vis[st]=1;
    for(int i=1;i<=n;++i){
        if(g[st][i]){
            if(!vis[i])dfs(i, st);
            else if(!flag && i != lst)flag=1,ans++;
        }
    }
}
int main(){
    int t; 
    cin>>t;
    for(int k=1;k<=t;++k){
        memset(g, 0, sizeof(g));
        memset(vis,0,sizeof(vis));
        memset(res, 0, sizeof(res));
        int s,cnt=0; ans=0; 
        cin>>n>>s;
        while(s--){
            int u,v; 
            cin>>u>>v; 
            g[u][v]= g[v][u]=1;
            res[u]=res[v]=1;
        }
        //flag=1表示这个连通块一定含环了
        for(int i=1;i<=n;++i){
            if(!vis[i]&&res[i]) flag=0,cnt++,dfs(i, i);
        }
        cout<<"Night sky #"<<k<<": "<<cnt<<" constellations, of which "<<ans<<" need to be fixed."<<endl<<endl;
    }
}