YbtOJ 「图论」 第4章 强连通分量

强连通分量 高效进阶

  • 在一个图G中 如果两个顶点u,v之间可以通过有向边互相到达 则称这两个顶点是强连通的
  • 如果有向图G中任意两个顶点都是强连通的 则称G是个强连通图
  • 如果s是G的一个强连通子图且没有另一个强连通子图s′包含了s 则称s是一个强连通分量

强连通分量由tarjan算法实现

[算法流程]

首先维护两个数组:

dfn(u)表示这个u节点遍历到的时间顺序(时间戳)

low(u)表示从节点u出发可以遍历到的最小节点编号

每一个强连通分量的最小编号的节点我们姑且称为"代表节点"

  1. 选取一个没有遍历过的节点作为起点 从起点出发进行dfs
  2. 首次搜索到点u时 设置初值:dfn(u)=low(u)=timer时间戳
  3. u压入栈尾
  4. 枚举u的出边(u,v) 分两种情况讨论:
    • 如果v没有遍历过 则遍历这个点 更新low(u)=min(low(u),low(v)) 因为存在从 u 到 v 的直接路径，所以 v 能够回溯到的已经在栈中的结点，u 也一定能够回溯到。
    • 如果v已经被遍历过且这个点还在栈中 令low(u)=min(low(u),dfn(v)) 因为有可能这个v节点就是代表节点 需要将这个u节点归入v组成的强连通分量中
    • 如果这个点不在栈中 说明这个点已经属于另一个强连通分量了 不要管它
  5. 当u的搜索结束后 如果dfn(u)=low(u) 说明这个点是这个强连通分量中的"代表节点"将这个点之后的所有点全部退栈 组成一个强连通分量

A. 【例题1】有向图缩点

[题目描述]

给定一个 n 个点 m 条边有向图，每个点有一个权值，求一条路径，使路径经过的点权值之和最大。你只需要求出这个权值和。

允许多次经过一条边或者一个点，但是，重复经过的点，权值只计算一次。

[输入格式]

第一行两个正整数 n,m

第二行 n 个整数，其中第 i 个数 ai 表示点 i 的点权。

第三至 m+2 行，每行两个整数 u,v，表示一条 u→v 的有向边。

[输出格式]

共一行，最大的点权之和。

[算法分析]

tarjan+拓扑+dp

其中拓扑排序是保证dp无后效性的算法 是一个调整图中dp顺序的算法

[代码实现]

封装了三个函数 可读性良好 实际上可以将dp和tuopu合并 或者直接逆序dp(tarjan后的序列是逆拓扑序)

luogu上40pts−50pts原因:建图之前没有清旧图 建新图的时候统计入度出错 拓扑排序中i和v写错......

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , f[N] , ans , a[N] , x[N] , y[N];

int head[N] , cnt;
struct node { int to , nxt; } e[N];
void add ( int u , int v ) { e[++cnt] = { v , head[u] }; head[u] = cnt; } 

int dfn[N] , low[N] , timer;
int scc[N] , id[N] , tot;
int in[N] , sta[100000000] , tp;
int rd[N] , res[N] , tmp;


void tarjan ( int u )
{
	dfn[u] = low[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] );
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( dfn[u] == low[u] )
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , scc[tot] += a[x];
			if ( x == u ) break;
		}
	}
}

void init()
{
	memset ( head , 0 , sizeof head );
	cnt = 0;
}

void tuopu ()
{
	tp = 0;
	for ( int i = 1 ; i <= tot ; i ++ ) if ( !rd[i] ) sta[++tp] = i , res[++tmp] = i;
	while ( tp )
	{
		int u = sta[tp--];
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			rd[v] --;
			if ( !rd[v] ) sta[++tp] = v , res[++tmp] = v;
		}
	}
}

void dp ()
{
	for ( int i = 1 ; i <= tot ; i ++ ) f[i] = scc[i];
	for ( int k = 1 ; k <= tmp ; k ++ )
	{
		int u = res[k];
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			f[v] = max ( f[v] , f[u] + scc[v] );
		}
	}
}
	
signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	n = read() , m = read();
	for ( int i = 1 ; i <= n ; i ++ ) a[i] = read();
	for ( int i = 1 ; i <= m ; i ++ ) x[i] = read() , y[i] = read() , add ( x[i] , y[i] );
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	init();
	for ( int i = 1 ; i <= m ; i ++ ) if ( id[x[i]] != id[y[i]] ) add ( id[x[i]] , id[y[i]] ) , rd[id[y[i]]] ++;
	tuopu();
	dp();
	for ( int i = 1 ; i <= tot ; i ++ ) ans = max ( ans , f[i] );
	cout << ans << endl;
	return 0;
}

B. 【例题2】受欢迎的牛

缩点后判断每一个强连通分量的出度 没有出度的就是明星 如果有两个或以上没有出度的 直接输出0即可

注意强连通分量缩点退栈的时候scc大小需要自增维护

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , f[N] , ans , a[N] , x[N] , y[N] , temp = 0 , cd[N];

int head[N] , cnt;
struct node { int to , nxt; } e[N];
void add ( int u , int v ) { e[++cnt] = { v , head[u] }; head[u] = cnt; }

int dfn[N] , low[N] , timer;
int scc[N] , id[N] , tot;
int in[N] , sta[100000000] , tp;

void tarjan ( int u )
{
	dfn[u] = low[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] );
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( dfn[u] == low[u] )
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , scc[tot] ++;
			if ( x == u ) break;
		}
	}
}

signed main ()
{
	n = read() , m = read();
	for ( int i = 1 ; i <= m ; i ++ ) x[i] = read() , y[i] = read() , add ( x[i] , y[i] );
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	for ( int i = 1 ; i <= m ; i ++ ) if ( id[x[i]] != id[y[i]] ) cd[id[x[i]]] ++;
	for ( int i = 1 ; i <= tot ; i ++ )
		if ( !cd[i] )
		{
			if ( temp ) { cout << "0" << endl; return 0; }
			temp = i;
		}
	cout << scc[temp] << endl;
	return 0;
}

C. 【例题3】最大半连通子图

[题目描述]

一个有向图 G=(V,E) 称为半连通的 (Semi-Connected)，如果满足：∀u,v∈V，满足 u→v 或 v→u，即对于图中任意两点 u,v，存在一条 u 到 v 的有向路径或者从 v到 u的有向路径。

若 G′=(V′,E′) 满足 V′⊆V，E′ 是 E中所有跟 V′ 有关的边，则称 G′ 是 G的一个导出子图。若 G′ 是 G的导出子图，且 G′ 半连通，则称 G′ 为 G的半连通子图。若 G′ 是 G所有半连通子图中包含节点数最多的，则称 G′ 是 G的最大半连通子图。

给定一个有向图 G，请求出 G的最大半连通子图拥有的节点数 K，以及不同的最大半连通子图的数目 C。由于 C可能比较大，仅要求输出 C对 X的余数。

[输入格式]

第一行包含三个整数 N,M,X。N,M分别表示图 $G 的点数与边数，X $的意义如上文所述。

接下来 M 行，每行两个正整数 a,b，表示一条有向边 (a,b)。图中的每个点将编号为 1,2,3…N，保证输入中同一个(a,b)不会出现两次。

[输出格式]

应包含两行，第一行包含一个整数 K，第二行包含整数 CmodX

[算法分析]

首先缩点 scc必定是半连通子图

而且在这个有向无环图（DAG）中，半连通子图都是一条链（可以举反例试试，这条链不可能有分支，否则将有两点无法抵达另一方 如果有分支且能到达另一方的 这个点显然会在缩点的时候被缩掉）

所以问题就转化为了在这个DAG中找最长链及最长链的个数

注意需要去重(可以利用used数组记录上一次这个点的出边 如果重复就跳过 而且因为scc缩点都是在一起的 所以重边也在一起 可以用这种方法去重)

记录f[i]以i为结尾的最长链大小 g[i]是与这个子图大小f[i]相等的子图的数目 即可dp

注意tarjan中break不要写成continue

[代码实现]

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , mod , f[N] , g[N] , x[N] , y[N] , no[N] , used[N] , maxf , maxg;//f[i][j]表示以i为根的子树中 背包容量为j的情况下的的最大价值 那么最后答案就是f[0][m]

int head[N] , cnt;
struct node { int to , nxt , w; } e[N];
void add ( int u , int v , int w = 0 ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }

void init()
{
	memset ( head , 0 , sizeof head );
	cnt = 0;
}

