ACM算法第九周

第一题

# 【模板】并查集

## 题目描述

如题，现在有一个并查集，你需要完成合并和查询操作。

## 输入格式

第一行包含两个整数 $N,M$ ,表示共有 $N$ 个元素和 $M$ 个操作。

接下来 $M$ 行，每行包含三个整数 $Z_i,X_i,Y_i$ 。

当 $Z_i=1$ 时，将 $X_i$ 与 $Y_i$ 所在的集合合并。

当 $Z_i=2$ 时，输出 $X_i$ 与 $Y_i$ 是否在同一集合内，是的输出 
 `Y` ；否则输出 `N` 。

## 输出格式

对于每一个 $Z_i=2$ 的操作，都有一行输出，每行包含一个大写字母，为 `Y` 或者 `N` 。

## 样例 #1

### 样例输入 #1

```
4 7
2 1 2
1 1 2
2 1 2
1 3 4
2 1 4
1 2 3
2 1 4
```

### 样例输出 #1

```
N
Y
N
Y
```

代码：

#include<bits/stdc++.h>
using namespace std;
int i,j,k,n,m,s,ans,f[10010],p1,p2,p3;
//f[i]表示i的集合名
int find(int k){
    //路径压缩
    if(f[k]==k)return k;
    return f[k]=find(f[k]);
}
int main()
{
    cin>>n>>m;
    for(i=1;i<=n;i++)
        f[i]=i;//初始化i的老大为自己
    for(i=1;i<=m;i++){
        cin>>p1>>p2>>p3;
        if(p1==1)
            f[find(p2)]=find(p3);
            //p3打赢了p2
        else
            if(find(p2)==find(p3))
            //是否是一伙的
                printf("Y\n");
            else
                printf("N\n");
    }
    return 0;
}

解题思路：

假定每个集的所有数都必须有父节点

每次查找某个点的父节点时，缩短该点的路径：

将该点的父节点转至其父节点的父节点，再从其新的父节点开始找，直到找到最终父节点

合并集时将该集的最终父节点更改为另一集的最终父节点

第二题：

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

## 题目背景

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

## 题目描述

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

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

对于两个站点 $x$ 和 $y(x\neq 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\neq v)$ 代表一条通道。

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

## 输出格式

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

## 样例 #1

### 样例输入 #1

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

### 样例输出 #1

```
2
```

代码：

#include<bits/stdc++.h>
#define LL long long
#define made return
#define in 0
#define China ;
using namespace std;
LL n,m,u,v,ans,cnt[1010],sum;
bool bj[1010],a[1010][1010];
void dfs(LL now){
    if(now==v){//如果走到终点了， 
        sum++;//路径总数加一。 
        for(int i=1;i<=n;i++)
            if(bj[i]==1)cnt[i]++;//每个被走过的点，被走总次数加一 
    }
    else{
        for(int i=1;i<=n;i++)
            if(a[now][i]==1&&bj[i]==0){//如果两点连通且下一步要走到的点未被走过， 
                bj[i]=1;//标记。
                dfs(i);
                bj[i]=0;//回溯一步。 
            }
    }
}
int main(){
    scanf("%lld%lld",&n,&m);
    while(m--){
        scanf("%lld%lld",&u,&v);
        a[u][v]=a[v][u]=1;//输入邻接矩阵。因为是无向的，所以u到v和v到u都要设为1。 
    }
    scanf("%lld%lld",&u,&v);
    dfs(u);
    if(sum>0){//dfs求解
        for(int i=1;i<=n;i++)
            if(cnt[i]==sum)ans++;//如果这个点被走过的总次数与路径总数相等，那么删去这个点起点与终点间一定不连通。 
        printf("%lld",ans-1);//因为起点也被算在内，所以总危险系数要减去起点的1。 
    }
    else printf("-1");//如果询问的两点无路径连通则输出'-1'。
}

解题思路：

可以使用 dfs（深度优先搜索）求解，求出 uu 到 vv 间的每一条路径，将路径总数统计，并将被经过的点被经过总数加一。如果一个点被经过的次数与总路径条数相等，那么这一个点就是 uu 和 vv 的关键点。

第三题：封锁阳光大学

代码：

