BZOJ 1907 树的路径覆盖 - 树形DP/贪心

最新推荐文章于 2018-12-19 18:55:41 发布

x_1023

最新推荐文章于 2018-12-19 18:55:41 发布

阅读量380

点赞数 1

CC 4.0 BY-SA版权

分类专栏：贪心树形DP

本文链接：https://blog.youkuaiyun.com/x_1023/article/details/78242270

树形DP 同时被 2 个专栏收录

6 篇文章

订阅专栏

贪心

5 篇文章

订阅专栏

本文介绍了解决特定问题的两种算法实现方法——树形动态规划（DP）与贪心算法。通过树形DP，文章详细展示了如何通过递归方式最小化节点间的连接代价，并给出具体代码实例。此外，文章还提出了一种基于贪心策略的算法，用于快速解决类似问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

树形DP的做法显然：
对于任意一个节点，它可以连接两个节点，那么设0状态为不能再连接节点，1为还可以再连接一个节点，伸出一条手臂可以再搭上别的节点。
0/1状态初值均设为1。
那么合并子树的过程中有如下的转移方式：

1.父节点和子树相连，则两个状态必须都为1，由于连接即为路径的延长，相当于取消子节点那一条连接着的路径的独立性，合并到父节点路径上，则可以消除那一条子节点路径的代价。
2.父节点不和子树相连，则若父节点状态可为0/1，子节点也为0，分别相加即可。
3.父节点伸出的一条路径（还未连节点那条）被子节点伸出的路径取代，则为父节点的已连接的所有子节点的0值和当前子节点的1值相加。

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<algorithm>

using namespace std;

const int maxn=10005;

struct edge
{
    int to,next;
}e[maxn<<1];

int n,cnt,ans,T;
int head[maxn];
bool vst[maxn];
int dp[maxn][2];

void insert(int a,int b)
{
    e[++cnt].to=b;e[cnt].next=head[a];head[a]=cnt;
}
void dfs(int u,int fa)
{
    dp[u][0]=dp[u][1]=1;
    int sum=0;
    for(int i=head[u];i;i=e[i].next)if(e[i].to!=fa)
    {
        dfs(e[i].to,u);
        dp[u][0]=min(dp[u][0]+dp[e[i].to][0],dp[u][1]+dp[e[i].to][1]-1);
        dp[u][1]=min(dp[u][1]+dp[e[i].to][0],sum+dp[e[i].to][1]);
        sum+=dp[e[i].to][0];
    }
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        cnt=ans=0;
        memset(head+1,0,sizeof(int)*n);
        memset(vst+1,0,sizeof(bool)*n);
        for(int i=1,u,v;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            insert(u,v);
            insert(v,u);
        }
        dfs(1,-1);
        printf("%d\n",min(dp[1][0],dp[1][1]));
    }
}

贪心的话考虑这样一张图：
这里写图片描述

对于1节点，若顺着上边传下来的边直接连下去，连到1的子节点上，那么一定不会比1和内部子节点自己形成回路更优（如果可以形成）。直接连下来则消去一个代价(eg:2)，还剩两个代价(3,4)。若内部形成回路(eg:1,2,3)，消去两个代价，增加一个代价（1独立成路径消耗），对于子节点数量大于2的情况均如是。
（如下图）考虑到在子节点(3)能够自己形成独立集的情况，父节点(1)向子节点(3)连边，不会更优，且父节点消耗了一次向别的子节点(2)连边,反而可能更差。
这里写图片描述

因此总结贪心策略为：对于一个父节点，子节点能够自行形成独立集时则不向它连边，若不能形成独立集则向它连边。

每个节点初始代价为1，求答案相当于合并消除代价。
有一个父节点x，可以连边的子节点有num个。若子节点能形成独立集（即不能连边）则直接加子节点dp值；若不能形成独立集则考虑有多少这样的子节点：
若num>=2则意味x可以形成独立集，根据贪心策略必须形成一个关于x的独立集，dp-=2,
若num==1则意味x不能形成独立集，打一个标记，然后和唯一的子节点连成链消去一个代价，dp-=1。

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<algorithm>

using namespace std;

const int maxn=10005;

struct edge
{
    int to,next;
}e[maxn<<1];

int n,cnt,ans,T;
int head[maxn];
int dp[maxn];
bool have[maxn];

void insert(int a,int b)
{
    e[++cnt].to=b;e[cnt].next=head[a];head[a]=cnt;
}
void dfs(int u,int fa)
{
    dp[u]=1;have[u]=true;
    int num=0;
    for(int i=head[u];i;i=e[i].next)if(e[i].to!=fa)
    {
        dfs(e[i].to,u);
        dp[u]+=dp[e[i].to];
        if(have[e[i].to])num++; 
    }
    if(num==1)dp[u]-=1;
    else if(num>=2)dp[u]-=2,have[u]=false;
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        cnt=ans=0;
        memset(head+1,0,sizeof(int)*n);
        for(int i=1,u,v;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            insert(u,v);
            insert(v,u);
        }
        dfs(1,-1);
        printf("%d\n",dp[1]);
    }
}