NEUQ-acm 预备队训练Week5—图论

本周基于BFS/DFS进一步练习，涉及连通图知识

P8604 [蓝桥杯 2013 国 C] 危险系数

题目背景

抗日战争时期，冀中平原的地道战曾发挥重要作用。

题目描述

地道的多个站点间有通道连接，形成了庞大的网络。但也有隐患，当敌人发现了某个站点后，其它站点间可能因此会失去联系。

我们来定义一个危险系数 $DF(x,y)$：

对于两个站点 $x$ 和 $y(x\ne y),$ 如果能找到一个站点 $z$，当 $z$ 被敌人破坏后，$x$ 和 $y$ 不连通，那么我们称 $z$ 为关于 $x,y$ 的关键点。相应的，对于任意一对站点 $x$ 和 $y$，危险系数 $DF(x,y)$ 就表示为这两点之间的关键点个数。

本题的任务是：已知网络结构，求两站点之间的危险系数。

输入格式

输入数据第一行包含 $2$ 个整数 $n(2\le n\le 1000)$，$m(0\le m\le 2000)$，分别代表站点数，通道数。

接下来 $m$ 行，每行两个整数 $u,v(1\le u,v\le n,u\ne v)$ 代表一条通道。

最后 $1$ 行，两个数 $u,v$，代表询问两点之间的危险系数 $DF(u,v)$。

输出格式

一个整数，如果询问的两点不连通则输出 $-1$。

样例输入 #1

7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6

样例输出 #1

2

提示

时限 1 秒, 64M。蓝桥杯 2013 年第四届国赛

思路

关键在于怎么判断哪个是关键点
dfs深搜，如果每条路都要经过这个点那么他就是关键点

代码

