luoguP5024 保卫王国

题目链接

问题分析

其实是比较明显的动态DP。

懒于再推一遍式子，直接用 最小权点覆盖=全集-最大权独立集，然后就和这道题一样了。题解可以看这里。

然后必须选或者不选的话，就直接把相应的点权变成$-infty$或$infty$就好了。如果是必须选，最后答案里不要忘了加回原来的值。

参考程序

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

const long long Maxn = 100010;
const long long INF = 10000000010;
struct matrix {
	long long A[ 2 ][ 2 ];
	matrix() {
		A[ 0 ][ 0 ] = A[ 0 ][ 1 ] = A[ 1 ][ 0 ] = A[ 1 ][ 1 ] = -INF;
		return;
	}
	matrix( long long *T ) {
		A[ 0 ][ 0 ] = A[ 0 ][ 1 ] = T[ 0 ];
		A[ 1 ][ 0 ] = T[ 1 ];
		A[ 1 ][ 1 ] = -INF;
		return;
	}
	matrix( long long a, long long b, long long c, long long d ) {
		A[ 0 ][ 0 ] = a; A[ 0 ][ 1 ] = b; A[ 1 ][ 0 ] = c; A[ 1 ][ 1 ] = d;
		return;
	}
	inline matrix operator * ( const matrix Other ) const {
		return matrix( max( A[ 0 ][ 0 ] + Other.A[ 0 ][ 0 ], A[ 0 ][ 1 ] + Other.A[ 1 ][ 0 ] ),
				max( A[ 0 ][ 0 ] + Other.A[ 0 ][ 1 ], A[ 0 ][ 1 ] + Other.A[ 1 ][ 1 ] ),
				max( A[ 1 ][ 0 ] + Other.A[ 0 ][ 0 ], A[ 1 ][ 1 ] + Other.A[ 1 ][ 0 ] ),
				max( A[ 1 ][ 0 ] + Other.A[ 0 ][ 1 ], A[ 1 ][ 1 ] + Other.A[ 1 ][ 1 ] ) );
	}
};
struct edge {
	long long To, Next;
	edge() : To( 0 ), Next( 0 ) {}
	edge( long long _To, long long _Next ) : To( _To ), Next( _Next ) {}
};
edge Edge[ Maxn << 1 ];
long long Start[ Maxn ], UsedEdge;
inline void AddEdge( long long x, long long y ) {
	Edge[ ++UsedEdge ] = ( edge ) { y, Start[ x ] };
	Start[ x ] = UsedEdge;
	return;
}
long long n, m, Cost[ Maxn ], NowCost[ Maxn ], Sum;
char Ch[ 10 ];
long long Deep[ Maxn ], Father[ Maxn ], Size[ Maxn ], Son[ Maxn ], Top[ Maxn ], Index[ Maxn ], Ref[ Maxn ], Dfn[ Maxn ], Used;
long long Dp[ Maxn ][ 2 ], LDp[ Maxn ][ 2 ];
matrix Tree[ Maxn << 2 ];

void Build_Cut();
void Build();
void Change( long long u, long long Key );
matrix Query( long long Ind, long long Left, long long Right, long long L, long long R );

