hdu1054

Strategic Game

Time Limit: 10000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 1054
64-bit integer IO format: %lld      Java class name: Main

Prev

Submit Status Statistics Discuss

Next

窗体顶端

Type:

None

 

None Graph Theory     2-SAT     Articulation/Bridge/Biconnected Component     Cycles/Topological Sorting/Strongly Connected Component     Shortest Path         Bellman Ford         Dijkstra/Floyd Warshall     Euler Trail/Circuit     Heavy-Light Decomposition     Stable Marriage Problem     Trees     Directed Minimum Spanning Tree     Flow/Matching         Graph Matching         Bipartite Matching         Hopcroft–Karp Bipartite Matching         Weighted Bipartite Matching/Hungarian Algorithm         Flow         Max Flow/Min Cut         Min Cost Max Flow     Minimum Spanning Tree DFS-like     Backtracking with Pruning/Branch and Bound     Basic Recursion     IDA* Search     Parsing/Grammar     DFS/BFS     Advanced Search Techniques         Binary Search/Bisection         Ternary Search Geometry     Basic Geometry     Computational Geometry     Convex Hull     Pick's Theorem Game Theory     Green Hackenbush/Colon Principle/Fusion Principle     Nim     Sprague-Grundy Number Matrix     Gaussian Elimination     Matrix Exponentiation Data Structures     Basic Data Structures     Binary Indexed Tree     Binary Search Tree     Hashing     Orthogonal Range Search     Range Minimum Query/Lowest Common Ancestor     Segment Tree/Interval Tree     Trie Tree     Sorting     Disjoint Set     Dancing link String     Aho Corasick     Knuth-Morris-Pratt(KMP)     Suffix Array/Suffix Tree Math     Basic Math     Big Integer Arithmetic     Number Theory         Chinese Remainder Theorem         Extended Euclid         Inclusion/Exclusion         Modular Arithmetic     Combinatorics         Group Theory/Burnside's         Counting         Probability/Expected Value Others     Tricky     Hardest     Unusual     Brute Force     Implementation     Constructive Algorithms     Two Pointer     Bitmask     Beginner     Discrete Logarithm/Shank's Baby-step Giant-step Algorithm     Greedy     Divide and Conquer Dynamic Programming Tag it!

窗体底端

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:

Sample 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)

Sample Output

1

2

 

题意：

       给出一棵n个结点的树，现在需要选择最少的点，使得所有的边都具有至少一个被选择的点，输出这个最少的点数。

分析：

       由于题目中的结点呈现树结构，所以可以考虑记忆化搜索。在建图的时候考虑存储每个结点子结点的数量。搜索点的顺序在树上是由上至下，dp[pos][0]，表示当前位于pos结点并且不选择pos结点时这个pos结点对应的子树最少需要选择多少个点才能在子树上满足题目的条件；dp[pos][1]表示的则是选择pos这个结点。如果pos这个结点没有选择，则它的子结点必须全部都被选择；如果pos没有被选择，则它的子结点可选择可不选择。即dp[i][0]=sum(dp[son[i][j]][1]) dp[i][1]=sum(min(dp[son[i][j]][0],dp[son[i][j]][1]))。

#include <cstdio>
#include <cstring>
int min(int a,int b){return a < b ? a : b;}
const int MAX_N = 1500;
int n;
int son[MAX_N + 1][MAX_N + 1],dp[MAX_N + 1][2],son_num[MAX_N + 1],f[MAX_N + 1];
// 位于pos，放或者不放soldier的行为带来的数量答案
int dfs(int pos,int key){
    if(dp[pos][key] != -1) return dp[pos][key];
    int ans = key;
    for(int i = 0 ; i < son_num[pos] ; i++)
        if(key == 0)
            ans += dfs(son[pos][i],1); // 子结点必须全部选择放1个soldier
        else
            ans += min(dfs(son[pos][i],0),dfs(son[pos][i],1));
    return dp[pos][key] = ans;
}
int main(){
    while(scanf("%d",&n) == 1){
        memset(dp,-1,sizeof dp);
        for(int i = 0 ; i < n ; i++) f[i] = i; // 用于寻找根结点
        for(int i = 0 ; i < n ; i++){
            int x,m; scanf("%d:(%d)",&x,&m);
            son_num[x] = m;
            for(int j = 0 ; j < m ; j++){
                scanf("%d",&son[x][j]);
                f[son[x][j]] = x;
            }
        }
        int ans = 0;
        for(int i = 0 ; i < n ; i++)if(f[i] == i)
            ans = min(dfs(i,1),dfs(i,0));
        printf("%d\n",ans);
    }
    return 0;
}