#include<bits/stdc++.h>
using namespace std;
struct Edge
{
    int t;
    int nexty;
}edge[200000];
int head[20000];
int cnt=0;//链式前向星
void add(int a,int b)//存边
{
    cnt++;
    edge[cnt].t=b;
    edge[cnt].nexty=head[a];
    head[a]=cnt;
}
bool used[20000]={0};//是否遍历过
int col[20000]={0};//每一个点的染色
int sum[2];//黑白两种染色各自的点数
bool dfs(int node,int color)//染色（返回false即impossible）
{
    if(used[node])//如果已被染过色
    {
        if(col[node]==color)return true;//如果仍是原来的颜色，即可行
        return false;//非原来的颜色，即产生了冲突，不可行
    }
    used[node]=true;//记录
    sum[col[node]=color]++;//这一种颜色的个数加1，且此点的颜色也记录下来
    bool tf=true;//是否可行
    for(int i=head[node];i!=0&&tf;i=edge[i].nexty)//遍历边
    {
        tf=tf&&dfs(edge[i].t,1-color);//是否可以继续染色
    }
    return tf;//返回是否完成染色
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    int a,b;
    while(m--)
    {
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);//存的是有向边，所以存两次
    }
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        if(used[i])continue;//如果此点已被包含为一个已经被遍历过的子图，则不需重复遍历
        sum[0]=sum[1]=0;//初始化
        if(!dfs(i,0))//如果不能染色
        {
            printf("Impossible");
            return 0;//直接跳出
        }
        ans+=min(sum[0],sum[1]);//加上小的一个
    }
    printf("%d",ans);//输出答案
    return 0;
}

第四题：

图的遍历

代码：

#include<bits/stdc++.h>
using namespace std;

#define MAXL 100010

int N, M, A[MAXL];
vector<int> G[MAXL]; //vector存图 

void dfs(int x, int d) {
    if(A[x]) return; //访问过 
    A[x] = d;
    for(int i=0; i<G[x].size(); i++)
        dfs(G[x][i], d);
}

int main() {
    int u, v;
    scanf("%d%d", &N, &M);
    for(int i=1; i<=M; i++) {
        scanf("%d%d", &u, &v);
        G[v].push_back(u); //反向建边 
    }
    for(int i=N; i; i--) dfs(i, i); 
    for(int i=1; i<=N; i++) printf("%d ", A[i]);
    printf("\n");
    return 0;
}

思路：

每次考虑每个点可以到达点编号最大的点，不如考虑较大的点可以反向到达哪些点

循环从N到1，则每个点i能访问到的结点的A值都是i

每个点访问一次，这个A值就是最优的

第五题：灾后重建

代码：

#include<bit/stdc++.h>
#define N 205
using namespace std;
int n,m;
int a[N];
int f[N][N];//邻接矩阵存边
inline void updata(int k){
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
    if(f[i][j]>f[i][k]+f[j][k])
    f[i][j]=f[j][i]=f[i][k]+f[j][k];//用这个新的更新所有前面的 
    return;
}
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++)
    scanf("%d",a+i);//依次输入每一个村庄建立完成时需要的时间
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++){
        f[i][j]=1e9;//初始化为保证它不爆炸范围内的最大值 
    }
    for(int i=0;i<n;i++)
    f[i][i]=0;
    int s1,s2,s3;
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&s1,&s2,&s3);
        f[s1][s2]=f[s2][s1]=s3;//初始化边长 
    }
    int q;
    cin>>q;
    int now=0;
    for(int i=1;i<=q;i++){//处理各询问 
        scanf("%d%d%d",&s1,&s2,&s3);
        while(a[now]<=s3&&now<n){
            updata(now);//依次更新点，使它可以被用来更新其他的点 
            now++;
        }
        if(a[s1]>s3||a[s2]>s3)cout<<-1<<endl;
        else {
            if(f[s1][s2]==1e9)cout<<-1<<endl;
            else cout<<f[s1][s2]<<endl;
        }
    }
    return 0;
} 

思路：

若该路不通(两端的村庄尚未重建)，则 dp[i][j]=infdp[i][j]=inf

状态转移方程：dp[i][j]=min{dp[i][j],dp[i][u]+dp[u][j]}

每重建一个村庄，就以该村庄为中转站更新与其相连的道路的距离