[APIO2018] Duathlon 铁人两项

题目

点这里看题目。

分析

首先，我们很容易看出，在 (s) 和 (f) 确定时，(c) 的备选数量就等于(s)到(f)所有简单路径的并的大小减二（要把(s)和(f)去掉）。

随手画几个图就会发现， (s) 到 (f) 所有简单路径的并似乎也就是(s)到(f)经过的所有点双的并。

考虑证明这个猜想。首先，由于点双之间最多只有一个公共点，所以每个点双内，每条从 (s) 到 (f) 的简单路径，必然是从一个固定点进入点双，从另一个固定点离开。

因而我们只需要再证明：在点双内部，对于任意三点(a, b, c)，必然存在简单路径满足从(a)到(c)到(b)。

为了方便，以下用(uoverset{c}{ ightarrow}v)表示从(u)向(v)连一条容量为(c)的边。

考虑构建一个网络来证明，如下：

1. 拆点。对于(u)拆成(u)和(u')，并且连接(uoverset{1}{ ightarrow} u')，表示每个点只能经过一次。

2. 拆边。无向边先要拆成有向边。对于有向边((u,v))，连接(u'overset{1}{ ightarrow} v)，表示边只能经过一次。

3. 连接源汇。连接(Soverset{2}{ ightarrow} c, a'overset{1}{ ightarrow} T,b'overset{1}{ ightarrow} T)。

这样，如果原图最大流为 (2) ，则存在需要的路径。

也就是说，我们需要证明，原图最大流，也即是最小割为 (2) 。

设最小割为(C)。显然(Cle 2)。那么我们需要证明(C>1)，即不可以只删除一条边就使得(S)到(T)不连通。

分类讨论：

1. 如果删除 (uoverset{1}{ ightarrow} u') 的边，我们就相当于拆掉了一个点。根据点双的定义，不影响连通性。

2. 如果删除 (u'overset{1}{ ightarrow} v) 的边，我们就相当于拆掉了一条边。由于这个操作影响比拆点更小，因而也不影响连通性。

3. 删除(a'overset{1}{ ightarrow} T)或者是(b'overset{1}{ ightarrow} T)。显然只删除一边而另一边留存都不会影响连通性。

因而有(C>1)，根据连边特性我们知道就有(C=2)，即命题成立。

这也就是说，我们的猜想也是成立的。

因而我们只需要统计任意两点之间，经过的点双的并的大小减二即可。

考虑建出圆方树，这样任意两点之间经过的点双就是路径上的方点。

下面需要使用到一个技巧：为圆方树上的点赋合适的权。

这一题中，我们首先可以猜想给方点赋为点双大小。由于两个点双之间最多只有一个交点，因而我们可以直接给圆点赋为 (-1) 进行扣除多余贡献。同时，圆点赋 (-1) 也能顺带处理 " 并集大小减二 " 这个情况。

总结一下，我们给圆点赋 (-1) ，方点赋大小，然后统计任意两个圆点之间路径的权值和即可。建出圆方树后一边 DFS 计算答案即可。时间(O(n))。

代码

#include <cstdio>

typedef long long LL;

const int MAXN = 2e5 + 5, MAXM = 2e6 + 5;

template<typename _T>
void read( _T &x )
{
	x = 0;char s = getchar();int f = 1;
	while( s > '9' || s < '0' ){if( s == '-' ) f = -1; s = getchar();}
	while( s >= '0' && s <= '9' ){x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar();}
	x *= f;
}

template<typename _T>
void write( _T x )
{
	if( x < 0 ){ putchar( '-' ); x = ( ~ x ) + 1; }
	if( 9 < x ){ write( x / 10 ); }
	putchar( x % 10 + '0' );
}

template<typename _T>
_T MIN( const _T a, const _T b )
{
	return a < b ? a : b;
}

struct GRAPH
{
	struct edge
	{
		int to, nxt;
	}Graph[MAXM << 1];
	
	int head[MAXN] = {}, cnt;
	
	GRAPH() { cnt = 0; }
	
	void addEdge( const int from, const int to )
	{
		Graph[++ cnt].to = to, Graph[cnt].nxt = head[from];
		head[from] = cnt;
	}
	
	void addE( const int from, const int to )
	{
		addEdge( from, to ), addEdge( to, from );
	}
	
	void nxt( int &ptr ) const { ptr = Graph[ptr].nxt; }
	edge& operator [] ( const int indx ) { return Graph[indx]; }
}G, T;

int stk[MAXN];
int siz[MAXN], w[MAXN];
int DFN[MAXN], LOW[MAXN];
LL ans;
int N, M, cnt, ID, top, tot, subn;

void Tarjan( const int u, const int fa )
{
	subn ++;
	DFN[u] = LOW[u] = ++ ID;
	w[stk[++ top] = u] = -1;
	for( int i = G.head[u], v ; i ; G.nxt( i ) )
		if( ( v = G[i].to ) ^ fa )
		{
			if( ! DFN[v] )
			{
				Tarjan( v, u );
				LOW[u] = MIN( LOW[u], LOW[v] );
				if( LOW[v] >= DFN[u] )
				{
					T.addE( ++ tot, u ), w[tot] ++;
					do T.addE( tot, stk[top] ), w[tot] ++;
					while( stk[top --] ^ v );
				}
			}
			else LOW[u] = MIN( LOW[u], DFN[v] );
		}
}

void DFS( const int u, const int fa )
{
	siz[u] = u <= N;
	for( int i = T.head[u], v ; i ; T.nxt( i ) )
		if( ( v = T[i].to ) ^ fa )
		{
			DFS( v, u ); 
			ans += 2ll * siz[u] * siz[v] * w[u];
			siz[u] += siz[v];
		}
	ans += 2ll * siz[u] * ( subn - siz[u] ) * w[u];
}

int main()
{
	read( N ), read( M ), tot = N;
	for( int i = 1, a, b ; i <= M ; i ++ )
		read( a ), read( b ), G.addE( a, b );
	for( int i = 1 ; i <= N ; i ++ )
		if( ! DFN[i] )
		{
			subn = 0;
			Tarjan( i, 0 );
			DFS( i, 0 );
		}
	write( ans ), putchar( '
' );
	return 0;
}