必做题Week9

唯一信仰.

于 2023-12-11 13:25:55 发布

阅读量53

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/2301_79178533/article/details/134850589

版权

【模板】并查集

题目描述

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

输入格式

第一行包含两个整数 $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

样例输出 #1

N
Y
N
Y

提示

对于 $30\%$ 的数据， $\le 10$ ， $\le 20$ 。

对于 $70\%$ 的数据， $\le 100$ ， $\le 10^3$ 。

对于 $100\%$ 的数据， $1\le N \le 10^4$ ， $1\le M \le 2\times 10^5$ ， $\le X_i, Y_i \le N$ ， $Z_i \in \{ 1, 2 \}$ 。

思路：模板

代码

#include<iostream>

using namespace std;

const int N = 2e5 + 10;
int fa[N];
int n, m, p1, p2, p3;

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

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		fa[i] = i;
	}
	for (int i = 1; i <= m; i++)
	{
		cin >> p1 >> p2 >> p3;
		if (p1 == 1)
		{
			fa[find(p2)] = find(p3);
		}
		else
			if (find(p2) == find(p3))
				printf("Y\n");
			else
				printf("N\n");
	}

	return 0;
}

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

题目背景

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

题目描述

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

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

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

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

输入格式

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

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

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

输出格式

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

样例 #1

样例输入 #1

样例输出 #1

提示

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

思路：分析可知，关键点对每条路都具有影响作用，故而我们可以考虑记录不同的从起点到达目标点的所有可能走过某一点的次数如果刚好等于到达次数那么就是一个关键点

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;

int g[N][N];
int n, m, x, y, ans[N], amount, end, sum = 0;
bool vis[N];

void dfs(int u)
{
	if (u == y)
	{
		amount++;
		for (int i = 1; i <= m; i++)
		{
			ans[i] += vis[i] ? 1 : 0;
		}
		return;
	}

	vis[u] = 1;
	for (int i = 1; i <= n; i++)
	{
		if (g[u][i])
		{
			if (vis[i])continue;
			dfs(i);
		}
	}
	vis[u] = 0;
}

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= m; i++)
	{
		cin >> x >> y;
		g[x][y] = g[y][x] = 1;
	}

	cin >> x >> y;
	dfs(x);
	for (int i = 1; i <= n; i++)
	{
		if (ans[i] == amount)sum++;
	}
	printf("%d", sum - 1);
	return 0;
}

封锁阳光大学

题目描述

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

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

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

输入格式

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

输出格式

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

样例 #1

样例输入 #1

样例输出 #1

Impossible

样例 #2

样例输入 #2

3 2
1 2
2 3

样例输出 #2

提示

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

思路：染色二分图，每一条边都有且仅有一个被它所连接的点被选中

代码

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N = 100010;

bool used[N];
int col[N], sum[2];
int q[N];
int h[N], e[N], ne[N], idx;
int n, m;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}


bool dfs(int u, int color)
{
    if(used[u])
    {
        if(col[u] == color)return true;
        return false;
    }

    used[u] = true;
    sum[col[u] = color]++;
    bool tf = true;

    for(int i = h[u]; i != -1 && tf; i = ne[i])
    {
        tf = tf && dfs(e[i], 1 - color);
    } 

    return tf;
}
int main()
{
    memset(h, -1, sizeof(h));
    cin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int a, b;
        cin >> 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]);
    }

    cout << ans;

    return 0;
}

图的遍历

题目描述

给出 $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

样例输入 #1

样例输出 #1

4 4 3 4

提示

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

思路：正着存点可能会经过很多没必要的操作，所以我们可以考虑倒着存

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10;
int ne[N], e[N], h[N], idx, maxx[N];
int ver[N];
int n, m;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int now, int st)//st是能到的当前能到的最大点
{
    if(maxx[now])return;
    maxx[now] = st;
    for(int i = h[now]; i != -1; i = ne[i])
        if(!maxx[e[i]])
            dfs(e[i], st);

    return;        
}

int main()
{
    memset(h, -1, sizeof(h));
    cin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int a, b;
        cin >> a >> b;
        add(b, a);//倒过来存点直接杀死比赛
    }

    for(int i = n; i > 0; i--)
        dfs(i, i);//一定能到自己，所以st先赋值为i

    for(int i = 1; i <= n; i++)
    {
        printf("%d ", maxx[i]);
    }    

    return 0;
}

灾后重建

题目背景

B 地区在地震过后，所有村庄都造成了一定的损毁，而这场地震却没对公路造成什么影响。但是在村庄重建好之前，所有与未重建完成的村庄的公路均无法通车。换句话说，只有连接着两个重建完成的村庄的公路才能通车，只能到达重建完成的村庄。

题目描述

给出 B 地区的村庄数 $N$ ，村庄编号从 $0$ 到 $N - 1$ ，和所有 $M$ 条公路的长度，公路是双向的。并给出第 $i$ 个村庄重建完成的时间 $t_i$ ，你可以认为是同时开始重建并在第 $t_i$ 天重建完成，并且在当天即可通车。若 $t_i$ 为 $0$ 则说明地震未对此地区造成损坏，一开始就可以通车。之后有 $Q$ 个询问 $(x, y, t)$ ，对于每个询问你要回答在第 $t$ 天，从村庄 $x$ 到村庄 $y$ 的最短路径长度为多少。如果无法找到从 $x$ 村庄到 $y$ 村庄的路径，经过若干个已重建完成的村庄，或者村庄 $x$ 或村庄 $y$ 在第 $t$ 天仍未重建完成，则需要输出 $- 1$ 。