int dfn[N] , low[N] , timer;
int sta[N] , in[N] , tp;
int scc[N] , id[N] , tot;

void tarjan ( int u )
{
	dfn[u] = low[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] ); 
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );	
	}
	if ( dfn[u] == low[u] )
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , scc[tot] ++;
			if ( x == u ) break;
		}
	}
}

signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	n = read() , m = read() , mod = read();
	for ( int i = 1 ; i <= m ; i ++ ) x[i] = read() , y[i] = read() , add ( x[i] , y[i] );
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	init();
	for ( int i = 1 ; i <= m ; i ++ ) if ( id[x[i]] != id[y[i]] ) add ( id[x[i]] , id[y[i]] );
	for ( int i = 1 ; i <= tot ; i ++ ) f[i] = scc[i] , g[i] = 1;
	for ( int u = tot ; u ; u -- )
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			if ( used[v] == u ) continue;
			used[v] = u;
			if ( f[v] < f[u] + scc[v] )
			{
				f[v] = f[u] + scc[v];
				g[v] = g[u];
			}
			else if ( f[v] == f[u] + scc[v] )
			{
				g[v] += g[u];
				g[v] %= mod;
			}
		}
	for ( int i = 1 ; i <= tot ; i ++ )
	{
		if ( maxf < f[i] ) 
		{
			maxf = f[i];
			maxg = g[i];
		}
		else if ( maxf == f[i] ) maxg += g[i] , maxg %= mod;
	}
	cout << maxf << endl << maxg << endl;
	return 0;
}

D. 【例题4】恒星的亮度

差分约束经典模板

  1. 我们对于ai−aj≥b的这样一个关系 化简之后可以得到ai≥aj+b 那么我们可以从j向i连边权为b的边表示这种关系 跑最长路

    无解:有正环即为无解 因为此时i和j都可以取得无穷小

  2. 如果是ai−aj≤b的关系 那么我们跑最短路

    无解:有负环即为无解

最大值求最短路 最小值求最长路

对于本题而言 选择第一种方式即可

在这里用spfa是过不去的 必须先缩点

对于T=1 那么连(a,b,0)和(b,a,0)两条边

T=2 a<b 也就是b−a≥1 那么连(a,b,1)

T=3 a≥b 那么连(b,a,0)

T=4 a−b≥1 那么连(b,a,1)

T=5 a≤b 那么连(a,b,0)

一定要注意 每个点的初始值必须为1

#include <bits/stdc++.h>
using namespace std;
#define int long long 
const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , val[N] , ans;

int head[N] , cnt;
int head1[N] , cnt1;
struct node { int to , nxt , w ; } e[N] , e1[N];
void add ( int u , int v , int w ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }
void add1 ( int u , int v , int w ) { e1[++cnt1] = { v , head1[u] , w }; head1[u] = cnt1; }

int dfn[N] , low[N] , timer;
int scc[N] , id[N] , tot;
int in[N] , sta[100000000] , tp;

void tarjan ( int u )
{
	dfn[u] = low[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] );
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( dfn[u] == low[u] )
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , scc[tot] ++;
			if ( x == u ) break;
		}
	}
}

signed main ()
{
	n = read() , m = read();
	for ( int i = 1 , op , a , b ; i <= m ; i ++ )
	{
		op = read() , a = read() , b = read();
		if ( op == 1 ) add ( a , b , 0 ) , add ( b , a , 0 );
		else if ( op == 2 ) add ( a , b , 1 );
		else if ( op == 3 ) add ( b , a , 0 );
		else if ( op == 4 ) add ( b , a , 1 );
		else add ( a , b , 0 );
	}
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	for ( int u = 1 ; u <= n ; u ++ )
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			if ( id[u] != id[v] ) add1 ( id[u] , id[v] , e[i].w );
			else if ( e[i].w == 1 ) { cout << "-1" << endl; return 0; }//自己和自己的差为1显然不合法
		}
	for ( int i = 1 ; i <= tot ; i ++ ) val[i] = 1;//
	for ( int u = tot ; u ; u -- )
	{
		ans += val[u] * scc[u];
		for ( int i = head1[u] ; i ; i = e1[i].nxt )
		{
			int v = e1[i].to;
			val[v] = max ( val[v] , val[u] + e1[i].w );
		}
	}
	cout << ans << endl;
	return 0;
}

E. 1.网络传输

