SGU 534 Computer Network

最新推荐文章于 2019-05-03 09:33:00 发布

原创最新推荐文章于 2019-05-03 09:33:00 发布 · 1.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dp #树 #直径

动态规划专栏收录该内容

56 篇文章

订阅专栏

本文探讨如何通过更改树形图中特定边的代价，以最小化代价使得树的直径变短。详细介绍了求解过程，包括找到树的中心、识别直径、计算代价以及使用树形动态规划的方法。通过实例解释了如何应用这些理论到实际问题中。

树形dp。好题！题目要求的是用最小的价值使得树直径变短，虽然，完全不是自己想出来的，但是为了纪念一下这道题，就发一篇题解吧。。。因为网上的题解实在是太少了。。。我找了很久很久才找到了一个大牛的博客里面讲了这道题。

附大牛dxhisboy博客：http://dxhisboy.blog.163.com/blog/static/2096440982011101595210606/。

还有就是参考了hust上 UESTC10 大牛比赛时的代码，

附链接：http://acm.hust.edu.cn/vjudge/contest/viewSource.action?id=267596 非常感谢这两位大牛！

首先我们需要想到，必须修改直径上的边才能达到使直接变短的目的。然后其实我们仔细想想的话会发现，对于一个一颗树，树的中心必存在于直径上，而且是位于直径中心位置的点（祥见dxhisboy大牛博客，讲的很容易懂）。然后如果我们知道了所有直径，

则最终我们要求的就是：

1、L1变短需要的代价加上使L2，L3变短的代价。

2、L4变短需要的代价。

3、L5变短需要的代价加上使L6，L7变短的代价。

这三者的最小值，直接在直径上跑一遍树dp就可以了。需要从中心跑，这样的话才不会漏情况。注意这组样例：

1 2 2 2

1 3 2 2

1 4 2 2

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#define LL long long
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;
const int N = 110100;
const int INF = 1e9;

struct Edge
{
    int u, v, t, p;
}E[N * 2];

int fir[N], next[N * 2], tot;

void Add_Edge(int u, int v, int t, int p)
{
    E[tot].u = u, E[tot].v = v;
    E[tot].t = t, E[tot].p = p;
    next[tot] = fir[u], fir[u] = tot ++;
}

int dp[N][2], end[N];
int n, dlen, du, ans, ct;
bool used[N * 2];

void dfs(int u, int fa)
{
    dp[u][0] = dp[u][1] = 0;
    end[u] = u;
    for(int i = fir[u]; ~i; i = next[i])
    {
        int v = E[i].v;
        if(v == fa) continue;
        dfs(v, u);
        int tmp = dp[v][0] + E[i].t;
        if(dp[u][0] < tmp)
        {
            dp[u][1] = dp[u][0];
            dp[u][0] = dp[v][0] + E[i].t;
            end[u] = end[v];
        }
        else if(dp[u][1] < tmp) dp[u][1] = tmp;
    }
    if(dp[u][0] + dp[u][1] > dlen)
    {
        dlen = dp[u][0] + dp[u][1];
        du = u;
    }
    return;
}

bool dfs1(int u, int fa, int now)
{
    bool flag = 0;int v, tmp;
    for(int i = fir[u]; ~i; i = next[i])
    {
        v = E[i].v;
        if(v == fa) continue;
        flag = dfs1(v, u, now + E[i].t);
        tmp = min(now, dlen - now);
        if(flag && ct < tmp)
        {
            ct = tmp;
            du = u;
        }
        if(flag) return 1;
    }
    return (now == dlen);
}

int solve(int u, int fa)
{
    int ret = 0, v;
    for(int i = fir[u]; ~i; i = next[i])
    {
        v = E[i].v;
        if(v == fa) continue;
        if(dp[u][0] == dp[v][0] + E[i].t)
        {
            int tmp = solve(v, u);
            if(E[i].p < tmp)
            {
                used[i] = 1;
                ret += E[i].p;
            }
            else ret += tmp;
        }
    }
    return ret == 0? INF : ret;
}

vector<int> path;
int cnt = 0;

void pt(int u, int fa)
{
    for(int i = fir[u]; ~i; i = next[i])
    {
        int v = E[i].v;
        if(v == fa) continue;
        if(dp[u][0] == dp[v][0] + E[i].t)
        {
            if(used[i])
            {
                path.push_back(i / 2 + 1);
                continue;
            }
            pt(v, u);
        }
    }
}

int main()
{
    //freopen("in.txt", "r", stdin);
    int u, v, t, p;
    while(scanf("%d", &n) != EOF)
    {
        CLR(fir, -1);tot = 0;
        for(int i = 1; i < n; i ++)
        {
            scanf("%d%d%d%d", &u, &v, &t, &p);
            Add_Edge(u, v, t, p);
            Add_Edge(v, u, t, p);
        }
        dlen = 0;du = 1;
        dfs(1, -1);///FOR dlen: 直径
        ct = 0; dfs1(end[du], -1, 0);/// FOR center.
        dfs(du, -1);/// Update dp;
        CLR(used, 0);
        int u = du, v, ptu = 0, pid = -1, r0 = 0, r1 = 0;
        for(int i = fir[u]; ~i; i = next[i])
        {
            v = E[i].v;
            if(dp[u][0] == dp[v][0] + E[i].t)
            {
                int tmp = solve(v, u);
                if(E[i].p < tmp)
                {
                    used[i] = 1;
                    r0 += E[i].p;
                    if(E[i].p > ptu)
                    {
                        ptu = E[i].p, pid = v;
                    }
                }
                else
                {
                    r0 += tmp;
                    if(tmp > ptu)
                    {
                        ptu = tmp;
                        pid = v;
                    }
                }
            }
            else if(dp[u][1] == dp[v][0] + E[i].t)
            {
                int tmp = solve(v, u);
                if(E[i].p < tmp)
                {
                    used[i] = 1;
                    r1 += E[i].p;
                }
                else r1 += tmp;
            }
        }
        path.clear();
        if(!r1)
        {
            if(ptu == r0) ptu = 0, pid = -1;
            ans = r0 - ptu;
            pt(u, pid);
        }
        else
        {
            if(r0 > r1)
            {
                ans = r1;
                dp[u][0] = dp[u][1];
                pt(u, pid);
            }
            else
            {
                ans = r0;
                for(int i = fir[u]; ~i; i = next[i])
                {
                    v = E[i].v;
                    if(v == pid && used[i])
                    {
                        path.push_back(i / 2 + 1);
                        break;
                    }
                }
                if(!path.size()) pt(pid, u);
            }
        }
        cnt = path.size();
        printf("%d\n%d\n", ans, cnt);
        printf("%d", path[0]);
        for(int i = 1; i < cnt; i ++)
        {
            printf(" %d", path[i]);
        }puts("");
    }
}