newcoder 79F 小H和圣诞树 换根 DP + 根号分治

Code:

#include <cstdio>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#define N 100003
#define ll long long
#define setIO(s) freopen(s".in", "r" , stdin)  , freopen(s".out", "w" , stdout)
using namespace std;
namespace IO
{
    char *p1,*p2,buf[100000];
    #define nc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
    int readint() {int x=0; char c=nc(); while(c<48) c=nc(); while(c>47) x=(((x<<2)+x)<<1)+(c^48),c=nc(); return x;}
    ll readll() {ll x=0; char c=nc(); while(c<48) c=nc(); while(c>47) x=(((x<<2)+x)<<1)+(c^48),c=nc(); return x;}
};
vector <int> G[N], ty[N], node;
int n , edges, tim, toop;
ll dis[N], depth[N];
int col[N], tax[N], id[N], A[N], size[N], S[N];
int hd[N], nex[N << 1], to[N << 1], top[N], dfn[N], fa[N], dep[N], son[N], siz[N];
ll val[N << 1];
bool cmp(int a, int b)
{
    return dfn[a] < dfn[b];
}
inline void addedge(int u, int v, int c)
{
    nex[++ edges] = hd[u], hd[u] = edges, to[edges] = v, val[edges] = 1ll * c;
}
void dfs1(int u, int ff)
{
    int i, v;
    fa[u] = ff, dep[u] = dep[ff] + 1, dfn[u] = ++ tim, siz[u] = 1;
    for(i = hd[u] ; i ; i = nex[i])
    {
        v = to[i];
        if(v == ff) continue;
        depth[v] = depth[u] + 1ll * val[i], dfs1(v, u), siz[u] += siz[v];
        if(siz[v] > siz[son[u]]) son[u] = v;
    }
}
void dfs2(int u, int tp)
{
    top[u] = tp;
    if(son[u]) dfs2(son[u], tp);
    for(int i = hd[u] ; i ; i = nex[i])
    {
        int v = to[i];
        if(v == fa[u] || v == son[u]) continue;
        dfs2(v, v);
    }
}
inline int LCA(int x, int y)
{
    while(top[x] ^ top[y])
    {
        dep[top[x]] > dep[top[y]] ? x = fa[top[x]] : y = fa[top[y]];
    }
    return dep[x] < dep[y] ? x : y;
}
inline ll Dis(int x, int y)
{
    return depth[x] + depth[y] - (depth[LCA(x, y)] << 1);
}
void solve1(int u, int ff, int cur)
{
    size[u] = (col[u] == cur), dis[u] = 0;
    for(int i = hd[u] ; i ; i = nex[i])
    {
        int v = to[i];
        if(v == ff) continue;
        solve1(v, u, cur),size[u] += size[v], dis[u] += (dis[v] + 1ll * size[v] * val[i]);
    }
}
void solve(int u, int ff, int cur)
{
    for(int i = hd[u] ; i ; i = nex[i])
    {
        int v = to[i];
        if(v == ff) continue;
        dis[v] += (dis[u] - dis[v] - 1ll * size[v] * val[i] + 1ll * (tax[cur] - size[v]) * val[i]);
        solve(v, u, cur);
    }
}
inline void addvir(int u, int v)
{
    G[u].push_back(v);
}
inline void insert(int x)
{
    if(toop < 2)
    {
        S[++ toop] = x;
        return ;
    }
    int lca = LCA(x, S[toop]);
    if(lca != S[toop])
    {
        while(toop > 1 && dep[S[toop - 1]] >= dep[lca]) addvir(S[toop - 1], S[toop]),-- toop;
        if(S[toop] != lca) addvir(lca, S[toop]), S[toop] = lca;
    }
    S[++ toop] = x;
}
void pre(int u, int ff, int cur)
{
    size[u] = (col[u] == cur), dis[u] = 0;
    for(int i = 0; i < G[u].size(); ++ i)
    {
        int v = G[u][i];
        pre(v, u, cur), size[u] += size[v], dis[u] += dis[v] + 1ll * size[v] * Dis(v, u);
    }
}
void work(int u, int ff, int cur)
{
    for(int i = 0; i < G[u].size() ; ++ i)
    {
        int v = G[u][i];
        dis[v] += (dis[u] - dis[v] - 1ll * size[v] * Dis(u, v) + 1ll * (tax[cur] - size[v]) * Dis(u, v));
        work(v, u, cur);
    }
}
void clear(int u)
{
    size[u] = dis[u] = 0;
    for(int i = 0; i < G[u].size(); ++ i) clear(G[u][i]) ;
    G[u].clear();
}
struct Node
{
    int a, b;
}ask[N];
vector < int > P[N];
vector < ll > answer[N];
int point[N];
int main()
{
    using namespace IO;
    // setIO("input");
    int i , j, idx = 0, m, Q;
    n = readint();
    m = sqrt(n);
    for(i = 1; i <= n ; ++ i) col[i] = readint(), ++tax[col[i]], ty[col[i]].push_back(i);
    for(i = 1; i < n ; ++ i)
    {
        int a = readint(), b = readint(), c = readint();
        addedge(a, b, c), addedge(b, a, c);
    }
    dfs1(1, 0), dfs2(1, 1);
    for(i = 1; i <= n ; ++ i)   if(tax[i] >= m) id[i] = ++idx;
    Q = readint();
    for(i = 1; i <= Q; ++ i)
    {
        ask[i].a = readint(), ask[i].b = readint();
        if(tax[ask[i].a] < tax[ask[i].b]) swap(ask[i].a, ask[i].b);
        if(tax[ask[i].a] >= m) P[ask[i].a].push_back(ask[i].b);
    }
    for(i = 1; i <= n ; ++ i)
    {
        if(tax[i] >= m)
        {
            solve1(1, 0, i), solve(1, 0, i);
            for(j = 0 ; j < P[i].size() ; ++ j)
            {
                int cur = P[i][j];
                ll re = 0;
                for(int k = 0; k < ty[cur].size(); ++ k)
                {
                    re += dis[ty[cur][k]];
                }
                answer[i].push_back(re);
            }
        }
    }
    for(int cas = 1; cas <= Q; ++ cas)
    {
        int a, b;
        a = ask[cas].a, b = ask[cas].b;
        if(tax[a] >= m) printf("%lld\n", a == b ? answer[a][point[a] ++ ] / 2 : answer[a][point[a] ++ ]);
        else
        {
            int tmp = 0;
            ll re = 0;
            for(i = 0; i < ty[a].size(); ++ i) A[++ tmp] = ty[a][i];
            for(i = 0; i < ty[b].size(); ++ i) A[++ tmp] = ty[b][i];
            sort(A + 1, A + 1 + tmp, cmp);
            tmp = unique(A + 1, A + 1 + tmp) - (A + 1);
            toop = 0;
            if(A[1] != 1) S[++ toop] = 1;
            for(i = 1 ; i <= tmp ; ++ i) insert(A[i]);
            while(toop > 1) addvir(S[toop - 1], S[toop]), --toop;
            pre(1, 0, b), work(1, 0, b);
            for(i = 0; i < ty[a].size(); ++ i) re += dis[ty[a][i]];
            printf("%lld\n", a == b ? re / 2 : re);
        }
    }
    return 0;
}

  

