专题:CF图论杂题

题目是来自HZW的博客(构造题我是各种不会...)

Solved	1 / 1	A	CodeForces 500A	New Year Transportation
Solved	1 / 1	B	CodeForces 437C	The Child and Toy
Solved	1 / 2	C	CodeForces 510C	Fox And Names
Solved	1 / 3	D	CodeForces 475B	Strongly Connected City
Solved	1 / 2	E	CodeForces 639B	Bear and Forgotten Tree 3
Solved	1 / 3	F	CodeForces 623A	Graph and String
Solved	1 / 20	G	CodeForces 449B	Jzzhu and Cities
Solved	1 / 4	H	CodeForces 543B	Destroying Roads

A

给一些线性排列的节点,每个节点有向后面第ai个节点的单向边,问是否能从1到T

1≤n,ai≤10^5

//直接模拟,1能到的点,所能到的点也是能到的,最后检查t
//
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int num[maxn];
int vis[maxn];

int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

	while(cin>>n>>m){
		memset(vis,0,sizeof vis);
		memset(num,0,sizeof num);
		for(int i=1;i<n;i++){
			cin>>num[i];
		}
		vis[1]=1;
		for(int i=1;i<n;i++){
			if(!vis[i])continue;
			vis[i+num[i]]=true;
		}
		if(vis[m])puts("YES");
		else puts("NO");
	}

#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

B

n个点.m条边的无向图,输入保证不含重边

删除一个点的代价是与这个点相邻的剩余点的权值和,求将所有点删除的最小代价

/*
很巧妙的思路,核心点在于,假设a,b两点相连
若先删除a,最终代价就是 b的权值+删除剩下所有点的花费
若先删除b,最终代价就是 a的权值+删除剩下所有点的花费
这个规则对于所有的相邻点都成立,简单来说,我们可以通过改变删除顺序,贪心的得到最小的代价
简单来说,对于任意一个边,其权值较大的一个端点就是我们先要删除的,也就是说代价是所有边中权值较小的一端
*/
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int num[maxn];
int vis[maxn];

int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

	while(cin>>n>>m){
		int ans=0;
		for(int i=1;i<=n;i++) cin>>num[i];
		while(m--){
			int a,b;
			cin>>a>>b;
			ans+=min(num[a],num[b]);
		}
		cout<<ans<<endl;
	}

#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

C

给定n个字符串，问是否存在一种自字母表,使得让这些字符串按照输入顺序排列满足字典序

1≤n,|S|≤100

 

直接按照输入顺序遍历,并建立一条从大字母到小字母的边,并记录所有点的入度

我们考虑dfs

对于入度为0的字母,自然放在新字母表的前端,然后把该字母节点删去,也就是把所有小于它的字母入度减一,如果入度为零了,自然也就可以放进剩下字母表的前端了

直到所有字母都进入字母表,进行检查是否合法,如果有的字母入度不为零,也就是还没入字母表,不存在答案

注意如果一个字符串是另一个字符串的前缀,它的字典序是更小的,也就是说如果一个字符串比他的前缀还靠前,不存在答案

其实这个过程也就是一个拓扑排序

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int stk[maxn];
int top;
int deg[maxn];
int alp[123];
vector<int>g[maxn];
char s[123][123];
int ans[123];
int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

	while(cin>>n){
		top=0;
		for(int i=0;i<30;i++)g[i].clear();
		memset(deg,0,sizeof deg);
//		for(int i=0;i<26;i++) alp[i]=i;
		for(int i=0;i<n;i++){
			cin>>s[i];
		}
		int flag=1;
		for(int i=0;i<n&&flag;i++){
			int len=strlen(s[i]);
			for(int j=i+1;j<n&&flag;j++){
				for(int k=0;k<len;k++){
					if(k>=strlen(s[j])){
						flag=0;
						break;
					}
					if(s[i][k]!=s[j][k]) {
						deg[s[j][k]-'a'+1]++;
						g[s[i][k]-'a'+1].push_back(s[j][k]-'a'+1);
						break;
					}
				}
			}
		}
		for(int i=1;i<=26;i++)if(!deg[i])stk[++top]=i;
		int cnt=0;
		while(top){
			int now=stk[top--];
			alp[cnt++]=now;
			for(int i=0;i<g[now].size();i++){
				int to=g[now][i];
				deg[to]--;
				if(!deg[to]){
					stk[++top]=to;
				}
			}
		}
		for(int i=1;i<=26;i++){
			if(deg[i]){
				flag=0;
				break;
			}
		}
		if(!flag)puts("Impossible");
		else {
			for(int i=0;i<26;i++){
				cout<<((char)(alp[i]+'a'-1));
			}
			cout<<endl;
		}
	}
