[HDU 5296] Annoying problem （DFS序性质+LCA）

最新推荐文章于 2019-10-04 03:06:48 发布
最新推荐文章于 2019-10-04 03:06:48 发布
阅读量743 收藏
点赞数
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012015746/article/details/51952784
版权

HDU - 5296

一棵树上有若干个点，每条边有一个边权
给一个初始为空的集合，每次向集合内添加一个点或者删除一个点
问每次操作结束后，将集合内所有点连起来的边权和为多少

假设集合内已经有一些点，那么再加一个点所增加的边权
将会是这个点到某一条链的距离

但是这条链不能随便挑选，否则可能会经过已经选择的边
挑选策略就是，找到集合内 dfs 序比当前点大和小的两个点组成的链
换句话来说，就是集合内 dfs 序最靠近当前点的两个点

设当前点 x ，这样选链，选出的链是 (u,v)，并且设 dfsn[u]<dfsn[v]
如果会经过已经选择的边，已经选择的点 y
那么，如果原树dfs是从 x ->y的，那么 x 就比 y的 dfs 序小
而 y 比 u、 v 的dfs序都小，所以原树的 dfs 是从 y ->x的
而这样一来， y 的dfs序就比 u 更靠近 x，同样不可能
所以，这样选链， x 到链的路径上不会经过重复的边

删除的时候基本相同

设len(u,v)为链(u,v)的长度
树上一点 x到链 (u,v)的距离为
len(u,x)+len(v,x)−len(u,v)2

#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <map>
#include <set>
#include <queue>
using namespace std;
typedef pair<int,int> Pii;
typedef long long LL;
typedef unsigned long long ULL;
typedef double DBL;
typedef long double LDBL;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))

const int maxn=1e5+10, maxq=maxn;
struct Graph
{
    int ndn, edn, last[maxn];
    int u[2*maxn], v[2*maxn], w[2*maxn], nxt[2*maxn];
    void init(int tn){ ndn=tn; edn=0; MST(last,-1);}
    void adde(int tu, int tv, int tw)
    {
        u[edn]=tu; v[edn]=tv; w[edn]=tw;
        nxt[edn]=last[tu];
        last[tu]=edn++;
    }
};

struct LCA
{
    Graph *G;
    int st[20][2*maxn]; // dfsn
    int dfst, stp, firp[maxn], dfsn[2][maxn], dist[maxn];
    void init(Graph*);
    int dfs(int);
    int get(int,int);
};

int N,Q;
Graph G;
LCA lca;
set<int> have;
bool intree[maxn];

int query(int);

int main()
{
    #ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
    #endif

    int T;
    scanf("%d", &T);
    for(int ck=1; ck<=T; ck++)
    {
        scanf("%d%d", &N, &Q);
        G.init(N);
        for(int i=1; i<N; i++)
        {
            int u,v,w;
            scanf("%d%d%d", &u, &v, &w);
            G.adde(u,v,w); G.adde(v,u,w);
        }
        lca.init(&G);
        have.clear();

        CLR(intree);
        int ans=0;
        printf("Case #%d:\n", ck);
        for(int i=0; i<Q; i++)
        {
            int opt, x;
            scanf("%d%d", &opt, &x);
            if(opt==1)
            {
                if(!intree[x])
                {
                    ans += query(x);
                    have.insert(lca.dfsn[0][x]);
                    intree[x]=1;                
                }
            }
            else
            {
                if(intree[x])
                {
                    have.erase(lca.dfsn[0][x]);
                    ans -= query(x);
                    intree[x]=0;                
                }
            }
            printf("%d\n", ans);
        }
    }
    return 0;
}

int query(int x)
{
    int u,v,res;
    set<int>::iterator it;
    int *dist=lca.dist;
    if(!have.size()) res=0;
    else
    {
        it=have.lower_bound(lca.dfsn[0][x]);
        if(it==have.begin() || it==have.end())
        {
            u = lca.dfsn[1][*have.begin()];
            v = lca.dfsn[1][*have.rbegin()];
        }
        else
        {
            u = lca.dfsn[1][*it];
            it--;
            v = lca.dfsn[1][*it];
        }
        res = dist[x] + dist[lca.get(u,v)] - dist[lca.get(x,u)] - dist[lca.get(x,v)];
    }
    return res;
}

