业余ACMer笔记·虚树

最新推荐文章于 2020-06-27 15:49:25 发布

灵隐寺未来职工

最新推荐文章于 2020-06-27 15:49:25 发布

阅读量206

点赞数

本文链接：https://blog.csdn.net/weixin_43918350/article/details/105866674

版权

概念

参考博客
就是保留选定结点和它们的LCA。具体实现就是先预处理一遍LCA，然后把重要结点按dfs序insert来建立虚树，然后在虚树上跑树上DP（突然想起今天算法课的半期考，第四题树上DP没来及写，暴风哭泣）
关键代码是insert函数的书写，可借鉴参考博客
在这里插入图片描述虚树的优点在于可以忽略不重要点带来的影响，其时间复杂度在于求LCA(O(nlogn))
代码来源上文参考博客

void insert(int u){
    if(top == 1) {stk[++top] = u;return;}//栈里只有根节点
    int lca = LCA(u,stk[top]);
    if(lca == stk[top]) {stk[++top] = u;return ;}//lca为栈顶元素
    while(top > 1 && dfn[lca] <= dfn[stk[top-1]])//相当于从当前的栈顶元素向上跳
    {
        VG[stk[top-1]].push_back(stk[top]);
        --top;
    }
    if(lca != stk[top])//如果发现lca不是重要点 
    {
        VG[lca].push_back(stk[top]);//注意是虚树边的存储结构
        stk[top] = lca;
    } 
    stk[++top] = u;
}

CF613D Kingdom and its Cities

原题地址
在这里插入图片描述

代码：
代码来源

#include <map>
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define reg register int
#define isdigit(x) ('0' <= (x)&&(x) <= '9')
template<typename T>
inline T Read(T Type)
{
    T x = 0,f = 1;
    char a = getchar();
    while(!isdigit(a)) {if(a == '-') f = -1;a = getchar();}
    while(isdigit(a)) {x = (x << 1) + (x << 3) + (a ^ '0');a = getchar();}
    return x * f;
}
const int MAXN = 100010;
vector<int> G[MAXN];
int dp[MAXN],size[MAXN];
int dfn[MAXN],dep[MAXN],fa[MAXN][20],poi[MAXN],st[MAXN],top,cnt;
bool vis[MAXN];
inline void add(int u,int v) {G[u].push_back(v);G[v].push_back(u);}
inline void dfs(int x,int f)
{
    dfn[x] = ++cnt;
    for(reg i = 0;i < G[x].size();i++)
    {
        int v = G[x][i];
        if(v == f) continue;
        dep[v] = dep[x] + 1,fa[v][0] = x;
        dfs(v,x);
    }
}
inline void adjust(int &u,int val)
{
    for(reg i = 18;i >= 0;i--)
        if(dep[fa[u][i]] >= val)
            u = fa[u][i];
}
inline int lca(int u,int v)
{
    if(dep[u] > dep[v]) adjust(u,dep[v]);
    if(dep[v] > dep[u]) adjust(v,dep[u]);
    if(u == v) return v;
    for(reg i = 18;i >= 0;i--)
        if(fa[u][i] != fa[v][i])
            u = fa[u][i],v = fa[v][i];
    return fa[u][0];
}
bool cmp(int a,int b) {return dfn[a] < dfn[b];}
inline void BuildTree(int m)
{
    top = 1,st[1] = 1,G[1].clear();
    for(reg i = 1;i <= m;i++)
    {
        if(poi[i] == 1) continue;
        int lc = lca(poi[i],st[top]);
        if(lc != st[top])
        {
            while(dfn[st[top - 1]] > dfn[lc]) add(st[top - 1],st[top]),top--;
            if(lc != st[top - 1]) G[lc].clear(),add(lc,st[top]),st[top] = lc;
            else add(lc,st[top--]);
        }
        G[poi[i]].clear(),st[++top] = poi[i];
    }
    for(reg i = 1;i < top;i++) add(st[i],st[i + 1]);
}
inline void dfs2(int x,int f)//由于不讨论两点直接相连的情况，所以不存在lca就是sta[top]的情况
{
    dp[x] = size[x] = 0;
    for(reg i = 0;i < G[x].size();i++)
    {
        int v = G[x][i];
        if(v == f) continue;
        dfs2(v,x);
        dp[x] += dp[v],size[x] += size[v]; 
    }
    if(vis[x]) dp[x] += size[x],size[x] = 1;
    else if(size[x] > 1) dp[x]++,size[x] = 0;
}
int main()
{
    int n = Read(1);
    for(reg i = 1;i < n;i++)
    {
        int u = Read(1),v = Read(1);
        add(u,v);
    }
    dep[1] = 1,dfs(1,0);
    for(reg i = 1;i <= 18;i++)
        for(reg j = 1;j <= n;j++)
            fa[j][i] = fa[fa[j][i - 1]][i - 1];
    int T = Read(1);
    while(T--)
    {
        memset(vis,0,sizeof(vis));
        int m = Read(1);
        for(reg i = 1;i <= m;i++)
        {
            poi[i] = Read(1);
            vis[poi[i]] = 1;
        }
        bool able = 0;
        for(reg i = 1;i <= m;i++)//直接相连就返回-1
            if(vis[fa[poi[i]][0]]&&poi[i] != 1)
            {
                printf("-1\n");
                able = 1;
                break;
            }
        if(able) continue;
        sort(poi + 1,poi + 1 + m,cmp);
        BuildTree(m);
        dfs2(1,0);
        printf("%d\n",dp[1]); 
    }
    return 0;
}

