刷题记录 kuangbin带你飞专题九：连通图

最新推荐文章于 2021-05-13 14:54:16 发布
最新推荐文章于 2021-05-13 14:54:16 发布
阅读量349 收藏
点赞数
分类专栏： 连通性问题 图论 kuangbin 文章标签： 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Raki_J/article/details/106671351
版权

这个专题实属虐心…各种debug搞到自闭
不过进步就是在自闭中产生的…
后面被反向边逼迫使用了链式前向星建图（双修？）

1.POJ 1236 Network of Schools

任务一：求出入度为0的连通分量数量
任务二：求加多少条边能让整个图强连通
对于第二问，因为要使整个图强连通，贪心的拿每一个出度为0的点对入度为0的点加边，这样下来最小的加边数就是max（入度，出度）

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
const int maxn=1e3+5,maxm=1e3+5;
int n,m,chu[maxn];
int dfn[maxn],low[maxn],vis[maxn],z[maxn],color[maxn],cnt[maxn],ru[maxn],t,k,tot;
vector<int>e[maxm];
void tarjan(int u,int fa){
	dfn[u]=low[u]=++tot;
	z[++k]=u;//入栈 
	vis[u]=1;
	for(int i=0;i<e[u].size();i++){
		if(!dfn[e[u][i]]){
			tarjan(e[u][i],fa);
			low[u]=min(low[u],low[e[u][i]]);
		}
		else if(vis[e[u][i]]){
			low[u]=min(low[u],dfn[e[u][i]]);
		}
	}
	if(low[u]==dfn[u]){
		t++;//连通分量的标号 
		do{
			color[z[k]]=t;    //属于这个连通分量 
			cnt[t]++;         //记录这个环中有多少个点
			vis[z[k]]=0; 
			k--;              //出栈 
		}while(u!=z[k+1]);
	}
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		while(1){
		    int v;
	    	scanf("%d",&v);
		    if(v==0)break;
	    	e[i].push_back(v);	
		}
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i,i);
	}
	int ans=0,maxx=0;
	for(int i=1;i<=n;i++){
		for(int j=0;j<e[i].size();j++){
			if(color[i]!=color[e[i][j]]){
				ru[color[e[i][j]]]++;
				chu[color[i]]++;
			}
		}
	}
	int x=0,y=0;
	for(int i=1;i<=t;i++){
		if(ru[i]==0)x++;
		if(chu[i]==0)y++;
	}
	if(t==1)cout<<x<<endl<<"0";
	else cout<<x<<endl<<max(x,y);
	return 0;
}

2.UVA 315 Network

求割点
uva读入恶心人

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
const int maxn=2e4+5,maxm=2e4+5;
int n,m;
bool cut[maxn];
int dfn[maxn],low[maxn],vis[maxn],z[maxn],color[maxn],cnt[maxn],du[maxn],t,k,tot;
vector<int>e[maxm];
void tarjan(int u,int root){//root代表此树的根 
	int child=0;
	dfn[u]=low[u]=++tot;
	for(int i=0;i<e[u].size();i++){
		int v=e[u][i];
		if(!dfn[v]){
			tarjan(v,root);
			low[u]=min(low[u],low[v]);
			if(low[v]>=dfn[u]&&u!=root)cut[u]=true;
			if(u==root)child++;
		}
		low[u]=min(low[u],dfn[v]);
	}
	if(u==root&&child>=2){
		cut[root]=true;
	}
}
void init(int n){
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
	memset(cut,false,sizeof(cut));
	for(int i=0;i<=n;i++){
		e[i].clear();
	}
}
int main(){
	int u,v;
	char c;
	while(cin>>n){
		if(n==0)break;
		init(n);
		while (scanf("%d", &u), u) {
			while (scanf("%c", &c), c != '\n') {
				scanf("%d", &v);
				e[u].push_back(v);
				e[v].push_back(u);
			}
		}
		for(int i=1;i<=n;i++){
	    	if(!dfn[i])tarjan(i,i);
    	}
    	int ans=0;
    	for(int i=1;i<=n;i++){
	    	if(cut[i])ans++;
    	}
    	cout<<ans<<endl;
	}
	return 0;
}

3.UVA 796 Critical Links

