week5

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

题目背景

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

题目描述

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

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

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

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

输入格式

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

接下来 mm 行，每行两个整数 u,v(1 \le u,v \le n,u\neq v)u,v(1≤u,v≤n,u=v) 代表一条通道。

最后 11 行，两个数 u,vu,v，代表询问两点之间的危险系数 DF(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

题解：

需要用dfs遍历所有点并记录节点经过的次数，如果节点经过次数与总次数相同，则说明该节点是关键节点。

#include<iostream>
#include<vector>
using namespace std;
vector <int> M[3000];
int a, b;
bool jilu[3000];
int jilucishu[3000];
int st, ed, cishu;
void dfs(int x) {
	jilu[x] = 1;
	if (x == ed) {
		cishu++;
		for (int e = 1; e <= a; e++) {
			if (jilu[e] == 1) {
				jilucishu[e]++;
			}
		}
		jilu[x] = 0;
		return;
	}
	for (int e = 0; e < M[x].size(); e++) {
		int abc = M[x][e];
		if (!jilu[abc]) {
			dfs(abc);
			jilu[abc] = 0;
		}
	}

	return;
}
int main() {

	cin >> a >> b;
	for (int e = 0; e < b; e++) {
		int x, y;
		cin >> x >> y;
		M[x].push_back(y);
		M[y].push_back(x);
	}
	cin >> st >> ed;

	dfs(st);
	int ans = 0;
	for (int e = 1; e <= a; e++) {
		if (jilucishu[e] == cishu) {
			ans++;
		}
	}
	if (ans == 0) {
		ans = -1;
	}
	else {

		ans -= 2;
	}
	cout << ans;
	system("pause");
	return 0;
}

P3916 图的遍历

题目描述

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

输入格式

第 11 行 22 个整数 N,MN,M，表示点数和边数。

接下来 MM 行，每行 22 个整数 U_i,V_iUi​,Vi​，表示边 (U_i,V_i)(Ui​,Vi​)。点用 1,2,\dots,N1,2,…,N 编号。

输出格式

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

输入输出样例

输入 #1

4 3
1 2
2 4
4 3

输出 #1

4 4 3 4

题解：

从后往前建图，否则会超时，把尾端最大值的大小赋值给前面的节点，并每个点都遍历一次，如果经过过了就跳过

#include<iostream>
#include<vector>
using namespace std;
bool vis[100001] = {0};
vector <int> M[100001];
int n, m, op, ed, jilu[100001] = { 0 }, zuida;
void dfs(int x)
{
    for (int i = 0; i < M[x].size(); i++)
    {
        int to = M[x][i];
        if (vis[to] == false)
        {
            vis[to] = true;
            jilu[to] = zuida;
            dfs(to);
        }
    }
}
int main()
{
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        cin >> ed >> op;
        M[op].push_back(ed);
    }
    for (int i = n; i > 0; i--)
    {
        if (vis[i] == true)
        {
            continue;
        }
        zuida = i;
        jilu[i] = zuida;
        vis[i] = true;
        dfs(i);
    }
    for (int i = 1; i <= n; i++)
    {
        cout << jilu[i];
        if (i != n)
        {
           cout << ' ';
        }
    }
}

P1330 封锁阳光大学

题目描述

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

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

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

输入格式

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

输出格式

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

输入输出样例

输入 #1

3 3
1 2
1 3
2 3

输出 #1

Impossible

题解：

用bfs遍历所有点，对经过的节点轮流赋值1和-1，如果相邻的两个端点数字相同，则说明不能封锁，最后判断1和-1的数量，最少的即为最少河蟹数

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int n, m, aa[10005], ans = 0;
bool panduan[10005];
vector<int>M[10005];
queue<int> N;
int main() {
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int x, y;
        cin >> x >> y;
        M[x].push_back(y);
        M[y].push_back(x);
    }
    for (int i = 1; i <= n; i++) {
        int a = 0, b = 0;
        if (!panduan[i] && !M[i].empty()) {
            N.push(i);
            aa[i] = 1;
            while (!N.empty()) {
                int now = N.front();
                N.pop();
                if (aa[now] == 1) a++;
                else if (aa[now] == -1) b++;
                panduan[now] = true;
                for (int i = 0; i < M[now].size(); i++) {
                    int to = M[now][i];
                    if (panduan[to]) {
                        if (aa[to] == aa[now]) {
                            cout << "Impossible";
                            return 0;
                        }
                    }
                    else {
                        N.push(to);
                        aa[to] = -aa[now];
                    }
                }
            }
        }
        ans += min(a, b);
    }
    cout << ans;
    return 0;
}