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

最新推荐文章于 2021-05-13 14:54:16 发布
最新推荐文章于 2021-05-13 14:54:16 发布
阅读量375 收藏
点赞数
分类专栏： 连通性问题 图论 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
关注
专栏目录
[kuangbin带你飞]专题九 连通图 题解报告
Alex
01-22 4237
专题链接 关于tarjan A - Network of Schools  原题地址 本题有2个问题，第一个是要算最少要给多少个点软件，才能使所有点都可以收到副本 第二个是要算最少加多少条边，使得图变成强连通 1：tarjan求强连通，然后缩点，计算入度为0的强连通分量 2：设现在有a个入度为0的点，b个出度为0的点（缩完点后的点），最合理的加边方法肯定是从出度为0的点
解题报告：【kuangbin带你飞】专题九 连通图
繁凡さん的博客
09-14 2973
目录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 172
A - Network of Schools POJ - 1236 思路：容易看出，处于同一个强连通分量里的点可以看成一个点，所以我们求出所有强连通分量然后计算出每个强连通分量的出度和入度，入度位0的个数就是最少要发的邮件的个数，第二问的答案是入度为0的个数和出度为0的个数的最大值。。。不会证明 #include <stdio.h> #include <algorithm>...
刷题记录 kuangbin带你飞专题一：简单搜索
Raki_J的博客
05-19 590
两天肝完 感觉自己的暴力水平上升了 码力大仙！！！ A.POJ1321 棋盘问题 有一个坑点就是可能相邻层没有棋盘，所以直接搜全部 #include<cstdio> #include<iostream> #include<cstring> #include<string> #include<algorithm> #include<cmath> #include<queue> #include<vector> us
刷题记录 kuangbin带你飞专题四：最短路练习
Raki_J的博客
05-22 523
写之前先给这个专题做个总结 知识点：单源最短路，全源最短路，求最短路中的最长边，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 2222
[kuangbin带你飞]专题一 简单搜索 [kuangbin带你飞]专题二 搜索进阶...
“kuangbin带你飞”专题计划——专题十四：数论基础
I_have_a_world的博客
05-13 391
[kuangbin带你飞]专题1-23 写在前面 1.目前还没啥写的。开始时间：2021-05-13（其实博客上看得到该博客创建时间的） 2.上一个专题刷的是网络流（博客总结），属于第一次接触。本来想的是一周特别高效，然后一周略划水，结果是五一期间高效，工作日有课略划水。还好，每个题都写了博客，收获很多 3.这个专题，我想应该每个题都涉及了不一样的知识吧。也建议每个题都写博客 4.写个感受？有与高四刷书的感觉了，激动，期待，轻松辛苦，有时候一本书要一个月才刷完，这不代表我效率低，只能代表这.
“kuangbin带你飞”专题计划——专题一：简单搜索
I_have_a_world的博客
04-01 349
kuangbin带你飞 1.难以提升emmmm。试着埋头搞专题，看能不能提升效率。 2.顺便当是复习了蓝桥杯了。 专题一：简单搜索 1.POJ-1321-棋盘问题 标签：暴力，搜索 题解:直接暴力，注意不要重复搜索 代码：我自己看的话点题目的链接就好了。粘贴在这里太繁琐，就没弄了。 2. ...
[kuangbin带你飞]专题九 连通图 题解+总结
放荡者的茶会
02-21 3545
kuangbin带你飞：点击进入新世界 总结： 本人算是初学者中的初学者，欢迎交流~ 由于是个人总结向，所以有点精简，但是坑点和结果是怎么算出来的都会提及，当然如果有什么疑问可以留言或者私信交流。 后续会整理一下tarjan相关模板。 文章目录总结：1.Network of Schools /强连通分量+缩点2.Network /割点模板题3.Critical Links /桥的模板题4.Ne...
POJ 2031 Building a Space Station(kuangbin带你飞 专题六：最小生成树)
01-31 357
大概题意就是要有n个空间站，给出三维坐标以及半径（是个球）..要每两个空间站之间都能互相通信啥的...问建立的最小花费是多少..花费就是两个空间站的距离...如果小于0当做0.. 两球之间的距离等于两球心之间的距离减去两球的半径...就能算出球面之间的距离了..然后最小生成树走起 #include #include #include #include #include #include usi
POJ 3026 Borg Maze(kuangbin带你飞 专题六：最小生成树，完结)
02-01 404
没看题，直接看了样例，大概意思就是给了一张迷宫吧，要把所有的A和S全部链接起来需要的最小边权...就是求最小生成树....but...，边的顶点和距离完全要自己解决...顶点编号直接从在图上跑了一遍给编了序号1-k，代表第几个点，-1代表墙，0代表可走的地方，对每个点进行一次bfs，并且在bfs过程中建立这个点对其他点的边..最后跑完最小生成树就行了. 不得不说调试了好久...以为是bfs写搓了
poj 1860 Currency Exchange ([kuangbin带你飞]专题四 最短路练习)
Strive
11-10 494
Description Several currency exchange points are working in our city. Let us suppose that each point specializes in two particular currencies and performs exchange operations only with these curren
2020牛客多校训练2 I Interval（对偶图最短路求最小割）
Raki_J的博客
07-14 1177
先转化成网格图，跑最大流是不可能跑最大流的，这数据范围一下就卡死，而且还要开mapmapmap来判重 只能跑跑对偶图最短路这样子 对偶图图如图所示，除了网格本来有的边之外的图就是对偶图，思想就是用两个点把你原图有的边给割掉，两点间的权值也等于原图这条边的权值，跑出来的最短路即为最小割 解释一下建图方式： 如果j>nj>nj>n就连到汇点 如果i<1i<1i<1就连到源点 建图完直接dijdijdij最短路即可（作死用spfaspfaspfa的话开心就好） 完整代码： .
2020牛客多校训练1 H Minimum-cost Flow（最小费用流）
Raki_J的博客
07-12 969
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 883
网络流24题： from：Luogu P4011 孤岛营救问题 P2756 飞行员配对方案问题 P2761 软件补丁问题 P4016 负载平衡问题 P3358 最长k可重区间集问题 P4014 分配问题 P4009 汽车加油行驶问题 P4015 运输问题 P2774 方格取数问题 P4012 深海机器人问题 P2762 太空飞行计划问题 P2770 航空路线问题 P2754 [CTSC1999]家园 / 星际转移问题 P3254 圆桌问题 P1251 餐巾计划问题 P2763 试题库问题 P2766 最
算法笔记：Dinic最大流和SPFA费用流
Raki_J的博客
06-06 881
先利用BFS对残余网络分层 一个节点的深度，就是源点到它最少要经过的边数。 利用BFS对残余网络分层，分完层后，利用DFS从前一层向后一层反复寻找增广路。 这里写图片描述 分完层后，从源点开始，用DFS从前一层向后一层反复寻找增广路(即要求DFS的每一步都必须要走到下一层的节点）。 因此，前面在分层时，只要进行到汇点的层次数被算出即可停止，因为按照该DFS的规则，和汇点同层或更下一层的节点，是不可能走到汇点的。 DFS过程中，要是碰到了汇点，则说明找到了一条增广路径。此时要增加总流量的值，消减路径上各边的容
简单记录 Part1.1
Raki_J的博客
12-05 844
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];
Raki的图论入门到进阶算法简单总结
Raki_J的博客
08-09 767
图论基础概念戳这里oiwiki 1.图的存储与遍历 图是相对线性数据结构更高级的模型，可以1对多也可以多对1，点与点之间，边与边之间都可以加上更多的限制，使其变得非常灵活，下面介绍两种最常用的图的存储方法 1.1 vector存图 用vector存图，会比较直观好懂 先弄出一个结构体，vvv为到达的顶点，www为这条边的边权 struct edge{ int v,w; }; vector<edge>e[maxn]; 存储 e[u].push_back((edge){v,w}); 遍历 fo
最短路径树简谈
Raki_J的博客
12-05 480
在最开始，我们要知道最短路径树是个什么东西，不同于最小生成树，最短路径树是选一个节点为根，得到一颗树上的所有点，与原图中根节点到其的最短距离相等。 因为很多要用到边的记录，然而我比较菜只会用链式前向星方便的记录边，所以在写最短路路径树的过程中全用的链式前向星存图（ 先来个比较板子的 CF545E Paths and Trees 题意：给定一张带正权的无向图和一个源点，求边权和最小的最短路径树。 思路：在跑dij的过程中记录每个点的前驱边，因为题目要求边权和最小，所以如果遇到相同的最短距离，我们应该选取前驱边
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值