#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

D

一个网格,你可以沿着格子上的线移动,

每一条横着贯穿的线只能向左或者向右走

每一个竖着贯穿的线只能向上或者向下走

问是否任意两点可达

 

dfs(我并不会),或者tarjan(敲得很舒服),写完看题解说可以只看外围情况...太菜了Orz

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
char hor[123];
char ver[123];
int g[23][23][23][23];
int vis[123][123];
const int dir[4][2]={1,0,-1,0,0,1,0,-1};
#define dx dir[d][0]
#define dy dir[d][1]
void dfs(int nx,int ny){
	vis[nx][ny]++;
	for(int d=0;d<4;d++){
		int x=nx+dx;
		int y=ny+dy;
		if(x&&y&&x<=n&&y<=m&&g[nx][ny][x][y]&&!vis[x][y]){
			dfs(x,y);
		}
	}
}
int main(){

#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif
	while(cin>>n>>m){
		cin>>(hor+1)>>(ver+1);
		memset(g,0,sizeof g);
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				if(hor[i]=='<'&&j){
					g[i][j][i][j-1]=1;
				}else if(hor[i]=='>'&&j<m){
					g[i][j][i][j+1]=1;
				}
			}
		}
		for(int i=1;i<=m;i++){
			for(int j=1;j<=n;j++){
				if(ver[i]=='v'&&j<n){
					g[j][i][j+1][i]=1;
				}else if(ver[i]=='^'&&j){
					g[j][i][j-1][i]=1;
				}
			}
		}
		int flag=1;
		memset(vis,0,sizeof vis);
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				memset(vis,0,sizeof vis);
				dfs(i,j);
				for(int k=1;k<=n;k++){
					for(int q=1;q<=m;q++){
						if(!vis[k][q]){
							flag=0;
							k=q=1e9;
						}
					}
				}
				if(!flag) i=j=1e9;
			}
		}
		if(flag) puts("YES");
		else puts("NO");
	}

#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
char hor[123],ver[123];
int stk[1234],top,cnt,dfn[1234],low[1234],numc,belong[1234];
int vis[1234];
struct node {
	int to,next;
}e[maxn];
int nume,head[1234];
void add(int a,int b){
	e[nume]=(node){b,head[a]};
	head[a]=nume++;
}
void tdfs(int now){
	dfn[now]=low[now]=++cnt;
	stk[top++]=now;
	vis[now]=1;
	for(int i=head[now];~i;i=e[i].next){
		int to=e[i].to;
		if(!dfn[to]){tdfs(to);low[now]=min(low[now],low[to]);}
		else if(vis[to]) low[now]=min(low[now],low[to]);
	}
	if(low[now]==dfn[now]){
		numc++;
		int to;
		do{
			to=stk[--top];
			belong[to]=numc;
			vis[to]=0;
		}while(to!=now);
	}
}
void tarjan(int numv=n){
	for(int i=1;i<=numv;i++){
		if(!dfn[i]) tdfs(i);
	}
}
int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

	while(cin>>n>>m){
		nume=top=numc=cnt=0;
		memset(head,-1,sizeof head);
		memset(dfn,0,sizeof dfn);
		memset(low,0,sizeof low);
		memset(belong,0,sizeof belong);
		memset(vis,0,sizeof vis);
		cin>>(hor+1)>>(ver+1);
		for(int i=1;i<=n;i++){
			if(hor[i]=='<')
				for(int j=2;j<=m;j++)
					add((i-1)*m+j,(i-1)*m+j-1);
			else for(int j=1;j<m;j++)
				add((i-1)*m+j,(i-1)*m+j+1);
		}
		for(int i=1;i<=m;i++){
			if(ver[i]=='v')
				for(int j=1;j<n;j++)
					add((j-1)*m+i,(j)*m+i);
			else for(int j=2;j<=n;j++)
					add((j-1)*m+i,(j-2)*m+i);
		}
		tarjan(n*m);
		puts((numc==1)?"YES":"NO");
	}

#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

E

给一个树的3种属性,点数,深度,直径

让你构造出来其中一种

 

先判断是否可行

再去构造深度

再去构造剩下的满足直径

再把其他点放在..不影响之前性质的地方(我一开始写的链式前向星存图,其实只用保留前驱节点就行..)

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
struct node {int to,cost,next;}e[maxm];int head[maxn],nume;
void add(int a,int b,int c=1){e[++nume]=(node){b,c,head[a]};head[a]=nume;}
int pre[maxn];

