图论/最小支配集

听大师们说。。。普通无向图最小支配集。。甚至二分图的最小支配集求解都是NP难度的。。。不过树形结构比较好求解，这个嘛，原因很简单啦，树本身是递归结构，比较容易dp嘛~

pku3659:

裸的，求树的最小支配集。令：

dp[u][0] = 以u为根，且在节点u放个发射塔所需要的最少发射塔总数。

dp[u][1] = u靠父节点覆盖。。。。

dp[u][2] = u靠子节点覆盖。。。。

则dp[u][0] = sigma{min{dp[v][0], min(dp[v][1], dp[v][2])}}+1,

dp[u][1] = sigma{min{dp[v][0], dp[v][1]}},

如果u的某个子节点dp[v][0]<=dp[v][2]，

则dp[u][2] = sigma{min{dp[v][0], dp[v][1]}},

否则：dp[u][2] = min{dp[v'][0]+sigma{dp[v][2]} (v != v')}

注意输出结果是:min{dp[1][0],dp[1][2]}，不是min(dp[1][0], min(dp[1][1], dp[1][2]))，原因比较显然吧，不过确实需要注意，偶一开始就在这WA了一次。

View Code

#include <iostream>
#include <cstdio>
#include <cstring>
usingnamespace std;

constint N =10100;

int n, tot, h[N], v[N<<1], nxt[N<<1], dp[N][3];

void add(int a, int b)
{
    v[tot] = b;
    nxt[tot] = h[a];
    h[a] = tot++;
}

void dpDfs(int pre, int u)
{
int i, sum;
bool flag =false;
    dp[u][0] = dp[u][1] = dp[u][2] = N;
for(i = h[u]; i !=-1; i = nxt[i])
    {
if(v[i] == pre)  continue;
        dpDfs(u, v[i]);
if(dp[v[i]][0] <= dp[v[i]][2])  flag =true;
    }
    sum =0;
for(i = h[u]; i !=-1; i = nxt[i])
    {
if(v[i] == pre)  continue;
        sum += min(dp[v[i]][0], min(dp[v[i]][1], dp[v[i]][2]));
    }
    dp[u][0] = sum+1;

    sum =0;
for(i = h[u]; i !=-1; i = nxt[i])
    {
if(v[i] == pre)  continue;
        sum += min(dp[v[i]][0], dp[v[i]][2]);
    }
    dp[u][1] = sum;

if(flag)  dp[u][2] = sum;
else
    {
        sum =0;
for(i = h[u]; i !=-1; i = nxt[i])
        {
if(v[i] == pre)  continue;
            sum += dp[v[i]][2];
        }
for(i = h[u]; i !=-1; i = nxt[i])
        {
if(v[i] == pre)  continue;
            dp[u][2] = min(dp[u][2], sum-dp[v[i]][2]+dp[v[i]][0]);
        }
    }
}

int main()
{
int i, a, b;
    scanf("%d", &n);
    tot =0;
    memset(h, -1, sizeof(h));
for(i =1; i < n; i++)
    {
        scanf("%d%d", &a, &b);
        add(a, b);
        add(b, a);
    }
    dpDfs(-1, 1);
    printf("%d\n", min(dp[1][0], dp[1][2]));
return0;
}

　　

 

 

 

 

 

转载于:https://www.cnblogs.com/zxndgv/archive/2011/08/15/2139681.html