void LCA::init(Graph *g)
{
    G=g;
    dfst = stp = 0;
    CLR(firp); CLR(dfsn); CLR(dist);
    dfs(1);

    int Lim=log2(stp);
    for(int j=1; j<=Lim; j++)
    {
        int len=1<<j-1, nlim=stp-(1<<j)+1;
        for(int i=1; i<=nlim; i++)
            st[j][i] = min(st[j-1][i], st[j-1][i+len]);
    }
}

int LCA::dfs(int u)
{
    dfsn[0][u] = ++dfst;
    st[0][++stp] = dfst;
    firp[u] = stp;
    dfsn[1][dfst] = u;

    for(int e=G->last[u]; ~e; e=G->nxt[e])
    {
        int v=G->v[e];
        if(dfsn[0][v]) continue;
        dist[v] = dist[u] + G->w[e];
        dfs(v);
        st[0][++stp] = dfsn[0][u];
    }
    return 0;
}

int LCA::get(int x, int y)
{
    int l=firp[x], r=firp[y];
    if( r<l ) swap(l,r);
    int flr = log2( r-l+1 );
    int nlen = 1<<flr;
    return dfsn[1][ min(st[flr][l], st[flr][r-nlen+1]) ];
}/*
HDU - 5296
一棵树上有若干个点，每条边有一个边权
给一个初始为空的集合，每次向集合内添加一个点或者删除一个点
问每次操作结束后，将集合内所有点连起来的边权和为多少

假设集合内已经有一些点，那么再加一个点所增加的边权
将会是这个点到某一条链的距离

但是这条链不能随便挑选，否则可能会经过已经选择的边
挑选策略就是，找到集合内dfs序比当前点大和小的两个点组成的链
换句话来说，就是集合内dfs序最靠近当前点的两个点

设当前点 x，这样选链，选出的链是 (u,v)，并且设dfsn[u] < dfsn[v]
如果会经过已经选择的边，已经选择的点 y
那么，如果原树dfs是从 x->y的，那么 x就比 y的dfs序小
而 y比 u、v的dfs序都小，所以原树的dfs是从 y->x的
而这样一来，y的dfs序就比 u更靠近 x，同样不可能
所以，这样选链，x到链的路径上不会经过重复的边

删除的时候基本相同

设len(u,v)为链(u,v)的长度
树上一点 x到链 (u,v)的距离为
( len(u,x) + len(v,x) - len(u,v))/2
*/
#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <map>
#include <set>
#include <queue>
using namespace std;
typedef pair<int,int> Pii;
typedef long long LL;
typedef unsigned long long ULL;
typedef double DBL;
typedef long double LDBL;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))

const int maxn=1e5+10, maxq=maxn;
struct Graph
{
    int ndn, edn, last[maxn];
    int u[2*maxn], v[2*maxn], w[2*maxn], nxt[2*maxn];
    void init(int tn){ ndn=tn; edn=0; MST(last,-1);}
    void adde(int tu, int tv, int tw)
    {
        u[edn]=tu; v[edn]=tv; w[edn]=tw;
        nxt[edn]=last[tu];
        last[tu]=edn++;
    }
};

struct LCA
{
    Graph *G;
    int st[20][2*maxn]; // dfsn
    int dfst, stp, firp[maxn], dfsn[2][maxn], dist[maxn];
    void init(Graph*);
    int dfs(int);
    int get(int,int);
};

int N,Q;
Graph G;
LCA lca;
set<int> have;
bool intree[maxn];

int query(int);

int main()
{
    #ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
    #endif

    int T;
    scanf("%d", &T);
    for(int ck=1; ck<=T; ck++)
    {
        scanf("%d%d", &N, &Q);
        G.init(N);
        for(int i=1; i<N; i++)
        {
            int u,v,w;
            scanf("%d%d%d", &u, &v, &w);
            G.adde(u,v,w); G.adde(v,u,w);
        }
        lca.init(&G);
        have.clear();

        CLR(intree);
        int ans=0;
        printf("Case #%d:\n", ck);
        for(int i=0; i<Q; i++)
        {
            int opt, x;
            scanf("%d%d", &opt, &x);
            if(opt==1)
            {
                if(!intree[x])
                {
                    ans += query(x);
                    have.insert(lca.dfsn[0][x]);
                    intree[x]=1;                
                }
            }
            else
            {
                if(intree[x])
                {
                    have.erase(lca.dfsn[0][x]);
                    ans -= query(x);
                    intree[x]=0;                
                }
            }
            printf("%d\n", ans);
        }
    }
    return 0;
}