int main(){
//#define test
#ifdef test
    freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

    while(cin>>n>>k>>m){
        if(k<m||k==n||k==1&&n>2||k>2*m){
            puts("-1");
            continue;
        }
        memset(pre,0,sizeof pre);
        for(int i=2;i<=m+1;i++) pre[i]=i-1;
        (m+2<=k+1) pre[m+2]=1;
        for(int i=m+3;i<=k+1;i++) pre[i]=i-1;
        for(int i=k+2;i<=n;i++) pre[i]=m;
        for(int i=2;i<=n;i++) cout<<pre[i]<<' '<<i<<endl;
    }

#ifdef test
    fclose(stdin);fclose(stdout);system("out.txt");
#endif
    return 0;
}

F

给n个点m个边

告诉你这个图其实是一个abc三个字母的字符串构成的

如果Si和Sj差距小于等于1,则连接一条无向边

问一个合法解,也就是问一种合法的染色

 

首先,记录入度

如果入度等于n-1,也就是和所有其他点都有边,这个字母自然是b

然后,对于任意一对没有染色的点,自然一个是a,一个是c

然后,其中和a连接的,自然是a,反之是c

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e3+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
int deg[maxn];
int g[maxn][maxn];
int ans[maxn];
int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

	while(cin>>n>>m){
		memset(g,0,sizeof g);
		memset(deg,0,sizeof deg);
		for(int i=0;i<m;i++){
			int a,b;
			scanf("%d%d",&a,&b);
			g[a][b]=g[b][a]=1;
			deg[a]++;
			deg[b]++;
		}
		memset(ans,0,sizeof ans);
		for(int i=1;i<=n;i++){
			if(deg[i]==n-1) ans[i]=2;
		}
		for(int i=1;i<=n;i++){
			if(ans[i]) continue;
			for(int j=i+1;j<=n;j++){
				if(!g[i][j]){
					ans[i]=1;ans[j]=3;
					for(int k=1;k<=n;k++){
						if(k==i||k==j||ans[k]) continue;
						if(g[k][i]) ans[k]=1;
						if(g[k][j]) ans[k]=3;
					}
				}
			}
		}
		int sin=1;
		for(int i=1;i<=n;i++){
			if(!ans[i]){
				sin=0;
				break;
			}
		}
		for(int i=1;i<=n&&sin;i++){
			for(int j=i+1;j<=n;j++){
				if(g[i][j]&&abs(ans[i]-ans[j])>1){
					sin=0;
					break;
				}
				if(!g[i][j]&&abs(ans[i]-ans[j])<=1){
					sin=0;
					break;
				}
			}
		}
		if(sin){
			puts("YES");
			for(int i=1;i<=n;i++)cout<<(char)(ans[i]+'a'-1);
			cout<<endl;
		}
		else puts("NO");
	}

#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

G

给一个无向图,又有一些额外边是从起点直接到某些点的,存在重边

问你最多删除多少个额外路,使得每个点到起点的最短路不变

 

先构造图,跑一边spfa,然后如果有特殊路大于当前最短路,直接删掉

否则枚举这个点的边,如果有和这个点相邻的点+边权等于到该点的特殊路径,也删掉

而对于任意一点

如果特殊路径被保存了一个,其他到该点的特殊路径也都应该被删除

如果该点的特殊路径等于其他走普通路径的距离,其他所有到该点的特殊路径也应该被删除

标记,剪枝一下即可

注意,该题卡spfa,但是用spfa+slf优化可以秒杀

当然,也可能是我这个做法比较臭(也有可能是因为重边太多了)

能想到的还有比如记录入度,如果入度大于1且有同样长度,就删除,速度应该差不多

还有就是先跑一遍spfa,然后加入特殊路之前先剪枝一波,然后再在原图的基础上跑一遍spfa

或者就是把有特殊路的节点标记上,如果这个点被松弛了,自然这个地方的特殊路就会被删除,最后统计...

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
#define ll long long
int casn,n,m,k;
struct node {int to;int cost;int next;}e[maxm];int head[maxn],nume;
inline void add(int a,int b,int c=1){e[++nume]=(node){b,c,head[a]};head[a]=nume;}
int road[maxn];
ll dis[maxn];
bool vis[maxn];
int que[maxn];
int go[maxn];

