HDU 5044 Tree（LCA）

最新推荐文章于 2019-08-21 18:35:43 发布

原创最新推荐文章于 2019-08-21 18:35:43 发布 · 752 阅读

1 ·

CC 4.0 BY-SA版权

ACM/ICPC 同时被 2 个专栏收录

198 篇文章

订阅专栏

图论

93 篇文章

订阅专栏

本文介绍了一种解决树状结构中特定操作的问题，并详细解释了如何使用LCA算法来优化路径上的节点和边的操作。通过手动栈扩展和输入流优化等技巧，实现了高效的查询与更新。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5044

题意：对于一棵树，可以进行两种操作：

ADD1 U V K：将U到V结点路上的结点的权值都增加K；

ADD2 U V K：将U到V结点路上的边的权值都增加K；

最后输出所有点和所有边的权值。

思路：思路出自http://blog.youkuaiyun.com/hongrock/article/details/39616757

学了下手动扩栈和输入流外挂

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 100010;
const int log = 20;

struct edge
{
    int to, id;
    edge() {}
    edge(int to, int id) : to(to), id(id) {}
};

vector <edge> g[maxn];

long long add[maxn][2], les[maxn], node[maxn], ed[maxn];
int deg[maxn], par[log][maxn], head[maxn], dep[maxn];
int n;

void dfs(int u, int fa)
{
    par[0][u] = fa;
    deg[u] = 0;
    for(int i = 0; i < g[u].size(); i++)
    {
        edge &e = g[u][i];
        int v = e.to;
        if(v != fa)
        {
            deg[u]++;
            head[v] = e.id;
            dep[v] = dep[u] + 1;
            dfs(v, u);
        }
    }
}

void init()
{
    dep[1] = 0;
    dfs(1, -1);
    for(int k = 0; k + 1 < log; k++)
    {
        for(int v = 0; v <= n; v++)
        {
            if(par[k][v] < 0)
                par[k + 1][v] = -1;
            else
                par[k + 1][v] = par[k][par[k][v]];
        }
    }
}

int lca(int u, int v)
{
    if(dep[u] > dep[v]) swap(u, v);
    for(int k = 0; k < log; k++)
    {
        if((dep[v] - dep[u]) >> k & 1)
            v = par[k][v];
    }
    if(u == v) return u;
    for(int k = log - 1; k >= 0; k--)
    {
        if(par[k][u] != par[k][v])
        {
            u = par[k][u];
            v = par[k][v];
        }
    }
    return par[0][u];
}

inline void in(int &x)
{
    x = 0;
    bool mk = 0;
    char c = getchar();
    while(c < 48 || c > 57)
    {
        if(c == '-')  mk = 1;
        c = getchar();
    }
    while(c >= 48 && c <= 57)
    {
        x = x * 10 + c - 48;
        c = getchar();
    }
    if(mk)  x = -x;
}

void solve()
{
    queue <int> que;
    for(int i = 1; i <= n; i++)
        if(!deg[i])
            que.push(i);
    while(!que.empty())
    {
        int x = que.front();
        que.pop();
        node[x] = add[x][0];
        add[x][0] -= les[x];
        int fa = par[0][x];
        add[fa][0] += add[x][0];
        add[fa][1] += add[x][1];
        ed[head[x]] = add[x][1];
        if(!(--deg[fa]))
            que.push(fa);
    }
}

int main()
{
    int t;
    scanf("%d", &t);
//    int size = 256 << 20; // 256MB
//    char *p = (char*)malloc(size) + size;
//    __asm__("movl %0, %%esp\n" :: "r"(p));
    for(int ca = 1; ca <= t; ca++)
    {
        int q;
        printf("Case #%d:\n", ca);
        scanf("%d%d", &n, &q);
        for(int i = 0; i <= n; i++)
        {
            g[i].clear();
            add[i][0] = add[i][1] = 0;
            les[i] = 0;
        }
        int a, b, c;
        char s[10];
        for(int i = 1; i < n; i++)
        {
            in(a), in(b);
            g[a].push_back(edge(b, i));
            g[b].push_back(edge(a, i));
        }
        init();
        while(q--)
        {
            scanf(" %s", s);
            scanf("%d%d%d", &a, &b, &c);
            int x = lca(a, b);
            if(s[3] == '1')
            {
                add[a][0] += c;
                add[b][0] += c;
                add[x][0] -= c;
                les[x] += c;
            }
            else
            {
                add[a][1] += c;
                add[b][1] += c;
                add[x][1] -= c * 2;
            }
        }
        solve();
        for(int i = 1; i <= n; i++)
            printf("%I64d%c", node[i], i == n ? '\n' : ' ');
        for(int i = 1; i < n; i++)
            printf("%I64d%c", ed[i], i == n - 1 ? '\n' : ' ');
        if(n == 1)
            putchar('\n');
    }
    return 0;
}