与树相关的题目 树形DP 总结，不断汇总中

最新推荐文章于 2017-04-16 16:25:40 发布
最新推荐文章于 2017-04-16 16:25:40 发布
阅读量950 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazy_ac/article/details/10082743
版权

 hdu 1561     The more, The Better   树形DP入门   利用分组背包的思想

#include<cstdio>
#include<vector>
#include<cstring>
using namespace std;
int dp[250][250];
vector<int> edge[250];
int n,m;
int val[250];
int max(int a,int b){
	return a>b?a:b;
}
/*
/
分组背包：
for 所有的组i
    for v=V..0
        for 所有的k属于组i
            f[v]=max{f[v],f[v-c[k]]+w[k]}
*/
void dfs(int u,int fa){//用分组背包的思想更易于理解以及掌握
	int i,j,k;
    dp[u][1]=val[u];
	for(i=0;i<edge[u].size();i++)//枚举每一组背包，即每一个儿子，每组背包至少去一个物品
	{
		int v=edge[u][i];
		if(v==fa) continue;
		dfs(v,u);
		int t=1;
		if(u==0) t=0;//u为根节点时不需要分配背包容量
		for(k=m;k>=1;k--)//枚举背包容量,dp[v][1....k]的状态（已经得出的最优状态）为v儿子这组背包的k个物品
		{
			for(j=1;j<=k-t;j++)//枚举第i组的每个物品，即第i个儿子的所有状态
			{    
				//u为根节点时子节点可得到的最大分配为枚举的背包容量，否则要减1
				if(dp[u][k-j]!=-1&&dp[v][j]!=-1)
				dp[u][k]=max(dp[u][k],dp[u][k-j]+dp[v][j]);//枚举每个物品，找到能让dp[u][k]更优的物品
                /*
				注意这里的讲究：
				j递增，k-j递减，所以保证了每次如果dp[u][k]被更新的话dp[u][k-j]的状态都是原来的状态（没有被v更新过），
				也保证了dp[u][k]是最多取一个物品来更新的，*_* 哈哈，终于把每个细节搞通了，ORZ myself
				*/
			}
			//其实就相当于用k-1的容量(u为0时是k)去分配给所有的儿子，得出最优的分配方案，再更新dp[u][k];
		}
	}
}
int  main()
{
	int i,a,b;
	while(scanf("%d%d",&n,&m),(n||m))
	{
		for(i=0;i<=n;i++) edge[i].clear();
		val[0]=0;
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",&a,&b);
			edge[a].push_back(i);
			val[i]=b;
		}
	    memset(dp,-1,sizeof(dp));dp[0][0]=0;
		dfs(0,-1);
		printf("%d\n",dp[0][m]);
	}
	return 0;
}

另一种写法

View Code 
#include<cstdio>
#include<vector>
#include<cstring>
using namespace std;
int dp[250][250];
vector<int> edge[250];
int n,m;
int val[250];
int max(int a,int b){
    return a>b?a:b;
}
/*
/
分组背包：
for 所有的组i
    for v=V..0
        for 所有的k属于组i
            f[v]=max{f[v],f[v-c[k]]+w[k]}
*/
void dfs(int u,int fa){//用分组背包的思想更易于理解以及掌握
    int i,j,k;
    dp[u][1]=val[u];
    for(i=0;i<edge[u].size();i++)//枚举每一组背包，即每一个儿子，每组背包至少去一个物品
    {
        int v=edge[u][i];
        if(v==fa) continue;
        dfs(v,u);
        int t=1;
        if(u==0) t=0;
        for(k=m;k>=1;k--)
         {
            for(j=t;j<=k-1;j++)//也相当于是枚举第i组背包的每个物品
            {
                if(dp[u][j]!=-1&&dp[v][k-j]!=-1)
                dp[u][k]=max(dp[u][k],dp[u][j]+dp[v][k-j]);//枚举每个物品，找到能让dp[u][k]更优的物品
            }
        }
    }
}
int  main()
{
    int i,a,b;
    while(scanf("%d%d",&n,&m),(n||m))
    {
        for(i=0;i<=n;i++) edge[i].clear();
        val[0]=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&a,&b);
            edge[a].push_back(i);
            val[i]=b;
        }
        memset(dp,-1,sizeof(dp));dp[0][0]=0;
        dfs(0,-1);
        printf("%d\n",dp[0][m]);
    }
    return 0;
}

 

　　

