UVA 10859 Placing Lampposts

题目大意：有一个无向无环图，有n个节点，m条边，可以再某些节点上放一个路灯，它可以照亮连接它的所有边，问你要把所有的边照亮，最少需要放几个路灯，再放路灯数最小的前提下，同时被两个路灯照亮的路径数最多。

思路：首先，要确定这是一个森林，我先开始就没想到这一点，认为它不是一棵树，然后就没有往树形DP上去想，囧。。

可是后面看了一下书，知道是森林了，也发现很难写，因为它有两个量要考虑。后来在看书，书上说了一个很好的考虑方法：要使放灯数a最小，且被两个路灯同时照亮的边数最多，那么我们可以考虑再a最小的时，同时满足只被一个路灯照亮的路径数最小。一般来说，如果有两个需要优化变量v1、v2，首先满足v1最小，在v1相同的情况下满足v2最小，那么可以把两个数组和成一个数x = M*v1+v2。M是一个很大的数，比“v2的最大理论值和v2的最小理论值之差”要大的数，这样，只要两个解的v1不同，则不管v2相差多少，都是v1起到决定性作用，只有当v1相同时才会看v2。那么x确定了之后，v1 = x/M，v2 = x%M。同时M也不宜取得过大，过大可能会造成溢出。这道题，我是按照书上的M的，M = 2000 。

然后就是树形DP了，设d[ i ][ j ]表示以i位根节点的子树，i节点的放灯状态为j（j=0表示不放，j=1表示放）的x的最小值（包括i与其父节点的边）。如果i节点不放灯，即j = 0，那么子节点必须有灯，d[ i ][ 0 ] = sum{d[ v ][ 1 ]}；如果i节点放灯，即j = 1，那么子节点可以放也可以不放，如果i不为树根节点，则初始值为M+1，如果是，则为M，状态转移时，d[ i ][ 1 ] = sum{min(d[ v ][ 0 ]+1,d[ v ][ 1 ]-1)}。

好了，具体看代码把，代码如下：

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

const int MAXN = 1111;

const int M = 2000;

struct Edge
{
    int t,next;
}edge[MAXN<<1];

int head[MAXN],tot;

void add_edge(int s,int t)
{
    edge[tot].t=t;
    edge[tot].next = head[s];
    head[s] = tot++;
}

int d[MAXN][2];

int vis[MAXN];

void dfs(int u,int root)
{
    //printf("u = %d,root = %d\n",u,root);
    vis[u]=1;
    d[u][0]=0;
    if(u!=root) d[u][1] = M+1;
    else d[u][1] =M;
    for(int e = head[u];e!=-1;e =edge[e].next)
    {
        int v = edge[e].t;
        if(vis[v]) continue;
        dfs(v,root);
        d[u][0] += d[v][1];
        if(d[v][0]+1>d[v][1]-1)
        {
            d[u][1] += d[v][1]-1;
        }
        else d[u][1] += d[v][0]+1;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        tot=0;
        memset(head,-1,sizeof(head));
        int a,b;
        int edge_tot=0;
        for(int i =0;i<m;i++)
        {
            scanf("%d%d",&a,&b);
            add_edge(a,b);
            add_edge(b,a);
            edge_tot++;
        }
        memset(vis,0,sizeof(vis));
        int ans1 = 0,ans2 =0;
        for(int i = 0;i<n;i++)
            if(!vis[i])
            {
                dfs(i,i);
                int tmp = min(d[i][0],d[i][1]);
                ans1 += tmp/M;
                ans2 += tmp%M;
            }
        printf("%d %d %d\n",ans1,edge_tot-ans2,ans2);
    }
    return 0;
}

上面那个是我看了一点书之后，自己写的，A了之后又看了下书，发现书上的状态和我定义的不太一样，它的d[ i ][ j ] 表示以i为根的子树，它的父亲节点的放灯状态为j的最小x值（包括它与它父亲节点的边）。也是分两种情况考虑：（1）i节点不放灯，那么它的父亲节点必须放灯，也就是j=1，d[ i ][ 1 ] = sum{d[ v ][ 0 ]}，如果i不是树根节点，那么还要+1；（2）i节点放灯，那么它的父亲节点可以放也可以不放，d[ i ][ 0 ] = sum{d[ v ][ 1 ]}，如果i不是父亲节点，那么要+M+1，如果是，要+M。最后的d[ i ][ 0 ]和d[ i ][ 1 ]，是两种情况分别对应的值的较小值。

具体代码如下：

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

const int INF = 0x0fffffff ;

const int MAXN = 1111;

const int M = 2000;

struct Edge
{
    int t,next;
}edge[MAXN<<1];

int head[MAXN],tot;

void add_edge(int s,int t)
{
    edge[tot].t=t;
    edge[tot].next = head[s];
    head[s] = tot++;
}

int d[MAXN][2];

int vis[MAXN];

void dfs(int u,int root)
{
    vis[u]=1;
    int a0 = INF,a1 = 1;
    if(u==root) a1 = 0;
    int b0 = M+1,b1 = M;
    if(u==root) b0 = M;
    for(int e = head[u];e!=-1;e =edge[e].next)
    {
        int v = edge[e].t;
        if(vis[v]) continue;
        dfs(v,root);
        a1 += d[v][0];
        b0 += d[v][1];
        b1 += d[v][1];
    }
    d[u][0] = min(a0,b0);
    d[u][1] = min(a1,b1);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        tot=0;
        memset(head,-1,sizeof(head));
        int a,b;
        int edge_tot=0;
        for(int i =0;i<m;i++)
        {
            scanf("%d%d",&a,&b);
            add_edge(a,b);
            add_edge(b,a);
            edge_tot++;
        }
        memset(vis,0,sizeof(vis));
        int ans1 = 0,ans2 =0;
        for(int i = 0;i<n;i++)
            if(!vis[i])
            {
                dfs(i,i);
                int tmp = min(d[i][0],d[i][1]);
                ans1 += tmp/M;
                ans2 += tmp%M;
            }
        printf("%d %d %d\n",ans1,edge_tot-ans2,ans2);
    }
    return 0;
}