POJ 1463 入门树dp Strategic game

题意: 给出一棵树, 现在要在一些点上放守卫, 每个守卫可以守护这个点上的边, 问最少放多少个守卫能守护所有的点.

思路:

18年写的记搜:

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

int n;
int father[1505];
int dp[1505][2];
int root;
int vis[1505]= {0};

void dfs(int x)
{
    vis[x]=1;
    //cout<<dp[2][0]<<endl;
    for(int i=0; i<n; i++)
    {
        if(father[i]==x&&vis[i]==0)
        {
            dfs(i);
            dp[x][0]+=dp[i][1];
            dp[x][1]+=min(dp[i][0],dp[i][1]);
            //if(x==2)cout<<i<<"fuck"<<father[i]<<" "<<x<<endl;
        }
    }
    //cout<<dp[2][0]<<endl;
}

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(father,-1,sizeof(father));
        memset(vis,0,sizeof(vis));
        for(int i=0; i<n; i++)
        {
            int l;
            scanf("%d",&l);
            getchar();
            getchar();
            int num;
            scanf("%d",&num);
            getchar();
            getchar();
            for(int j=0; j<num; j++)
            {
                int k;
                scanf("%d",&k);
                father[k]=l;
            }
        }
        for(int i=0; i<n; i++)
            if(father[i]==-1)
                root=i;
        for(int i=0; i<n; i++)
        {
            dp[i][0]=0;
            dp[i][1]=1;
        }
        /*for(int k=0; k<n; k++)
        {
            cout<<dp[k][0]<<" "<<dp[k][1]<<endl;
        }*/
        //cout<<root<<endl;
        dfs(root);
        /*for(int k=0; k<n; k++)
        {
            cout<<dp[k][0]<<" "<<dp[k][1]<<endl;
        }*/
        printf("%d\n",min(dp[root][0],dp[root][1]));
    }
}

19年写的拓扑排序+dp:

#include<bits/stdc++.h>
using namespace std;
const int M = 6005;
int head[M];
int ei;
struct node {
    int v, nxt;
} edge[M];
int n;

void addEdge(int x, int y) {
    edge[ei].v = y;
    edge[ei].nxt = head[x];
    head[x] = ei++;
}

int fa[M];
int List[M];//拓扑排序(从叶到根)后的数组
int li;
int s = 0;//root
int dp[2][M];


void bfs() {//拓扑排序
    li = 0;
    int x = s;
    stack<int> stack1;
    queue<int> q;
    q.push(x);
    while (!q.empty()) {
        x = q.front();
        q.pop();
        stack1.push(x);
        for (int i = head[x]; i != -1; i = edge[i].nxt) {
            int v = edge[i].v;
            q.push(v);
        }
    }
    while (!stack1.empty()) {
        List[li++] = stack1.top();
        stack1.pop();
    }
}


void init() {
    memset(fa, -1, sizeof(fa));
    memset(head, -1, sizeof(head));
    ei = 0;
    int SON, FATHER;
    int sonum;
    for (int i = 0; i < n; i++) {
        scanf("%d:(%d)", &FATHER, &sonum);
        for (int j = 1; j <= sonum; j++) {
            scanf("%d", &SON);
            addEdge(FATHER, SON);
            fa[SON] = FATHER;
        }
    }
    for (int i = 0; i < n; i++) {
        if (fa[i] == -1) {
            s = i;
            break;
        }
    }
    bfs();
}

void solve() {
    memset(dp, 0, sizeof(dp));
    for (int i = 0; i < n; i++) {
        int u = List[i];
        int sum0 = 0, sum1 = 0;
        for (int j = head[u]; j != -1; j = edge[j].nxt) {
            int v = edge[j].v;
            sum1 += min(dp[1][v], dp[0][v]);
            sum0 += dp[1][v];
        }
        dp[0][u] = sum0;//代表这个位置不放, 那儿子节点必须得放
        dp[1][u] = sum1 + 1;//这个位置放了, 总的就得+1, 不过儿子节点可放可不放(取最小).
    }
    printf("%d\n", min(dp[0][s], dp[1][s]));
}

int main() {
    while (~scanf("%d", &n)) {
        init();
        solve();
    }
    return 0;
}