动态规划--树型dp

1. 树的最长路径

在这里插入图片描述

定义:树中两个点直接的最远距离称为树的直径

先说一个结论
先任意找到一个树中一个点u,找到距离u最远的一个点v,那么v一定是树的直径(树的直径不唯一)的一个端点。

将树的直径的集合转换为且以某个顶点为一条路径的最高点的集合。
那么就可以枚举每个顶点,当前顶点为路径的最高一个顶点,路径只能往下面延伸。这样。最长路径一定会在这个集合里面。

//要找到一条路径,使得使得路径两端的点的距离最远。
//枚举所有根节点,找到当前根节点的所有子树里面最长的和第二长的路径。
//使用dfs,第一得出推导式。第二从最底层开始看看行不行,如果可以,再看看倒数第二层,如果可以,那么就可以。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;



const int N=10010,INF=0x3f3f3f3f;
int head[N*2];
int e[N*2];
int ne[N*2];
int w[N*2];
int f[N][2];
int idx;
int n;
int res=0;

void add(int a,int b,int c)
{
    e[idx]=b;
    ne[idx]=head[a];
    w[idx]=c;   //w[a]==w[b]==w[a,b];
    head[a]=idx++;
}

void dfs(int u,int father)
{
    //dfs先考虑边界条件,因为叶子节点向下没有边,所以为0
    //所以初始化为0
    f[u][1]=f[u][0]=0; //表示最长和次长的边都是0
    for(int i=head[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==father)continue;  //不能走回路
        dfs(j,u);
        if(f[j][1]+w[i]>=f[u][1])  //u的子树里面的最长边加上(u,j)这条边大于u的最长边,更新最大和次长边。
        {
            f[u][0]=f[u][1];
            f[u][1]=f[j][1]+w[i];
        }
        else if(f[j][1]+w[i]>f[u][0])  //否则更新次长边
        {
            f[u][0]=f[j][1]+w[i];
        }
    }
    res=max(res,f[u][1]+f[u][0]);  //更新最大值。
}

