Codeforces 1140G Double Tree 倍增 + dp

刚开始, 我以为两个点肯定是通过树上最短路径过去的, 无非是在两棵树之间来回切换, 这个可以用倍增 + dp

去维护它。 但是后来又发现, 它可以不通过树上最短路径过去, 我们考虑这样一种情况, 起点在奇树里面, 终点
在偶树里面, 然后这两个点最短路径里面点到对应点的距离都很大, 这种情况下我们就需要从别的地方绕过去, 这样

就不是走树上最短路径了, 但是如果我们将对应点的距离更新成最短距离, 上面这个倍增 + dp的方法就可行了, 所以

我们可以用最短路去更新对应点之间的距离, 将它变成最小值。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ull unsigned long long

using namespace std;

const int N = 3e5 + 7;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000000007;
const double eps = 1e-13;
const double PI = acos(-1);

int n, q, depth[N];
LL d[N], gg[N], dp[N][2][2][20];
int f[N][20];
vector<pair<int, PLL>> G[N];
vector<PLI> E[N];

void dfs(int u, int fa, PLL dis) {
    depth[u] = depth[fa] + 1;
    if(u > 1) {
        f[u][0] = fa;
        dp[u][0][0][0] = min(dis.fi, dis.se + d[u] + d[fa]);
        dp[u][1][1][0] = min(dis.se, dis.fi + d[u] + d[fa]);
        dp[u][0][1][0] = min(dis.fi + d[fa], dis.se + d[u]);
        dp[u][1][0][0] = min(dis.se + d[fa], dis.fi + d[u]);
        for(int i = 1; i < 20; i++) f[u][i] = f[f[u][i - 1]][i - 1];
        for(int i = 1; i < 20; i++) {
            int v = f[u][i - 1];
            dp[u][0][0][i] = min(dp[u][0][0][i - 1] + dp[v][0][0][i - 1], dp[u][0][1][i - 1] + dp[v][1][0][i - 1]);
            dp[u][1][1][i] = min(dp[u][1][1][i - 1] + dp[v][1][1][i - 1], dp[u][1][0][i - 1] + dp[v][0][1][i - 1]);
            dp[u][0][1][i] = min(dp[u][0][0][i - 1] + dp[v][0][1][i - 1], dp[u][0][1][i - 1] + dp[v][1][1][i - 1]);
            dp[u][1][0][i] = min(dp[u][1][1][i - 1] + dp[v][1][0][i - 1], dp[u][1][0][i - 1] + dp[v][0][0][i - 1]);
        }
    }
    for(auto& e : G[u]) {
        if(e.fi == fa) continue;
        dfs(e.fi, u, e.se);
    }
}