void spfa(int st=1,int ed=n){
  int top=0,end=0,now;
  memset(dis,INF,sizeof dis);
  memset(vis,0,sizeof vis);
  que[end++]=st,dis[st]=0;
  while(top!=end){
    now=que[top++],top%=maxn;
    vis[now]=false;
    for(int i=head[now];i;i=e[i].next){
      int to=e[i].to;
      if(now==to) continue;
      if(dis[now]+e[i].cost<dis[to]){
        dis[to]=dis[now]+e[i].cost;
        if(!vis[to]){
       	 vis[to]=true;
        	if(dis[to]<dis[que[top]]){
		  		  top--;
		  		  if(top==-1)top=maxn-1;
		  		  que[top]=to;
					}else{
						que[end++]=to;
						end%=maxn;
					}
				}
      }
    }
  }
}

int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif

	cin>>n>>m>>k;
	for(int i=0;i<m;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	int ans=0;
	int cnt=0;
	for(int i=1;i<=k;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		add(1,a,b);
		road[i]=b;
		go[i]=a;
	}
	spfa();
	memset(vis,0,sizeof vis);
	for(int i=1;i<=k;i++){
		if(vis[go[i]]||road[i]>dis[go[i]]){
			ans++;
			continue;
		}
		for(int j=head[go[i]];j;j=e[j].next){
			int to=e[j].to;
			if(dis[go[i]]==dis[to]+e[j].cost){
				ans++;
				break;
			}
		}
		vis[go[i]]=1;
	}
	cout<<ans<<endl;

#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}

H

给一个无权图,问你如何删除最多的边

才能使得s1 t1的距离依然大于l1,s2 t2的距离依然大于l2

n<=3000

 

原题等价于最少多少条边可满足l1,l2的条件,其他的边都可以删掉

首先如果两个路无交集,就是要保留s1 t1,s2 t2的路径边数之和

然后n^2枚举共同路径,如果走共同路径的路径长度满足条件,就更新答案

注意点数可以达到3000,我的floyd一直T,改成n次spfa+slf优化就ac了...原谅我spfa敲得太顺手了..

#include <string.h>
#include <iostream>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn=1e5+10;
const int maxm=1e6+10;
const int INF=0x3f3f3f3f;
int casn,n,m,k;
struct node {int to,cost,next;}e[maxm];int head[maxn],nume;
void add(int a,int b,int c=1){e[++nume]=(node){b,c,head[a]};head[a]=nume;}
int s1,s2,t1,t2,l1,l2;
int dis[3000+15][3000+15];
bool vis[maxn];
int que[maxn];
void spfa(int st=1,int ed=n){
  int top=0,end=0,now;
  memset(vis,0,sizeof vis);
  que[end++]=st,dis[st][st]=0;
  while(top!=end){
    now=que[top++],top%=maxn;
    vis[now]=false;
    for(int i=head[now];i;i=e[i].next){
      int to=e[i].to;
      if(now==to) continue;
      if(dis[st][now]+e[i].cost<dis[st][to]){
        dis[st][to]=dis[st][now]+e[i].cost;
        if(!vis[to]){
       	 vis[to]=true;
        	if(dis[now][to]<dis[now][que[top]]){
		  		top--;
		  		if(top==-1)top=maxn-1;
		  		que[top]=to;
			}else{
				que[end++]=to;
				end%=maxn;
			}
		}
      }
    }
  }
}

int main(){
//#define test
#ifdef test
	freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
#endif
	ios::sync_with_stdio(false);
	cin>>n>>m;
	memset(dis,0x3f,sizeof dis);
	for(int i=0;i<m;i++){
		int a,b;
		cin>>a>>b;
		add(a,b,1);
		add(b,a,1);
	}
	cin>>s1>>t1>>l1;
	cin>>s2>>t2>>l2;
	for(int i=1;i<=n;i++){
		spfa(i);
	}
	int flag=1;
	if(dis[s1][t1]>l1||dis[s2][t2]>l2){
		flag=0;
	}
	int ans=dis[s1][t1]+dis[s2][t2];
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			int d1=dis[s1][i]+dis[j][t1];
			int d2=dis[s2][i]+dis[j][t2];
			int mid=dis[i][j];
			int d3=dis[s1][j]+dis[i][t1];
			int d4=dis[s2][j]+dis[i][t2];
			if(d1+mid<=l1&&d2+mid<=l2){
				ans=min(ans,d1+d2+mid);
			}
			if(d3+mid<=l1&&d4+mid<=l2){
				ans=min(ans,d3+d4+mid);
			}
			if(d1+mid<=l1&&d4+mid<=l2){
				ans=min(ans,d1+d4+mid);
			}
			if(d3+mid<=l1&&d2+mid<=l2){
				ans=min(ans,d3+d2+mid);
			}
		}
	}
	if(flag) cout<<m-ans<<endl;
	else puts("-1");
#ifdef test
	fclose(stdin);fclose(stdout);system("out.txt");
#endif
	return 0;
}