hdu 4003  Find Metal Mineral

/*
还是分组背包的思想，与上一题差不多
不过这个题目有一个特点，花费的是边权
所以每次分配背包容量时，都要加上相应的边权消耗
dp[i][j]表示以i为根的子树，放j个机器人去遍历（不回来）的最小花费
dp[i][0]就表示没有机器人停留在子树中，即派了一个机器人下去，
遍历完后又回来了，其实就等于子树中边权值和的两倍
*/
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
vector<pair<int,int> > edge[10010];
int dp[10010][15];
int m;
int min(int a,int b){return a>b?b:a;}
void dfs(int u,int fa){
	int i,j,k;
	for(i=0;i<edge[u].size();i++){
		int v=edge[u][i].first;
		if(v==fa) continue;
		dfs(v,u);
		for(k=m;k>=0;k--){
			dp[u][k]+=dp[v][0]+2*edge[u][i].second;//dp[v][0]表示遍历v子树后回来，即没有机器人停留在子树中
			for(j=1;j<=k;j++)
				dp[u][k]=min(dp[u][k],dp[u][k-j]+dp[v][j]+j*edge[u][i].second);//派j个机器人给v子树就会经过u-v之间的边j次
		}
	}
}
int main(){
	int n,s,i,a,b,w;
	while(scanf("%d%d%d",&n,&s,&m)!=EOF){
		for(i=0;i<=n;i++) edge[i].clear();
		for(i=0;i<n-1;i++){
			scanf("%d%d%d",&a,&b,&w);
			edge[a].push_back(make_pair(b,w));
			edge[b].push_back(make_pair(a,w));
		}
		memset(dp,0,sizeof(dp));
		dfs(s,0);
		printf("%d\n",dp[s][m]);
	}
}

　poj 1849 Two   类似于上面一题，m=2

View Code 
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
vector<pair<int,int> > edge[10010];
int dp[10010][15];
int m;
int min(int a,int b){return a>b?b:a;}
void dfs(int u,int fa){
    int i,j,k;
    for(i=0;i<edge[u].size();i++){
        int v=edge[u][i].first;
        if(v==fa) continue;
        dfs(v,u);
        for(k=m;k>=0;k--){
            dp[u][k]+=dp[v][0]+2*edge[u][i].second;
            for(j=1;j<=k;j++)
                dp[u][k]=min(dp[u][k],dp[u][k-j]+dp[v][j]+j*edge[u][i].second);
        }
    }
}
int main(){
    int n,s,i,a,b,w;
    while(scanf("%d%d",&n,&s)!=EOF){
        m=2;
        for(i=0;i<=n;i++) edge[i].clear();
        for(i=0;i<n-1;i++){
            scanf("%d%d%d",&a,&b,&w);
            edge[a].push_back(make_pair(b,w));
            edge[b].push_back(make_pair(a,w));
        }
        memset(dp,0,sizeof(dp));
        dfs(s,0);
        printf("%d\n",dp[s][m]);
    }
}

 

http://www.codeforces.com/problemset/problem/161/D

判断树中有多少的长度为k的简单路径dp[i][j]记录以i为根长度为j的路径数(i为路径的端点) ，每次回溯上来的时候维护dp[i][1--k]的值就好了

View Code 
#include<cstdio>
#include<vector>
#include<cstring>
using namespace std;
typedef __int64 lld;
lld dp[50010][510];
lld ans;
vector<int> g[50010];
int k;
void dfs(int u,int fa)
{
    int i,j;
    dp[u][0]=1;
    for(i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(v==fa) continue;
        dfs(v,u);
        for(j=1;j<=k;j++) ans+=dp[u][j-1]*dp[v][k-j];
        for(j=1;j<=k;j++) dp[u][j]+=dp[v][j-1];
    }
}
int main()
{
    int n,i,j,a,b;
    scanf("%d%d",&n,&k);
    for(i=0;i<n-1;i++)
    {
        scanf("%d%d",&a,&b);
        g[a].push_back(b);
        g[b].push_back(a);
    }
    memset(dp,0,sizeof(dp));
    ans=0;
    dfs(1,0);
    printf("%I64d\n",ans);
    return 0;
}

 


hdu 3586 Information Disturbing