#include <bits/stdc++.h>
using namespace std;
const int Max=1e3+5;
int n, m;
vector<int> G[Max];
int st,ed;
int visited[Max];
int totl=0;
int cnt[Max];
void dfs(int now){
    if(now==ed){
        totl++;
        //cout << "zhaodaol" << endl;
        for(int i = 1; i <= n; i++){
            if(visited[i]==1)
                cnt[i]++;
        }
        return;
        }
    for(int i = 0; i < G[now].size(); i++){
        int next = G[now][i];
        if(visited[next]==0){
            visited[next]=1;
            dfs(next);
            visited[next]=0;
        }
    }
    return;
}
int main(){
    cin >> n >> m;
    int u,v;
    for(int i = 0; i < m; i++){
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    cin >> st >> ed;
    visited[st]=1;
    dfs(st);
    int ans=0;
    for(int i = 1; i <= n; i++){
        if(cnt[i]==totl){
            ans++;
        }
    }
    cout << ans-2;
}

P3916 图的遍历

题目描述

给出 $N$ 个点，$M$ 条边的有向图，对于每个点 $v$，求 $A(v)$ 表示从点 $v$ 出发，能到达的编号最大的点。

输入格式

第 $1$ 行 $2$ 个整数 $N,M$，表示点数和边数。

接下来 $M$ 行，每行 $2$ 个整数 $U_i,V_i$，表示边 $(U_i,V_i)$。点用 $1,2,\dots ,N$ 编号。

输出格式

一行 $N$ 个整数 $A(1),A(2),\dots ,A(N)$。

样例输入 #1

4 3
1 2
2 4
4 3

样例输出 #1

4 4 3 4

提示

• 对于 $60\%$ 的数据，$1\le N,M\le 10^3$。
• 对于 $100\%$ 的数据，$1\le N,M\le 10^5$。

思路

先开始，从结点1到n遍历，每一遍都bfs求可到达的最大点
当然会超时啦~
所以我们可以倒着遍历，从最大结点遍历，经过的点都可到达这个最大的点，这样的话最坏情况下就是$O(n)$，
所以问题转化为怎么倒着遍历，想到把图直接倒着存，即边的方向改变，这样又将倒着遍历转化为正着啦

代码

#include <bits/stdc++.h>
using namespace std;
const int Max=1e5+5;
int n,m;
vector<int> G[Max];
queue<int> q;
int visited[Max];
int cnt[Max];
int main(){
    cin >> n >> m;
    for(int i = 1; i <= m; i++){
        int u,v;
        cin >> u >> v;
        G[v].push_back(u);  //倒存图
    }
    int n1=n;
    while(n1>0){  //倒着遍历，从最大的结点开始
        if(visited[n1]==1) {n1--; continue;}
        q.push(n1);
        visited[n1]=1;
        while(!q.empty()){
            int now=q.front();
            q.pop();
            for(int j = 0; j < G[now].size(); j++){
                int next=G[now][j];
                if(visited[next]==0){
                    visited[next]=1;
                    q.push(next);
                    if(cnt[next]==0) cnt[next]=n1;
                    //cnt[next]=(cnt[next]<n1)? n1: cnt[next];
                }
            }
        }
        n1--;
    }
    for(int i = 1; i <= n; i++)  
    if(cnt[i]<i) cout << i << " ";  //结点本身就已经是子连通图中最大的
    else cout << cnt[i] << " " ;
}

P1330 封锁阳光大学

题目描述

曹是一只爱刷街的老曹，暑假期间，他每天都欢快地在阳光大学的校园里刷街。河蟹看到欢快的曹，感到不爽。河蟹决定封锁阳光大学，不让曹刷街。

阳光大学的校园是一张由 $n$ 个点构成的无向图，$n$ 个点之间由 $m$ 条道路连接。每只河蟹可以对一个点进行封锁，当某个点被封锁后，与这个点相连的道路就被封锁了，曹就无法在这些道路上刷街了。非常悲剧的一点是，河蟹是一种不和谐的生物，当两只河蟹封锁了相邻的两个点时，他们会发生冲突。

询问：最少需要多少只河蟹，可以封锁所有道路并且不发生冲突。

输入格式

第一行两个正整数，表示节点数和边数。
接下来 $m$ 行，每行两个整数 $u,v$，表示点 $u$ 到点 $v$ 之间有道路相连。

输出格式

仅一行如果河蟹无法封锁所有道路，则输出 Impossible，否则输出一个整数，表示最少需要多少只河蟹。

样例输入 #1

3 3
1 2
1 3
2 3

样例输出 #1

Impossible

样例输入 #2

3 2
1 2
2 3

样例输出 #2

1

提示

【数据规模】
对于 $100\%$ 的数据，$1\le n\le 10^4$，$1\le m\le 10^5$，保证没有重边。

思路

先开始，找到所有结点度最大的那个点，移除该节点及边，直到所有的边都移除或者结点都移除了，但是没有考虑到度相同时取不同的结点得到的未必是最小的解（也是，这样求解都没用到广搜，深搜，不符合咱本周的专题bushi~）
行不通，好我们换思路
而我更喜欢广搜，因为不用递归，那我们来看一下怎么应用bfs
因为不一定是连通图，我们一个子图一个子图来遍历
河蟹一定是间隔着放的，放了我们就标记一下，那么他相邻的点就肯定不能放了，也可以给个标记，当子图遍历过后，发现有两个相邻的点都要放或都不放，就产生了冲突，直接return，结束循环
每个子图遍历后，累加最小放河蟹数的答案就可以了

#include <bits/stdc++.h>
using namespace std;
const int Max=1e5+5;
int n, m;  //总结点和总边数

int Vis[Max];  //标记走没走过
int ke[Max];  //放不放河蟹
vector<int> G[Max];  //存图
queue<int> q;
int main(){
    int ans=0;  //answer
    //int cnt=0, vis=0;   //cnt条被封的路，vis个不可用的点
    cin >> n >> m;
    for(int i = 1; i <= m; i++){  //存图
        int u,v;  
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    for(int i = 1; i <= n; i++){  //遍历整个图
        if(Vis[i]==1) continue;  //要是走过了，就说明该点所在子图已被封锁
        //memset(ke,0,sizeof(ke));
        q.push(i);
        Vis[i]=1;
        ke[i]=1;
        int num2=0, num1=1;  //num1为放，num2为没放，记录子图放的个数
        while(!q.empty()){
            //cout << "la";
            int now=q.front();
            q.pop();
            for(int j = 0; j < G[now].size(); j++){
                int temp=G[now][j];
                //cout << j << endl;
                if(Vis[temp]==1){
                    if(ke[now]==ke[temp]){  //已经走过了，发现了冲突
                        cout << "Impossible";
                        return 0;
                    }
                }
                else{
                    Vis[temp]=1;
                    ke[temp]=(ke[now]+1)%2;  //能不能放
                    if(ke[temp]==1) num1++;  //能放
                    else num2++;  //不能
                    q.push(temp);
                }
            }
        }
        ans+= min(num1,num2);  //子图中取最小的可封锁数
    }
    cout << ans;
}