输入格式

第一行包含两个正整数 $N, M$ ，表示了村庄的数目与公路的数量。

第二行包含 $N$ 个非负整数 $t_0,t_1,\cdots,t_{N-1}$ ，表示了每个村庄重建完成的时间，数据保证了 $t_0 \le t_1 \le \cdots \le t_{N-1}$ 。

接下来 $M$ 行，每行 $3$ 个非负整数 $i, j, w$ ， $w$ 为不超过 $10000$ 的正整数，表示了有一条连接村庄 $i$ 与村庄 $j$ 的道路，长度为 $w$ ，保证 $i\neq j$ ，且对于任意一对村庄只会存在一条道路。

接下来一行也就是 $M + 3$ 行包含一个正整数 $Q$ ，表示 $Q$ 个询问。

接下来 $Q$ 行，每行 $3$ 个非负整数 $x, y, t$ ，询问在第 $t$ 天，从村庄 $x$ 到村庄 $y$ 的最短路径长度为多少，数据保证了 $t$ 是不下降的。

输出格式

共 $Q$ 行，对每一个询问 $(x, y, t)$ 输出对应的答案，即在第 $t$ 天，从村庄 $x$ 到村庄 $y$ 的最短路径长度为多少。如果在第 $t$ 天无法找到从 $x$ 村庄到 $y$ 村庄的路径，经过若干个已重建完成的村庄，或者村庄 $x$ 或村庄 $y$ 在第 $t$ 天仍未修复完成，则输出 $- 1$ 。

样例 #1

样例输入 #1

样例输出 #1

-1
-1
5
4

提示

对于 $30\%$ 的数据，有 $N\le 50$ ；
对于 $30\%$ 的数据，有 $t_i=0$ ，其中有 $20\%$ 的数据有 $t_i=0$ 且 $N > 50$ ；
对于 $50\%$ 的数据，有 $Q\le 100$ ；
对于 $100\%$ 的数据，有 $1\le N\le 200$ ， $0\le M\le \dfrac{N\times(N-1)}{2}$ ， $1\le Q\le 50000$ ，所有输入数据涉及整数均不超过 $10^5$ 。

思路：Floyd算法，然后该改造一下预处理的过程

代码

#include<bits/stdc++.h>
using namespace std;
const int MAX_INT=0x3f3f3f3f;
int villageCount, roadCount, distanceMatrix[201][201], repairTime[203];
bool isRepaired[203];
inline int readInt()
{
    char c=getchar(); int total=0, sign=1;
    while(!(c>='0'&&c<='9')) {if(c=='-') sign=-1; c=getchar();}
    while(c>='0'&&c<='9') {total=((total<<1)+(total<<3))+(c-'0'); c=getchar();}
    return total*sign;
}
int main()
{
    memset(distanceMatrix, MAX_INT, sizeof(distanceMatrix));
    villageCount=readInt(); roadCount=readInt();
    for(int i=1; i<=villageCount; i++)  repairTime[i]=readInt();
    for(int i=1; i<=roadCount; i++)
    {
        int a=readInt()+1, b=readInt()+1, weight=readInt();
        distanceMatrix[a][b]=weight; distanceMatrix[b][a]=weight;
    }
    repairTime[villageCount+1]=MAX_INT;
    int queryCount=readInt();
    int currentVillage=0;
    while(queryCount--)
    {
        int startVillage=readInt()+1, endVillage=readInt()+1, time=readInt();
        while(repairTime[currentVillage+1]<=time)
        {
            currentVillage++;
            isRepaired[currentVillage]=1;
            for(int i=1; i<=villageCount; i++)  for(int j=1; j<=villageCount; j++)  if(isRepaired[i]&&isRepaired[j]) distanceMatrix[i][j]=min(distanceMatrix[i][j],distanceMatrix[i][currentVillage]+distanceMatrix[currentVillage][j]);
            for(int k=1; k<=villageCount; k++)  for(int j=1; j<=villageCount; j++)  if(isRepaired[k]&&isRepaired[j]) distanceMatrix[currentVillage][j]=min(distanceMatrix[currentVillage][j],distanceMatrix[currentVillage][k]+distanceMatrix[k][j]);
            for(int k=1; k<=villageCount; k++)  for(int j=1; j<=villageCount; j++)  if(isRepaired[k]&&isRepaired[j]) distanceMatrix[j][currentVillage]=min(distanceMatrix[j][currentVillage],distanceMatrix[j][k]+distanceMatrix[k][currentVillage]);
        }
        if(!isRepaired[startVillage]||!isRepaired[endVillage]||distanceMatrix[startVillage][endVillage]>=10000000) printf("-1\n");
        else
        {
            for(int k=1; k<=villageCount; k++)  if(isRepaired[k]) distanceMatrix[startVillage][endVillage]=min(distanceMatrix[startVillage][endVillage],min(distanceMatrix[startVillage][k]+distanceMatrix[k][endVillage],distanceMatrix[k][startVillage]+distanceMatrix[endVillage][k]));
            printf("%d\n",distanceMatrix[startVillage][endVillage]);
        }
    }
    return 0;
}