View Code 
//去掉一些边使得根节点不与叶子节点连通，在去掉的总的边权<=m的前提下
//使得所有边中最大的边权尽可能的小
#include<cstdio>
#include<cstring>

const int INF = 100000;
const int maxn = 1010;

struct node{
    int v,w,next;
}edge[100010];

int head[maxn];
int tot;
void add(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
//二分判可行
//dfs 求出 子树中去掉的边权之和，如果大于u->v之间的边权，则改为去u->之间的边
//然后一层层回溯上去就好了
int dfs(int u,int fa,int num)
{
    int sum=0;
    bool flag=false;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        if(edge[i].v==fa) continue;
        int s=dfs(edge[i].v,u,num);
        if(s>edge[i].w&&edge[i].w<=num)
        {
            s=edge[i].w;
        }
        sum+=s;
        flag=true;
    }
    if(!flag) return INF;
    return sum;
}
int main()
{
     int n,m,i,j,a,b,c;
     while(scanf("%d%d",&n,&m),(n||m))
     {
         tot=0;
         memset(head,-1,sizeof(head));
         for(i=0;i<n-1;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             add(a,b,c);
             add(b,a,c);
         }
         int l=1,r=1001;
         int ans=-1;
         while(l<=r)
         {
             int mid=(l+r)>>1;    
             if(dfs(1,1,mid)<=m)
             {
                    ans=mid;
                    r=mid-1;
             }
             else l=mid+1;
         }
         printf("%d\n",ans);
     }
}

 

 

zoj 3506 cut the tree

View Code 
/*
 题意：给出一颗树，每个节点都有一个权值，每次可以砍掉一条边，然后你可以在分开的两个集合中选一个，
 求恰好砍m次能获得的最大权值和最小权值
 
 这题的关键在于细节处理，+1，-1都要很小心
 di[i]表示以i为根的子树的边的数量
dp[i][j]代表以i为根的子树砍j刀所能获得的最小权值，最大权值的话只需将所有点的权值变成负的再dfs即可
求完dp后，要进行简单的转换才是答案
假设最后剩下的节点属于i为根的子树，则i与父节点之间的边肯定是被砍掉的
用dp[i][j]来更新答案时，需要先算出j的范围，即以i为根的子树至少需要砍几刀，最多能够砍几刀
树边有n-1条，以i为根的子树最多有di【i]条边，总共要砍m条边
所以i子树外的其他边最多能够砍 n-1-di[i] 条，所以i子树至少要砍m-(n-1-di[i])条，小于0时就是0了
最多能砍min(di[i],m-1)条，因为i与父节点之间的边被砍掉了
 */
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int INF = 100000000;
const int maxn = 1010;
int dp[maxn][30];
vector<int> g[maxn];
int val[maxn];
int di[maxn];
int n, m;
int min(int a, int b) {
    return a < b ? a : b;
}
int max(int a, int b) {
    return a > b ? a : b;
}
void dfs(int u, int fa) {
    int i, j, k;
    dp[u][0] = val[u];//在第一次遍历到u的时候先记录u节点的权值，待回溯的时候再加上
    di[u] = 0;
    for (i = 1; i <= m; i++)
        dp[u][i] = INF;
    for (i = 0; i < (int) g[u].size(); i++) {
        int v = g[u][i];
        if (v == fa)
            continue;
        dfs(v, u);
        di[u] += di[v] + 1;
        for (k = m; k >= 0; k--) {
            dp[u][k] += dp[v][0];//一刀都不砍
            for (j = 1; j <= k; j++)//保留u->v之间的边
                dp[u][k] = min(dp[u][k], dp[v][j] + dp[u][k - j]);
            for (j = 1; j <= di[v] + 1 && j <= k; j++)//砍掉u->v之间的边
                dp[u][k] = min(dp[u][k], dp[u][k - j]);
        }
    }
}
int solve() {
    dfs(1, 0);
    int ans = dp[1][m];
    for (int i = 2; i <= n; i++) {
        for (int j = max(0, m - n + di[i]+1); j <= di[i] && j < m; j++)//i与父节点之间的边一定砍掉（j<m）
            ans = min(ans, dp[i][j]);//i子树的外面 至多 能砍 (n-1-di[i])刀，其他的刀必须要在i子树内砍
    }
    return ans;
}
int main() {
    int i, j, a, b;
    while (scanf("%d%d", &n, &m) != EOF) {
        for (i = 1; i <= n; i++)
            g[i].clear();
        for (i = 1; i <= n; i++)
            scanf("%d", &val[i]);
        for (i = 1; i <= n - 1; i++) {
            scanf("%d%d", &a, &b);
            g[a].push_back(b);
            g[b].push_back(a);
        }
        printf("%d ", solve());
        for (i = 1; i <= n; i++)
            val[i] = -val[i];
        printf("%d\n", -solve());
    }
}

 

 poj 1155 TELE

