[USACO15JAN]Grass Cownoisseur G

传送门


比赛的时候tarjan算法出锅了，赶快来复习一下。

题意：给一个\(n\)个点\(m\)条边的有向图，其中可以选择一条边逆行一次，问在这个基础上如何选择一条回路，使其经过的点最多。（重复经过的点只算一次，\(n,m \leqslant 10^5\)）。


首先，一个强连通分量内的点都可以选，那么不妨先用tarjan算法缩点，新图中每个点的权值就是原图中该连通分量中点的个数。

那么问题变成了，如何在一个DAG上选择一条从节点\(x\)开始点权和尽量大的回路，其中可以有一条边逆行一次。


因此可以枚举这条边，对于一条边\(u,v\)，只要求出从\(x\)到\(u\),和从\(v\)到\(x\)的点权和最大的路径。拿\(x\)到\(u\)为例，题解中几乎都用的是spfa来求解，但是spfa算法本身的时间复杂度是不稳定的。实际上因为这个图是DAG，因此可以用拓扑排序解决。只不过要拓扑排序两次，先是处理出所有\(x\)走不到的节点，再是从\(x\)开始拓扑排序并更新答案。

至于从\(v\)到\(x\)，建反图，用同样的算法即可解决。


这题还有一种做法是分层图，将新图复制一分，并且如果有边\(u \to v\)，就再连边\(v \to u + n\)，代表逆行一次。这样同时也能满足走到第二层后就回不到第一层了，刚好符合只能逆行一次的限制。而且分层图同样是DAG，用拓扑排序来解决最长路问题即可。

#include<bits/stdc++.h>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e5 + 5;
In ll read()
{
	ll ans = 0;
	char ch = getchar(), las = ' ';
	while(!isdigit(ch)) las = ch, ch = getchar();
	while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
	if(las == '-') ans = -ans;
	return ans;
}
In void write(ll x)
{
	if(x < 0) x = -x, putchar('-');
	if(x >= 10) write(x / 10);
	putchar(x % 10 + '0');
}

int n, m;
struct Edge
{
	int nxt, to;
}e[maxn];
int head[maxn], ecnt = -1;
In void addEdge(int x, int y)
{
	e[++ecnt] = (Edge){head[x], y};
	head[x] = ecnt;
}

int dfn[maxn], low[maxn], cnt = 0;
bool in[maxn];
int st[maxn], top = 0, col[maxn], num[maxn], ccol = 0;
In void tarjan(int now)
{
	dfn[now] = low[now] = ++cnt;
	st[++top] = now, in[now] = 1;
	forE(i, now, v)
	{
		if(!dfn[v])
		{
			tarjan(v);
			low[now] = min(low[now], low[v]);
		}
		else if(in[v]) low[now] = min(low[now], dfn[v]);
	}
	if(low[now] == dfn[now])
	{
		int x; ++ccol;
		do
		{
			x = st[top--], in[x] = 0;
			col[x] = ccol, num[ccol]++;
		}while(x != now);
	}
}

Edge e2[maxn];
int head2[maxn], ecnt2 = -1, du[maxn];
In void addEdge2(int x, int y)
{
	e2[++ecnt2] = (Edge){head2[x], y};
	head2[x] = ecnt2;
	du[y]++;
}
In void buildGraph(bool flg)
{
	Mem(head2, -1), ecnt2 = -1, Mem(du, 0);
	for(int u = 1; u <= n; ++u)
		forE(i, u, v)
			if(col[u] ^ col[v]) flg ? addEdge2(col[u], col[v]) : addEdge2(col[v], col[u]);
}

int dis1[maxn], dis2[maxn];
/*bool vis[maxn];
In void spfa(int* dis)
{
	Mem(vis, 0);
	queue<int> q; q.push(col[1]); dis[col[1]] = num[col[1]];
	while(!q.empty())
	{
		int now = q.front(); q.pop();
		vis[now] = 0;
		for(int i = head2[now], v; ~i && (v = e2[i].to); i = e2[i].nxt) 
		{
			if(dis[v] < dis[now] + num[v])
			{
				dis[v] = dis[now] + num[v];
				if(!vis[v]) q.push(v), vis[v] = 1;
			}
		}
	}
}*/
In void topo(int* dis)
{
	queue<int> q;
	for(int i = 1; i <= ccol; ++i) if(!du[i] && i != col[1]) q.push(i);
	while(!q.empty())
	{
		int now = q.front(); q.pop();
		for(int i = head2[now], v; ~i && (v = e2[i].to); i = e2[i].nxt) 
			if(!--du[v] && v != col[1]) q.push(v);
	}
	q.push(col[1]), dis[col[1]] = num[col[1]];
	while(!q.empty())
	{
		int now = q.front(); q.pop();
		for(int i = head2[now], v; ~i && (v = e2[i].to); i = e2[i].nxt) 
		{
			dis[v] = max(dis[v], dis[now] + num[v]);
			if(!--du[v]) q.push(v);
		}
	}
}

int main()
{
	Mem(head, -1), ecnt = -1;
	n = read(), m = read();
	for(int i = 1; i <= m; ++i)
	{
		int x = read(), y = read();
		addEdge(x, y); 
	}
	for(int i = 1; i <= n; ++i) if(!dfn[i]) tarjan(i);
	buildGraph(1), topo(dis1);
	buildGraph(0), topo(dis2);
	int ans = 0;
	for(int u = 1; u <= n; ++u)
		forE(i, u, v)
			if(col[u] ^ col[v])
			{
				if(!dis1[col[v]] || !dis2[col[u]]) continue;
				ans = max(ans, dis1[col[v]] + dis2[col[u]] - num[col[1]]);	
			} 
	write(ans), enter;
	return 0;
}