数据结构之基环树——骑士，Island，旅行加强版，Number of Simple Paths，Traffic Network in Numazu，Card Game

最新推荐文章于 2024-04-21 21:04:00 发布
最新推荐文章于 2024-04-21 21:04:00 发布
阅读量229 收藏
点赞数 2
分类专栏： # 基环树 文章标签： 数据结构 动态规划 c语言 基环树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Emm_Titan/article/details/120131512
版权

文章目录


基环树的常见解法

  • 若干个基环树互相独立
  • 断环为链（随便断一条）
  • 环外树和环外树之间的树形DP
  • 环变链后整体可以用数据结构简单维护操作

[ZJOI2008]骑士

luogu2607

每个人都有讨厌的人，将这个条件转换成两人之间存在一条边

原图则转换成了若干个互不干扰的基环树

单独考虑一棵基环树

对于“树”的部分，可以树形 D P DP DP

对于“环”的部分，不用单调队列，直接随便找一条环上边，强制断开

基环树就彻底变成了一棵树

设计 d p u , 0 / 1 dp_{u,0/1} dpu,0/1​转移

  • 父亲选，则所有儿子不能选
  • 父亲不选，则儿子可选可不选
  • 儿子之间也是互相独立的

分别以断开的边的两端作为树根，最后就是max(dp[S][0], dp[T][0])

为什么没有dp[S][1],dp[T][1]？

  • 以S为例，dp[S][0]是S为树根时强制不选的最大值
  • 此时 T T T是树中一个节点，会根据转移方程式决定T是否选择
  • 如果dp[S][0]是不含 T T T的，说明最佳方案本来就是S,T都不选择
  • 所以就不能出现dp[S][1]，最佳方案可能包含了T
  • dp[T][0]同理
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define int long long 
#define maxn 1000005
int n, cnt, S, T, ID;
int w[maxn], head[maxn], to[maxn << 1], nxt[maxn << 1];
int dp[maxn][2];
bool vis[maxn];

void addedge( int u, int v ) {
	to[cnt] = v, nxt[cnt] = head[u], head[u] = cnt ++;
	to[cnt] = u, nxt[cnt] = head[v], head[v] = cnt ++;
}

void dfs1( int u, int id ) {
	vis[u] = 1;
	for( int i = head[u];~ i;i = nxt[i] ) {
		if( i == id ) continue;
		int v = to[i];
		if( vis[v] ) {
			S = u, T = v, ID = i;
			continue;
		}
		else 
			dfs1( v, i ^ 1 );
	}
}

void dfs2( int u, int id ) {
	dp[u][0] = 0, dp[u][1] = w[u];
	for( int i = head[u];~ i;i = nxt[i] ) {
		if( i == id or i == ID or i == ( ID ^ 1 ) ) continue;
		int v = to[i];
		dfs2( v, i ^ 1 );
		dp[u][0] += max( dp[v][0], dp[v][1] );
		dp[u][1] += dp[v][0];
	}
}

signed main() {
	memset( head, -1, sizeof( head ) );
	scanf( "%lld", &n );
	for( int i = 1, x;i <= n;i ++ ) {
		scanf( "%lld %lld", &w[i], &x );
		addedge( i, x );
	}
	int ans = 0;
	for( int i = 1;i <= n;i ++ ) {
		if( vis[i] ) continue;
		dfs1( i, -1 );
		int t = 0;
		dfs2( S, -1 ); t = max( t, dp[S][0] );
		dfs2( T, -1 ); t = max( t, dp[T][0] );
		ans += t;
	}
	printf( "%lld\n", ans );
	return 0;
}

[IOI2008] Island

luogu4381

同样的，这是相互独立的若干棵基环树

问题转化为求若干个基环树的直径之和

单独考虑一个基环树，设计状态转移方程

边权变成入点的点权

f i : i f_i:i fi​:i子树内以 i i i为链端的最长链长度

g i : i g_i:i gi​:i子树内的直径