View Code 
/*
DP[i][j]表示以i为根节点的子树总共使j个客户收到信息的最大报酬
dp[u][j+k]=max(dp[u][j+k],dp[u][j]+dp[v][k]-w) u是v的父节点，w为u、v的边权
*/
#include<cstdio>
#include<cstring>
#define max(a,b) a>b?a:b
const int INF = 1000000000;
const int maxn = 3010;
int head[maxn],dp[maxn][maxn],n,m;
int num[maxn];
struct EDGE{
    int v,w,next;
}edge[maxn];
int  tot;
void add_edge(int s,int t,int w){
    edge[tot].v=t;
    edge[tot].w=w;
    edge[tot].next=head[s];
    head[s]=tot++;
}
void dfs(int u,int fa){
    int i,j,k,tmp[maxn];
    for(i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa) continue;
        dfs(v,u);
        for(j=0;j<=num[u];j++)
            tmp[j]=dp[u][j];//先预存下所有的最优值，因为在下面的更新过程中有可能会被更新掉
         for(j = 0; j <= num[u]; j ++)
            for(k = 1; k <= num[v]; k ++)
                dp[u][j+k] = max(dp[u][j+k], tmp[j]+dp[v][k]-edge[i].w);
        num[u] += num[v];//利用回溯，自底向上的进行DP
    }
}
int main(){
    int i,j,k,a,c;
    tot=0;
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            dp[i][j]=-INF;
    for(i=1;i<=n-m;i++){
        scanf("%d",&k);
        for(j=0;j<k;j++){
            scanf("%d%d",&a,&c);
            add_edge(i,a,c);
        }
    }
    memset(num,0,sizeof(num));
    for(i=n-m+1;i<=n;i++){
        num[i]=1;
        scanf("%d",&dp[i][1]);
    }
    dfs(1,0);
    for(i=m;i>=0;i--){
        if(dp[1][i]>=0){//输出最多的可能的用户数，在不亏本的前提下
            printf("%d\n",i);
            break;
        }
    }
    return 0;
}

 

poj 3107

View Code 
/*
求一棵树分别去掉哪些点后可以使得剩下的点集中点数最多的连通块的点数最小
直接进行一次DFS求解即可
*/

#include<cstdio>
#include<cstring>
const int maxn = 50010;
struct node{
    int v,next;
}edge[maxn*2];
int head[maxn];
int E,ans,n;
void add(int a,int b)
{
    edge[E].v=b;
    edge[E].next=head[a];
    head[a]=E++;
}
inline int max(int a,int b){
    return a>b?a:b;
}
inline int min(int a,int b){
    return a<b?a:b;
}
int res[maxn];
int dfs(int u,int fa)
{
    int i,Max=0;
    int s=1;
    for(i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==fa) continue;
        int t=dfs(v,u);
        Max=max(Max,t);
        s+=t;
    }
    Max=max(Max,n-s);
    res[u]=Max;
    ans=min(ans,Max);
    return s;
}
int main()
{
    int i,j,a,b;
    while(scanf("%d",&n)!=EOF)
    {
        E=0;ans=100000000;
        for(i=1;i<=n;i++) head[i]=-1;
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            add(a,b);
            add(b,a);
        }
        dfs(1,0);
        for(i=1;i<=n;i++)
        {
            if(res[i]==ans)
                printf("%d ",i);
        }
        puts("");
    }
    return 0;
}

 

poj 1655

View Code 
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
vector<int> edge[20010];
int son[20010];
int ans[20010];
int max(int a,int b){
    return a>b?a:b;
}
void dfs(int u,int fa)
{
    son[u]=1;
    ans[u]=1;
    for(int i=0;i<edge[u].size();i++)
    {
        int to=edge[u][i];
        if(to==fa) continue;
        dfs(to,u);
        son[u]+=son[to];
        ans[u]=max(ans[u],son[to]);
    }
}
int main()
{
    int t,n,i,j,a,b;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(i=0;i<=n;i++) edge[i].clear();
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            edge[a].push_back(b);
            edge[b].push_back(a);
        }
        dfs(1,0);
        int ret=~0u>>1;
        int id;
        for(i=1;i<=n;i++)
        {
            if(max(ans[i],n-son[i])<ret) 
            {
                ret=max(ans[i],n-son[i]);
                id=i;
            }
        }
        printf("%d %d\n",id,ret);

    }
}

 