int main()
{
    cin>>n;
    memset(head,-1,sizeof head);
    for(int i=0;i<n-1;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    dfs(1,-1);
    cout<<res<<endl;
    return 0;
}

2.树的中点.

在这里插入图片描述

任意一个点u,它有两种情况,要么以u为起点向下延伸找到最长距离,要么往上面延伸找到最长距离。
往下面找很简单。关键是往上面找,那么就需要先dfs找一下每个顶点的最长路径和次长路径。然后再一次dfs来求出每个顶点往上面(父节点)搜索的最长路径。
最后每个顶点比较一下往上面和往下面搜索的最长距离。最终找到最长距离的最小值

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=10010,M=N*2,INF=0x3f3f3f3f;

int head[N];
int e[M];
int ne[M];
int idx;
int w[M];
int n;
int d1[N],d2[N],up[N];
int s[N];


void add(int a,int b,int c)
{
    e[idx]=b;
    ne[idx]=head[a];
    w[idx]=c;
    head[a]=idx++;
}
void dfs(int u,int father)
{
    d1[u]=d2[u]=-INF;
    for(int i=head[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==father)
            continue;
        dfs(j,u);
        if(d1[j]+w[i]>=d1[u])
        {
            d2[u]=d1[u];
            d1[u]=d1[j]+w[i];
            s[u]=j;  //点u地最长地子树地第一个节点是j
        }
        else if(d1[j]+w[i]>d2[u])
        {
            d2[u]=d1[j]+w[i];
        }
    }
    
    if(d1[u]==-INF)
    {
        d1[u]=d2[u]=0;
    }
}


void dfs_1(int u,int father)
{
    for(int i=head[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j==father)continue;
        if(j==s[u])  //那么j不能走,只能走右边
        {
            up[j]=max(up[u],d2[u])+w[i];
        }
        else
        {
            up[j]=max(up[u],d1[u])+w[i];
        }
        dfs_1(j,u);
    }
}

int main()
{
    cin>>n;
    memset(head,-1,sizeof head);
    for(int i=0;i<n-1;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    //先找每个节点往下面的最长距离和次长距离
    dfs(1,-1);
    dfs_1(1,-1);
    
    int res=INF;
    for(int i=1;i<=n;i++)
    {
        res=min(res,max(d1[i],up[i]));
    }
    cout<<res;
    return 0;
    
}

由于第三题需要用到一些数学地知识,所以先去补一补数学知识。连接链接在这里

4.二叉苹果树

先去看有依赖的背包问题(模板题)

在这里插入图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=110,INF=0x3f3f3f3f;
int head[N],e[N*2],ne[N*2],w[N*2];
int idx;
int n,m;
int f[N][N];

void add(int a,int b,int c)
{
    e[idx]=b;
    ne[idx]=head[a];
    w[idx]=c;
    head[a]=idx++;
}

void dfs(int u,int father)   //表示以u为根节点,找到体积为j的最大价值
{
    for(int i=head[u];i!=-1;i=ne[i])  //枚举物品组
    {
        int son=e[i];
        if(son==father)continue;
        dfs(son,u);   //找到当前节点子树的各个体积的最大价值
        for(int j=m;j>=0;j--)  //枚举体积
        {
            for(int k=0;k<j;k++)   //决策,也就是看给当前子树分配多少空间可以使得以u为根节点总价值最大
            {
                f[u][j]=max(f[u][j],f[son][k]+w[i]+f[u][j-k-1]);   //父亲节点一定要选,所以孩子节点的体积最大只能选j-1
            }
        }
        
    }
}
int main()
{
    cin>>n>>m;
    memset(head,-1,sizeof head);
    for(int i=0;i<n-1;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
        add(b,a,c);
    }
    
    dfs(1,-1);
    cout<<f[1][m]<<endl;
    return 0;
}

5.战略游戏

在这里插入图片描述

本题思路:可以先去看“没有上司的舞会”一题。树形dp+状态机

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int N=1510,M=N*2;

int head[N],e[M],ne[M],w[M];
int idx;
int n;
int f[N][2];   //f[i][0]表示i为根节点的子树且i不选的最小摆放士兵
bool st[N];  //找父节点

void add(int a,int b)
{
    e[idx]=b;
    ne[idx]=head[a];
    head[a]=idx++;
}

void dfs(int u)   //有像图,不用father节点
{
    //考虑最底层的dfs,叶子节点.
    f[u][1]=1,f[u][0]=0;
    for(int i=head[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        dfs(j);
        f[u][0]+=f[j][1];
        f[u][1]+=min(f[j][0],f[j][1]);
    }
    
}

int main()
{
    while(scanf("%d",&n)!=-1)
    {
        memset(head,-1,sizeof head);
        memset(st,0,sizeof st);
        idx=0;
        for(int i=0;i<n;i++)
        {
            int id,cnt;
            scanf("%d:(%d)",&id,&cnt);
             while (cnt -- )    //当前节点的子节点
             {
                int ver;
                scanf("%d", &ver);
                add(id, ver);
                st[ver] = true; // ver 有父节点
            }
            
        }
         //找根节点
        int root=0;
        while(st[root])   //由于节点编号是0-n-1,所以从0开始找,0不一定是根节点,要注意
        {
            root++;
        }
        dfs(root);
        int res=min(f[root][0],f[root][1]);
        cout<<res<<endl;
    }
}

6.皇宫守卫

在这里插入图片描述

#include <iostream>
#include <cstring>
using namespace std;

/*
以下注释为早期笔记,希望对你有所帮助

状态机 + 树形Dp问题
状态表示:
    f(i, 0):第i号结点被他的父结点安排的守卫看住的方案数
    f(i, 1):第i号结点被他的子结点安排的守卫看住的方案数
    f(i, 2):第i号结点自己安排守卫看住的方案数
状态计算:(j是i的子结点)
    f(i, 0) = sum{min(f(j,1), f(j,2))}
        i是被他父结点看住的,那他的子结点要么自己看自己,要么被自己的子结点看住
    f(i, 1) = min{w(k) + f(k, 2) - sum{min(f(j,1), f(j,2))}}
        i如果是被子结点看住的,那么就要枚举他是被哪个子结点看住的所有方案,对所有方案求最小值
        这里的sum不包括j==k的情况,因此需要手动额外减去
    f(i, 2) = sum{min(f(j,0), f(j,1), f(j,2))} + w(u)
        i是被自己看住的,那他的子结点可以被父结点看住,可以自己看自己,也可以被自己的子结点看住
*/
const int N = 1510;
int n;
int h[N], w[N], e[N], ne[N], idx;
int f[N][3];
bool st[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void dfs(int u) {
    f[u][0] = 0;
    f[u][1] = 1e9; //f[u][1]求最小值,初始化为最大值
    f[u][2] = w[u];//初始化放置自己的代价
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        dfs(j);
        f[u][0] += min(f[j][1], f[j][2]);
        f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
    }
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        //f[u][0]中记录了sum{min(f(j,1), f(j,2))},再从中减去对应的贡献即可得到remain ver
        f[u][1] = min(f[u][1], f[u][0] + f[j][2] - min(f[j][1], f[j][2]));
    }
}
int main() {
    memset(h, -1, sizeof h);
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        int id, cnt, cost;
        cin >> id >> cost >> cnt;
        w[id] = cost;
        while (cnt--) {
            int ver;
            cin >> ver;
            add(id, ver);
            st[ver] = true;
        }
    }
    int root = 1;
    while (st[root]) ++root;
    dfs(root);
    printf("%d\n", min(f[root][1], f[root][2]));
    return 0;
}


  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值