原文地址:https://www.cnblogs.com/guangheli/p/11367477.html

时间: 2024-11-29 10:16:22

newcoder 79F 小H和圣诞树 换根 DP + 根号分治的相关文章

换根dp「小奇的仓库&#183;randomwalking&#183;」

把以前考试换根题集中写一下 随便选一个点做根一遍$dfs$求子树内贡献,再通过特殊手段算$ans[1]$,最后$dfs$求其他$ans$ 拆成子树内,子树外分别算贡献差,得儿子是很常见套路了 小奇的仓库 $M<=15$ 题解 很久之前做的换根dp,当时觉得真是神仙,现在看还是觉得很神仙 不同于一般换根dp,这个题$n^2$并不好写 所以$n^2$算法就省略了 考虑$M$非常小,可以计算$M$对答案影响 一个直接的想法是先算出来原答案,再减去现在答案 //本来为j现在异或M,变化了j-delta

不知哪个OJ 小x游世界树 换根?不知。

小x游世界树 (yggdrasi.pas/c/cpp) [问题描述] 小x得到了一个(不可靠的)小道消息,传说中的神岛阿瓦隆在格陵兰海的某处,据说那里埋藏着亚瑟王的宝藏,这引起了小x的好奇,但当他想前往阿瓦隆时发现那里只有圣诞节时才能到达,然而现在已经春天了,不甘心的他将自己的目的地改成了世界树,他耗费了大量的时间,终于将自己传送到了世界树下.世界树是一棵非常巨大的树,它有着许许多多的枝条以及节点,每个节点上都有一个平台.好不容易来到传说中的世界树下,小x当然要爬上去看看风景.小x每经过一条边都