求桥
uva读入再次恶心人
对于求桥有不同的写法，有时候会出现玄学错误…

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
const int maxn=2e5+5,maxm=5e5+5;
int n,m;
int dfn[maxn],low[maxn],t,k,tot;
vector<int>e[maxm];
struct edge{
	int u,v;
}qiao[maxm];
bool cmp(edge a,edge b){
	if(a.u==b.u)return a.v<b.v;
	return a.u<b.u;
}
void tarjan(int u,int root){//root代表此树的根 
	dfn[u]=low[u]=++tot;
	for(int i=0;i<e[u].size();i++){
		int v=e[u][i];
		if(!dfn[v]){
			tarjan(v,u);
			low[u]=min(low[u],low[v]);
			if(low[v]>dfn[u]){
				t++;
				qiao[t].u=min(u,v);
				qiao[t].v=max(u,v);
			}
		}
		else if(v!=root)low[u]=min(low[u],dfn[v]);
	}
	return;
}
void init(int n){
	t=0;
	tot=0;
	k=0;
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
	for(int i=0;i<=n;i++){
		e[i].clear();
	}
}
int main(){
	while(cin>>n){
	init(n);
	int u,v,num;
	char c1,c2;
	for(int i=1;i<=n;i++){
		cin>>u>>c1>>num>>c2;
		u++;
		while(num--){
			cin>>v;
			v++;
			e[u].push_back(v);
		}
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i,0);
	}
	sort(qiao+1,qiao+1+t,cmp);
	printf("%d critical links\n",t);
	for(int i=1;i<=t;i++){
    	printf("%d - %d\n",qiao[i].u-1,qiao[i].v-1);
	}
	cout<<endl;
}
	return 0;
}

4.POJ 3694 Network

求加边的过程中，桥的数量
正解应该是每次加边后求出lca，加入这条边之后这个环上面的边就都不是桥了
借鉴了大神的题解的方法，在求桥的过程中求出每个点的深度，然后用check函数将两个点逐渐跳到lca，并将路径上的桥消去

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
const int maxn=2e5+5,maxm=4e5+5,inf=0x3f3f3f3f;
int dfn[maxn],low[maxn],fa[maxn],dep[maxn],qiao[maxn],n,m,t,tot;
vector<int>e[maxm*2];
void tarjan(int u,int root){
	dfn[u]=low[u]=++tot;
	for(int i=0;i<e[u].size();i++){
		int v=e[u][i];
		if(v==root)continue;
		if(!dfn[v]){
			fa[v]=u;
			dep[v]=dep[u]+1;
			tarjan(v,u);
			low[u]=min(low[u],low[v]);
			if(low[v]>dfn[u]){
				t++;
				qiao[v]=1;
			}
		}
		else low[u]=min(low[u],dfn[v]);
	}
	return;
}
void check(int u,int v){
	while(dep[u]>dep[v]){
		if(qiao[u])t--,qiao[u]=0;
		u=fa[u];
	}
	while(dep[v]>dep[u]){
		if(qiao[v])t--,qiao[v]=0;
		v=fa[v];
	}
	while(u!=v){
		if(qiao[u])qiao[u]=0,t--;
		if(qiao[v])qiao[v]=0,t--;
		u=fa[u];
		v=fa[v];
	}
}
void qibao(int n){
	memset(low,0,sizeof(low));
	memset(dfn,0,sizeof(dfn));
	memset(fa,0,sizeof(fa));
	memset(dep,0,sizeof(dep));
	memset(qiao,0,sizeof(qiao));
	t=tot=0;
	for(int i=0;i<=n;i++){
		e[i].clear();
	}
}
int main(){
	int n,m,u,v,tt=1;
	while(scanf("%d%d",&n,&m)!=EOF){
		if(n==0&&m==0)break;
		qibao(max(n,m));
		for(int i=1;i<=m;i++){
			scanf("%d%d",&u,&v);
			e[u].push_back(v);
			e[v].push_back(u);
		}
		cin>>m;
		for(int i=1;i<=m;i++){
			if(!dfn[i])tarjan(i,i);
		}
		printf("Case %d:\n",tt++);
		for(int i=1;i<=m;i++){
			scanf("%d%d",&u,&v);
			check(u,v);
			cout<<t<<endl;
		}
		cout<<endl;
	}
	return 0;
}

5.POJ 3177 Redundant Paths