首先可以利用拓扑做有向图，求出所有的环，顺便转移出每个点的信息

  • v ∈ s o n u v\in son_u v∈sonu​
  • 直径是 v v v子树内的直径
    • g u = max ⁡ ( g u , g v ) g_u=\max(g_u,g_v) gu​=max(gu​,gv​)
  • 直径是由 u u u的两条链拼接而成，其中一条链过 v v v
    • g u = max ⁡ ( f u + f v + w u , v , g u ) g_u=\max(f_u+f_v+w_{u,v},g_u) gu​=max(fu​+fv​+wu,v​,gu​)
  • 最长链为 v v v这一条链
    • f u = max ⁡ ( f u , f v + w u , v ) f_u=\max(f_u,f_v+w_{u,v}) fu​=max(fu​,fv​+wu,v​)

考虑环上的点信息更新

  • 基环树直径可能是某个点的环外子树直径
  • 基环树直径可能是两个环点的最长链拼接，再加上环上距离

同样的，枚举环上某一条边，强制断边，变成一条单链后

可以用前缀和差分求环上两点的距离，距离有两种

  • 恰好顺着断边的顺序
    • s u m j − s u m i sum_j-sum_i sumj​−sumi​
  • 反着走环
    • l e n − ( s u m j − s u m i ) len-(sum_j-sum_i) len−(sumj​−sumi​)

则环上点拼接成直径的转移为

max ⁡ ( f i + f j + s u m j − s u m i , f i + f j + l e n − s u m j + s u m i ) \max(f_i+f_j+sum_j-sum_i,f_i+f_j+len-sum_j+sum_i) max(fi​+fj​+sumj​−sumi​,fi​+fj​+len−sumj​+sumi​)

发现 i , j i,j i,j之间是独立的，枚举到 j j j时，记录前面最大贡献的 i i i

M a x 1 = max ⁡ { f i − s u m i } ; M a x 2 = max ⁡ { f i + s u m i } Max_1=\max\{f_i-sum_i\};Max_2=\max\{f_i+sum_i\} Max1​=max{fi​−sumi​};Max2​=max{fi​+sumi​}

max ⁡ ( f j + s u m j + M a x 1 , f j + l e n − s u m j + M a x 2 ) \max(f_j+sum_j+Max_1,f_j+len-sum_j+Max_2) max(fj​+sumj​+Max1​,fj​+len−sumj​+Max2​)

但是只有当环跑完后我们才知道环长 l e n len len

所以可以把 l e n len len提出去，最后加上再选较大值

#include <queue>
#include <cstdio>
#include <iostream>
using namespace std;
#define int long long
#define maxn 1000005
queue < int > q;
int to[maxn], d[maxn], w[maxn], f[maxn], g[maxn];
bool vis[maxn];
int n;

int dfs( int now ) {
	int x = to[now], sum = w[now];
	int ans1 = g[now], Max1 = f[now];
	int ans2 = - 1e18, Max2 = f[now];
	while( x ^ now ) {
		d[x] = 0;
		ans1 = max( ans1, g[x] );
		ans1 = max( ans1, f[x] + sum + Max1 );
		ans2 = max( ans2, f[x] - sum + Max2 );
		Max1 = max( Max1, f[x] - sum );
		Max2 = max( Max2, f[x] + sum );
		sum += w[x];
		x = to[x];
	}
	return max( ans1, ans2 + sum );
}

signed main() {
	scanf( "%lld", &n );	
	for( int i = 1;i <= n;i ++ )
		scanf( "%lld %lld", &to[i], &w[i] ), d[to[i]] ++;
	for( int i = 1;i <= n;i ++ )
		if( ! d[i] ) q.push( i );
	while( ! q.empty() ) {
		int u = q.front(); q.pop();
		int v = to[u];
		g[v] = max( g[v], max( g[u], f[v] + f[u] + w[u] ) );
		f[v] = max( f[v], f[u] + w[u] );
		d[v] --;
		if( ! d[v] ) q.push( v );
	}
	int ret = 0;
	for( int i = 1;i <= n;i ++ ) 
		if( d[i] ) ret += dfs( i );
	printf( "%lld\n", ret );
	return 0;
}

[NOIP2018 提高组] 旅行 加强版

luogu5049

  • m=n-1
    • 就是单纯的一棵树，直接dfs搜就可以了
  • m=n
    • 基环树