缩点+dp

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , dis[N] , ans , x[N] , y[N] , w[N];

int head[N] , cnt;
struct node { int to , nxt , w; } e[N];
void add ( int u , int v , int w ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }

int dfn[N] , low[N] , timer;
int id[N] , scc[N] , tot;
int sta[N] , in[N] , tp;

void tarjan ( int u )
{
	low[u] = dfn[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] );
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( dfn[u] == low[u] ) 
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , scc[tot] ++ , in[x] = 0;
			if ( x == u ) break;
		}
	}
}

signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	n = read() , m = read();
	for ( int i = 1 ; i <= m ; i ++ ) x[i] = read() , y[i] = read() , w[i] = read() , add ( x[i] , y[i] , w[i] );
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	memset ( head , 0 , sizeof head ) , cnt = 0;
	for ( int i = 1 ; i <= m ; i ++ ) if ( id[x[i]] != id[y[i]] ) add ( id[x[i]] , id[y[i]] , w[i] );
	memset ( dis , inf , sizeof dis );
	dis[id[1]] = 0;
	for ( int u = tot ; u ; u -- )
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			dis[v] = min ( dis[v] , dis[u] + e[i].w );
		}
	cout << dis[id[n]] << endl;
	return 0;
}

F. 2.通讯问题

注意清理要清干净 最后统计的答案就是所有节点到父亲节点的距离和

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

const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , minv[N] , ans , x[N] , y[N] , w[N];

int head[N] , cnt;
struct node { int to , nxt , w; } e[N];
void add ( int u , int v , int w ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }

int dfn[N] , low[N] , timer;
int id[N] , scc[N] , tot;
int sta[N] , in[N] , tp;

void tarjan ( int u )
{
	low[u] = dfn[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] );
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( dfn[u] == low[u] ) 
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , scc[tot] ++ , in[x] = 0;
			if ( x == u ) break;
		}
	}
}

void init()
{
	memset ( head , 0 , sizeof head );
	cnt = 0;
	
	memset ( dfn , 0 , sizeof dfn );
	memset ( low , 0 , sizeof low );
	timer = 0;
	
	memset ( id , 0 , sizeof id );
	memset ( scc , 0 , sizeof scc );
	tot = 0;
	
	memset ( sta , 0 , sizeof sta );
	memset ( in , 0 , sizeof in );
	tp = 0;
	
	memset ( minv , inf , sizeof minv );
	ans = 0;
}

signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	while(1)
	{
		init();
		n = read() , m = read();
		if ( n == 0 && m == 0 ) break;
		for ( int i = 1 ; i <= m ; i ++ ) x[i] = read() , y[i] = read() , w[i] = read() , add ( x[i] , y[i] , w[i] );
		for ( int i = 0 ; i < n ; i ++ ) if ( !dfn[i] ) tarjan(i);
		memset ( head , 0 , sizeof head ) , cnt = 0;
		for ( int i = 1 ; i <= m ; i ++ ) if ( id[x[i]] != id[y[i]] ) add ( id[x[i]] , id[y[i]] , w[i] );
		minv[id[0]] = 0;
		for ( int u = tot ; u ; u -- )
			for ( int i = head[u] ; i ; i = e[i].nxt )
			{
				int v = e[i].to;
				minv[v] = min ( minv[v] , e[i].w );
			}
		for ( int i = 1 ; i <= tot ; i ++ ) ans += minv[i];
		cout << ans << endl;
	}
	return 0;
}

G. 3.删点次数

如果无环 答案显然为最长链长度

  1. 最长链上的点不能两两删去 所以最优解≥最长链长度
  2. 同时 如果每次都在最长链上取走一个点 可以得到一个恰好为最长链长度的方案 因此最优解≤最长链长度

最后缩点求最长链即可 注意dp的初值

#include <bits/stdc++.h>
using namespace std;
#define int long long 
const int N = 1e6 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , dis[N] , x[N] , y[N] , rd[N] , ans;

int head[N] , cnt;
struct node { int to , nxt , w ; } e[N] , e1[N];
void add ( int u , int v , int w = 0 ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }

int dfn[N] , low[N] , timer;
int sta[N] , in[N] , tp;
int id[N] , scc[N] , tot;

void tarjan ( int u )
{
	dfn[u] = low[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] ); 
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( low[u] == dfn[u] )
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , scc[tot] ++;
			if ( x == u ) break;
		}
	}
}