poj 1741  树的分治算法  买一送一（poj 1987）

View Code 
/*
详见09年国家队论文 《分治算法在树的路径问题中的应用》
每次先找到重心，可以用反证法证明以重心为根的子树中的节点数不超过n/2
所以每次在子树中重新找重心的时候都把问题的规模缩小了1/2即分治了，
这样子树的深度就不会超过log(n)
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 10010;
bool used[maxn];
int head[maxn], son[maxn] , d[maxn] , ans[maxn];
struct node {
    int v,w,next;
}edge[2*maxn];
int tot,Max,root,cnt,m,n;
void add(int a,int b,int w)
{
    edge[tot].v=b;
    edge[tot].w=w;
    edge[tot].next=head[a];
    head[a]=tot++;
}
void init()
{
    memset(used,false,sizeof(used));
    memset(head,-1,sizeof(head));
    int a,b,w;tot=0;
    for(int i=1;i<n;i++) 
    {
        scanf("%d%d%d",&a,&b,&w);
        add(a,b,w);
        add(b,a,w);
    }
}
void  get_root(int u,int fa,int size)//poj 1695 实现的功能 找重心
{
    int mx=-1;
    son[u]=1;
    for(int i=head[u],to;i!=-1;i=edge[i].next)
    {
        to=edge[i].v;
        if(used[to] || to==fa) continue;
        get_root(to,u,size);
        son[u]+=son[to];
        if(son[to]>mx) mx=son[to];
    }
    if(size-son[u]>mx) mx=size-son[u];
    if(mx<Max) Max=mx,root=u; 
}
void get_dis(int u,int len,int fa)
{
    d[++cnt]=len;
    for(int i=head[u],to;i!=-1;i=edge[i].next)
    {
       to=edge[i].v;
       if(used[to] || to==fa) continue;
       get_dis(to,len+edge[i].w,u);
    }
}
int calc(int u,int len)//nlog(n)
{
    cnt=0;
    int sum=0;
    get_dis(u,len,-1);
    sort(d+1,d+cnt+1);
    for(int i=1,j=cnt;i<=j;i++)
    {
        while(d[i]+d[j]>m && i<=j) j--;
        if(i<j) sum+=j-i;
    }
    return sum;
}
int find_root(int u)
{
    Max=son[u];
    get_root(u,0,Max);
    return root;
}
void solve(int u)//可以证明搜索树的深度上界为log(n)
{
    u=find_root(u);
    ans[u]=calc(u,0);
    used[u]=true;
    for(int i=head[u],to;i!=-1;i=edge[i].next)
    {
        to=edge[i].v;
        if(used[to]) continue;
        ans[u]-=calc(to,edge[i].w);
        solve(to);
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF && n)
    {
        init();
        son[1]=n;
        solve(1);
        int res=0;
        for(int i=1;i<=n;i++) res+=ans[i];
        printf("%d\n",res);
    }
    return 0;
}

 

 

poj 2378

View Code 
#include<cstdio>
#include<vector>
#include<cstring>
using namespace std;
const int maxn = 10010;
vector<int> edge[maxn];
int sum[maxn],ans[maxn],n;
void dfs(int u,int fa){
     sum[u]=1;
     int i,j; 
     bool flag=true;
     for(i=0;i<edge[u].size();i++){
         int to=edge[u][i];
         if(to==fa) continue ;
         dfs(to,u);
         if(sum[to]>n/2) flag=false;
         sum[u]+=sum[to];
     }
     if(flag&&n-sum[u]<=n/2) ans[u]=true;
}
int main(){
    int i,a,b;
    while(scanf("%d",&n)!=EOF){
        memset(ans,0,sizeof(ans));
        for(i=0;i<=n;i++) edge[i].clear();
        for(i=0;i<n-1;i++){
            scanf("%d%d",&a,&b);
            edge[a].push_back(b);
            edge[b].push_back(a);
        }
        dfs(1,0);
        for(i=1;i<=n;i++){
            if(ans[i])
                printf("%d\n",i);
        }
        puts("");
    }
    return 0;
}

 

 二分+树形DP+状态压缩 http://www.bnuoj.com/bnuoj/problem_show.php?pid=17189

View Code 
/*

给出一棵树，每个节点都有一个质量，一种颜色，
总共有7种颜色，每条边都有一个花费v，砍断一条边可以获得该子树所有的节点
但是要花费v的能量，总能量为tot
最后问你在收集满所有的颜色种类的前提下
能获得的最大的质量的果子是多少（所有获得的果子中最小的质量）
二分答案，判断通过质量大于等于mid的所有节点能否完成目标
dp[i][j]表示i子树颜色状态为j时的最小花费
sum[i]表示i子树总的颜色状态
*/

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int inf = 0x3f3f3f3f;
const int M = 110;
int dp[M][(1<<7)+1];
int sum[M],col[M],cut[M],qual[M];
vector<int> edge[M];
void Min(int &a,int b){
    if(b<a) a=b;
}
void dfs(int u,int fa,int mid)
{
    memset(dp[u],0x3f,sizeof(dp[u]));
    dp[u][0]=0;sum[u]=0;
    for(int i=0;i<edge[u].size();i++)
    {
        int v=edge[u][i];
        if(v==fa) continue;
        dfs(v,u,mid);
        sum[u]|=sum[v];
        for(int j=0;j<(1<<7);j++)
        {
            if(dp[u][j]==inf) continue;
            for(int k=0;k<(1<<7);k++)
                Min(dp[u][j|k],dp[u][j]+dp[v][k]);
        }
    }
    if(qual[u]>=mid) sum[u]|=(1<<col[u]);//如果u的质量符合要求，把该颜色并入sum【u】
    Min(dp[u][sum[u]],cut[u]);//一刀砍断，只需要一条边的花费，看是否能更新相应的状态，这里把边转换为了点权
}
int get(char s){
    if(s=='R') return 0;
    if(s=='G') return 1;
    if(s=='B') return 2;
    if(s=='I') return 3;
    if(s=='V') return 4;
    if(s=='Y') return 5;
    if(s=='O') return 6;
}
int main()
{
    int t,i,j,k,n,tot,fa;
    char s[10];
    scanf("%d",&t);
    while(t--)
    {
        for(i=0;i<=n;i++) edge[i].clear();
        scanf("%d%d",&n,&tot);
        for(i=1;i<=n;i++)
        {
            scanf("%s%d%d%d",s,&qual[i],&fa,&cut[i]);
            col[i]=get(s[0]);
            edge[fa].push_back(i);
            edge[i].push_back(fa);
        }cut[0]=inf;
        int l=1,r=1000,mid;
        int best=-1;
        while(l<=r)
        {
            mid=(l+r)>>1;
            dfs(0,-1,mid);
            if(dp[0][(1<<7)-1]<=tot) 
            {
                best=mid;
                l=mid+1;
            }
            else r=mid-1;
        }
        if(best==-1) printf("Stay hungry\n");
        else printf("%d\n",best);
    }
    return 0;
}

 

 zoj 3527 带环的树形DP