问加多少条边可以让图成为双连通图
先缩点
入度为1的点数量为ans
答案为（ans+1）/2
这是怎么来的呢？将入度为1的点两两相连就可以了，所以点数为奇数的话要+1

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
const int maxn=1e5+5,maxm=1e6+5,inf=0x3f3f3f3f;
int low[maxn],dfn[maxn],tot,k,t,z[maxn],head[maxm],len=1;
int color[maxm],ru[maxn];
struct edge{
	int v,nex;
}e[maxm];
void add_edge(int u,int v){
	e[++len].v=v;
	e[len].nex=head[u];
	head[u]=len;
}
void tarjan(int u,int root){
	dfn[u]=low[u]=++tot;
	z[++k]=u;
	for(int i=head[u];i;i=e[i].nex){
		int v=e[i].v;
		if(!dfn[v]){
			tarjan(v,i);
			low[u]=min(low[u],low[v]);
		}
		else if(i!=(root^1))low[u]=min(low[u],dfn[v]);
	}
	if(low[u]==dfn[u]){
		t++;//连通分量的标号 
		do{
			color[z[k]]=t;    //属于这个连通分量 
			k--;              //出栈 
		}while(u!=z[k+1]);
	}
}
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		int u,v;
		cin>>u>>v;
		add_edge(u,v);
		add_edge(v,u);
	}
	tarjan(1,0);
	int ans=0;
	for(int u=1;u<=n;u++){
		for(int j=head[u];j;j=e[j].nex){
			int v=e[j].v;
			if(color[u]!=color[v])ru[color[v]]++;
		}
	}
	for(int i=1;i<=t;i++){
		if(ru[i]==1)ans++;
	}
	cout<<(ans+1)/2;
}

6.HDU 4612 Warm up

缩点建树+树的直径
缩点后得到一棵树
因为树上每条边都是桥，所以桥的数量=联通分量数-1
问加一条边能让桥的数量最少为多少
树的直径的上的桥最多
所以用桥的数量-树的直径即为答案
wa到哭，让我晚上整个人都清醒了

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn=2e5+5,maxm=2e6+5,inf=0x3f3f3f3f;
int low[maxn],dfn[maxn],tot,top,t,z[maxn],head[maxn],len,len2,d;
int color[maxn],head2[maxn],vis[maxn],ans,n,m;
struct edge{
	int v,nex;
}e[maxm],e2[maxm];
inline int read()
{
    int x=0,k=1; char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')k=-1;c=getchar();}
    while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*k;
}
void init(){
	memset(head,-1,sizeof(head));
	memset(vis,0,sizeof(vis));
	memset(dfn,0,sizeof(dfn));
	tot=0,t=0,len=0,len2=0,top=0,d=0;
}
inline void add_edge(int u,int v){
	e[len].v=v;
	e[len].nex=head[u];
	head[u]=len++;
}
inline void add_edge2(int u,int v){
	e2[len2].v=v;
	e2[len2].nex=head2[u];
	head2[u]=len2++;
}
void build(){
	len2=0;
	memset(head2,-1,sizeof(head2));
	for(int u=1;u<=n;u++){
		for(int j=head[u];j!=-1;j=e[j].nex){
			int v=e[j].v;
			if(color[u]!=color[v]){
				add_edge2(color[u],color[v]);
			}
		}
	}
}
void tarjan(int u,int root){
	low[u]=dfn[u]=++tot;
	vis[u]=1;
	z[top++]=u;
	int flag=1;
	for(int i=head[u];i!=-1;i=e[i].nex){
		int v=e[i].v;
		if(v==root&&flag){
			flag=0;
			continue;
		}
		if(!dfn[v]){
			tarjan(v,u);
			low[u]=min(low[u],low[v]);
		}
		else if(vis[v]){
			low[u]=min(low[u],dfn[v]);
		}
	}
	if(low[u]==dfn[u]){
		t++;
		int v;
		while(1){
			v=z[top-1];
			top--;
			color[v]=t;
			vis[v]=0;
			if(v==u)break;
		}
	}
}
int dfs(int u,int fa){
	int d1=0,d2=0;
	for(int i=head2[u];i!=-1;i=e2[i].nex){
		int v=e2[i].v;
		if(v==fa)continue;
		int d=dfs(v,u)+1;
		if(d>d1)d2=d1,d1=d;
		else if(d>d2)d2=d;
	}
	ans=max(ans,d1+d2);
	return d1;
}
int main(){
	int u,v;
	while(scanf("%d%d",&n,&m)&&(n+m)){
	init();
	for(int i=1;i<=m;i++){
		u=read(),v=read();
		if(u==v)continue;
		add_edge(u,v);
		add_edge(v,u);
	}
	tarjan(1,-1);
	build();
	ans=0;
	dfs(1,-1);
	printf("%d\n",t-ans-1);
	}
	return 0;
}