一个点只能访问未访问点，或者选择回溯

考虑对于基环树环上点的几种选择

  • case1

在这里插入图片描述

对于节点3，肯定是由2过来的，最佳选择是先遍历完非环的树的点5,6，再走环

是不会选择回溯到2的

  • case2

在这里插入图片描述

3的环边5是其所有边中最小的，优选走环，后遍历非环树，不选择回溯

  • case3

在这里插入图片描述

3的环边6不是最大也不是最小，选择先遍历5再走环边，最后遍历8，同样不会选择回溯

发现只有当环边是最大边的时候就会选择遍历完非环树后回溯

但真的这样就直接回溯了吗？

  • case4

在这里插入图片描述

走到3的时候，遍历5,6，但是发现回溯后走的是9并没有比8小，也是应该不回溯的

综上，只有环边是最大边且比回溯后走的第一条边大的时候才会选择回溯

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 500005
vector < int > ans;
struct node { int u, v; }edge[maxn << 1];
int head[maxn], to[maxn << 2], nxt[maxn << 2], f[maxn];
bool vis[maxn], circle[maxn];
bool flag1, flag2, flag3;
int n, m, cnt, Max;

void dfs1( int u ) {
	vis[u] = 1;
	ans.push_back( u );
	for( int i = head[u];~ i;i = nxt[i] ) {
		int v = to[i];
		if( vis[v] ) continue;
		else dfs1( v );
	}
}

void dfs2( int now, int fa ) {
	if( flag2 ) return;
	if( ! f[now] ) f[now] = fa;
	else {
		do {
			circle[fa] = 1;
			fa = f[fa];
		} while( fa ^ f[now] );
		flag2 = 1;
		return;
	}
	for( int i = head[now];~ i;i = nxt[i] )
		if( to[i] ^ fa ) dfs2( to[i], now );
}

void dfs3( int u ) {
	vis[u] = 1;
	ans.push_back( u );
	if( circle[u] ) {
		bool flag = 0;
		for( int i = head[u];~ i;i = nxt[i] ) {
			if( flag3 ) break;
			if( ! circle[to[i]] or vis[to[i]] ) continue;
			int v = to[i];
			i = nxt[i];
			while( vis[to[i]] ) i = nxt[i];
			if( ~ i ) Max = to[i];
			else if( v > Max ) flag = flag3 = 1;
			break;
		}
		for( int i = head[u];~ i;i = nxt[i] ) 
			if( vis[to[i]] or ( flag and circle[to[i]] ) ) continue;
			else dfs3( to[i] );
	}
	else
		for( int i = head[u];~ i;i = nxt[i] )
			if( vis[to[i]] ) continue;
			else dfs3( to[i] );
}

int main() {
	scanf( "%d %d", &n, &m );
	if( m == n - 1 ) flag1 = 1;
	for( int i = 1, u, v;i <= m;i ++ ) {
		scanf( "%d %d", &u, &v );
		edge[i] = { u, v };
		edge[i + m] = { v, u };
	}
	m <<= 1;
	sort( edge + 1, edge + m + 1, []( node x, node y ) { return x.v > y.v; } );
	memset( head, -1, sizeof( head ) );
	for( int i = 1;i <= m;i ++ ) {
		int u = edge[i].u, v = edge[i].v;
		to[cnt] = v, nxt[cnt] = head[u], head[u] = cnt ++;
	}
	if( flag1 ) dfs1( 1 );
	else {
		dfs2( 1, 0 );
		Max = 1e9;
		dfs3( 1 );
	}
	for( auto i : ans ) printf( "%d ", i );
	return 0;
}

CF1454E Number of Simple Paths

CF1454E

非常简单

跑出环和非环树

  • 两个点隶属于同一个环点的非环树（之间不会经过环）
    • 从子树大小中选两个数， s i z ∗ ( s i z − 1 ) / 2 siz*(siz-1)/2 siz∗(siz−1)/2
  • 经过环的两点之间的方案数有两种（走环的不同方向）
    • 从子树中选一个，在子树外选一个， s i z ∗ ( n − s i z ) / 2 ∗ 2 = s i z ∗ ( n − s i z ) siz*(n-siz)/2*2=siz*(n-siz) siz∗(n−siz)/2∗2=siz∗(n−siz)