个人感觉，虚树在这里的意义在于剪枝了很多情况，比如
在这里插入图片描述
要考虑的情况减少了。

血压游戏

原题地址
在这里插入图片描述

代码：
考虑树的分层，因为只有深度相同的松鼠才会打起来，而对每一个深度都新建一颗虚树来简化运算。
代码来源

#include<bits/stdc++.h>
#define int long long
#define MAXN 200010
using namespace std;
int n,s,A[MAXN],head[MAXN],tot,deep[MAXN],pre[MAXN][20],lg[MAXN],dfsn[MAXN],NODE,stk[MAXN],top,dp[MAXN],ans;
vector<int> P[MAXN];
vector<int> E[MAXN];
struct node{
    int ed,last;
}G[MAXN<<2];
bool cmp(int X,int Y){
    return dfsn[X]<dfsn[Y];
}
void Add(int st,int ed){
    tot++;
    G[tot]=node{ed,head[st]};
    head[st]=tot;
}
int LCA(int x,int y){//求LCA
    if(deep[x]<deep[y])swap(x,y);
    while(deep[x]>deep[y])x=pre[x][lg[deep[x]-deep[y]]-1];
    if(x==y)return x;
    for(int i=lg[deep[x]]-1;i>=0;i--){
        if(pre[x][i]==pre[y][i])continue;
        x=pre[x][i],y=pre[y][i];
    }
    return pre[x][0];
}
void Insert(int x)//注意这里插入的结点深度都相同
{//虚树中插入节点
    if(top==1)
    {
        if(x!=stk[top])stk[++top]=x;
        return;
    }
    int lca=LCA(stk[top],x);
    while(top>=2&&dfsn[lca]<=dfsn[stk[top-1]])
    {
        E[stk[top-1]].push_back(stk[top]);
        top--;
    }
    if(lca!=stk[top])E[lca].push_back(stk[top]),stk[top]=lca;
    stk[++top]=x;
}
void DFS(int x,int fa){
    dfsn[x]=++NODE;
    deep[x]=deep[fa]+1;
    pre[x][0]=fa;
    for(int i=1;(1<<i)<=deep[x];i++)pre[x][i]=pre[pre[x][i-1]][i-1];
    for(int i=head[x];i;i=G[i].last){
        int t=G[i].ed;
        if(t==fa)continue;
        DFS(t,x);
    }
}
void solve(int x){//在虚树中dp一波
    const int sz=E[x].size();
    dp[x]=0;
    stk[++top]=x;
    if(sz==0){
        dp[x]=A[x];
        return;
    }
    for(int i=0;i<sz;i++){
        int t=E[x][i];
        solve(t);
        if(dp[t]!=0)dp[x]+=max(1LL,dp[t]-(deep[t]-deep[x]));
    }
}
signed main(){
    for(int i=1;i<=MAXN-10;i++)lg[i]=lg[i-1]+(1<<(lg[i-1])==i);
    scanf("%lld %lld",&n,&s);
    for(int i=1;i<=n;i++)scanf("%lld",&A[i]);
    for(int x,y,i=1;i<=n-1;i++){
        scanf("%lld %lld",&x,&y);
        Add(x,y);
        Add(y,x);
    }
    DFS(s,0);
    for(int i=1;i<=n;i++)P[deep[i]].push_back(i);
    for(int i=1;i<=n;i++){
        sort(P[i].begin(),P[i].end(),cmp);
        if(P[i].size()==0)continue;
        top=0;
        stk[++top]=s;
        const int sz=P[i].size();
        for(int j=0;j<sz;j++){
            int t=P[i][j];
            Insert(t);
        }
        while(top>=2)E[stk[top-1]].push_back(stk[top]),top--;
        top=0;
        solve(s);
        if(dp[s])ans+=max(1LL,dp[s]-1);
        for(int i=1;i<=top;i++)E[stk[i]].clear(),dp[stk[i]]=0;//注意不要用memset，要回滚清空
    }
    cout<<ans;
    return 0;
}