换根DP

换根dp的通法:1.第一次扫描时,任选一个点为根,在"有根树"上执行一次树形DP,也就在回溯时发生的,自底向上的状态转移. 2.第二次扫描时,从刚才选出的根出发,对整棵树执行一次dfs,在每次递归前进行自上向下的推导,计算出换根后的解. 1.POJ3585 Accumulation Degree dp[i]以i为根的子树中,把i作为源点的最大流量 转移\(dp[x]=\sum_{y\epsilon son(x)}^{}\left\{\begin{matrix} min(dp[y],le

poj3585 Accumulation Degree(换根dp)

传送门 换根dp板子题(板子型选手 题意: 一棵树确定源点和汇点找到最大的流量(拿出一整套最大瘤板子orz const int maxn=2e5+10; int head[maxn],tot; struct node { int nt,to;long long w; }q[2*maxn]; long long dp[maxn];int cnt[maxn]; void insert(int u,int v,long long w) { q[tot].nt=head[u];q[tot].w=w;q[

【换根dp】9.22小偷

换根都不会了 题目大意 给定一棵$n$个点的树和树上一撮关键点,求到所有$m$个关键点距离的最大值$dis_{max}\le LIM$的点的个数. $n,m\le 30000,LIM\le 30000$ 题目分析 考虑在求出一个点的情况下如何转移到其子节点. 对点$u$最直接关心的状态是$mx[u]$:所有关键点到$u$的最大距离. 对点$u$的子节点$v$来说,$u$能带给它的只是“外面的世界”——$v$子树的补集这块贡献,也就是对于$u$的除了$v$子树的$mx[u]$. 因为$mx[u]$

codeforces1156D 0-1-Tree 换根dp

题目传送门 题意: 给定一棵n个点的边权为0或1的树,一条合法的路径(x,y)(x≠y)满足,从x走到y,一旦经过边权为1的边,就不能再经过边权为0的边,求有多少边满足条件? 思路:设$f[u]$为以1为根,自下而上到$u$的末节点是1的合法路径数量,$g[u]$代表以1为根,自下而上到$v$末节点是0的合法路径数量,这个可以通过一遍dfs简单求解. 再设$nf[u]$和$ng[u]$代表以u为根的两种合法路径数量,进行换根dfs,在换根的过程中: 若某一条边是0边,则: $ng[st.to]=

HDU 2196 Computer 二次扫描与换根DP

题意:给定一棵树,求树上所有点到其最远点的距离. 数据范围: 1 <= N <= 100000 ------------------------------------------我是分割线------------------------------------------ 题解:对于每个节点u来说,其可能到达的最长距离为max{其子树内的最长距离,其父节点不经过u的子树内的最长距离}.于是,我们便可以在第一遍dfs中预处理节点x到其子树内的最长距离,顺带求一下次长距离,方便转移. // f[

换根dp+暴力+预处理+记忆化搜索——cf1292C好题!

/** 给定一棵树,要求给树边赋值[0,n-2],每个值只能使用一次 S = mex(u,v), mex(u,v)是u-v路径上没有出现过的编号最小的值 问使得S最大的赋值方式 由于很难直接统计答案,所以考虑统计每条边的贡献 包含(0)路径的贡献tot1是其左右子树size的乘积 包含(0,1)的路径的贡献tot2是其左右子树的size乘积 ...依次类推 显然:只包含(1,2)这样的路径是没有贡献的 那么原问题转化为如何分配[0,n-2],使得最后的乘积和最大 dp[u][v]表示路径(u,v

CodeForce - 1187 E. Tree Painting (换根dp)

You are given a tree (an undirected connected acyclic graph) consisting of nn vertices. You are playing a game on this tree. Initially all vertices are white. On the first turn of the game you choose one vertex and paint it black. Then on each turn y