#include <cstdio>
#include <vector>
using namespace std;
#define int long long
#define maxn 200005
vector < int > G[maxn];
int T, n;
bool flag;
int f[maxn], siz[maxn];
bool circle[maxn];

void dfs1( int u, int fa ) {
	if( flag ) return;
	if( ! f[u] ) f[u] = fa;
	else {
		do {
			circle[fa] = 1;
			fa = f[fa];
		} while( f[u] ^ fa );
		flag = 1;
		return;
	}
	for( auto v : G[u] ) 
		if( v ^ fa ) dfs1( v, u );
}

void dfs2( int u, int fa ) {
	siz[u] = 1;
	for( auto v : G[u] ) {
		if( v == fa or circle[v] ) continue;
		else dfs2( v, u ), siz[u] += siz[v];
	}
}

signed main() {
	scanf( "%lld", &T );
	while( T -- ) {
		scanf( "%lld", &n );
		flag = 0;
		for( int i = 1;i <= n;i ++ ) 
			circle[i] = f[i] = 0, G[i].clear();
		for( int i = 1, u, v;i <= n;i ++ ) {
			scanf( "%lld %lld", &u, &v );
			G[u].push_back( v );
			G[v].push_back( u );
		}
		dfs1( 1, 0 );
		int ans = 0;
		for( int i = 1;i <= n;i ++ )
			if( circle[i] ) {
				dfs2( i, 0 );
				ans += siz[i] * ( siz[i] - 1 ) / 2 + siz[i] * ( n - siz[i] );
			}
		printf( "%lld\n", ans );
	}
	return 0;
}

Traffic Network in Numazu

HDU6393

同样的，断环为链

两点间的距离分为三种

  • 两点在同一棵非环树内，直接求出两个点的lca，再计算
  • 经过环
    • 两点到环的两端，然后加上断的边长
    • 两点到环的相反两端，然后加上断的边长

利用线段树可以维护，但是树状数组更好写

断树后进行dfn序的重置，修改一条边其实是对于一个连续区间的修改

#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
#define int long long
#define maxn 100005
struct node { int u, v, w; }E[maxn];
vector < node > G[maxn];
int Ti, n, Q, cnt, S, T, id, len;
int L[maxn], R[maxn], t[maxn], f[maxn], dep[maxn];
int p[maxn][20];

int lowbit( int i ) { return i & -i; }

void modify( int i, int val ) {
	for( ;i <= n;i += lowbit( i ) ) 	
		t[i] += val;
}

int query( int i ) {
	int ans = 0;
	for( ;i;i -= lowbit( i ) )
		ans += t[i];
	return ans;
}

int find( int x ) { return x == f[x] ? x : f[x] = find( f[x] ); }

void dfs( int u, int fa, int w ) {
	dep[u] = dep[fa] + 1;
	p[u][0] = fa;
	for( int i = 1;i < 20;i ++ )
		p[u][i] = p[p[u][i - 1]][i - 1];
	L[u] = ++ cnt;
	modify( L[u], w );
	for( auto i : G[u] )
		if( i.v ^ fa ) dfs( i.v, u, i.w );
	R[u] = cnt;
	modify( R[u] + 1, -w );
}

int lca( int u, int v ) {
	if( dep[u] < dep[v] ) swap( u, v );
	for( int i = 19;~ i;i -- )
		if( dep[p[u][i]] >= dep[v] )
			u = p[u][i];
	if( u == v ) return u;
	for( int i = 19;~ i;i -- )
		if( p[u][i] ^ p[v][i] )
			u = p[u][i], v = p[v][i];
	return p[u][0];
}

int dis( int x, int y ) {
	return query( L[x] ) + query( L[y] ) - query( L[lca( x, y )] ) * 2;
}

