[USACO21FEB] Minimizing Edges P

题目

点这里看题目。

分析

这道题就离离离离离谱

首先不难发现 \(f_G(u,x)\) 实际上只和到达 \(u\) 的奇偶最短路长度相关。

那么很快就导出一种特例——即对于某个点，存在两种奇偶性的最短路的情况，可以发现此时 \(G\) 是二分图。那么我们只需要考虑一种最短路，因此可以直接建立最短路树，得到答案为 \(n-1\) 。

考虑一般情况，即 \(G\) 上面有奇环的情况，此时对于任意的点，都有两种奇偶性的最短路。因此可以设 \(d_u\) 表示 \(u\) 的最短路，而用 \(d'_u\) 表示 \(u\) 的奇偶性与 \(d_u\) 不同的另一条最短路。一个显然的性质是 \(d<d'\) 。

分析一下 \(G'\) 必须满足的条件：

1. 在 \(u\) 的邻接点中，必须有一个点 \(v\) ，满足 \(d_u=d_v+1\) ；
2. 在 \(u\) 的邻接点中，必须有一个点 \(v\) ，满足 \(d'_u=d'_v+1\) 或者 \(d'_u=d_v+1\) ；

注意到我们其实只关心 \((d,d')\) 这样的有序对，我们就可以得到集合 \(S(d,d')=\{u|d_u=d,d'_u=d'\}\) 。再简化一点，我们其实只关心 \(S(d,d')\) 的大小，所以我们可以直接设 \(f(d,d')=|S(d,d')|\) 。

根据之前的条件，我们再分析一下对于 \((d,d')\) ，它的连边情况：

1. 直接和 \((d-1,d'-1)\) 相连；
2. 直接和 \((d-1,d'+1)\) 和 \((d+1,d'-1)\) 相连；
3. 如果 \(d+1=d'\) ，此时可以和 \((d-1,d'+1)\) 和 \((d,d')\) 相连，这种情况特殊在它的表现是在 \(S\) 内部连边；

画一个图会更好理解：

绿色为合法连边。上图左侧是一般的连边，上图右侧是内部的连边

注意到，如果按照 \(d+d'\) 分层，那么只有 1 为跨层连，而 2,3 均为同层连。这启发我们可以按照 \(d+d'\) 和 \(d\) 的优先级进行处理。

一个显然的性质是：如果我们可以找到一种最优的连边方法，使得每个点的 \(d\) 和 \(d'\) 都可以转移过来，那么这就是最优解之一。

其实不一定很显然，但是看起来是对的，证明 " 下次一定 "

因此我们就可以考虑给每个点找相邻点，不难想到可以按顺序贪心！

下面我们就可以愉快地讨论了：

1. 如果 \(f(d-1,d'-1)>0,f(d-1,d'+1)=0\) ，那么没得说，只能全部连到 \(f(d-1,d'-1)\) 上；

2. 如果 \(f(d-1,d'-1)>0,f(d-1,d'+1)>0\) 且 \(d+1<d'\) ，此时有可能 \(S(d-1,d'+1)\) 的点需要连接到 \(S(d,d')\) 中的点来。设这样的需求边为 \(t\) 条，分类讨论：

   1. 如果 \(t\le f(d,d')\) ，那么可以先分配 \(t\) 个连接，剩下的点可以直接连到 \((d-1,d'-1)\) 上面一次解决问题；而钦定的 \(t\) 个点还需要满足 \(d'\) ，因此需要向 \(S(d+1,d'-1)\) 连 \(t\) 条边。
   2. 如果 \(t>f(d,d')\) ，那么我们也可以重复地连 \(t\) 条边，此时 \(S(d,d')\) 里的点还需要满足 \(d'\) 。经过下面的分析，我们可以知道将 \(f(d,d')\) 条边连至 \((d+1,d'-1)\) 会更优。

   注意到上面我们默认存在 \((d+1,d'-1)\) ；如果不存在，那么下传的给 \((d+1,d'-1)\) 的边只能连到 \((d-1,d'-1)\) 。

3. 如果 \(f(d-1,d'-1)>0,f(d-1,d'+1)>0\) 且 \(d+1=d'\) ，此时我们可以在 \((d,d')\) 内部连边。这部分的讨论类似于 2 部分；但特殊的情况是，这样的 \((d,d')\) 一定找不到对应的 \((d+1,d'-1)\) ，所以原本下传的 \(t\) 条边需要内部消化，不难发现这样的贡献是 \(\lceil\frac t 2\rceil\) 。

   在这里我们也可以解释为什么 2.2 中需要下传：无论这 \(t\) 条边连在哪里，它一定会带来贡献；但如果向下传递，它就有可能连接到 \(d+1=d'\) 的点，使得只缺 \(d'\) 的点变多。粗算一下，只缺 \(d'\) 的点代价为 \(\frac{1}{2}\) ，而 \(d,d'\) 都缺的点代价为 \(1\) ，显然这样会划算一些。

运用 set 可以获得 \(O(n\log_2n)\) 的复杂度，足以通过本题。如果分层并用指针应该可以做到 \(O(n)\) 。

小结：

1. 本题一个妙处在于不区分 \(d,d'\) 的实际奇偶，而只关心相对奇偶，一下子就让讨论方便了许多。相当于是简化信息，关注相对信息。
2. 另一个妙处在于分析 \((d,d')\) 的连接情况，使得需要考虑的连边大大减少，简化了问题。
3. 最后一个点在于目标的转化，我们将目标转化到了一个等效的状态——即每个点的 \(d,d'\) 都得到了满足，那么它就是合法的。虽然并不是很显然，但它告诉我们可以从目标入手反推。

代码

点我查看代码

#include <set>
#include <cstdio>
#include <utility>
#include <algorithm>
using namespace std;

#define rep( i, a, b ) for( int i = (a) ; i <= (b) ; i ++ )
#define per( i, a, b ) for( int i = (a) ; i >= (b) ; i -- )

typedef pair<int, int> Node;

const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 5, MAXM = 2e5 + 5;

#define DX first
#define DY second

template<typename _T>
void read( _T &x )
{
	x = 0; char s = getchar(); int f = 1;
	while( s < '0' || '9' < s ) { f = 1; if( s == '-' ) f = -1; s = getchar(); }
	while( '0' <= s && 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;
	if( 9 < x ) write( x / 10 );
	putchar( x % 10 + '0' );
}

struct Edge
{
	int to, nxt;
}Graph[MAXM << 2];

set<Node> s;
Node seq[MAXN];

int dist[MAXN << 1];

int head[MAXN << 1];
int N, M, cnt;

bool Cmp( const Node &x, const Node &y )
{
	int tx = x.DX + x.DY, ty = y.DX + y.DY;
	return tx == ty ? x.DX < y.DX : tx < ty;
}

void Clean()
{
	cnt = 0, s.clear();
	rep( i, 1, N << 1 ) head[i] = 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 BFS()
{
	static int q[MAXN << 1], h, t;
	h = 1, t = 0; rep( i, 1, N << 1 ) q[i] = 0;
	rep( i, 1, N << 1 ) dist[i] = INF;
	dist[q[++ t] = 1] = 0;
	for( int u, v ; h <= t ; )
	{
		u = q[h ++];
		for( int i = head[u] ; i ; i = Graph[i].nxt )
			if( dist[v = Graph[i].to] > dist[u] + 1 )
				dist[q[++ t] = v] = dist[u] + 1;
	}
}

int main()
{
	int T;
	read( T );
	while( T -- )
	{
		read( N ), read( M ), Clean();
		rep( i, 1, M ) { int a, b; 
			read( a ), read( b ); 
			AddE( a, b + N ), AddE( a + N, b );
		}
		BFS(); bool flg = true;
		rep( i, 1, N )
		{
			if( dist[i] < dist[i + N] ) seq[i] = Node( dist[i], dist[i + N] );
			else seq[i] = Node( dist[i + N], dist[i] );
			if( seq[i].DY == INF ) flg = false;
		}
		if( flg == false ) { write( N - 1 ), putchar( '\n' ); continue; }
		
		sort( seq + 1, seq + 1 + N, Cmp ); int ans = 0, t = 0;
		for( int i = 1, r ; i <= N ; i = r )
		{
			for( r = i ; r <= N && seq[r] == seq[i] ; r ++ );
			s.insert( seq[i] );
			Node lu = Node( seq[i].DX - 1, seq[i].DY - 1 );
			flg = s.find( lu ) != s.end();
			if( t <= r - i ) 
			{
				if( flg ) ans += ( i > 1 ) * ( r - i );
				else ans += ( i > 1 ) * ( r - i ), t = r - i;
			}
			else ans += ( i > 1 ) * t, t = r - i;
			if( r > N || seq[r] != Node( seq[i].DX + 1, seq[i].DY - 1 ) )
			{
				if( seq[i].DX + 1 != seq[i].DY ) ans += t;
				else ans += t + 1 >> 1; t = 0;
			}
		}
		write( ans ), putchar( '\n' );
	}
	return 0;
}