7.HDU 4635 Strongly connected

给定一个有向图，求最大可以增加多少条边使得这个仍然不是强连通
首先要知道一点：完全图的边数为n*（n-1）
然后减去图中本来就有的m条边
再减去入度或出度为0的点能跟其他点连的边or被其他点连的边，即为最终答案

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define int long long
using namespace std;
const int maxn=1e5+5,maxm=1e5+5;
int n,m,chu[maxn],qq,a[maxn],b[maxn];
int dfn[maxn],low[maxn],vis[maxn],z[maxn],color[maxn],cnt[maxn],ru[maxn],t,k,tot;
vector<int>e[maxm];
void tarjan(int u){
	dfn[u]=low[u]=++tot;
	z[++k]=u;//入栈 
	vis[u]=1;
	for(int i=0;i<e[u].size();i++){
		if(!dfn[e[u][i]]){
			tarjan(e[u][i]);
			low[u]=min(low[u],low[e[u][i]]);
		}
		else if(vis[e[u][i]]){
			low[u]=min(low[u],dfn[e[u][i]]);
		}
	}
	if(low[u]==dfn[u]){
		t++;//连通分量的标号 
		do{
			color[z[k]]=t;    //属于这个连通分量 
			cnt[t]++;         //记录这个环中有多少个点
			vis[z[k]]=0; 
			k--;              //出栈 
		}while(u!=z[k+1]);
	}
}
void init(int n){
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
	memset(z,0,sizeof(z));
	memset(vis,0,sizeof(vis));
	memset(color,0,sizeof(color));
	memset(cnt,0,sizeof(cnt));
	memset(ru,0,sizeof(ru));
	memset(chu,0,sizeof(chu));
	memset(a,0,sizeof(a));
	memset(b,0,sizeof(b));
	for(int i=0;i<=n;i++){
		e[i].clear();
	}
	t=0;
	k=0;
	tot=0;
}
signed main(){
	int tt;
	cin>>tt;
	while(tt--){
	qq++;
	cin>>n>>m;
	init(max(n,m));
	for(int i=1;i<=m;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		a[i]=u;
		b[i]=v;
		e[u].push_back(v);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i])tarjan(i);
	}
	for(int i=1;i<=n;i++){
		for(int j=0;j<e[i].size();j++){
			int u=color[i];
			int v=color[e[i][j]];
			if(u!=v){
				chu[u]++;
				ru[v]++;
			}
		}
	}
	int minv=n;
	for(int i=1;i<=t;i++){
		if(ru[i]==0||chu[i]==0)minv=min(minv,cnt[i]);
	}
	int ans=n*(n-1)-m-minv*(n-minv);
	if(t==1)printf("Case %lld: -1\n",qq);
	else printf("Case %lld: %lld\n",qq,ans);
	}
	return 0;
}

8.HDU 4685 Prince and Princess

夹带私货的题，二分图完美匹配+缩点，之后补（虽然会用最大流求最大匹配数）

9.HDU 4738 Caocao’s Bridges

