poj 1463 Strategic game

http://poj.org/problem?id=1463

有两种做法，一种是二分图，一种是树形DP，这里两种都做了。

二分图的。

就是经典的二分图最小点覆盖，要选取最小的点，使得所有的边与这些点关联，（可以一条边关联两个点，为了需要哟）

那么我们建的是无向边，因为可以互相关联，还是利用经典的拆点思想，

本来要若原图中i与j有边。我们要连的是i到j+n，j到i+n，但这样连的效果和i与j连，j与i连是一样的。所以为了节省空间，我们这样连

然后就是匈牙利算法，求最小点覆盖=最大匹配数

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<vector>
#define maxn 2000
using namespace std;
vector<int>node[maxn];
int mm[maxn];
int visit[maxn];
int n;
int dfs(int fa)
{
    for(int i=0;i<node[fa].size();i++)
    {
        int v=node[fa][i];
        if(!visit[v])
        {
            visit[v]=1;
            if(mm[v]==-1||dfs(mm[v]))
            {
                mm[v]=fa;
                return 1;
            }
        }
    }
    return 0;
}

void solve()
{
     int cnt=0;
     memset(mm,-1,sizeof(mm));
     for(int i=0;i<n;i++)
     {
         memset(visit,0,sizeof(visit));
         if(dfs(i)) cnt++;
     }
     cout<<cnt/2<<endl;
//因为连的是双向边，所以求的的匹配数是所需答案的2倍
}
int main()
{

    int u,num;
    int v;
    while(cin>>n)
    {
        for(int i=0;i<=n;i++)
            node[i].clear();
        for(int i=0;i<n;i++)
        {
            scanf("%d:(%d)",&u,&num);//这个读入要注意
            while(num--)
            {
                cin>>v;
                node[u].push_back(v);//要连双向边
                node[v].push_back(u);
            }
        }
        solve();
    }
    return 0;
}

树形DP

用DP[I][0]来表示该点没有放兵，以这个点为根的子树所需的最少兵数。

用DP[I][1]来表示该点有放兵，以这个点为根的子树所需的最少兵数。

那么可以得到状态方程

dp[fa][0]+=dp[son][1];//如果该父亲不放，那么儿子必须放
dp[fa][1]+=min(dp[son][0],dp[son][1]);//如果该父亲放，儿子在放和不放之间选择最小的

访问的时候，因为要先知道儿子的信息，所以类似于后续遍历

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<vector>
#define maxn 100000
using namespace std;
int dp[maxn][2];
int n;
int root;
vector<int>node[maxn];
void init()
{
    int u,v,num;
    root=-1;
    for(int i=0;i<=n;i++)
        node[i].clear();
    for(int i=0;i<n;i++)
    {
        scanf("%d:(%d)",&u,&num);//读入要注意
        if(root==-1)root=u;//第一个点是根
        while(num--)
        {
            cin>>v;
            node[u].push_back(v);//连有向边
        }
    }
}
int solve(int fa)
{
    dp[fa][0]=0;dp[fa][1]=1;
    for(int i=0;i<node[fa].size();i++)
    {
        int son=node[fa][i];
        solve(son);
//其实觉得类似于后续遍历，因为父亲要用到儿子的信息，
//所以要先知道儿子的
        dp[fa][0]+=dp[son][1];//如果该父亲不放，那么儿子必须放
        dp[fa][1]+=min(dp[son][0],dp[son][1]);
//如果该父亲放，儿子在放和不放之间选择最小的
    }
    return min(dp[fa][0],dp[fa][1]);
}
int main()
{
    while(cin>>n)
    {
        init();
        printf("%d\n",solve(root));//
    }
    return 0;
}