hihocoder 1243 树形DP

hihocoder1243

描述

王先生抢走了MX班里的妹子。为了报复，MX决定炸毁王先生的城市。

城市可以看成是一棵n个结点的无根树。MX需要炸毁树上的每一条边，但是同一条边仅能被炸一次。

MX可选用的轰炸操作有两种：

1.选定两个结点u,v，并将从u到v的最短路径上的每一条边都炸毁。（如果路径上已经有被炸毁的边，则不能进行这次操作）

2.选定一个结点u，并将与u直接相连的每一条边都炸毁。（如果与u直接相连的已经有被炸毁的边，则不能进行这次操作）

请求出完成任务所需要的最少总操作次数。

简述就是通过最少的方式覆盖完所有的边，且边只能被覆盖一次~~

很明显的树形DP

dp[i][0/1]:=第i个点没有/有进行第二个操作，且全部覆盖了以i为根的子树的最少操作数

flag[i]:=第i个点没有进行第二个操作且孩子里面有flag[i]个没有进行第二个操作的数量

dp[i][0/1]:=第i个点没有/有进行第二个操作，且全部覆盖了以i为根的子树的最少操作数
flag[i]:=第i个点没有进行第二个操作且孩子里面有flag[i]个没有进行第二个操作的数量
如果flag[v]为奇数，那么u->v这条边可以合并到v的路径内~~~~
状态转移：
dp[u][1]=∑dp[v][0];
if(dp[v][1]<dp[v][0]+((flag[v]+1)%2))
    dp[u][0]+=dp[v][1];
else dp[u][0]+=dp[v][0]+((flag[v]+1)%2),flag[u]++;
dp[u][0]-=flag[u]/2;  //合并~~~  式子1

题解里面提到还应该对flag[v]奇偶性进行讨论，其实不用，显然dp[v][1]==dp[v][0]+((flag[v]+1)%2)的话取后者最优，因为可以合并，即减去flag[u]/2

那么到底应不应该分开讨论flag[v]的奇偶性，也不用，这个奇偶性只会对更新父亲的dp[u][0]有影响

那么还原dp[u][0]+=dp[v][0]-flag[v]/2+(flag[v]+1)%2;   注这里的dp[v][0]没有进行式子1

-flag[v]/2+(flag[v]+1)%2随着flag的增大变小，与奇偶性无关，所以只要确保flag[u]越来越大就好

#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for0(a,b) for(int a=0;a<=b;a++)//0---(b-1)
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
#define cnt_one(i) __builtin_popcount(i)
#define stl(c,itr) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c,__ll &d){READ(m);READ(a);READ(b);READ(c);read(d);}
template < class T > inline  void out(T a){if(a<0){putchar('-');a=-a;}if(a>9)out(a/10);putchar(a%10+'0');}
template < class T > inline  void outln(T a){out(a);puts("");}
template < class T > inline  void out(T a,T b){out(a);putchar(' ');out(b);}
template < class T > inline  void outln(T a,T b){out(a);putchar(' ');outln(b);}
template < class T > inline  void out(T a,T b,T c){out(a);putchar(' ');out(b);putchar(' ');out(c);}
template < class T > inline  void outln(T a,T b,T c){out(a);putchar(' ');outln(b);putchar(' ');outln(b);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int cnt_edge=200010;
const int cnt_v=100010;
int head[cnt_v],cnt_e;
struct EDGE{int u,v,next,cost;}edge[cnt_edge];
void addedge(int u,int v,int cost=0)
{edge[cnt_e].u=u;edge[cnt_e].v=v;edge[cnt_e].cost=cost;edge[cnt_e].next=head[u];head[u]=cnt_e++;}
void init(){cnt_e=0;memset(head,-1,sizeof(head));}
#define erg(i,u) for(int i=head[u];i!=-1;i=edge[i].next)

int n;
int dp[cnt_v][2];
int flag[cnt_v];
//dp[i][0]:=点i没有爆炸没有爆炸
//dp[i][1]:=点i爆炸了~~
//flag[i]:= 点i没有爆炸且孩子节点有flag[i]%2个没有爆炸~~

void dfs2(int u,int pre)
{
    int ccc=0;
    dp[u][0]=0;
    dp[u][1]=1;
    erg(i,u)
    {
        int v=edge[i].v;
        if(v==pre)continue;
        dfs2(v,u);
        dp[u][1]+=dp[v][0];
        if(dp[v][1]<dp[v][0]+((flag[v]+1)%2))
            dp[u][0]+=dp[v][1];
        else dp[u][0]+=dp[v][0]+((flag[v]+1)%2),flag[u]++;
    }
    dp[u][0]-=flag[u]/2;  //合并~~~
}
int main()
{
    init();
    read(n);
    for1(i,n-1)
    {
        int a,b;
        read(a,b);
        addedge(a,b);
        addedge(b,a);
    }
    dfs2(1,0);
    outln(min(dp[1][0],dp[1][1]));
}