poj 3659 Cell Phone Network——树形dp最少点覆盖所有点点支配集

火碳黑 — Mon, 11 Apr 2011 14:06:00 GMT

Cell Phone Network

Description

Farmer John has decided to give each of his cows a cell phone in hopes to encourage their social interaction. This, however, requires him to set up cell phone towers on his N (1 ≤ N ≤ 10,000) pastures (conveniently numbered 1..N) so they can all communicate.

Exactly N-1 pairs of pastures are adjacent, and for any two pastures A and B (1 ≤ A ≤ N; 1 ≤ B ≤ N; A ≠ B) there is a sequence of adjacent pastures such that A is the first pasture in the sequence and B is the last. Farmer John can only place cell phone towers in the pastures, and each tower has enough range to provide service to the pasture it is on and all pastures adjacent to the pasture with the cell tower.

Help him determine the minimum number of towers he must install to provide cell phone service to each pasture.

Input

* Line 1: A single integer: N
* Lines 2..N: Each line specifies a pair of adjacent pastures with two space-separated integers: A and B

Output

* Line 1: A single integer indicating the minimum number of towers to install

Sample Input

Sample Output

题意：农民的n个地方需要建电话亭，A有电话，则A相邻的点可以要电话亭也可以不需要电话亭。
分析：最少点覆盖。
分三种情况：
dp[u][0]u建个亭
dp[u][1]u不建亭，不依赖父节点，但u的孩子必须有一个有亭
dp[u][2]u不建亭，依赖于父节点（只要父节点能建个亭）。
代码：

#include <stdio.h>
#include <stdlib.h>
#define inf (1 << 29)
#define Min(a, b) (a) < (b) ? (a) : (b)
#define maxn 21000
struct T
{
    int v, next;
}fn[maxn];
int th;
int g[maxn], dp[maxn][3], degree[maxn];
void add(int u, int v)
{
    fn[th].v = v, fn[th].next = g[u], g[u] = th++;
}
void dfs(int u, int f)
{
    if (u != 1 && degree[u] == 1)
    {
        dp[u][0] = 1;
        dp[u][1] = inf;
        dp[u][2] = 0;
        return;
    }
    dp[u][0] = 1;
    int i, v, sign, min, del;
    for (i = g[u], sign = 0, min = inf; i != -1; i = fn[i].next)
    {
         v = fn[i].v;
        if (v == f)
        {
            continue;
        }
        dfs(v, u);
        //如果取u，则孩子v取MIN(的可取[v被自己覆盖]，依赖孩子的孩子[表示v不用已经被覆盖，不依赖u]，依赖父节点u[因为父节点现在取了])
        dp[u][0] += Min(Min(dp[v][0], dp[v][1]), dp[v][2]);
        if (dp[v][0] <= dp[v][1])//u不取也不依赖于父节点，则u依赖于孩子，保证一个孩子被取。
        {
            dp[u][1] += dp[v][0];
            sign = 1;//选了一个有电话的，标志1
        }
        else//选了一个孩子没电话的，要保存min，如果sign没标志过，就得利用有电话的最小值得那个人。
        {
            dp[u][1] += dp[v][1];
            if (min > dp[v][0])
            {
                min = dp[v][0];
                del = dp[v][1];
            }
        }
        dp[u][2] += Min(dp[v][0], dp[v][1]);//u不取，则u依赖于父节点，则取v不依赖与u的最优情况
    }
    if (!sign)
    {
        dp[u][1] += min - del;
    }
}
int main()
{
    int n, u, v, i, j;
    while (scanf("%d", &n) - EOF)
    {
        th = 0;
        for (i = 0; i <= n; i++)
        {
            degree[i] = 0;
            g[i] = -1;
            dp[i][0] = dp[i][1] = dp[i][2] = 0;
        }
        for (i = 1; i < n; i++)
        {
            scanf("%d%d", &u, &v);
            add(u, v);
            add(v, u);
            degree[u]++;
            degree[v]++;
        }
        if (n == 1)
        {
            printf("0\n");
            continue;
        }
        dfs(1, 0);
        printf("%d\n", Min(dp[1][0], dp[1][1]));
    }
    return 0;
}

火碳黑 2011-04-11 22:06 发表评论