int getLca(int u, int v) {
    if(depth[u] < depth[v]) swap(u, v);
    for(int i = 19; i >= 0; i--)
        if(depth[f[u][i]] >= depth[v]) u = f[u][i];
    if(u == v) return u;
    for(int i = 19; i >= 0; i--)
        if(f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
    return f[u][0];
}

PLL calc(int u, int op1, int v) {
    int dis = depth[u] - depth[v];
    LL g[2], tmp[2];
    g[op1] = 0;
    g[op1 ^ 1] = d[u];
    for(int i = 19; i >= 0; i--) {
        if(dis >> i & 1) {
            tmp[0] = g[0], tmp[1] = g[1];
            g[0] = min(tmp[0] + dp[u][0][0][i], tmp[1] + dp[u][1][0][i]);
            g[1] = min(tmp[1] + dp[u][1][1][i], tmp[0] + dp[u][0][1][i]);
            u = f[u][i];
        }
    }
    return mk(g[0], g[1]);
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%lld", &d[i]);
    for(int i = 2; i <= n; i++) {
        int u, v; LL w1, w2;
        scanf("%d%d%lld%lld", &u, &v, &w1, &w2);
        G[u].push_back(mk(v, mk(w1, w2)));
        G[v].push_back(mk(u, mk(w1, w2)));
        E[u].push_back(mk(w1 + w2, v));
        E[v].push_back(mk(w1 + w2, u));
    }
    priority_queue<PLI, vector<PLI>, greater<PLI> > que;
    for(int i = 1; i <= n; i++) {
        gg[i] = d[i];
        que.push(mk(d[i], i));
    }
    while(!que.empty()) {
        int u = que.top().se;
        LL val = que.top().fi;
        que.pop();
        if(val > gg[u]) continue;
        for(auto& e : E[u]) {
            if(gg[e.se] > val + e.fi) {
                gg[e.se] = val + e.fi;
                que.push(mk(gg[e.se], e.se));
            }
        }
    }
    for(int i = 1; i <= n; i++) d[i] = gg[i];
    dfs(1, 0, mk(0, 0));
    scanf("%d", &q);
    while(q--) {
        int u, v;
        scanf("%d%d", &u, &v);
        int op1 = (u & 1) ? 0 : 1;
        int op2 = (v & 1) ? 0 : 1;
        if(u & 1) u = (u + 1) >> 1;
        else u >>= 1;
        if(v & 1) v = (v + 1) >> 1;
        else v >>= 1;
        int Lca = getLca(u, v);
        PLL disu = calc(u, op1, Lca);
        PLL disv = calc(v, op2, Lca);
        printf("%lld\n", min(disu.fi + disv.fi, disu.se + disv.se));
    }
    return 0;
}

/*

*/

原文地址:https://www.cnblogs.com/CJLHY/p/10606646.html

时间: 2024-09-29 11:03:32

Codeforces 1140G Double Tree 倍增 + dp的相关文章

CodeForces 30C Shooting Gallery 简单dp

题目链接:点击打开链接 给定n个气球 下面n行 x y t val 表示气球出现的坐标(x,y) 出现的时刻t,气球的价值val 枪每秒移动1个单位的距离 问: 射击的最大价值,开始时枪瞄准的位置任意. 思路: dp一下.. #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #include <math.h> #include <set

CodeForces - 383C Propagating tree(dfs + 线段树)

题目大意: 给出一棵树,树上每个节点都有权值,然后有两个操作. 1 x val 在结点x上加上一个值val,x的儿子加上 -val,x的儿子的儿子加上 - (-val),以此类推. 2 x 问x节点的值. 思路分析: 每个节点上加值都是给自己的儿子节点加,而且这个是颗树. 比如样例上的,如果你给node 1加一个值,那么五个节点都加. 再给node 2加个值,2的儿子节点也加了,之前给1加的值也要加到2号节点的儿子. 所以你会发现节点的儿子会存在一个从属的关系. 这样的话,我们可以把所有节点从新

codeforces Name That Tune (概率dp)

题意: D - Name That Tune Time Limit:1000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Practice CodeForces 499D Appoint description:  System Crawler  (2015-01-05) Description It turns out that you are a great fan of rock b

hdu 4863 Centroid of a Tree 树dp

代码来自baka.. #include<iostream> #include<cstdio> #include<cstring> #include<string> #include<algorithm> #include<map> #include<queue> #include<stack> #include<set> #include<cmath> #include<vecto

Bestcoder round #65 &amp;&amp; hdu 5593 ZYB&#39;s Tree 树形dp

Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)Total Submission(s): 354    Accepted Submission(s): 100 Problem Description ZYB has a tree with N nodes,now he wants you to solve the numbers of nodes distanced no m

codeforces161D - Distance in Tree 树形dp

题意:给你一棵树,问你树中距离为k的有多少种情况. 解题思路:树形dp  维护每个节点(1-K)深度的情况, 解题代码: 1 // File Name: 161d.cpp 2 // Author: darkdream 3 // Created Time: 2014年08月03日 星期日 19时20分10秒 4 5 #include<vector> 6 #include<list> 7 #include<map> 8 #include<set> 9 #incl

Codeforces 360C Levko and Strings dp

题目链接:点击打开链接 题意: 给定长度为n的字符串s,常数k 显然s的子串一共有 n(n-1)/2 个 要求找到一个长度为n的字符串t,使得t对应位置的k个子串字典序>s #include<stdio.h> #include<iostream> #include<string.h> #include<algorithm> #include<vector> #include<set> using namespace std; #

hdu5593/ZYB&#39;s Tree 树形dp

ZYB's Tree Memory Limit: 131072/131072 K (Java/Others) 问题描述 ZYBZYB有一颗NN个节点的树,现在他希望你对于每一个点,求出离每个点距离不超过KK的点的个数. 两个点(x,y)(x,y)在树上的距离定义为两个点树上最短路径经过的边数, 为了节约读入和输出的时间,我们采用如下方式进行读入输出: 读入:读入两个数A,BA,B,令fa_ifa?i??为节点ii的父亲,fa_1=0fa?1??=0;fa_i=(A*i+B)\%(i-1)+1fa

Codeforces 459E Pashmak and Graph(dp+贪心)

题目链接:Codeforces 459E Pashmak and Graph 题目大意:给定一张有向图,每条边有它的权值,要求选定一条路线,保证所经过的边权值严格递增,输出最长路径. 解题思路:将边按照权值排序,每次将相同权值的边同时加入,维护每个点作为终止点的最大长度即可. #include <cstdio> #include <cstring> #include <algorithm> using namespace std; const int maxn = 3