int query(int x)
{
    int u,v,res;
    set<int>::iterator it;
    int *dist=lca.dist;
    if(!have.size()) res=0;
    else
    {
        it=have.lower_bound(lca.dfsn[0][x]);
        if(it==have.begin() || it==have.end())
        {
            u = lca.dfsn[1][*have.begin()];
            v = lca.dfsn[1][*have.rbegin()];
        }
        else
        {
            u = lca.dfsn[1][*it];
            it--;
            v = lca.dfsn[1][*it];
        }
        res = dist[x] + dist[lca.get(u,v)] - dist[lca.get(x,u)] - dist[lca.get(x,v)];
    }
    return res;
}

void LCA::init(Graph *g)
{
    G=g;
    dfst = stp = 0;
    CLR(firp); CLR(dfsn); CLR(dist);
    dfs(1);

    int Lim=log2(stp);
    for(int j=1; j<=Lim; j++)
    {
        int len=1<<j-1, nlim=stp-(1<<j)+1;
        for(int i=1; i<=nlim; i++)
            st[j][i] = min(st[j-1][i], st[j-1][i+len]);
    }
}

int LCA::dfs(int u)
{
    dfsn[0][u] = ++dfst;
    st[0][++stp] = dfst;
    firp[u] = stp;
    dfsn[1][dfst] = u;

    for(int e=G->last[u]; ~e; e=G->nxt[e])
    {
        int v=G->v[e];
        if(dfsn[0][v]) continue;
        dist[v] = dist[u] + G->w[e];
        dfs(v);
        st[0][++stp] = dfsn[0][u];
    }
    return 0;
}

