hdu4003 分类： hdu 2015-07-20 10:37 14人阅读 评论(0) 收藏

---

很有有意思的树形DP

---

题意：

给一棵n个结点的树, 结点编号为1~n,

每条边都有长度. 有k个机器人从S点出发,

问让机器人遍历所有边,最少路程和是多少?

1<= n <=10000, 1 <= S <= n, 1 <= k <= 10

---

如果让一个机器人从根出发,遍历所有树之后再回到根,
那么花费一定是所有边权之和的两倍,因为每条边都走了两次。

而这道题中,机器人遍历完之后,并不需要走回出发点, 所以有些边只走了一次就可以了。
考虑一种简单情形，如果用1台机器人走,权值和最大的根到叶子路径只走一次是最优的。
最小花费 = sum*2 – {根到叶子路径的最大权值和}

---

可以有这样一个思路：
我们可以让k台机器人减少的花费尽量大.

对于i节点,我们可以选择派1~k个机器人去走
需要注意,如果派x个机器人走向某个子节点v,
那么E(i,v)就会被走了x次, 花费了x*w(i, v).
而原始的sum中每条边只走了两次,
所以走E(i,v)的花费减少了 2*w(i,v) - x*w(i,v)

---

状态表示: f(i,j) 表示子树i用j个机器人最多可以减少的花费

状态转移式:
f(i,j)= max{f(i,j-x)+f(v,x)+2*w(i,x)-k*w(i,x)}
(1<=x<=j 且 v是i的儿子节点)

最终答案 ans = sum * 2 - f(S, k)

时间复杂度：O(n*k^2)

---

dp(i,j)表示用j个机器人遍历i的子树所花费的最小费用

我们可以将机器人数量视为背包容积。
将i结点的每棵子树视为一组物品，并且每组物品中至少要选一个物品。

这样做背包就可以啦！~

状态转移方程为:
Cost[0]=dp(i,j)+dp(son,0)+2∗w(i,son)
Cost[1]=min{dp(son,x)+dp(i,j−x)+k∗w(i,son)}(1<=x<=j)
dp(i,j)=min{Cost[0],Cost[1]}

当然实现时可以写得更简单。

时间复杂度：O(n*k^2)

---

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <string>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <utility>
#include <iostream>
#include <algorithm>

const int maxn = 10005, maxk = 12, INF = 0x3f3f3f3f;

template<class Num>void read(Num &x)
{
    char c; int flag = 1;
    while((c = getchar()) < '0' || c > '9')
        if(c == '-') flag *= -1;
    x = c - '0';
    while((c = getchar()) >= '0' && c <= '9')
        x = (x<<3) + (x<<1) + (c-'0');
    x *= flag;
    return;
}
template<class Num>void write(Num x)
{
    if(x < 0) putchar('-'), x = -x;
    static char s[20];int sl = 0;
    while(x) s[sl++] = x%10 + '0',x /= 10;
    if(!sl) {putchar('0');return;}
    while(sl) putchar(s[--sl]);
}

struct Edge
{
    int v, w, next;
    Edge(int v = 0,int w = 0,int next = 0):v(v),w(w),next(next){}
}edge[maxn<<1];
int el, head[maxn];
int n, S, R;
int ans, sum;
int dp[maxn][maxk];

void NewEdge(int u,int v,int w)
{
    edge[++el] = Edge(v, w, head[u]), head[u] = el;
}
void clear()
{
    ans = el = sum = 0;
    memset(head, 0, sizeof(head));
    memset(dp, 0, sizeof(dp));
}
void dfs(int a,int fa)
{
    for(int i = head[a], p, w; i ; i = edge[i].next)
        if((p = edge[i].v) != fa) 
        {
            dfs(p, a), w = edge[i].w;

            for(int j = R; j > 0; j--)
                for(int k = 1; k <= j; k++)
                {
                    int tmp = dp[a][j-k] + dp[p][k] + (2 - k)*w;
                    dp[a][j] = std::max(dp[a][j], tmp);
                }
        }
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("hdu4003.in","r",stdin);
    freopen("hdu4003.out","w",stdout);
#endif

    while(std::cin >> n)
    {
        clear(), std::cin >> S >> R;

        for(int i = 1, u, v, w; i < n; i++)
        {
            read(u), read(v), read(w), sum += w;
            NewEdge(u, v, w), NewEdge(v, u, w);
        }

        dfs(S, 0);

        for(int i = 1; i <= R; i++)
            ans = std::max(dp[S][i], ans);

        ans = (sum<<1) - ans;

        std::cout << ans << std::endl;
    }

#ifndef ONLINE_JUDGE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

---

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <string>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <utility>
#include <iostream>
#include <algorithm>

const int maxn = 10005, maxk = 12, INF = 0x3f3f3f3f;

template<class Num>void read(Num &x)
{
    char c; int flag = 1;
    while((c = getchar()) < '0' || c > '9')
        if(c == '-') flag *= -1;
    x = c - '0';
    while((c = getchar()) >= '0' && c <= '9')
        x = (x<<3) + (x<<1) + (c-'0');
    x *= flag;
    return;
}
template<class Num>void write(Num x)
{
    if(x < 0) putchar('-'), x = -x;
    static char s[20];int sl = 0;
    while(x) s[sl++] = x%10 + '0',x /= 10;
    if(!sl) {putchar('0');return;}
    while(sl) putchar(s[--sl]);
}

struct Edge
{
    int v, w, next;
    Edge(int v = 0,int w = 0,int next = 0):v(v),w(w),next(next){}
}edge[maxn<<1];
int el, head[maxn];
int n, S, R;
int ans, sum;
int dp[maxn][maxk];

void NewEdge(int u,int v,int w)
{
    edge[++el] = Edge(v, w, head[u]), head[u] = el;
}
void clear()
{
    ans = el = sum = 0;
    memset(head, 0, sizeof(head));
    memset(dp, 0, sizeof(dp));
}
void dfs(int a,int fa)
{
    for(int i = head[a], p, w; i ; i = edge[i].next)
        if((p = edge[i].v) != fa) 
        {
            dfs(p, a), w = edge[i].w;

            for(int j = R; j >= 0; j--)
            {
                dp[a][j] = dp[a][j] + dp[p][0] + (w<<1);    

                for(int k = 1; k <= j; k++)
                   dp[a][j] = std::min(dp[a][j], dp[a][j-k] + dp[p][k] + k*w);
            }
//          dp[a][0] += dp[p][0] + (w<<1);
        }
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("hdu4003.in","r",stdin);
    freopen("hdu4003.out","w",stdout);
#endif

    while(std::cin >> n)
    {
        clear(), std::cin >> S >> R;

        for(int i = 1, u, v, w; i < n; i++)
        {
            read(u), read(v), read(w);
            NewEdge(u, v, w), NewEdge(v, u, w);
        }

        dfs(S, 0);

        std::cout << dp[S][R] << std::endl;
    }

#ifndef ONLINE_JUDGE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。