signed main() {
	scanf( "%lld", &Ti );
	while( Ti -- ) {
		scanf( "%lld %lld", &n, &Q );
		cnt = 0;
		for( int i = 1;i <= n;i ++ ) {
			G[i].clear();
			f[i] = i;
			t[i] = 0;
			for( int j = 0;j < 20;j ++ )
				p[i][j] = 0;
		}
		for( int i = 1, u, v, w;i <= n;i ++ ) {
			scanf( "%lld %lld %lld", &u, &v, &w );
			if( find( u ) == find( v ) )
				S = u, T = v, id = i, len = w;
			else {
				G[u].push_back( { u, v, w } );
				G[v].push_back( { v, u, w } );
				E[i] = { u, v, w };
				f[find( v )] = find( u );
			}
		}
		dfs( 1, 0, 0 );	
		for( int i = 1, opt, x, y;i <= Q;i ++ ) {
			scanf( "%lld %lld %lld", &opt, &x, &y );
			if( ! opt ) 
				if( x == id ) len = y;
				else {
					int now = p[E[x].u][0] == E[x].v ? E[x].u : E[x].v;
					modify( L[now], y - E[x].w );
					modify( R[now] + 1, E[x].w - y );
					E[x].w = y;
				}
			else 
				printf( "%lld\n", min( dis( x, y ), min( dis( x, S ) + dis( y, T ), dis( x, T ) + dis( y, S ) ) + len ) );
		}
	}
	return 0;
}

Card Game

HDU6403

一张牌的两面，要求朝上面的数字互不相同

显然是将牌的两面连边，一条边也就代表一张牌，数字互不相同就是选择不同的点

  • 对于“树”的方案
    • 钦定其中某个点不选，则剩下的点都被钦定，方案数为树的大小
  • 对于“环”的方案
    • 只有两种方案（均选左和均选右）

这是很基础的“牌的两面”基环树应用的处理方法

转回此题，题目可以翻译为

将牌的反面向正面连边，求反转最少边数的方案数，使得每个点的入度不超过1

显然当且仅当图为树或基环树的时候才有解

且此题很有可能有重边和自环

同样的将环拆成链后再单独考虑被强断的那条边的贡献

对于树就单纯的树形 D P DP DP做

具体而言

  • 求出每个连通块的点数和边数

  • 若边数不是点数或者点数减一，就无解

  • 若边数等于点数，说明是个基环树

    • 断开一条边后以边的两端开始遍历一遍分别求出最少反转的边数

      （边数跟连边的边权有关，下面有阐释）

    • 如果加上这条边的贡献相同方案数为2，否则为1

  • 若边数等于点数减一，说明是个普通的树

    • 树形 D P DP DP，求出以每个点为根（钦定不选）的最少反转次数

    • 其实最少反转数在换根 D P DP DP父亲向儿子转移的时候才会发生变化，且变化只有 1 1 1

      如何根据边权推测变化+1或者-1

      • 对于一张牌，正面向反面建边权为1，反面向正面建边权为0
      • u u u不选时的答案为 d p u dp_u dpu​，转移到儿子 v v v不选时
      • 如果 u → v u\rightarrow v u→v的边权为1，说明一张牌本来是 u u u在上， d p u dp_u dpu​为了不选 u u u将其反转了
      • 那么变成不选 v v v时，就需要选择 u u u，这张牌就变成了不反转，操作次数就减一
      • 所以 d p v = d p u − 1 dp_v=dp_u-1 dpv​=dpu​−1
      • 反之自然是 d p v = d p u + 1 dp_v=dp_u+1 dpv​=dpu​+1
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define int long long
#define mod 998244353
#define maxn 200005
int Case, n, node, edge, cnt, S, T, id, top;
int head[maxn], to[maxn], nxt[maxn], w[maxn], f[maxn], g[maxn], dp[maxn];
bool vis[maxn];

void dfs1( int now ) {
	vis[now] = 1;
	node ++;
	for( int i = head[now];~ i;i = nxt[i] ) {
		edge ++;
		if( ! vis[to[i]] ) dfs1( to[i] );
	}
}

void dfs2( int now, int ID ) {
	vis[now] = 1;
	f[now] = 0;
	for( int i = head[now];~ i;i = nxt[i] ) {
		if( i == ID ) continue;
		if( ! vis[to[i]] ) {
			dfs2( to[i], i ^ 1 );
			f[now] += f[to[i]] + w[i];
		}
		else S = now, T = to[i], id = i;
	}
}