int LCA::get(int x, int y)
{
    int l=firp[x], r=firp[y];
    if( r<l ) swap(l,r);
    int flr = log2( r-l+1 );
    int nlen = 1<<flr;
    return dfsn[1][ min(st[flr][l], st[flr][r-nlen+1]) ];
}
mis_deer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU刷题地图+精选详细笔记
10-26
本人准备2020年保研机试时刷的题目（虽然最后机试取消了，...来自某中流985，在HDU和vjudge平台上大概刷了400道。本文件地图（excel表格）包含了绝大部分我刷过的题目，笔记中具有思路、代码、总结和心得。 大佬勿入！
【HDU】5296 Annoying problem【树链剖分+分类讨论】
poursoul
07-27 921
传送门：【HDU】5296 Annoying problem这题我是分类讨论做的，没想到多校题解的方法my  code:my~~code:#include <stdio.h> #include <string.h> #include <algorithm> using namespace std ;typedef long long LL ;#define clr(a,x) memset ( a ,
【LCA】HDU 5296 Annoying problem
10-04 105
通道：http://acm.hdu.edu.cn/showproblem.php?pid=5296 题意：给一棵n个节点的树，再给q个操作，初始集合S为空，每个操作要在一个集合S中删除或增加某些点，输出每次操作后：要使得集合中任意两点互可达所耗最小需要多少权值。（记住只能利用原来给的树边。给的树边已经有向。10万个点，10万个操作） 思路： 代码： 1...
hdu5296(2015多校1)--Annoying problem(lca+一个公式)
随风的专栏
07-22 1396
Annoying problem Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 483    Accepted Submission(s): 148 Problem Description Coco has a
hdu5296（倍增lca）
08-27 84
对于这道题，虽然题中有个求最小值，但它不是需要进行选择边的那种题，如果给定确定的点，把这些点连到一起，使得任意两点可达，那么只有一种方法（当然，去除掉多余的边，即叶子节点和根节点都必须在集合中）。所以可以每次加边时，只要找到一种方法，把它加入到已有树中就可以了，并且只有一种方法（当然，还是要去掉多余的边）。 至于根据dfs序找，假设要加入x这个点： 1)集合中有dfs序大于x...
HDU 5296 Annoying problem
Mr.Phoebe的专栏
07-22 983
这是用倍增法按照题解公式写的代码，除了题解的那种操作细节以及公式以外其他都是最简单的那种LCA…// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algorithm> #include <iostream> #include <iomanip> #include <cstrin
HDU 1022 Train Problem I 附详细思路
07-31
HDU 1022 Train Problem I 附详细思路
【HDU 3993】田忌赛马 题解+勘误
12-14
【HDU 3993】田忌赛马 题解+勘误 题解这里就略写一下了，主要是勘误。 这道题是2011年之前的多校训练题，2020年的今天，我们一个集训队全部挂在上面了。最后在HDU看到了9年前的讨论区，才知道这题有如下问题： speed...
HDU+2000-2099+解题报告
08-31
ACM题库，一些题目和答案，以及解题报告，传上来共享
hdu 1695 GCD（欧拉函数+容斥原理）.docx
10-29
hdu 1695 GCD（欧拉函数+容斥原理）.docx
hdu 5296 lca+dfs应用，lca倍增法模板
、Poppy
07-25 468
题目大意：给出一棵树，每个边都有一个权值，现在有一个空的集合，两种操作，1 x吧x节点放到集合中(如果还没放入)，2 x把x节点从集合中拿出来(已放入)。每次操作后输出最小的边权和，保证这些边可以将这些点连起来。 首先明确一点的是，两个点x，y最短的路径肯定是经过两点的lca的，而新添一个点u之后，也就是这个点要连到这条链上去的话，是有下面的公式的： 首先是u到x的距离，dis[u]+dis[
HDU5296从一棵树上取出若干不连通的点
ONE_PIECE的专栏
07-25 432
#include #include #include #include #include #include #include #include #include #include #include #define cl(a,b) memset(a,b,sizeof(a)) #define max(x,y) ((x)>(y)?(x):(y)) #define min(x,y) ((x)<(y)?(x
HDU 5296
Napoleon2004的博客
07-08 215
#include&lt;bits/stdc++.h&gt; using namespace std; const int M=100010; map&lt;int,int&gt;mp; map&lt;int,int&gt;::iterator t; struct node{ int d,l,to; }edge[2*M]; int len,index,a[M],b[M],dfn[M],dis...
hdu5296
acmer的随记
07-21 313
题意：给定一颗边权树，动态地在点集中增加和删除点。求当前所在点集中使得所有点都连通的最小边权和。 解法： 首先介绍一个结论： 树上点u到以x和y为端点的链的最段距离可以在O(n)预处理和O(logn)时间复杂度内求出。
HDU 5296 Annoying problem（LCA模板+树的dfs序心得）
Must so
07-25 1661
Problem Description Coco has a tree, whose nodes are conveniently labeled by 1,2,…,n, which has n-1 edge，each edge has a weight. An existing set S is initially empty. Now there are two kinds of op
hdu 5296 Annoying problem(LCA)
不慌不忙、不急不躁
07-31 741
题目链接：hdu 5296 Annoying problem 先求出dfs序，然后每次修改一个节点u，找到dfs最接近u的两个点，a，b的dfs序分别大于和小于u的。修改值即为dp[u] - dp[lca(a,u)] - dp[lca(b,u)] + dp[lca(a, b)]，dp[i]表示i到根节点的权值和。但集合中的节点的dfs序都大于或小于u时，a，b即用最大和最小的即可。
hdu5296 01字典树
weixin_30652897的博客
01-20 54
根据二进制建一棵01字典树，每个节点的答案等于左节点0的个数 * 右节点1的个数 * 2，遍历整棵树就能得到答案。 AC代码： #include<cstdio> using namespace std; const int mod=998244353; const int maxn=2; struct node{ node *next[maxn]; //0 1节点...
HDU2222+WA
最新发布
03-08
HDU2222+WA 是指杭电OJ（杭州电子科技大学在线评测系统）上的一道题目，题目编号为2222，题目名称为"WA"。这道题目是一个字符串匹配的问题，要求判断一个字符串中是否包含另一个字符串中的所有字符（不考虑顺序）。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值