View Code 
/*
很好的树形DP，破环为树；
这道题目很特殊，看到的时候根本无从下手，因为以前没接触过这种类型的树形DP，网上搜了一下发现自己简直弱爆了。。
这是一类最简单的树形DP，考虑某个节点选或不选，然后把两种状态从叶子向根更新上去即可，
但是这道题中给你的不是一棵树，是图，特殊的图
每个点都只有一个父亲（或一个儿子），所以形成的环是简单环，所以可以考虑破环，
从环上的一个点出发开始DP，这个点的两种状态（选或不选）分别枚举一下
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long lld;
const lld inf = (lld)1<<50;
const int M = 100010;
int w[M];
int n;
int head[M],nxt[M],pnt[M],wi[M],p[M];
int E;
lld dp[M][2];
void add(int a,int b,int w)
{
    pnt[E]=b;
    wi[E]=w;
    nxt[E]=head[a];
    head[a]=E++;
}
void dfs(int u,int F)
{
    dp[u][0]=0;
    dp[u][1]=w[u];
    for(int i=head[u];i!=-1;i=nxt[i])
    {
        if(pnt[i]!=F)
            dfs(pnt[i],F);
        dp[u][0]+=max(dp[pnt[i]][0],dp[pnt[i]][1]);
        dp[u][1]+=max(dp[pnt[i]][0],dp[pnt[i]][1]+wi[i]);
    }
}
lld solve(int u)
{
    dp[u][0]=0;
    dp[u][1]=-inf;//不选u，这个状态不合法
    lld ans1=0,ans2=0;
    for(int i=head[u];i!=-1;i=nxt[i])
    {
        dfs(pnt[i],u);
        ans1+=max(dp[pnt[i]][0],dp[pnt[i]][1]);
    }
    dp[u][0]=-inf;//选u，这个状态不合法
    dp[u][1]=w[u];
    for(int i=head[u];i!=-1;i=nxt[i])
    {
        dfs(pnt[i],u);
        ans2+=max(dp[pnt[i]][0],dp[pnt[i]][1]+wi[i]);
    }
    return max(ans1,ans2);
}
int vis[M];
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        E=0;
        fill(head,head+n+1,-1);
        fill(p,p+n+1,-1);
        for(int i=1,j;i<=n;i++)
        {
            scanf("%d%d%d",&w[i],&j,&p[i]);
            add(p[i],i,j);
        }
        fill(vis,vis+n+1,-1);
        lld ans=0;
        for(int i=1,j;i<=n;i++)
        {
             if(vis[i]!=-1) continue;
             for(j=i;vis[j]==-1;j=p[j])
                 vis[j]=i;
             if(vis[j]==i) ans+=solve(j);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

 

 

 

haha593572013
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
概率dp 树形dp经典题目加解析
04-28
概率dp 树形dp经典题目加解析........高斯求期望...............
面试中所有二叉树题目总结（java版）
etdeng的专栏
11-29 886
package BinaryTreeSummary; import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Stack;
关于树的一些算法
码迹天涯的专栏
08-30 384
阿里笔试，第二题，在一棵树中找出两个节点，他们的最大值为
笔试题中有关树的问题汇总
hsd2012的专栏
09-04 3356
树的基本概念 树（Tree）是一种简单的非线性结构。所有数据元素之间有明显的层次特性。 常用名词 根节点：没有父节点的节点。 叶子节点：没有子节点的节点。 节点的度：一个节点所拥有的后件个数称为该节点的读。 树的度：所有节点中最大的度。 树的深度：树的最大层次。 二叉树 概念 二叉树是一种每一个节点最多有两颗子树的树。 特性 1.在二叉树的第k层，最多有2^(k
数据结构——树的遍历相关笔试题
Su_coding的博客
04-16 2303
一颗二叉树的先序遍历：ABDECFG；中序遍历：DBEAFCG；后序遍历：DEBFGCA。对于二叉树的遍历在之前的博客中有介绍： http://blog.csdn.net/Su_coding/article/details/701844191.根据先序和中序遍历写出后序遍历：思路： 根据先序遍历可知根节点为A； 根据中序遍历可知DBE为A的左子树，FCG为A的右子树； 递归实现，把DBE当作一颗新
二叉树常见问题整理
yy254117440的博客
11-22 4584
做leetcode二叉树的题目做了不少，觉得有必要总结一下。因为题型多归多，但其实无非就是dfs和bfs，总结一些常见的解法，对于加深这两周算法的理解很有帮助。 在做dfs的时候，主要思路是可以从上到下也可以从下到上，也就是分析每一个子树的根节点，然后分析该子树的内部子树或者外部子树的根节点，以此得出递归关系，也即是分治的思想。同时，对于每个节点的处理尝试利用前序、后序、中序遍历三种方法。 做b
树形DP（动态规划）.pptx
01-12
树形DP.pptx
树形DP浅略总结
05-13
NOIP 提高2_树形DP
10-30
NOIP 提高2_树形DP
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
通信原理期末考试试题及答案2份.doc
04-18
通信原理期末考试试题及答案2份.doc
Skeleton-Low Poly 低多边形骨架模型Unity插件美术资源包unitypackage
04-18
Skeleton-Low Poly 低多边形骨架模型Unity插件美术资源包unitypackage 支持Unity版本2019.4.29或更高 直接的低多边形骨架。 特点： - 低多边形（9k tris，8.5） - 适用于 Unity 5 及更高 版本 - 完全装配 - 包括一个 fbx 格式的模型 - PBR 纹理 - 高清纹理
基于ssm+vue学生学籍管理系统源码数据库文档.zip
04-18
基于ssm+vue学生学籍管理系统源码数据库文档.zip
工作汇报 年终总结45.pptx
04-18
引言 年度工作回顾 系统进展与亮点 技术创新与应用 市场反馈与用户评价 存在问题与挑战 未来展望与计划 结束语与感谢 一、引言 简要介绍智能家居系统的重要性和发展趋势 回顾本年度的工作目标和重点 二、年度工作回顾 系统建设与维护 完成的项目与里程碑 系统稳定性与可靠性提升 团队建设与培训 团队成员构成与职责 培训与技能提升活动 合作伙伴与资源整合 与供应商、合作伙伴的合作情况 资源整合与利用 三、系统进展与亮点 功能扩展与优化 新增功能介绍与效果评估 现有功能的优化与改进 用户体验提升 界面设计与交互优化 用户反馈与改进措施 四、技术创新与应用 物联网技术的应用 传感器与通信技术的升级 大数据分析与应用 智能家居的智能化管理 自动化控制与节能策略 安全防护与预警系统 五、市场反馈与用户评价 市场反馈分析 市场需求与竞争态势 市场占有率与增长趋势 用户评价总结 用户满意度调查结果
2024年带式输送机市场分析报告.pptx
04-18
行业分析报告
JSP-SSM健身俱乐部客户关系管理系统可升级SpringBoot源码.7z
最新发布
04-18
前台框架基于Bootstrap这一HTML5响应式框架，能够自适应不同终端设备的屏幕大小，为用户提供良好的浏览体验。开发环境兼容myEclipse、Eclipse、Idea等多种工具，配合mysql数据库，实现数据的存储与管理。后台则采用SSM（SpringMVC + Spring + Mybatis）框架，保证系统的稳定与高效运行。 系统主要包括会员信息管理、员工信息管理、设备信息管理以及退出模块。会员信息管理模块详细记录了会员的基本信息、健身目标、消费记录以及健身习惯等，同时设有会员投诉管理模块，用于收集和处理会员的意见与建议。员工信息管理模块则涵盖了员工的基本信息、工资发放情况等，帮助俱乐部进行人事管理。设备信息管理模块则负责建立器械档案，跟踪维修情况，并合理安排器械摆放位置，以延长器械使用寿命。 数据库设计方面，会员表记录了会员的各项基本信息，包括姓名、性别、职业等；部门表与员工表则分别用于记录俱乐部的组织机构和员工信息；会员消费表记录了会员的消费详情；员工工资表则用于记录员工的工资发放情况；留言表用于收集会员的留言及回复；设备类别表与设备表则详细记录了会所内器械的分类与具
工作汇报 年终总结5.pptx
04-18
引言 年度工作回顾 系统进展与亮点 技术创新与应用 市场反馈与用户评价 存在问题与挑战 未来展望与计划 结束语与感谢 一、引言 简要介绍智能家居系统的重要性和发展趋势 回顾本年度的工作目标和重点 二、年度工作回顾 系统建设与维护 完成的项目与里程碑 系统稳定性与可靠性提升 团队建设与培训 团队成员构成与职责 培训与技能提升活动 合作伙伴与资源整合 与供应商、合作伙伴的合作情况 资源整合与利用 三、系统进展与亮点 功能扩展与优化 新增功能介绍与效果评估 现有功能的优化与改进 用户体验提升 界面设计与交互优化 用户反馈与改进措施 四、技术创新与应用 物联网技术的应用 传感器与通信技术的升级 大数据分析与应用 智能家居的智能化管理 自动化控制与节能策略 安全防护与预警系统 五、市场反馈与用户评价 市场反馈分析 市场需求与竞争态势 市场占有率与增长趋势 用户评价总结 用户满意度调查结果
2024年实木指接板行业分析报告.pptx
04-18
行业分析报告
基于Java的高校教师绩效考核系统的设计与实现【附源码】.zip
04-18
基于Java的高校教师绩效考核系统的设计与实现【附源码】.zip
python树形dp
04-08
树形动态规划（Tree DP）是一种常用的动态规划算法，用于解决树结构相关的问题。在Python中，可以使用递归或者迭代的方式实现树形DP。 树形DP的基本思想是，从树的叶子节点开始，逐层向上计算每个节点的状态，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值