void init()
{
	memset ( head , 0 , sizeof head );
	cnt = 0;
}

signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	n = read() , m = read();
	for ( int i = 1 ; i <= m ; i ++ ) x[i] = read() , y[i] = read() , add ( x[i] , y[i] );
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	init();
	for ( int i = 1 ; i <= m ; i ++ ) if ( id[x[i]] != id[y[i]] ) add ( id[x[i]] , id[y[i]] );
	for ( int i = 1 ; i <= tot ; i ++ ) dis[i] = scc[i];
	for ( int u = tot ; u ; u -- )
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			dis[v] = max ( dis[v] , dis[u] + scc[v] );
		}
	for ( int i = 1 ; i <= tot ; i ++ ) ans = max ( ans , dis[i] );
	cout << ans << endl;
	return 0;

H. 4.软件安装

树上背包 是选课的升级版

先构造出老图后缩点 然后新图进行dp

注意需要建立一个虚拟节点 向新图中入度为0的点连边 保证整个结构是树而不是森林

之后做树上背包即可 设f[i][j]表示以i为根的子树中 容量为j的最大价值 那么最后答案就是f[0][m]

转移的时候每一个f[i][wei[i]]都要赋值为val[i] 确保这个节点必须被选取到

注意原图和新图需要区分好

#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5; 
const int inf = 0x3f3f3f3f;
int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , dis[N] , ans , vv[N] , ww[N] , f[N][N] , rd[N];

int head[N] , cnt;
int head1[N] , cnt1;
struct node { int to , nxt , w; } e[N] , e1[N];
void add ( int u , int v , int w = 0 ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }
void add1 ( int u , int v , int w = 0 ) { e1[++cnt1] = { v , head1[u] , w }; head1[u] = cnt1; }

int dfn[N] , low[N] , timer;
int id[N] , val[N] , wei[N] , tot;
int sta[N] , in[N] , tp;

void tarjan ( int u )
{
	low[u] = dfn[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] );
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );
	}
	if ( dfn[u] == low[u] ) 
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , val[tot] += vv[x] , wei[tot] += ww[x];
			if ( x == u ) break;
		}
	}
}

void dfs ( int u )
{
	for ( int i = head1[u] ; i ; i = e1[i].nxt )
	{
		int v = e1[i].to;
		dfs(v);
		for ( int j = m ; j >= wei[u] ; j -- )
			for ( int k = wei[v] ; k <= j - wei[u] ; k ++ )
				f[u][j] = max ( f[u][j] , f[u][j-k] + f[v][k] );
	}
}

signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	n = read() , m = read();
	for ( int i = 1 ; i <= n ; i ++ ) ww[i] = read();
	for ( int i = 1 ; i <= n ; i ++ ) vv[i] = read();
	for ( int i = 1 , u ; i <= n ; i ++ ) if ( u = read() ) add ( u , i );
	for ( int i = 1 ; i <= n ; i ++ ) if ( !dfn[i] ) tarjan(i);
	for ( int u = 1 ; u <= n ; u ++ )
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			if ( id[u] != id[v] ) add1 ( id[u] , id[v] ) , rd[id[v]] ++;
		}
	for ( int i = 1 ; i <= tot ; i ++ ) if ( !rd[i] ) add1 ( 0 , i );
	for ( int i = 1 ; i <= tot ; i ++ ) f[i][wei[i]] = val[i];
	dfs(0);
	cout << f[0][m] << endl; 
	return 0;
}

I. 5.宫室宝藏

[题目描述]

在宽广的非洲荒漠中，生活着一群勤劳勇敢的羊驼家族。被族人恭称为“先知”的Alpaca L. Sotomon是这个家族的领袖，外人也称其为“所驼门王”。所驼门王毕生致力于维护家族的安定与和谐，他曾亲自率军粉碎河蟹帝国主义的野蛮侵略，为族人立下赫赫战功。所驼门王一生财宝无数，但因其生性节俭低调，他将财宝埋藏在自己设计的地下宫殿里，这也是今天Henry Curtis故事的起点。Henry是一个爱财如命的贪婪家伙，而又非常聪明，他费尽心机谋划了这次盗窃行动，破解重重机关后来到这座地下宫殿前。