Zoj 1134——Strategic Game最少点覆盖边

火碳黑 — Tue, 27 Apr 2010 15:05:00 GMT

Strategic Game

Time Limit: 10 Seconds Memory Limit: 32768 KB

Bob enjoys playing computer games, especially strategic games, but sometimes he cannot find the solution fast enough and then he is very sad. Now he has the following problem. He must defend a medieval city, the roads of which form a tree. He has to put the minimum number of soldiers on the nodes so that they can observe all the edges. Can you help him?

Your program should find the minimum number of soldiers that Bob has to put for a given tree.

The input file contains several data sets in text format. Each data set represents a tree with the following description:

the number of nodes
the description of each node in the following format
node_identifier:(number_of_roads) node_identifier1 node_identifier2 ... node_identifier
or
node_identifier:(0)

The node identifiers are integer numbers between 0 and n-1, for n nodes (0 < n <= 1500). Every edge appears only once in the input data.

For example for the tree:

the solution is one soldier ( at the node 1).

The output should be printed on the standard output. For each given input data set, print one integer number in a single line that gives the result (the minimum number of soldiers). An example is given in the following table:

Input

4
0:(1) 1
1:(2) 2 3
2:(0)
3:(0)
5
3:(3) 1 4 2
1:(1) 0
2:(0)
0:(0)
4:(0)

Output

1
2

题意：给出树的结点之间的关系,如1:(2) 2 3 ，表示2和3的父亲都是1.在1点设点，则其邻接点2和3都可被覆盖，求出最少要多少个点才能覆盖整棵树。即最小顶点覆盖。

分析：树的各点之间只有一条边，而且树明显的特性是有层次的数据结构。f[u][0]表示以u为根且u不加入覆盖集的最小顶点覆盖，f[u][1]表示以u为根且u加入覆盖集的最小顶点覆盖。每个点都有两个状态，就是加入与不加入覆盖集。

最优子结构：要知道f[u][0]=只需知道u的子节点个数；要知道f[u][1]，则要知道分别以u的孩子v们为根的最小顶点覆盖，对这种情况，每个孩子可加入也可不加入覆盖集（取最优的），以为树有层次，所以要知道根部，就要知道孩子的最小顶点覆盖，孩子的最小顶点覆盖跟父亲没有关系。

子问题重叠：这里没有子问题重叠。

边界问题：每个节点对应两种边界问题，即当处理一个节点是，有取和不取两种情况。

子问题独立：对于u的孩子v1，v2：v1的孩子跟v2的孩子毫无关系。这种性质延伸到u的所有孩子上，即每个孩子的解互相没有关系。

代码：

#include<stdio.h>
#define Min(a, b) a < b ? a : b
#define maxn 1510
int up[maxn], f[maxn][2], n;
void dp(int u)
{
    if (f[u][1] != -1)
    {
        return;
    }
    int i, v;
    for (v = 0, f[u][1] = 1, f[u][0] = 0; v < n; v++)//对于每个点，递归到每个孩子解决问题后才能解决自身问题
    {
        if (up[v] == u)
        {
            dp(v);
            f[u][1] += Min(f[v][0], f[v][1]);
            f[u][0] += f[v][1];
        }
    }
}
int main()
{
    int i, u, v, m, root;
    while (scanf("%d", &n) != EOF)
    {
        for (i = 0; i < n; i++)
        {
            up[i] = -1;
            f[i][0] = f[i][1] = -1;
        }
        for (i = 0; i < n; i++)
        {
            scanf("%d:(%d)", &u, &m);
            while (m--)
            {
                scanf("%d", &v);
                up[v] =  u;
            }
        }
        root = 0;
        while (up[root] != -1)
        {//查找根结点
            root = up[root];
        }
        dp(root);
        printf("%d\n", Min(f[root][1], f[root][0]));
    }
    return 0;
}

火碳黑 2010-04-27 23:05 发表评论

C++博客-夜幻梦回-文章分类-树形DP

poj 3659 Cell Phone Network——树形dp最少点覆盖所有点 点支配集

Zoj 1134——Strategic Game最少点覆盖边

poj 3659 Cell Phone Network——树形dp最少点覆盖所有点点支配集