当天由于要准备半期考的原因，没有参赛，但当天晚上补了补题，结果头铁，试图使用Dsu on tree来做。理论上感觉貌似可行，维护一个数组记录以某个结点为根节点的子树，a[i]为深度为i的点到达该点还剩的松鼠数。然鹅现在看一周前的代码感觉莫名其妙，好像自己的a[i]在维护从深度为i的点到该子树根节点的损失的松鼠数，布吉岛当时在想啥，估计复习数据库复习得有点蒙。不过现在知道了更简明的做法，也懒得重新敲Dsu on tree了，胡B贴一发WA的代码吧。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#include<set>
using namespace std;
#define maxn 200010
typedef long long ll;
int n, rt;
ll dup[maxn], fa[maxn], son[maxn], msize[maxn], ans[maxn], sum = 0, a[maxn], svm[maxn];
vector<int>g[maxn];
int vis[maxn], tvp = 1, dep[maxn], mdp[maxn], Son;
ll dfs1(ll x, ll f)//树链剖分找重儿子
{
	msize[x] = 1; vis[x] = 1; dep[x] = dep[f] + 1; mdp[x] = dep[x];
	svm[x] = a[x];
	for (register ll i = 0; i < g[x].size(); i++)
	{
		ll to = g[x][i];
		if (to == f) continue;
		svm[x] += dfs1(to, x);
		msize[x] += msize[to];
		if (msize[to] > msize[son[x]]) son[x] = to;
		mdp[x] = max(mdp[x], dep[to]);
	}
	return svm[x];
}
void add(int x, int f)
{
	int i, to;
	for (i = 0; i < g[x].size(); i++)
	{
		to = g[x][i];
		if (to == f || to == Son) continue;//注意不能直接写成to==son[x]
		add(to, x);
	}
	dup[dep[x]] = dup[dep[x]] + a[x] - ans[x];
}
void dfs2(ll x, ll f, bool keep)//统计
{
	ll i, to;
	for (i = 0; i < g[x].size(); i++)
	{
		to = g[x][i];
		if (to == f) continue;
		if (to != son[x]) dfs2(to, x, false);
	}
	if (son[x])
	{
		dfs2(son[x], x, true);
	}
	Son = son[x];
	add(x, f); Son = 0;//思考Son
	for (i = dep[x]; i <= mdp[x]; i++)
	{
		if (dup[i] > 1)
		{
			sum++;
			dup[i]--;
		}
	}
	ans[x] = sum;
	sum = 0;
	if (!keep)
	{
		//sum = 0;
		for (i = dep[x]; i <= mdp[x]; i++)
		{
			dup[i] = 0;
		}
	}
}

int main()
{
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	int i, j, ta, tb;
	ll cs = 0;
	cin >> n >> rt;
	for (i = 1; i <= n; i++) cin >> a[i];
	for (i = 1; i < n; i++)
	{
		cin >> ta >> tb;
		g[ta].push_back(tb); g[tb].push_back(ta);
	}
	dep[rt] = 1;
	svm[rt] = dfs1(rt, 0);
	dfs2(rt, 0, true);
	for (i = 1; i <= n; i++) cs = cs + a[i] - ans[i];
	cout << cs << endl;
	return 0;
}

灵隐寺未来职工

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
业余ACMer笔记·虚树

概念参考博客就是保留选定结点和它们的LCA。具体实现就是先预处理一遍LCA，然后把重要结点按dfs序insert来建立虚树，然后在虚树上跑树上DP（突然想起今天算法课的半期考，第四题树上DP没来及写，暴风哭泣）关键代码是insert函数的书写，可借鉴参考博客虚树的优点在于可以忽略不重要点带来的影响，其时间复杂度在于求LCA(O(nlogn))代码来源上文参考博客void insert(...
复制链接

扫一扫