整座宫殿呈矩阵状，由R×C间矩形宫室组成，其中有N间宫室里埋藏着宝藏，称作藏宝宫室。宫殿里外、相邻宫室间都由坚硬的实体墙阻隔，由一间宫室到达另一间只能通过所驼门王独创的移动方式——传送门。所驼门王为这N间藏宝宫室每间都架设了一扇传送门，没有宝藏的宫室不设传送门，所有的宫室传送门分为三种：

  1. “横天门”：由该门可以传送到同行的任一宫室；

  2. “纵寰门”：由该门可以传送到同列的任一宫室；

  3. “任意门”：由该门可以传送到以该门所在宫室为中心周围8格中任一宫室（如果目标宫室存在的话）。

深谋远虑的Henry当然事先就搞到了所驼门王当年的宫殿招标册，书册上详细记录了每扇传送门所属宫室及类型。而且，虽然宫殿内外相隔，但他自行准备了一种便携式传送门，可将自己传送到殿内任意一间宫室开始寻宝，并在任意一间宫室结束后传送出宫。整座宫殿只许进出一次，且便携门无法进行宫室之间的传送。不过好在宫室内传送门的使用没有次数限制，每间宫室也可以多次出入。

现在Henry已经打开了便携门，即将选择一间宫室进入。为得到尽多宝藏，他希望安排一条路线，使走过的不同藏宝宫室尽可能多。请你告诉Henry这条路线最多行经不同藏宝宫室的数目。

[输入格式]

输入文件sotomon.in第一行给出三个正整数N, R, C。

以下N行，每行给出一扇传送门的信息，包含三个正整数xi, yi, Ti，表示该传送门设在位于第xi行第yi列的藏宝宫室，类型为Ti。Ti是一个1~3间的整数，1表示可以传送到第xi行任意一列的“横天门”，2表示可以传送到任意一行第yi列的“纵寰门”，3表示可以传送到周围8格宫室的“任意门”。

保证1≤xi≤R，1≤yi≤C，所有的传送门位置互不相同。

[输出格式]

输出文件sotomon.out只有一个正整数，表示你确定的路线所经过不同藏宝宫室的最大数目。

[算法分析]

tarjan缩点+建图优化

首先 对于传送门的连边我们容易想到以下方法：

  1. 对于每一个“横天门”，我们向同一行的所有宫室连出一条有向边。
  2. 对于每一个“纵寰门”，我们向同一列的所有宫室连出一条有向边。
  3. 对于每一个“任意门”，我们向“九宫格”内的另外八个宫室连出一条有向边。

显然需要优化 容易想到：没有宝藏的宫室，既没有对其他宫室的出边，也没有对答案有贡献的点权，可以忽略不计，不参与建图。

则建边方法转化为：

  1. 对于每一个“横天门”，我们向同一行的所有有宝藏的宫室连出一条有向边。
  2. 对于每一个“纵寰门”，我们向同一列的所有有宝藏的宫室连出一条有向边。
  3. 对于每一个“任意门”，我们向“九宫格”内的另外八个宫室中有宝藏的连出一条有向边。

这种建边方法还是不够优化 对于一行之内全是横向门的数据会退化到O(n2) 考虑继续优化

我们新建n+r+c个节点 前r个表示每一行的代表节点 中间c个表示每一列的代表节点 后n个表示所有有宝藏的宫殿节点

那么，建边方式发生如下变化：

  1. 对于每一个“横天门”，我们向表示这一行的节点连出一条有向边。
  2. 对于每一个“纵寰门”，我们向表示这一列的节点连出一条有向边。
  3. 对于每一个“任意门”，我们向“九宫格”内的另外八个宫室中有宝藏的连出一条有向边。
  4. 对于节点 1−R，向这一行所有有宝藏的宫室连出一条有向边。
  5. 对于节点R+1−R+C，向这一列所有有宝藏的宫室连出一条有向边。

对于任意门周围是否有宝藏节点可以使用stlmap存储

[代码实现]

自认为可读性极好的代码/kk

#include <bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
#define mkp make_pair
const int N = 1e7 + 5; 
const int inf = 0x3f3f3f3f;
const int dx[9] = { 0 , 0 , 0 , 1 , -1 , 1 , 1 , -1 , -1 };
const int dy[9] = { 0 , 1 , -1 , 0 , 0 , 1 , -1 , 1 , -1 };

