Holiday's Accommodation

HDU 4118

题目描述：

一棵树,现在给出一个旅行规则:每个人本来有一个家,每个点对应一个人.现在他要去旅行,会选择某一个顶点作为他的家,最后要求每一个人都有一个家,没有两个人共用一个家.要使这些人的旅行路程之和最大,输出最大的路程之和.

题解：

思维题.同时也是树形dp常用的思维.枚举边,看这条边的贡献度.发现一条边,两边有两堆点,a,b,b较小,那么b的所有点一定可以过去到边的另一个,a的那边也会有b过来,并且对其他边的考虑没有影响.那么答案其实就是每一条边的权值*较小的那个*2,就是对答案的贡献.

重点：

树上的思维,点的角度不好考虑,就从边对答案的贡献度来遍历边

代码：

#pragma comment(linker, "/STACK:10240000000000,10240000000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(int i = a;i < b;i++)
#define REP_D(i, a, b) for(int i = a;i <= b;i++)

typedef long long ll;

using namespace std;

const int maxn = 1e5 + 100;
int n, dp[maxn];
ll ans;
struct info
{
    int to, len;
};
vector<info> G[maxn];

void dfs(int u, int fa)//简单的搞出点的个数
{
    dp[u] = 1;
    REP(i, 0, G[u].size())
    {
        int v = G[u][i].to;
        if(v!=fa)
        {
            dfs(v, u);
            dp[u] += dp[v];
        }
    }
}
void dfs_ans(int u, int fa, int pre_len)//遍历边
{
    if(fa == 0)
    {
        ;
    }
    else
    {
        ll t = (ll)min(dp[u], n - dp[u]);
        ans = ans + t*(ll)pre_len;
    }
    REP(i, 0, G[u].size())
    {
        int v = G[u][i].to, len = G[u][i].len;
        if(v!=fa)
            dfs_ans(v, u, len);
    }
}

void solve()
{
    ans = 0;
    dfs(1, 0);
    dfs_ans(1, 0, 0);
    printf("%I64d\n", ans*2);
}
int main()
{
    //freopen("8Hin.txt", "r", stdin);
    //freopen("8Hout.txt", "w", stdout);
    int ncase;
    scanf("%d", &ncase);
    REP_D(_, 1, ncase)
    {
        printf("Case #%d: ", _);
        scanf("%d", &n);
        REP_D(i, 1, n)
        {
            G[i].clear();
        }
        REP_D(i, 1, n - 1)
        {
            int a, b, len;
            scanf("%d%d%d", &a, &b, &len);
            info t;
            t.to = b;
            t.len = len;
            G[a].push_back(t);
            t.to = a;
            G[b].push_back(t);
        }
        solve();
    }
    return 0;
}