HDU 5378 Leader in Tree Land【树形DP】

最新推荐文章于 2019-07-16 15:37:00 发布
最新推荐文章于 2019-07-16 15:37:00 发布
阅读量597 收藏 1
点赞数
分类专栏： 动态规划 & 贪心
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/47447651
版权

第一种思路是最普遍的树形DP
dp[u][i] 表示u这个节点以及下面的子树，有i个leader的方案数。
首先，我们考虑，每棵子树上面的leader，他们的个数是不会因为父亲节点的取值而减少的，所以符合加法性质，因此可以直接累加上去。于是可以用背包的方式直接累加上去。
其次，要计算一次组合数，和普通的树形DP相像，从一开始可以分配 Csz[v]sz[u] 种方案，可分配的颜色随着分配的子树逐渐减少。
最后，考虑u这个节点的情况。分两种情况讨论，u节点是leader，那么就是从子树背包的 numofleader−1 的情况转移，只有一种情况；如果u节点不是leader，那么就是从 numofleader 的情况转移，但是有 sz[u]−1 种情况，可以将这个模型理解成是插板法：将子树的权值按顺序从小到大排列，那么u的权值可以插在除了最后一位的所有位置，共 sz[u]−1 种可能。

//      whn6325689
//      Mr.Phoebe
//      http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=1010;
const int MOD=1e9+7;

int n,K;

struct Edge
{
    int to,next;
}e[MAXN<<1];
int head[MAXN],tot;
int sz[MAXN];
ll dp[MAXN][MAXN],ret[2][MAXN],C[MAXN][MAXN];

void init()
{
    CLR(dp,0);
    CLR(head,-1);tot=0;
}

void addedge(int u,int v)
{
    e[tot].to=v;
    e[tot].next=head[u];
    head[u]=tot++;
}
void dfs(int u,int fa=-1)
{
    sz[u]=1;
    for(int i=head[u]; ~i; i=e[i].next)
    {
        int v=e[i].to;
        if(v==fa)   continue;
        dfs(v,u);
        sz[u]+=sz[v];
    }
    ret[0][0]=1;
    int all=0,cur=0;
    for(int i=head[u]; ~i; i=e[i].next)
    {
        int v=e[i].to;
        if(v==fa)   continue;
        for(int j=0; j<=min(K,all+sz[v]+1); j++)ret[cur^1][j]=0;
        for(int j=min(K,all); j>=0; j--)
        {
            if(!ret[cur][j])    continue;
            for(int k=1; k<=min(K,sz[v]); k++)
            {
                ret[cur^1][j+k]+=ret[cur][j]*dp[v][k]%MOD*C[sz[u]-1-all][sz[v]]%MOD;
                ret[cur^1][j+k]%=MOD;
            }
        }
        cur^=1;
        all+=sz[v];
    }
    for(int i=min(K,sz[u]); i>=1; i--)
    {
        //  printf("dp[%d][%d]=%I64d\n",v,i,ret[cur][i]);
        dp[u][i]=ret[cur][i]*(sz[u]-1)%MOD+ret[cur][i-1];
        dp[u][i]%=MOD;
    }
}
int main()
{
    C[0][0]=1;
    for(int i=1; i<MAXN; i++)
    {
        C[i][0]=C[i][i]=1;
        for(int j=1; j<i; j++)
            C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD;
    }
    int T,cas=1;
    read(T);
    while(T--)
    {
        init();
        read(n),read(K);
        for(int i=0, u, v; i<n-1; i++)
        {
            read(u),read(v);
            addedge(u,v);
            addedge(v,u);
        }
        dfs(1);
        printf("Case #%d: %I64d\n",cas++,dp[1][K]);
    }
    return 0;
}

可以用求概率的思想来解决这个问题。令以i号节点为根的子树为第i棵子树，设这颗子树恰好有sz[i]个点。那么第i个点是第i棵子树最大值的概率为 1/sz[i] ，不是最大值的概率为 (sz[i]−1)/sz[i] 。现在可以求解恰好有 k 个最大值的概率。
令dp[i][j]表示考虑编号从 1 到i的点，其中恰好有 j 个点是其子树最大值的概率。 很容易得到如下转移方程：dp[i][j]=dp[i−1][j]∗(sz[i]−1)/sz[i]+dp[i−1][j−1]/sz[i]。这样 dp[n][k] 就是所有点中恰好有 k 个最大值的概率。
题目要求的是方案数，用总数n！乘上概率就是答案。计算的时候用逆元代替上面的分数即可