又是一题坑的我爆炸的题
用之前的找桥的tarjan疯狂无敌爆炸wa
以后求桥都用这个 链式前向星+反向边来求
其实这个题很简单，求桥的过程中更新桥的最小权值就可以了，如果图本来就不连通就输出-1，特判最小权值为0，因为最少还是需要一个人去炸桥，所以为1

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <stdlib.h>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
using namespace std;
const int maxn=2e4+5,maxm=2e6+5,inf=0x3f3f3f3f;
int n,m;
int dfn[maxn],low[maxn],k,tot,ans,tcnt,head[maxn],cnt;
int qiao[maxm];
struct edge{
	int v,w,nex;
}e[maxm];
inline void add(int u,int v,int w){
	e[++cnt].nex=head[u];
	e[cnt].v=v;
	e[cnt].w=w;
	head[u]=cnt;
}
void tarjan(int u,int root){//root代表此树的根 
	dfn[u]=low[u]=++tot;
	for(int i=head[u];i!=-1;i=e[i].nex){
		int v=e[i].v;
		if(!dfn[v]){
			tarjan(v,i);
			low[u]=min(low[u],low[v]);
			if(low[v]>dfn[u]){
				ans=min(ans,e[i].w);
			}
		}
		else if(i!=(root^1))low[u]=min(low[u],dfn[v]);
	}
	return;
}
void init(){
	tot=0;
	k=0;
	cnt=1;
	tcnt=0;
	ans=inf;
	memset(dfn,0,sizeof(dfn));
	memset(low,0,sizeof(low));
	memset(head,-1,sizeof(head));
}
int main(){
	while(cin>>n>>m){
	if(n==0&&m==0)break;
	init();
	int u,v,w;
	for(int i=1;i<=m;i++){
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	for(int i=1;i<=n;i++){
		if(!dfn[i]){
			tarjan(i,0);
			tcnt++;
		}
	}
	if(tcnt>1)puts("0");
    else if(ans==inf)puts("-1");
	else if(ans==0)puts("1");
	else printf("%d\n",ans);
    }
	return 0;
}

刷题记录不是题解，写的十分简略，见谅qwq
自闭自闭自闭自闭自闭自闭…

爱睡觉的Raki
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[kuangbin带你飞]专题九 连通图 题解报告
Alex
01-22 4172
专题链接 关于tarjan A - Network of Schools  原题地址 本题有2个问题，第一个是要算最少要给多少个点软件，才能使所有点都可以收到副本 第二个是要算最少加多少条边，使得图变成强连通 1：tarjan求强连通，然后缩点，计算入度为0的强连通分量 2：设现在有a个入度为0的点，b个出度为0的点（缩完点后的点），最合理的加边方法肯定是从出度为0的点
解题报告：【kuangbin带你飞】专题九 连通图
繁凡さん的博客
09-14 2781
目录A、POJ 1236 Network of Schools（有向图缩点）B、UVA 315 Network（找割点）C、UVA 796 Critical Links（桥）D、POJ 3694 NetworkE、POJ 3177 Redundant PathsF、HDU 4612 Warm upG、HDU 4635 Strongly connected（最多可加边数使得仍然非强连通）H、HDU 4685 Prince and PrincessI、HDU 4738 Caocao's Bridges A、PO
[kuangbin带你飞]专题九 连通图
PCCCCC的博客
09-07 157
A - Network of Schools POJ - 1236 思路：容易看出，处于同一个强连通分量里的点可以看成一个点，所以我们求出所有强连通分量然后计算出每个强连通分量的出度和入度，入度位0的个数就是最少要发的邮件的个数，第二问的答案是入度为0的个数和出度为0的个数的最大值。。。不会证明 #include <stdio.h> #include <algorithm>...
刷题记录 kuangbin带你飞专题一：简单搜索
Raki_J的博客
05-19 530
两天肝完 感觉自己的暴力水平上升了 码力大仙！！！ A.POJ1321 棋盘问题 有一个坑点就是可能相邻层没有棋盘，所以直接搜全部 #include<cstdio> #include<iostream> #include<cstring> #include<string> #include<algorithm> #include<cmath> #include<queue> #include<vector> us
刷题记录 kuangbin带你飞专题四：最短路练习
Raki_J的博客
05-22 477
写之前先给这个专题做个总结 知识点：单源最短路，全源最短路，求最短路中的最长边，bellman ford算法求有负权的最短路，bellman or SPFA判断环，反向建图，差分约束，层次图建立层点（连通点）。 应该是覆盖最短路所有内容了 1.POJ 2387 Til the Cows Come Home 模板题 2.POJ 2253 Frogger Floyd模板题，只要看到这个数据范围冲就完事了（n<=800） 3.POJ 1797 Heavy Transportation 题意：求能到达终点的最
kuangbin带你飞专题合集
繁凡さん的博客
05-28 2151
[kuangbin带你飞]专题一 简单搜索 [kuangbin带你飞]专题二 搜索进阶...
“kuangbin带你飞”专题计划——专题十四：数论基础
I_have_a_world的博客
05-13 334
[kuangbin带你飞]专题1-23 写在前面 1.目前还没啥写的。开始时间：2021-05-13（其实博客上看得到该博客创建时间的） 2.上一个专题刷的是网络流（博客总结），属于第一次接触。本来想的是一周特别高效，然后一周略划水，结果是五一期间高效，工作日有课略划水。还好，每个题都写了博客，收获很多 3.这个专题，我想应该每个题都涉及了不一样的知识吧。也建议每个题都写博客 4.写个感受？有与高四刷书的感觉了，激动，期待，轻松辛苦，有时候一本书要一个月才刷完，这不代表我效率低，只能代表这.
“kuangbin带你飞”专题计划——专题一：简单搜索
I_have_a_world的博客
04-01 318
kuangbin带你飞 1.难以提升emmmm。试着埋头搞专题，看能不能提升效率。 2.顺便当是复习了蓝桥杯了。 专题一：简单搜索 1.POJ-1321-棋盘问题 标签：暴力，搜索 题解:直接暴力，注意不要重复搜索 代码：我自己看的话点题目的链接就好了。粘贴在这里太繁琐，就没弄了。 2. ...
[kuangbin带你飞]专题九 连通图 题解+总结
放荡者的茶会
02-21 3473
kuangbin带你飞：点击进入新世界 总结： 本人算是初学者中的初学者，欢迎交流~ 由于是个人总结向，所以有点精简，但是坑点和结果是怎么算出来的都会提及，当然如果有什么疑问可以留言或者私信交流。 后续会整理一下tarjan相关模板。 文章目录总结：1.Network of Schools /强连通分量+缩点2.Network /割点模板题3.Critical Links /桥的模板题4.Ne...
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
kuangbin的ACM模板动态规划计算几何：线与线求交，线与面求交，求凸包，半平面求交等若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
kuangbin巨巨 ACM模板~ 有需要的朋友可以下载了~
2020牛客多校训练2 I Interval（对偶图最短路求最小割）
Raki_J的博客
07-14 1132
先转化成网格图，跑最大流是不可能跑最大流的，这数据范围一下就卡死，而且还要开mapmapmap来判重 只能跑跑对偶图最短路这样子 对偶图图如图所示，除了网格本来有的边之外的图就是对偶图，思想就是用两个点把你原图有的边给割掉，两点间的权值也等于原图这条边的权值，跑出来的最短路即为最小割 解释一下建图方式： 如果j>nj>nj>n就连到汇点 如果i<1i<1i<1就连到源点 建图完直接dijdijdij最短路即可（作死用spfaspfaspfa的话开心就好） 完整代码： .
2020牛客多校训练1 H Minimum-cost Flow（最小费用流）
Raki_J的博客
07-12 923
H题 先给出每条边的费用，qqq组询问，问当每条边的流量为u/vu/vu/v时，跑到流量为1的最小费用 看到数据范围就知道肯定最多只能跑一次费用流，不然会直接TTT飞 思路：求最小费用流的过程中记录每一次增广路增加的流和费用，用mapmapmap记录，最后贪心选择费用小的边进行输出（官方题解和一般的题解我一个都看不懂） #include<bits/stdc++.h> #define int long long using namespace std; const int inf=0x3f3f
Raki的网络流24题题解总结
Raki_J的博客
08-15 789
网络流24题： from：Luogu P4011 孤岛营救问题 P2756 飞行员配对方案问题 P2761 软件补丁问题 P4016 负载平衡问题 P3358 最长k可重区间集问题 P4014 分配问题 P4009 汽车加油行驶问题 P4015 运输问题 P2774 方格取数问题 P4012 深海机器人问题 P2762 太空飞行计划问题 P2770 航空路线问题 P2754 [CTSC1999]家园 / 星际转移问题 P3254 圆桌问题 P1251 餐巾计划问题 P2763 试题库问题 P2766 最
简单记录 Part1.1
Raki_J的博客
12-05 767
1.CF1328D Carousel 分类讨论： 1：为偶数，输出12121212… 2：为奇数， 但是有两个连续的图形相同，从此位置断开输出121212… 且没有任何相邻的图形相同，输出121212…3 #include<bits/stdc++.h> #define int long long using namespace std; constexpr int maxn=4e5+5,inf=0x3f3f3f3f,mod=1e9+7; int n,m,t,a[maxn],res[maxn];
并查集板子llkkyyy
最新发布
08-19
- *1* *2* [「kuangbin带你飞」专题五并查集专题题解](https://blog.csdn.net/weixin_51216553/article/details/121643742)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值