【PAT甲级复习】 专题复习六：图的遍历与最小生成树

专题复习六（9.8）：图的遍历与最小生成树

1 图的DFS遍历

注意：如果已知给定的图是一个连通图，则只需要一次DFS就能完成遍历。

伪代码如下：
DFS(u){
    vis[u] = 1;
    for(从u出发能到达的所有顶点v){
        if(!vis[v]) DFS(v);
    }
}

DFSTrave(G){
    for(G的所有顶点u){
        if(!vis[u]) DFS(u);
    }
}

2 图的BFS遍历

伪代码如下：
BFS(u){
    queue<int> q;
    q.push(u);
    inq[u] = 1;
    while(!q.empty()){
        u = q.front();
        q.pop();
    	for(从u出发能到达的所有顶点v){
        	if(!inq[v]){
                q.push(v);
                inq[v] = 1;
            }
    	}        
    }
}

BFSTrave(G){
    for(G的所有顶点u){
        if(!inq[u]) BFS(u);
    }
}

3 例题解析

3.1 A1034 Head of a Gang (30 分)

考察图的DFS遍历，主要注意每条边只能访问一次，而不是在下一个点没有访问过时加上边权，这样会导致有正环的图出现问题。（还是贴柳神的代码了）

#include <iostream>
#include <map>
using namespace std;
map<string, int> stringToInt;
map<int, string> intToString;
map<string, int> ans;
int idNumber = 1, k;
int stoifunc(string s) {
    if(stringToInt[s] == 0) {
        stringToInt[s] = idNumber;
        intToString[idNumber] = s;
        return idNumber++;
    } else {
        return stringToInt[s];
    }
}
int G[2010][2010], weight[2010];
bool vis[2010];
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 dfsTrave() {
    for(int i = 1; i < idNumber; i++) {
        if(vis[i] == false) {
            int head = i, numMember = 0, totalweight = 0;
            dfs(i, head, numMember, totalweight);
            if(numMember > 2 && totalweight > k)
                ans[intToString[head]] = numMember;
        }
    }
}
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;
}

3.2 A1076 Forwards on Weibo (30 分)

考察图的BFS遍历，带层数的广度优先，因为一个用户只能转发一次，所以用inq判断当前结点是否入队过了，如果入队过了就不能重复入队（重复转发消息），inq 邻接表v 都可以使用int只存储id，queue的数据类型必须为node，同时保存它的id和layer层数，控制不超过L层。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
struct Node{
    int v, depth;
};
vector<int> Adj[MAXN];
bool inq[MAXN] = {0};
int n, l, k, ansnum = 0;
void BFS(int v, int depth){
    fill(inq, inq+MAXN, 0);
    ansnum = 0;
    queue<Node> q;
    q.push({v,0});
    inq[v] = 1;
    while(!q.empty()){
        Node tnode = q.front();
        int u = tnode.v;
        int d = tnode.depth;
        if(d == l) break;
        q.pop();
        for(int i=0; i<Adj[u].size(); i++){
            int next = Adj[u][i];
            if(!inq[next]){
                q.push({next, d+1});
                if(d+1 <= l) ansnum++;
                inq[next] = 1;
            }
        }
    }
}

int main(){
    int num, temp, qry;
    scanf("%d %d",&n,&l);
    for(int i=1; i<=n; i++){
        scanf("%d",&num);
        for(int j=0; j<num; j++){
            scanf("%d",&temp);
            Adj[temp].push_back(i);
        }
    }
    scanf("%d",&k);
    for(int i=0; i<k; i++){
        scanf("%d",&qry);
        BFS(qry, 0);
        printf("%d\n",ansnum);
    }
}

4 最小生成树

最小生成树的两个性质：

1. 边数等于顶点数减1，树内一定不会有环。
2. 最小生成树可能不唯一，但边权之和一定是唯一的。

两个算法：prim算法与kruskal算法，前者适用于稠密图，后者适用于稀疏图。

**prim算法与Dijkstra算法使用的思想几乎完全相同，只在数组d[]的含义上有区别，**其中Dijkstra算法的数组d[]含义为起点s到达顶点v的最短距离，而prim算法的数组d[]含义为顶点v与集合S的最短距离。

const int MAXV = 1000;
const int INF = 1000000000;
int n, G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV] = {0};

int prim(){ //默认0号为初始点，返回最小生成树的边权之和
    fill(d, d+MAXV, INF);
    d[0] = 0;
    int ans = 0;
    for(int i=0; i<n; i++){
        int MIN = INF, u = -1;
        for(int j=0; j<n; j++){
            if(!vis[j] && d[j] < MIN){
                MIN = d[j];
                u = j;
            }
        }
        if(u == -1) return;
        vis[u] = 1;
        ans += d[u];
        for(int v=0; v<n; v++){
            if(!vis[v] && G[u][v] != INF && G[u][v] < d[v]){
                d[v] = G[u][v];
            }
        }
    }
    return ans;
}

kruskal算法的思想简单来说：每次选取图中边权最小的边，如果边两端的顶点在不同的连通块中，就把这条边加入最小生成树中。

const int MAXV = 1000;
const int MAXE = 10010;
struct edge{
    int u, v;
    int cost;
}E[MAXE];

bool cmp(const edge &a, const edge &b){
    return a.cost < b.cost;
}

int father[MAXV];
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;
}

void Union(int a, int b){
    int faA = findFather(a);
    int faB = findFather(b);
    if(faA != faB) father[faA] = faB;
}

int kruskal(int n, int m){  //n为顶点个数，m为图的边数
    int ans = 0, num_edge = 0;
    for(int i=1; i<=n; i++) father[i] = i;
    sort(E, E + m, cmp);
    for(int i=0; i<m; i++){
        int faU = findFather(E[i].u);
        int faV = findFather(E[i].v);
        if(faU != faV){
            father[faU] = faV;
            ans += E[i].cost;
            num_edge++;
            if(num_edge == n-1) break;
        }
    }
    if(num_edge != n-1) return -1;  //无法连通时返回-1
    else return ans;
}