//      whn6325689
//      Mr.Phoebe
//      http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=1010;
const int MOD=1e9+7;

ll dp[MAXN][MAXN];
int n,K;

struct Edge
{
    int to,next;
}e[MAXN<<1];
int head[MAXN],tot;

void init()
{
    CLR(dp,0);
    CLR(head,-1);tot=0;
}

void addedge(int u,int v)
{
    e[tot].to=v;
    e[tot].next=head[u];
    head[u]=tot++;
}

ll fac[MAXN],inv[MAXN];
int sz[MAXN];

void dfs(int u,int fa=-1)
{
    sz[u]=1;
    for(int i=head[u];~i;i=e[i].next)
        if(e[i].to!=fa)
        {
            dfs(e[i].to,u);
            sz[u]+=sz[e[i].to];
        }
}

int main()
{
    inv[0]=inv[1]=1;
    fac[0]=fac[1]=1;
    for(int i=2; i<MAXN; i++)
    {
        inv[i]=(MOD-MOD/i)*inv[MOD%i]%MOD;
        fac[i]=fac[i-1]*i%MOD;
    }
    int T,cas=1;
    read(T);
    while(T--)
    {
        init();
        read(n),read(K);
        for(int i=0,u,v;i<n-1;i++)
        {
            read(u),read(v);
            addedge(u,v);addedge(v,u);
        }
        dfs(1);
        dp[0][0]=1;
        for(int i=1;i<=n;i++)
            for(int j=0;j<=K;j++)
            {
                dp[i][j]=dp[i-1][j]*(sz[i]-1)%MOD*inv[sz[i]]%MOD;
                if(j>0)
                    dp[i][j]=(dp[i][j]+dp[i-1][j-1]*inv[sz[i]]%MOD)%MOD;
            }
        ll ans=dp[n][K]*fac[n]%MOD;
        printf("Case #%d: %I64d\n",cas++, ans);

    }
    return 0;
}
SuPhoebe
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 5378 Leader in Tree Land 树形背包
九野的博客
08-12 1766
链接 题解转自： 题意: 给定n k 下面n-1行给出一棵树。 把数字1-n填到树的节点上。 填完后计算leader节点个数，若这个点是leader，则这个点上填的数>这个点的子树上填的数 问：恰好有k个leader节点的 填涂方案数. 思路: dp[i][j]表示以i点为根的子树 有恰好j个leader的方案数。 如果u 是叶子节点则 dp[u][0] = 0, dp
HDU 5378 Leader in Tree Land
Magle
08-14 741
Leader in Tree Land Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 433    Accepted Submission(s): 173 Problem Description Tree land ha
hdu 5378 Leader in Tree Land
Stubird_的专栏
08-12 460
一道很神奇的题目。 给你一颗树，重新给节点编号，一个子树编号最大的那个节点控制整个子树，求有k个控制节点的方案数。 题解的做法是先去求这个点成为控制点的概率，然后再去背包。 算出的概率×N！就是答案了。 神奇从来没想过可以通过概率来算出方案数，太神奇了。`#pragma comment(linker, “/STACK:1024000000,1024000000”)include includ
HDU 5378 Leader in Tree Land（树形dp+组合数）
LSD20164388的博客
08-07 265
Leader in Tree Land Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 879    Accepted Submission(s): 429   Problem Description Tree land has n...
hdu 5378 Leader in Tree Land（dp+逆元）
不慌不忙、不急不躁
08-12 811
题目链接：hdu 5378 Leader in Tree Land 问题可以理解成N个节点的树，有K个ministers的概率，最后乘上N!。每个节点为ministers的概率即为1 / son（以该节点为根节点的子树包含的节点个数），同样不为ministers的概率为(son-1)/son。所以没有必要考虑树的结构，直接根句子节点的个数转移dp[i][j] dp[i][j] = dp
HDU - 5378 Leader in Tree Land 树形dp
07-16 74
HDU - 5378 dp[ i ][ j ]表示 i 这棵子树填满， 有 j 个满足条件的方案数。 转移的时候组合数乘一乘。 #include<bits/stdc++.h> #define LL long long #define LD long double #define ull unsigned long long #define fi first ...
DP.rar_DP_hdu_动态规划_动态规划 C++
最新发布
09-20
标题中的“DP.rar”表明这是一个关于动态规划的资料压缩包，而“DP_hdu”暗示了这些题目可能来自杭州电子科技大学（HDU）的在线编程平台。动态规划通常用于解决那些可以通过子问题的最优解来构建原问题最优解的问题...
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
HDU DP题解
02-07
HDU上DP大集合，里面包括题，题解，代码，对DP入门者很实用，对DP老手也是有很大的提高
HDU DP动态规划
03-31
【标题】"HDU DP动态规划"涉及到的是在算法领域中的动态规划（Dynamic Programming，简称DP）技术，这是解决复杂问题的一种高效方法，尤其适用于有重叠子问题和最优子结构的问题。动态规划通常用于优化多阶段决策...
面试经典动态规划问题
Mr.Phoebe的专栏
02-21 9225
经典动态规划问题三角数塔问题设有一个三角形的数塔，顶点为根结点，每个结点有一个整数值。从顶点出发，可以向左走或向右走，如图所示：要求从根结点开始，请找出一条路径，使路径之和最大，只要输出路径的和。思路从叶节点倒推回根，因为每个节点只可能向左或者向右，所以转移方程为dp[i][j] = num[i][j] + max(dp[i+1][j],dp[i+1][j+1])代码#include <stdio.
ACM竞赛中的逆向思维
Mr.Phoebe的专栏
10-29 2093
在竞赛过程中，尤其是近期训练，遇到了不少一定要用逆向思维才能解决的题目。 为此做一系列的总结。希望能够对大家有所帮助。 同时，我也会做成PPT，供14级训练使用。其中有部分问题摘自于2005年国家集训队唐文斌的《正难则反–浅谈逆向思维在解题中的应用》论文。容斥方面逆向思维在容斥方面的应用相当广泛，也可以说容斥就是逆向思维的一种体现。HDU 5072 Coprime 同色三角形题目大意：给了nn个
Google Code Jam 2018: Qualification Round
Mr.Phoebe的专栏
04-09 1705
资格赛，除了最后一题比较有趣以外，其他都比较简单 Saving The Universe Again 贪心 一开始想着尽可能将S往前移，但是想了想觉得这样移动好多次，可能才等于后面的S往前移一位的成果。 所以就变成尽可能地将C往末尾移（末尾一段连续的C就不用考虑了），即，每一次移动减少的伤害最大。 int T,n; vi a1,a2; int main() { cin&gt;&...
LeetCode 446. Arithmetic Slices II - Subsequence
Mr.Phoebe的专栏
11-24 1485
一道长得一副dp的样子的dp题。这道题难度不算特别大，因为看得出来肯定是dp题。因为，一个等差序列里面有好几个小的等差序列。 例如，2 4是一个等差序列，2 4 6是一个等差序列。 所以我们发现等差序列是可以扩展的。那么就得到了，咱们的转移方程的一部分 dp[i][delta]=dp[j][delta]+1dp[i][delta] = dp[j][delta] + 1 其中i，j是表示该数在
Poj 1112 Team Them Up!
Mr.Phoebe的专栏
08-12 1097
首先分析这道题目，题目给出的是一个有向图，即如果有A认识B，但不一定有B认识A。但是在所分配的组里面，任意两个人都要互相认识。 1、 先读入数据建立有向图，然后对这个有向图进行处理，如果两个点之间的边是单向边，就认为两个点之间无边（因为这两个人不互相认识），对于两个点间的双向边，即建立一条无向边（这两个人互相认识），这样就可以把一个有向图转化为一个无向图。 2、 将这个无向图转化为它的
UVA 12297 Super Poker（矩阵快速幂）
Mr.Phoebe的专栏
06-07 1089
想到了一个递推式 f(n,k)=f(n−k,k)+f(n−k,k−1)∗4+f(n−k,k−2)∗6+f(n−k,k−3)∗4+f(n−k,k−4)f(n, k) = f(n-k, k) + f(n-k, k-1) * 4 + f(n-k, k-2) * 6 + f(n-k, k-3) * 4 + f(n-k, k-4) 这里f(n,k)f(n, k)表示用k张牌组成和为N的方案数，在递推的时候
HDU 5353 Average
Mr.Phoebe的专栏
08-06 1036
思路： 找到一个非零的点，然后从左贪心地走一遍，然后从右贪心走一遍 贪心就是如果现在的数是大于零的数，则给下一位； 如果现在的数是小于零的数，则下一位给我。比赛的时候就是想太多了….// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algorith
背包与树形DP入门详解：动态规划解题策略
本文将深入探讨背包动态规划（Dynamic Programming, DP）中的两种主要形式：背包DP和树形DP，以及它们在实际问题中的应用。首先，我们将从基础概念出发，解释多组测试用例处理技巧，如当遇到未告知组数的测试用例时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值