int read ()
{
	int x = 0 , f = 1;
	char ch = cin.get();
	while ( !isdigit ( ch ) ) { if ( ch == '-' ) f = -1; ch = cin.get(); }
	while ( isdigit ( ch ) ) { x = ( x << 1 ) + ( x << 3 ) + ( ch ^ 48 ); ch = cin.get(); }
	return x * f;
}

int n , m , q , f[N] , maxx , num[N] , xx[N] , yy[N];//f[i][j]表示以i为根的子树中 背包容量为j的情况下的的最大价值 那么最后答案就是f[0][m]

int head[N] , cnt;
int head1[N] , cnt1;
struct node { int to , nxt , w; } e[N] , e1[N];
void add ( int u , int v , int w = 0 ) { e[++cnt] = { v , head[u] , w }; head[u] = cnt; }
void add1 ( int u , int v , int w = 0 ) { e1[++cnt1] = { v , head1[u] , w }; head1[u] = cnt1; }

int dfn[N] , low[N] , timer;
int sta[N] , in[N] , tp;
int scc[N] , id[N] , tot;

void tarjan ( int u )
{
	dfn[u] = low[u] = ++timer;
	sta[++tp] = u , in[u] = 1;
	for ( int i = head[u] ; i ; i = e[i].nxt )
	{
		int v = e[i].to;
		if ( !dfn[v] ) tarjan(v) , low[u] = min ( low[u] , low[v] ); 
		else if ( in[v] ) low[u] = min ( low[u] , dfn[v] );	
	}
	if ( dfn[u] == low[u] )
	{
		tot ++;
		while ( tp )
		{
			int x = sta[tp--];
			id[x] = tot , in[x] = 0 , scc[tot] += num[x];
			if ( x == u ) break;
		}
	}
}

map < pii , int > mp;

int heng ( int x ) { return x; } 
int zong ( int x ) { return x + n; } 
int bao ( int x ) { return x + n + m; } 

int check ( int x , int y ) { return 1 <= x && x <= n && 1 <= y && y <= m && mp[mkp(x,y)]; }


signed main ()
{
	ios::sync_with_stdio(false);
	cin.tie(0) , cout.tie(0);
	q = read() , n = read() , m = read(); 
	for ( int i = 1 ; i <= q ; i ++ )
	{
		int x = read() , y = read() , op = read();
		num[bao(i)] = 1;
		add ( heng(x) , bao(i) ) , add ( zong(y) , bao(i) );
		if ( op == 1 ) add ( bao(i) , heng(x) );
		if ( op == 2 ) add ( bao(i) , zong(y) );
		if ( op == 3 ) xx[i] = x , yy[i] = y;
		mp[mkp(x,y)] = i;
	}
	for ( int i = 1 ; i <= q ; i ++ )
		if ( xx[i] && yy[i] )
			for ( int j = 1 , x , y ; j <= 8 ; j ++ )
				if ( check ( x = xx[i] + dx[j] , y = yy[i] + dy[j] ) )
					add ( bao(i) , bao(mp[mkp(x,y)]) );
	
	for ( int i = 1 ; i <= n + m + q ; i ++ ) if ( !dfn[i] ) tarjan(i);
	for ( int u = 1 ; u <= n + m + q ; u ++ )
		for ( int i = head[u] ; i ; i = e[i].nxt )
		{
			int v = e[i].to;
			if ( id[u] != id[v] ) add1 ( id[u] , id[v] );
		}
	for ( int i = 1 ; i <= tot ; i ++ ) f[i] = scc[i];
	for ( int u = tot ; u ; u -- )
		for ( int i = head1[u] ; i ; i = e1[i].nxt )
		{
			int v = e1[i].to;
			f[v] = max ( f[v] , f[u] + scc[v] );	
		}
	for ( int i = 1 ; i <= tot ; i ++ ) maxx = max ( maxx , f[i] );
	cout << maxx << endl;
	return 0;
}
posted @   Echo_Long  阅读(281)  评论(0)  编辑  收藏  举报
相关博文：
·  YbtOJ 「图论」 第5章 强连通分量
·  Tarjan 杂题
·  [学习笔记]强连通分量
·  强连通分量
·  强连通分量学习笔记
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· winform 绘制太阳，地球，月球 运作规律
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
点击右上角即可分享
微信分享提示
AI IDE Trae