int main() {
	scanf( "%lld%lld", &n, &m ); scanf( "%s", Ch );
	for( long long i = 1; i <= n; ++i ) scanf( "%lld", &Cost[ i ] );
	for( long long i = 1; i < n; ++i ) {
		long long x, y; scanf( "%lld%lld", &x, &y );
		AddEdge( x, y ); AddEdge( y, x );
	}
	Build_Cut();
	Build();
	for( long long i = 1; i <= m; ++i ) {
		long long a, x, b, y;
		scanf( "%lld%lld%lld%lld", &a, &x, &b, &y);
		if( x == 0 ) { Sum -= Cost[ a ]; Sum += INF; Change( a, INF ); }
		else { Sum -= Cost[ a ]; Sum += -INF; Change( a, -INF ); }
		if( y == 0 ) { Sum -= Cost[ b ]; Sum += INF; Change( b, INF ); }
		else { Sum -= Cost[ b ]; Sum += -INF; Change( b, -INF ); }

		matrix Temp = Query( 1, 1, n, Index[ 1 ], Dfn[ 1 ] );
		long long Ans = max( Temp.A[ 0 ][ 0 ], Temp.A[ 1 ][ 0 ] );
		Ans = Sum - Ans;
		if( x == 1 ) Ans = Ans + INF + Cost[ a ];
		if( y == 1 ) Ans = Ans + INF + Cost[ b ];
		if( Ans >= INF ) printf( "-1
" ); else printf( "%lld
", Ans );

		if( x == 0 ) { Sum -= INF; Sum += Cost[ a ]; Change( a, Cost[ a ] ); } 
		else { Sum -= -INF; Sum += Cost[ a ]; Change( a, Cost[ a ] ); }
		if( y == 0 ) { Sum -= INF; Sum += Cost[ b ]; Change( b, Cost[ b ] ); }
		else { Sum -= -INF; Sum += Cost[ b ]; Change( b, Cost[ b ] ); }
	}
	return 0;
}

void Dfs1( long long u, long long Fa ) {
	Deep[ u ] = Deep[ Fa ] + 1;
	Father[ u ] = Fa;
	Size[ u ] = 1;
	for( long long t = Start[ u ]; t; t = Edge[ t ].Next ) {
		long long v = Edge[ t ].To;
		if( v == Fa ) continue;
		Dfs1( v, u );
		if( Size[ v ] > Size[ Son[ u ] ] ) Son[ u ] = v;
		Size[ u ] += Size[ v ];
	}
	return;
}

void Dfs2( long long u, long long Fa ) {
	if( Son[ u ] ) {
		Top[ Son[ u ] ] = Top[ u ];
		Index[ Son[ u ] ] = ++Used;
		Ref[ Used ] = Son[ u ];
		Dfs2( Son[ u ], u );
	}
	for( long long t = Start[ u ]; t; t = Edge[ t ].Next ) {
		long long v = Edge[ t ].To;
		if( v == Fa || v == Son[ u ] ) continue;
		Top[ v ] = v; Index[ v ] = ++Used; Ref[ Used ] = v;
		Dfs2( v, u );
	}
	return;
}

void Build_Cut() {
	Dfs1( 1, 0 );
	Top[ 1 ] = 1; Index[ 1 ] = ++Used; Ref[ Used ] = 1;
	Dfs2( 1, 0 );
	for( int i = 1; i <= n; ++i ) Dfn[ Top[ i ] ] = max( Dfn[ Top[ i ] ], Index[ i ] );
	return;
}

void Dfs3( long long u, long long Fa ) {
	LDp[ u ][ 1 ] = NowCost[ u ];
	for( long long t = Start[ u ]; t; t = Edge[ t ].Next ) {
		long long v = Edge[ t ].To;
		if( v == Fa || v == Son[ u ] ) continue;
		Dfs3( v, u );
		LDp[ u ][ 0 ] += max( Dp[ v ][ 0 ], Dp[ v ][ 1 ] );
		LDp[ u ][ 1 ] += Dp[ v ][ 0 ];
	}
	if( Son[ u ] ) Dfs3( Son[ u ], u );
	Dp[ u ][ 0 ] = LDp[ u ][ 0 ] + max( Dp[ Son[ u ] ][ 0 ], Dp[ Son[ u ] ][ 1 ] );
	Dp[ u ][ 1 ] = LDp[ u ][ 1 ] + Dp[ Son[ u ] ][ 0 ];
	return;
}

void RealBuild( long long Ind, long long Left, long long Right ) {
	if( Left == Right ) {
		Tree[ Ind ] = matrix( LDp[ Ref[ Left ] ] );
		return;
	}
	long long Mid = ( Left + Right ) >> 1;
	RealBuild( Ind << 1, Left, Mid );
	RealBuild( Ind << 1 | 1, Mid + 1, Right );
	Tree[ Ind ] = Tree[ Ind << 1 ] * Tree[ Ind << 1 | 1 ];
	return;
}

matrix Query( long long Ind, long long Left, long long Right, long long L, long long R ) {
	if( L <= Left && Right <= R ) return Tree[ Ind ];
	long long Mid = ( Left + Right ) >> 1;
	if( R <= Mid ) return Query( Ind << 1, Left, Mid, L, R );
	if( L > Mid ) return Query( Ind << 1 | 1, Mid + 1, Right, L, R );
	return Query( Ind << 1, Left, Mid, L, R ) * Query( Ind << 1 | 1, Mid + 1, Right, L, R );
}

void Build() {
	for( long long i = 1; i <= n; ++i ) NowCost[ i ] = Cost[ i ];
	for( long long i = 1; i <= n; ++i ) Sum += NowCost[ i ];
	Dfs3( 1, 0 );
	RealBuild( 1, 1, n );
	return;
}

void Update( long long Ind, long long Left, long long Right, long long x ) {
	if( Left == Right ) {
		Tree[ Ind ] = matrix( LDp[ Ref[ Left ] ] );
		return;
	}
	long long Mid = ( Left + Right ) >> 1;
	if( x <= Mid ) Update( Ind << 1, Left, Mid, x );
	if( x > Mid ) Update( Ind << 1 | 1, Mid + 1, Right, x );
	Tree[ Ind ] = Tree[ Ind << 1 ] * Tree[ Ind << 1 | 1 ];
	return;
}

void Change( long long u, long long Key ) {
	matrix Last = Query( 1, 1, n, Index[ Top[ u ] ], Dfn[ Top[ u ] ] );
	LDp[ u ][ 1 ] += -NowCost[ u ] + Key; NowCost[ u ] = Key;
	Update( 1, 1, n, Index[ u ] );
	matrix Temp = Query( 1, 1, n, Index[ Top[ u ] ], Dfn[ Top[ u ] ] );
	u = Father[ Top[ u ] ];
	while( u ) {
		matrix TTT = Query( 1, 1, n, Index[ Top[ u ] ], Dfn[ Top[ u ] ] );
		LDp[ u ][ 0 ] += -max( Last.A[ 0 ][ 0 ], Last.A[ 1 ][ 0 ] ) + max( Temp.A[ 0 ][ 0 ], Temp.A[ 1 ][ 0 ] );
		LDp[ u ][ 1 ] += -Last.A[ 0 ][ 0 ] + Temp.A[ 0 ][ 0 ];
		Last = TTT;
		Update( 1, 1, n, Index[ u ] );
		Temp = Query( 1, 1, n, Index[ Top[ u ] ], Dfn[ Top[ u ] ] );
		u = Father[ Top[ u ] ];
	}
	return;
}