【BZOJ1179】【Apio2009】Atm 强连通分量缩点+拓扑DP/拓扑最长路 kosaraju+tarjan+dfs转非递归三种代码

题解:

首先第一个阶段,

可以写kosaraju、也可以写tarjan。

这两种还都分递归和dfs转非递归。

----------------------------------四种方案。

第二个阶段,可以写拓扑DP

也可以写最长路

----------------------------------乘上之前的,,八种方案。

本文写了kosaraju递归版,tarjan递归版,kosaraju非递归版。

……只怪学校oj系统栈太小。。都是逼得啊。

代码1(tarjan):

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 501000
using namespace std;
struct KSD
{
	int u,v,next;
}e[N],E[N];
int head[N],cnt,Head[N];

void add(int u,int v)
{
	cnt++;
	e[cnt].u=u;
	e[cnt].v=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
void Add(int u,int v)
{
	cnt++;
	E[cnt].v=v;
	E[cnt].next=Head[u];
	Head[u]=cnt;
}

int dfn[N],low[N];
int group,id[N];
bool in[N];

int stk[N],top;
int fee[N],Fee[N];
bool Bar[N],bar[N];
void tarjan(int x)
{
	dfn[x]=low[x]=++cnt;
	stk[++top]=x,in[x]=1;
	for(int i=head[x];i;i=e[i].next)
	{
		if(!dfn[e[i].v])
		{
			tarjan(e[i].v);
			low[x]=min(low[x],low[e[i].v]);
		}
		else if(in[e[i].v])low[x]=min(low[x],dfn[e[i].v]);
	}
	if(low[x]==dfn[x])
	{
		group++;
		do{
			in[stk[top]]=0,id[stk[top]]=group;
			Fee[group]+=fee[stk[top]];
			Bar[group]|=bar[stk[top]];
		}while(stk[top--]!=x);
	}
}
int n,m,s,p;
bool ok[N];
void bfs()
{
	int i,u,v;
	stk[top=1]=s;
	while(top)
	{
		u=stk[top--];
		ok[u]=1;
		for(i=head[u];i;i=e[i].next)
		{
			v=e[i].v;
			if(!ok[v])stk[++top]=v;
		}
	}
}
int dp[N],d[N];
int main()
{
//	freopen("test.in","r",stdin);
	int i,j,k;
	int a,b,c;
	int u,v;
	scanf("%d%d",&n,&m);
	for(i=1;i<=m;i++)scanf("%d%d",&a,&b),add(a,b);
	for(i=1;i<=n;i++)scanf("%d",&fee[i]);
	scanf("%d%d",&s,&p);
	for(i=1;i<=p;i++)scanf("%d",&c),bar[c]=true;

	for(c=cnt,cnt=0,i=1;i<=n;i++)if(!dfn[i])tarjan(i);
	bfs();
	for(cnt=0,i=1;i<=c;i++)
	{
		if((!ok[e[i].u])||(!ok[e[i].v]))continue;
		a=id[e[i].u],b=id[e[i].v];
		if(a==b)continue;
		Add(a,b);
		d[b]++;
	}

	stk[top=1]=id[s];
	int ans=0;
	while(top)
	{
		u=stk[top--];
		if(Bar[u])ans=max(ans,dp[u]+Fee[u]);
		for(i=Head[u];i;i=E[i].next)
		{
			v=E[i].v;
			dp[v]=max(dp[v],dp[u]+Fee[u]);
			d[v]--;
			if(!d[v])stk[++top]=v;
		}
	}
	printf("%d\n",ans);
	return 0;
}

代码2(kosaraju):

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 501000
using namespace std;
struct KSD
{
	int u,v,next;
}e[N],ez[N];
int head[N],lux[N],cnt;
inline void add(int u,int v)
{
	cnt++;
	ez[cnt].v=e[cnt].u=u;
	e[cnt].v=v;
	ez[cnt].next=lux[v];
	e[cnt].next=head[u];
	head[u]=lux[v]=cnt;
}
inline void add2(int u,int v)
{
	cnt++;
	ez[cnt].v=v;
	ez[cnt].next=lux[u];
	lux[u]=cnt;
}

bool vis[N];
int dfn[N],top;
int id[N],group;

int n,m,s,p;
int fee[N];
bool bar[N];

int Fee[N];
bool Bar[N];

void dfs1(int x)
{
	vis[x]=1;
	for(int i=head[x];i;i=e[i].next)if(!vis[e[i].v])dfs1(e[i].v);
	dfn[++top]=x;
}
void dfs2(int x)
{
	id[x]=group;
	Bar[group]|=bar[x];
	Fee[group]+=fee[x];
	for(int i=lux[x];i;i=ez[i].next)if(!id[ez[i].v])dfs2(ez[i].v);
}
int d[N],dp[N];
bool ok[N];
void bfs()
{
	int i,u,v;
	dfn[top=1]=s;
	while(top)
	{
		u=dfn[top--];
		ok[u]=1;
		for(i=head[u];i;i=e[i].next)
		{
			v=e[i].v;
			if(!ok[v])dfn[++top]=v;
		}
	}
}
int main()
{
//	freopen("test.in","r",stdin);
	int i,j,k;
	int a,b,c;
	scanf("%d%d",&n,&m);
	while(m--)scanf("%d%d",&a,&b),add(a,b);
	for(i=1;i<=n;i++)scanf("%d",&fee[i]);
	scanf("%d%d",&s,&p);
	while(p--)scanf("%d",&c),bar[c]=true;

	bfs();
	for(i=1;i<=n;i++)if(!vis[i])dfs1(i);
	for(i=top;i;i--)if(!id[dfn[i]])group++,dfs2(dfn[i]);
	memset(lux,0,sizeof(lux));
	c=cnt,cnt=0;

	for(i=1;i<=c;i++)
	{
		if(!ok[e[i].u])continue;
		a=id[e[i].u],b=id[e[i].v];
		if(a==b)continue;
		add2(a,b);
		d[b]++;
	}
	dfn[top=1]=id[s];
	int ans=0;
	while(top)
	{
		a=dfn[top--];
		if(Bar[a])ans=max(ans,dp[a]+Fee[a]);
		for(i=lux[a];i;i=ez[i].next)
		{
			c=ez[i].v;
			dp[c]=max(dp[c],dp[a]+Fee[a]),d[c]--;
			if(!d[c])dfn[++top]=c;
		}
	}
	printf("%d\n",ans);
	return 0;
}

代码3(kosaraju+主要部分转非递归):

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 501000
using namespace std;
struct KSD
{
	int u,v,next;
}e[N],ez[N];
int head[N],lux[N],cnt;
inline void add(int u,int v)
{
	cnt++;
	ez[cnt].v=e[cnt].u=u;
	e[cnt].v=v;
	ez[cnt].next=lux[v];
	e[cnt].next=head[u];
	head[u]=lux[v]=cnt;
}
inline void add2(int u,int v)
{
	cnt++;
	ez[cnt].v=v;
	ez[cnt].next=lux[u];
	lux[u]=cnt;
}

bool vis[N];
int dfn[N],top;
int id[N],group;

int n,m,s,p;
int fee[N];
bool bar[N];

int Fee[N];
bool Bar[N];

int stk[N];
int which[N];
inline void dfs1(int x)
{
	int i,u,v;
	vis[x]=1;
	which[x]=head[x];
	stk[top=1]=x;
	while(top)
	{
		u=stk[top];
		i=which[u];
		if(!i)
		{
			top--;
			dfn[++cnt]=u;
			continue;
		}
		if(!vis[v=e[i].v])
		{
			vis[v]=1;
			which[v]=head[v];
			stk[++top]=v;
		}
		which[u]=e[i].next;
	}
}/*   ***************************************这个注释部分的dfs转非递归写挂了
inline void dfs2(int x)
{
	int i,u,v;
	stk[top=1]=x;
	group++;
	while(top)
	{
		u=stk[top--];
		id[u]=group;
		Bar[group]|=bar[u];
		Fee[group]+=fee[u];
		for(i=lux[u];i;i=ez[i].next)
			if(!id[v=ez[i].v])
				stk[++top]=v;
	}
}*/
void dfs2(int x)
{
	id[x]=group;
	Bar[group]|=bar[x];
	Fee[group]+=fee[x];
	for(int i=lux[x];i;i=ez[i].next)if(!id[ez[i].v])dfs2(ez[i].v);
}
int d[N],dp[N];
bool ok[N];
void bfs()
{
	int i,u,v;
	dfn[top=1]=s;
	while(top)
	{
		u=dfn[top--];
		ok[u]=1;
		for(i=head[u];i;i=e[i].next)
		{
			v=e[i].v;
			if(!ok[v])dfn[++top]=v;
		}
	}
}
int main()
{
//	freopen("test.in","r",stdin);
	int i,j,k;
	int a,b,c;
	scanf("%d%d",&n,&m);
	while(m--)scanf("%d%d",&a,&b),add(a,b);
	for(i=1;i<=n;i++)scanf("%d",&fee[i]);
	scanf("%d%d",&s,&p);
	while(p--)scanf("%d",&c),bar[c]=true;
	c=cnt,cnt=0;

	bfs();
	for(cnt=0,i=1;i<=n;i++)if(!vis[i])dfs1(i);
	for(cnt=0,i=n;i;i--)if(!id[dfn[i]])group++,dfs2(dfn[i]);
	memset(lux,0,sizeof(lux));

	for(cnt=0,i=1;i<=c;i++)
	{
		if(!ok[e[i].u])continue;
		a=id[e[i].u],b=id[e[i].v];
		if(a==b)continue;
		add2(a,b);
		d[b]++;
	}
	dfn[top=1]=id[s];
	int ans=0;
	while(top)
	{
		a=dfn[top--];
		if(Bar[a])ans=max(ans,dp[a]+Fee[a]);
		for(i=lux[a];i;i=ez[i].next)
		{
			c=ez[i].v;
			dp[c]=max(dp[c],dp[a]+Fee[a]),d[c]--;
			if(!d[c])dfn[++top]=c;
		}
	}
	printf("%d\n",ans);
	return 0;
}
时间: 2024-10-11 20:10:01

【BZOJ1179】【Apio2009】Atm 强连通分量缩点+拓扑DP/拓扑最长路 kosaraju+tarjan+dfs转非递归三种代码的相关文章

【差分约束系统】【强连通分量缩点】【拓扑排序】【DAG最短路】CDOJ1638 红藕香残玉簟秋,轻解罗裳,独上兰舟。

题意: 给定n个点(点权未知)和m条信息:u的权值>=v的权值+w 求点权的极小解和极大解(无解则输出-1) 极小解即每个点的点权可能的最小值 极大解即每个点的点权可能的最大值 题解: 差分约束系统 对于val[u]>=val[v]+w 要得到极小解,v是没有受限制的,其最小值为0 而u受到v的限制,显然,val[u]的最小值就是val[v]+w 在多条件限制下,我们用v连向u边权为w的边表示每个限制条件val[u]>=val[v]+w 那么如果得到的是拓扑图,则按拓扑序求到每个点的最长

【强连通分量缩点】【拓扑排序】【dp预处理】CDOJ1640 花自飘零水自流,一种相思,两处闲愁。

题意: 在n个点m条边的有向图上,从1出发的回路最多经过多少个不同的点 可以在一条边上逆行一次 题解: 在同一个强连通分量中,显然可以经过当中的每一个点 因此先将强连通分量缩点,点权为强连通分量的点数 如果不逆行,那么答案就是1所在的强连通分量的点数 如果逆行了,那么逆行的边必然在缩点后的拓扑图上 假设逆行的边为u->v,那么该回路可分为1到v和u到1两部分 经过的最多点数即1到v与u到1路径上的最大点权和减去1的点权 (这里的点指的都是缩点后的点) 例子中在边4->3上逆行就能从1出发经过所

【bzoj1179】[Apio2009]抢掠计划atm 强连通分量缩点+spfa

Input 第一行包含两个整数N.M.N表示路口的个数,M表示道路条数.接下来M行,每行两个整数,这两个整数都在1到N之间,第i+1行的两个整数表示第i条道路的起点和终点的路口编号.接下来N行,每行一个整数,按顺序表示每个路口处的ATM机中的钱数.接下来一行包含两个整数S.P,S表示市中心的编号,也就是出发的路口.P表示酒吧数目.接下来的一行中有P个整数,表示P个有酒吧的路口的编号 Output 输出一个整数,表示Banditji从市中心开始到某个酒吧结束所能抢劫的最多的现金总数. Sample

BZOJ 1179 Atm(强连通分量缩点+DP)

题目说可以通过一条边多次,且点权是非负的,所以如果走到图中的一个强连通分量,那么一定可以拿完这个强连通分量上的money. 所以缩点已经很明显了.缩完点之后图就是一个DAG,对于DAG可以用DP来求出到达每一个点的money最大值.具体实现我用的是bfs. 然后如果一个强连通分量内有酒馆,那么这个点就可以更新答案啦. # include <cstdio> # include <cstring> # include <cstdlib> # include <iost

POJ 3114 - Countries in War(强连通分量+缩点+拓扑排序+DAG最短路)

Countries in War Time Limit:1000MS    Memory Limit:65536KB    64bit IO Format:%I64d & %I64u Appoint description: Description In the year 2050, after different attempts of the UN to maintain peace in the world, the third world war broke out. The impor

ZOJ3795 Grouping(强连通分量+缩点+记忆化搜索)

题目给一张有向图,要把点分组,问最少要几个组使得同组内的任意两点不连通. 首先考虑找出强连通分量缩点后形成DAG,强连通分量内的点肯定各自一组,两个强连通分量的拓扑序能确定的也得各自一组. 能在同一组的就是两个强连通分量在不同的从入度0到出度0的强连通分量的路径上. 那么算法很直观就能想到了,用记忆化搜索,d[u]表示从强连通分量u出发到出度为0的强连通分量最少要几个组(最多有几个点). 1 #include<cstdio> 2 #include<cstring> 3 #inclu

tarjan算法(强连通分量 + 强连通分量缩点 + 桥 + 割点 + LCA)

这篇文章是从网络上总结各方经验 以及 自己找的一些例题的算法模板,主要是用于自己的日后的模板总结以后防失忆常看看的, 写的也是自己能看懂即可. tarjan算法的功能很强大, 可以用来求解强连通分量,缩点,桥,割点,LCA等,日后写到相应的模板题我就会放上来. 1.强连通分量(分量中是任意两点间都可以互相到达) 按照深度优先遍历的方式遍历这张图. 遍历当前节点所出的所有边.在遍历过程中: ( 1 ) 如果当前边的终点还没有访问过,访问. 回溯回来之后比较当前节点的low值和终点的low值.将较小

算法:强连通分量缩点

有时对于一个有向图我们及其渴望将其变为一个有向无环图,这样我们就要用到强连通分量缩点了. 例题 洛谷3387 缩点 题目背景 缩点+DP. 题目描述 给定一个 n个点 m条边有向图,每个点有一个权值,求一条路径,使路径经过的点权值之和最大.你只需要求出这个权值和. 允许多次经过一条边或者一个点,但是,重复经过的点,权值只计算一次. 输入格式 第一行两个正整数n,m. 第二行n个整数,依次代表点权. 第三至(m + 2)行,每行两个整数u,v,表示一条u -> v的有向边. 输出格式 共一行,最大

UVALIVE 4287 Proving Equivalences (强连通分量+缩点)

题意:给定一个图,问至少加入多少条边能够使这个图强连通. 思路:首先求出这个图的强连通分量.然后把每个强连通分量缩成一个点.那么这个图变成了一个DAG,求出全部点的入度和出度,由于强连通图中每个节点的入度和出度至少为1.那么我们求出入度为零的节点数量和出度为零的节点数量.答案取最大值,由于在一个DAG中加入这么多边一定能够使这个图强连通.注意当这个图本身强连通时要特判一下,答案为零. #include<cstdio> #include<cstring> #include<cm