week 5周报（简单图及例题）

T1

题目背景

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

题目描述

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

我们来定义一个危险系数 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

由题意可得这是一个无向图，因此我们在建边时要建双向边，用vector存储。当我们不重复的遍历所有从u到v的路径，如果这些路径的数量等于其中一些节点经过的次数，那么这些节点就是关键节点，因此我们只需要用一个数组记录每个节点经过的次数。代码如下：

#include<bits/stdc++.h>
using namespace std;
int x,y,n,m,st,ed;
int vis[1005];
int tot=0;
int cnt[1005];
vector<int> T[1005];
void dfs(int now)
{
	//cout<<now<<endl;
	if(now==ed)
	{ 
		tot++;
		for(int k=1;k<=n;k++)
		{
			if(vis[k]==1)
			{
				cnt[k]++; 
			}
		}
		return;
	}
	for(int p=0;p<T[now].size();p++)
	{
		int to=T[now][p];
		if(vis[to]==0)
		{
			vis[to]=1;
			dfs(to);
			vis[to]=0;
			//这里不能return
		}
	}
	return;	
}
int main()
{
	memset(vis,0,sizeof(vis));
	memset(cnt,0,sizeof(cnt));
	cin>>n>>m;
	for(int i=0;i<m;i++)
	{
		cin>>x>>y;
		T[x].push_back(y);
		T[y].push_back(x);
	}
	cin>>st>>ed;
	dfs(st);
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		if(cnt[i]==tot)
		{
			ans++;
		}
	}
	cout<<--ans;
	return 0;
}

T2

题目描述

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

说明/提示

• 对于 60\%60% 的数据，1 \leq N,M \leq 10^31≤N,M≤103。
• 对于 100\%100% 的数据，1 \leq N,M \leq 10^51≤N,M≤105。

 这题的关键思想在于反向建边，因为验证的时候的是反向回溯的，从大往小遍历，如果之前到达过，呢么之前的答案一定更大。代码如下：

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

int n,m,x,y;
vector<int> G[100005];
int ans[100005];

void dfs(int now,int st)
{
	if(ans[now])
	{
		return;
	}
	ans[now]=st;
	for(int i=0;i<G[now].size();i++)
	{
		int to=G[now][i];
		dfs(to,st);
	}
}


int main()
{
	memset(ans,0,sizeof(ans));
	 cin>>n>>m;
	 for(int i=1;i<=m;i++)
	 {
	 	cin>>x>>y;
	 	G[y].push_back(x);
	 }
	for(int o=n;o>0;o--)
	{
			dfs(o,o);
	}
	for(int i=1;i<=n;i++)
	{
		cout<<ans[i];
		if(i<n)
		{
			cout<<" ";
		}
	}
	return 0;
}

T3

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

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

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

输入格式

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

输出格式

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

输入输出样例

输入 #1复制

3 3
1 2
1 3
2 3

输出 #1复制

Impossible

输入 #2复制

3 2
1 2
2 3

输出 #2复制

1

 这题我们同样也是建立双向边，用链式前向星存边，对每个子图遍历，染色，记录较少的颜色最后累加输出即可；代码如下：

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

int n,m,x,y;
int ans=0;
struct edge
{
	int d,next;	
}e[200001];
int head[20001]={0};
int cnt=0;
void add(int a,int b)
{
	cnt++;
	e[cnt].d=b;
	e[cnt].next=head[a];
	head[a]=cnt;
}
int col[20000]={0};
int sum[3];


bool dfs(int node,int color)
{
	if(col[node])
	{
		if(col[node]==color)
		{
			return true;
		}
		if(col[node]!=color)
		{
			return false;
		}
	}
	col[node]=color;
	sum[color]++;
	bool tf = true;
	for(int i=head[node];tf && i!=0;i=e[i].next)
	{
		tf=tf && dfs(e[i].d,color%2+1);
	}
	return tf;
}
int main()
{
	 cin>>n>>m;
	 for(int i=1;i<=m;i++)
	 {
	 	cin>>x>>y;
	 	add(x,y),add(y,x);
	 }
	 for(int i=1;i<=n;i++)
	 {
	 	if(col[i])
	 	{
	 		continue;	
		}
		sum[1]=sum[2]=0;
		if(!dfs(i,1))
		{
			cout<<"Impossible";
			return 0;
		}
		ans+=sum[1]<=sum[2]?sum[1]:sum[2];
	 }
	 
	cout<<ans;
	return 0;
}