• JSOI2015 Salesman(树型DP)


    【luogu6082】

     【题目描述】

    某售货员小T要到若干城镇去推销商品,由于该地区是交通不便的山区,任意两个城镇之间都只有唯一的可能经过其它城镇的路线。

    小T 可以准确地估计出在每个城镇停留的净收益。这些净收益可能是负数,即推销商品的利润抵不上花费。

    由于交通不便,小T经过每个城镇都需要停留,在每个城镇的停留次数与在该地的净收益无关,因为很多费用不是计次收取的,而每个城镇对小T的商品需求也是相对固定的,停留一次后就饱和了。

    每个城镇为了强化治安,对外地人的最多停留次数有严格的规定。

    请你帮小T 设计一个收益最大的巡回方案,即从家乡出发,在经过的每个城镇停留,最后回到家乡的旅行方案。

    你的程序只需输出最大收益,以及最优方案是否唯一。

    方案并不包括路线的细节,方案相同的标准是选择经过并停留的城镇是否相同。因为取消巡回也是一种方案,因此最大收益不会是负数。

    小T 在家乡净收益是零,因为在家乡是本地人,家乡对小 T当然没有停留次数的限制。

    【Input】

    输入的第一行是一个正整数n(5<=n<=100000),表示城镇数目。城镇以1到n的数命名。

    小T 的家乡命名为1。

    第二行和第三行都包含以空格隔开的n-1个整数,第二行的第i个数表示在城镇i+1停留的净收益。第三行的第i个数表示城镇i+1规定的最大停留次数。

    所有的最大停留次数都不小于2。

    接下来的n-1行每行两个1到n的正整数x,y,之间以一个空格隔开,表示x,y之间有一条不经过其它城镇的双向道路。

    输入数据保证所有城镇是连通的。 

    【Output】

    输出有两行,第一行包含一个自然数,表示巡回旅行的最大收益。

    如果该方案唯一,在第二行输出“solution is unique”,否则在第二行输出“solution is not unique”。

    【Sample Input】

      9
      -3 -4 2 4 -2 3 4 6
      4 4 2 2 2 2 2 2
      1 2
      1 3
      1 4
      2 5
      2 6
      3 7
      4 8
      4 9

    【Sample Output】

      9

       solution is unique

     

    【Solution】
    这个题目乍一看是个图诶
    但是是DAG
    就相当于一棵树
    那么考虑到状态不同决策不同
    很容易联想到动态规划

    对于第一个问题
      关键是考虑每一个点的访问限制
      假设对于当前点i的限制是cnt[i]
      那么最多只能访问其cnt[i] - 1棵子树
      因为要留出一次机会回溯到出发点
      对于家乡的话就初始化成最大值,无限制访问

    对于第二个问题
      路径唯一或不唯一
      唯一的情况不用解释
      不唯一的情况: 

    • 存在一种最优方案使得经过的某个点 u 满足dp[u]=0 。
    • 存在在一种最优方案使得经过的某个点 u 存在至少 cnt[u] 个儿子, 且第 cnt[u] 大收益非负的儿子不唯一。(权值相同)

    重点:1.给所有的子树进行排序,取前cnt[i] - 1棵子树

       2.排序后取到负值后结束

    //YouXam
    #include <algorithm>
    #include <cstdio>
    #include <cstring>
    using namespace std;
    const int N = 100000;
    struct edge {
        int i, next;
    } edges[2 * N + 5];
    int head[N + 5], tot, n, w[N + 5], limit[N + 5], dp[N + 5], ansn[N + 5],sonn[N + 5];
    void add(int u, int v) {
        edges[++tot].i = v;
        edges[tot].next = head[u];
        head[u] = tot;
    }
    bool cmp(int a, int b) { return dp[a] > dp[b]; }
    void dfs(int root, int f) {
        dp[root] = w[root];
        int sontot = 0, soni = 0;
        for (int i = head[root]; i; i = edges[i].next)
            if (edges[i].i != f) dfs(edges[i].i, root);
        for (int i = head[root]; i; i = edges[i].next)
            if (edges[i].i != f) sonn[++sontot] = edges[i].i;
        sort(sonn + 1, sonn + 1 + sontot, cmp);
        while (soni < min(limit[root] - 1, sontot) && dp[sonn[soni + 1]] >= 0)
            dp[root] += dp[sonn[++soni]], ansn[root] |= ansn[sonn[soni]];//按位或
        if (soni < sontot && soni > 0 && dp[sonn[soni]] == dp[sonn[soni + 1]] || dp[sonn[soni]] == 0 && soni > 0 && soni <= limit[root] - 1)//两种情况,注意边界
            ansn[root] = 1;
    }
    int main() {
        scanf("%d", &n);
        for (int i = 1; i < n; i++) scanf("%d", &w[i + 1]);
        for (int i = 1; i < n; i++) scanf("%d", &limit[i + 1]);
        for (int i = 1; i < n; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            add(u, v);
            add(v, u);
        }
        limit[1] = n + 1;//在家乡没有停留限制
        dfs(1, 0);
        printf("%d
    %s", dp[1], ansn[1] ? "solution is not unique" : "solution is unique");
        return 0;
    }
    Code
    风吹过,我来过~
  • 相关阅读:
    重新整理 .net core 实践篇————配置系统之盟约[五]
    重新整理 .net core 实践篇————依赖注入应用之援军[四]
    重新整理 .net core 实践篇————依赖注入应用之生命法则[三]
    重新整理 .net core 实践篇————依赖注入应用[二]
    重新整理 .net core 实践篇————配置应用[一]
    spring cloud 学习笔记 客户端(本地)均衡负载(三)
    Leetcode之插入区间
    Leetcode之两棵二叉搜索树中的所有元素
    Leetcode之二叉树的层序遍历
    LeetCode之验证二叉搜索树
  • 原文地址:https://www.cnblogs.com/rui-4825/p/12638198.html
Copyright © 2020-2023  润新知