void dfs3( int now, int ID ) {
	dp[++ top] = g[now];
	for( int i = head[now];~ i;i = nxt[i] )
		if( i == ID or i == ( id ^ 1 ) or i == id ) continue;
		else {
			g[to[i]] = g[now] + ( w[i] ? -1 : 1 );
			dfs3( to[i], i ^ 1 );
		}
}

signed main() {
	scanf( "%lld", &Case );
	nxt :
	while( Case -- ) {
		scanf( "%lld", &n );
		memset( head, -1, sizeof( head ) );
		memset( vis, 0, sizeof( vis ) );
		cnt = 0;
		for( int i = 1, x, y;i <= n;i ++ ) {
			scanf( "%lld %lld", &x, &y );
			w[cnt] = 1, to[cnt] = y, nxt[cnt] = head[x], head[x] = cnt ++;
			w[cnt] = 0, to[cnt] = x, nxt[cnt] = head[y], head[y] = cnt ++;
		}
		for( int i = 1;i <= n;i ++ )
			if( ! vis[i] ) {
				node = edge = 0;
				dfs1( i );
				edge >>= 1;
				if( edge > node ) {
					printf( "-1 -1\n" );
					goto nxt;
				}
			}
		memset( vis, 0, sizeof( vis ) );
		int ret = 0, ans = 1; n <<= 1;
		for( int i = 1;i <= n;i ++ )
			if( ! vis[i] ) {
				S = T = cnt = top = 0, id = -1;
				dfs2( i, -1 );
				g[i] = f[i];
				dfs3( i, -1 );
				if( ! S ) {
					sort( dp + 1, dp + top + 1 );
					for( int j = 1;j <= top;j ++ )
						if( dp[j] == dp[1] ) cnt ++;
						else break;
					ret += dp[1];
				}
				else {
					id &= 1;
					if( g[S] + id == g[T] + ( id ^ 1 ) ) cnt = 2;
					else cnt = 1;
					ret += min( g[S] + id, g[T] + ( id ^ 1 ) );
				}
				ans = ans * cnt % mod;
			}
		printf( "%lld %lld\n", ret, ans );
	}
	return 0;
}
ikrvxt
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python数据结构之图的实现方法
09-21
### Python 数据结构之图的实现方法 在计算机科学领域中，图是一种非常重要的非线性数据结构，广泛应用于网络分析、地图导航系统、社交网络分析等多个方面。本篇文章将详细介绍如何利用 Python 实现图的数据结构，...
数据结构迷宫问题代码.pdf
11-16
在这个数据结构迷宫问题中，我们探讨了一个使用深度优先搜索(DFS)算法解决经典路径寻找问题的方法。迷宫被表示为一个二维数组，其中0表示可通行区域，1表示不可通行的墙壁。目标是从起点(start)找到一条到达终点(end...
洛谷2607 骑士（基环树+树形DP）
Michael_GLF的博客
11-07 273
传送门 【题目分析】 第一眼：咦这不简单树形DP吗？ 第二眼：嗯？这不是有N条边吗？怎么就树形DP了？ 第三眼：唉好像拆一条边不就N-1条边了吗？哎嘿嘿我太聪明了。。。。 噼里啪啦打完一交，WA完。。。。。。。一脸懵？？？才发现可能直接将整个图（以为保证连通）拆成两个联通块了。。。。。 然后画画图，发现肯定是拆环上的边，搞个并查集记录一下好了。 然后对于拆掉的边，直接分别强制两端点不...
acwing-1080. 骑士(基环树dp)
m0_46656833的博客
06-09 166
Z 国的骑士团是一个很有势力的组织，帮会中聚集了来自各地的精英。 他们劫富济贫，惩恶扬善，受到了社会各界的赞扬。 可是，最近发生了一件很可怕的事情：邪恶的 Y 国发起了一场针对 Z 国的侵略战争。 战火绵延五百里，在和平环境中安逸了数百年的 Z 国又怎能抵挡得住 Y 国的军队。 于是人们把所有希望都寄托在了骑士团身上，就像期待有一个真龙天子的降生，带领正义打败邪恶。 骑士团是肯定具备打败邪恶势力的能力的，但是骑士们互相之间往往有一些矛盾。 每个骑士有且仅有一个他自己最厌恶的骑士（当然不是他自己），他是绝对不
「ZJOI 2008」骑士「基环树DP」
_Gion
08-26 383
BZOJ 题目传送门 Luogu 题目传送门 题意 求由基环树组成的森林的最大权独立集，n&amp;amp;lt;=106n&amp;amp;lt;=106nfi,0fi,0f_{i,0}和fi,1fi,1f_{i,1}分别表示在以结点iii为根的子树内，iii选/不选的最大独立集的权值 转移：fi,0=∑j∈son(i)max(fj,0,fj,1)fi,0=∑j∈son(i)max(fj,0,fj,1)f_{i,0}=...
[BZOJ1040][ZJOI2008]骑士-基环树-动态规划
「嫌われ者のフィロソフィ」
10-30 681
骑士Description　　Z国的骑士团是一个很有势力的组织，帮会中汇聚了来自各地的精英。他们劫富济贫，惩恶扬善，受到社会各界的赞扬。最近发生了一件可怕的事情，邪恶的Y国发动了一场针对Z国的侵略战争。战火绵延五百里，在和平环境中安逸了数百年的Z国又怎能抵挡的住Y国的军队。于是人们把所有的希望都寄托在了骑士团的身上，就像期待有一个真龙天子的降生，带领正义打败邪恶。骑士团是肯定具有打败邪恶势力的能力的
[ZJOI2008]骑士 基环树树形DP
xgc_woker的博客
04-19 219
Description 给你n个节点，第i个节点不能与b[i]共存，权值为a[i]，让你求一个集合使这个集合点权最大。Sample Input 3 10 2 20 3 30 1Sample Input 30看到这道题首先会想到没有上司的晚会那题。 然后考虑做树形DP，然后我就不会做了，因为他有环。。。 然后我就上网查到了基环树这个东西，膜了一波。 你想这个图实际上是个无向图，且一个
datastruct1_C语言_SHORTEST-PATHS_shortest path_哈夫曼编码_数据结构算法
09-19
一些数据结构算法的例子，包括哈夫曼编码、图的表示、关键路径、最短路径等
数据结构教学课件：chapter11
05-17
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和操作数据。Chapter11的主题是图（Graphs），这是数据结构中一个重要的部分，广泛应用于计算机网络、地图表示、任务排序、关系建模等多个领域。 图...
java文件操作之Path,Paths,Files
08-30
在Java 7及更高版本中，文件操作有了显著的改进，引入了`Path`, `Paths` 和 `Files` 类，以提供更加灵活和高效的文件系统操作。这些类是Java NIO (New I/O) 包的一部分，位于`java.nio.file`包下。本文将详细介绍这...
Luogu P2607 [ZJOI2008]骑士___基环树+树形dp
生如夏花之绚烂
03-20 290
题目大意： 从N个骑士中选出一个骑士军团，使得军团内没有矛盾的两人（不存在一个骑士与他最痛恨的人一同被选入骑士军团的情况），并且，使得这支骑士军团最具有战斗力。 为了描述战斗力，我们将骑士按照1至N编号，给每名骑士一个战斗力的估计，一个军团的战斗力为所有骑士的战斗力总和。 对于30%的测试数据，满足N ≤ 10； 对于60%的测试数据，满足N ≤ 100； 对于80%的测试数据，满足...
基环树
zxy160的博客
08-09 664
一、基环树 首先什么是树就不解释了，如果这都不知道，应该也接触不到基环树吧 在了解了树的基础上来解释基环树——树加一条边使之成环（也就是说，在严格意义上来说，基环树并不是树，就像老婆饼没有老婆一样，基环树是个图） 二、基环内向树 首先它是一个有向图，它构成类似基环树的结构，有一个特点是每个点都有且只有一个出度，并且环外的节点方向指向环内 三、基环外向树 与基环内向树相反，它有且...
[基环树入门][ZJOI2008]骑士/CF1027F Session in BSU
Wall-E
08-20 310
最近一下子看到好多基环树的题，先做两道入门吧 解释基环树——树加一条边使之成环 这里想说一下基环树和tarjan最基本的区别：基环树入度出度至多为1。 树形DP还有一种特殊情况——基环树的DP，基环树就是一颗树上再加一条边，处理基环树问题时一般先找出环再处理，然后再搞来搞去就行啦 例如[ZJOI2008]骑士 利用基环树只有一条多余边的性质对其进行特判，其余树形dp   ps  f[i...
基环树：
_Griefs
08-24 284
把树再加一条边，形成一个环。 处理基环树的方法，一般就是找出环，并且把环当成广义上的树根，处理树，然后处理环。 一、AcWing 358. 岛屿： 你准备有限一个公园，该公园由 N 个岛屿组成，当地管理部门从每个岛屿出发向另外一个岛屿建了一座桥，不过桥是可以双向行走的。 同时，每对岛屿之间都有一艘专用的往来两岛之间的渡船。 相对于乘船而言，你更喜欢步行。 你希望所经过的桥的总长度尽可能的长，但受到...
洛谷[ZJOI2008]骑士（基环树二次DP法+树形DP）
我们都有光明的未来
11-29 257
原题链接 题意： 每个骑士有一个不可以同时上场的骑士，和一个战斗力。求最大战斗力。 思路： 类似没有上司的舞会。 这个题构成的是基环树森林,取每个基环树的最大值累加就是答案。 把每个基环树环上的一条边断开后，就构成了一棵树，这时候就相当于是没有上司的舞会那道题了。存图的时候默认的关系是两个人不能同时选择，也就需要分别强制选一个不选另一个，来跑两次DP，取max. 存图的时候存有向边，边的指向两种都可以。 注意答案会爆int。 代码： #include<bits/stdc++.h> using n
约会 Rendezvous （基环树（内向） + tarjan缩点 + LCA）
anchengao1503的博客
07-11 221
题干：　　给定一个有 n 个顶点的有向图，每个顶点有且仅有一条出边。每次询问给出两个顶点 ai 和 bi​​，求满足以下条件的 xi​​ 和 yi：　　1、从顶点 ai 沿出边走 xi 步与从顶点 bi 沿出边走 yi 步到达的顶点相同时，max(xi,yi) 最小。　　2、满足以上条件的情况下 min(xi,yi) 最小。　　3、如果以上条件没有给出一个唯一的解，则还需要满足 xi≥y...
bzoj 2791 [Poi2012]Rendezvous 倍增lca 基环树
make_it_for_good的博客
11-14 630
这是一个基环内向树森林。两个点如果在一个子树中，直接倍增lca。 否则两个点先走到环上，然后一个点不动，另一个点走到这个点。#include <bits/stdc++.h> using namespace std; #define N 510000 int n,q,top,cnt; int fa[N][21]; int vis[N],st[N],inc[N],root[N],deep[N]; in
树和基环树上两点间最短距离问题
最新发布
xuxizhe0104的博客
04-21 250
对于基环树讲，我们可以将环上的每个点都当作根节点来对其子树进行一次dfs做预处理（同普通树）并记录所属根节点，在询问时，如果两点属于同一根节点的子树，那么按照普通树的询问来处理，否则我们将环上若干个相邻的点进行编号为1……tot，那么我们就可以得到两个根之间有两个走法，第一个是dis = abs( id[ x ] - id[ y ])，第二个则是tot-dis，最后取两者最小值加上d[ x ] + d[ y ]就是最短距离了。共 q 行，每行表示一个询问的答案，即点 u 到点 v 的最短距离。
基环树总结
ZhuRanCheng的博客
07-15 1211
基环树总结
java代码写：查找红黑树是否All simple paths from any node x to a descendant leaf have the same number of black nodes
04-20
红黑树是一种自平衡的二叉搜索树，以及由此衍生出来的查找树等。它要求对于任何一个节点到其任何后代叶子节点的所有简单路径上，黑节点的数量是相同的。 在Java代码中，可以通过递归的方式来判断红黑树中所有简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值