UVALive2038-Strategic game（树形dp or 二分图匹配）

题目链接

http://acm.hust.edu.cn/vjudge/problem/35474

题意

给定一棵树，要求选择最少的点，对于任意一个没有被选中的点，那么和它相邻的点中一定有点被选到

思路

1. 树形dp：
状态 && 转移方程
对于任意一个点，其状态只有选和不选两种，并且其选择受父节点是否被选择影响，因此定义状态： d[i][s] 对于结点i，其父节点的选择状态为s（s == 0 / 1），所需选择的最少结点数
I. 选择结点i必定是合法决策，因此：

d[i][s] = sum(d[k][1]) + 1 （k ∈ son(i)）

II. 考虑可以不选择结点i，即当i == root or s == 1时（结点i为根节点或其父节点已经被选择），那么此时可以不选择结点i：

tmp = sum(d[k][0]) （k ∈ son(i)）

d[i][s] = min(d[i][s], tmp)

目标状态
d[root][1 / 0]
细节
将无根树转有根树的过程中做dp
2. 最小点覆盖
对于任意一个没有被选中的点，那么其相邻结点中必定有一个被选中，等价于选择最少的点，使所有边都被覆盖，即二分图的最小点覆盖，等于二分图的最大匹配边数
细节
因先将该树进行染色

代码

1. 树形dp

#include <iostream>
#include <cstring>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <deque>
#include <bitset>
#include <algorithm>
using namespace std;

#define PI acos(-1.0)
#define LL long long
#define PII pair<int, int>
#define PLL pair<LL, LL>
#define mp make_pair
#define IN freopen("in.txt", "r", stdin)
#define OUT freopen("out.txt", "wb", stdout)
#define scan(x) scanf("%d", &x)
#define scan2(x, y) scanf("%d%d", &x, &y)
#define scan3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define sqr(x) (x) * (x)
#define pr(x) cout << #x << " = " << x << endl
#define lc o << 1
#define rc o << 1 | 1
#define pl() cout << endl
#define CLR(a, x) memset(a, x, sizeof(a))
#define FILL(a, n, x) for (int i = 0; i < n; i++) a[i] = x

const int maxn = 1500 + 5;
int n, d[maxn][3];
vector<int> G[maxn];
bool vis[maxn][3];

void init() {
    for (int i = 0; i < n; i++) G[i].clear();
    CLR(vis, 0);
}

int dp(int i, int s, int f) {
    if (vis[i][s]) return d[i][s];
    vis[i][s] = 1;
    //choose is always legal
    d[i][s] = 1;
    for (int j = 0; j < G[i].size(); j++) {
        int k = G[i][j];
        if (k == f) continue;
        d[i][s] += dp(k, 1, i);
    }
    //not choose
    if (f == -1 || s == 1) {
        int tmp = 0;
        for (int j = 0; j < G[i].size(); j++) {
            int k = G[i][j];
            if (k == f) continue;
            tmp += dp(k, 0, i);
        }
        d[i][s] = min(tmp, d[i][s]);
    }
    return d[i][s];
}

int main() {
    while (~scan(n)) {
        init();
        for (int i = 0; i < n; i++) {
            int x, k, y;
            scanf("%d:(%d)", &x, &k);
            while (k--) {
                scan(y);
                G[x].push_back(y);
                G[y].push_back(x);
            }
        }
        int res = dp(0, 0, -1);
        printf("%d\n", res);
    }
    return 0;
}

1. 二分图匹配

#include <iostream>
#include <cstring>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <deque>
#include <bitset>
#include <algorithm>
using namespace std;

#define PI acos(-1.0)
#define LL long long
#define PII pair<int, int>
#define PLL pair<LL, LL>
#define mp make_pair
#define IN freopen("in.txt", "r", stdin)
#define OUT freopen("out.txt", "wb", stdout)
#define scan(x) scanf("%d", &x)
#define scan2(x, y) scanf("%d%d", &x, &y)
#define scan3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define sqr(x) (x) * (x)
#define pr(x) cout << #x << " = " << x << endl
#define lc o << 1
#define rc o << 1 | 1
#define pl() cout << endl

const int maxn = 2000;
const int maxm = 10005 << 1;
const int INF = 0x3e3e3e3e;
int n, m;

struct Edge {
    int from, to, cap, flow;
};

struct Dinic {
    int n, m, s, t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn], cur[maxn];

    void addedge(int u, int v, int c) {
        edges.push_back((Edge) {u, v, c, 0});
        edges.push_back((Edge) {v, u, 0, 0});
        m = edges.size();
        G[u].push_back(m - 2);
        G[v].push_back(m - 1);
    }

    bool bfs() {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        vis[s] = 1, d[s] = 0;
        while (!Q.empty()) {
            int x = Q.front();
            Q.pop();
            int _s = G[x].size();
            for (int i = 0; i < _s; i++) {
                Edge &e = edges[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int dfs(int x, int a) {
        if (x == t || a == 0) return a;
        int flow = 0, f;
        for (int &i = cur[x]; i < G[x].size(); i++) {
            Edge &e = edges[G[x][i]];
            if (d[e.to] == d[x] + 1 && ((f = dfs(e.to, min(a, e.cap - e.flow))) > 0)) {
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;
                if (a == 0) break;
            }
        }
        return flow;
    }

    int max_flow(int s, int t) {
        this->s = s;
        this->t = t;
        int flow = 0;
        while (bfs()) {
            memset(cur, 0, sizeof(cur));
            flow += dfs(s, INF);
        }
        return flow;
    }
};

vector<int> G[maxn];
int color[maxn];

bool bi_color(int u) {
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (color[v] == color[u]) return false;
        if (!color[v]) {
            color[v] = 3 - color[u];
            if (!bi_color(v)) return false;
        }
    }
    return true;
}

void init() {
    for (int i = 0; i < maxn; i++) G[i].clear();
    memset(color, 0, sizeof(color));
}

int main() {
    int n;
    while (~scan(n)) {
        init();
        for (int i = 0; i < n; i++) {
            int x, k, y;
            scanf("%d:(%d)", &x, &k);
            while (k--) {
                scan(y);
                G[x].push_back(y);
                G[y].push_back(x);
            }
        }
        color[0] = 1;
        if (!bi_color(0)) puts("0");
        else {
            Dinic D;
            int S = n + 1, T = n + 2;
            for (int i = 0; i < n; i++) {
                if (color[i] == 1) D.addedge(S, i, 1);
                if (color[i] == 2) D.addedge(i, T, 1);
                for (int j = 0; j < G[i].size(); j++) {
                    int k = G[i][j];
                    if (color[i] == 1 && color[k] == 2) D.addedge(i, k, 1);
                }
            }
            int ans = D.max_flow(S, T);
            printf("%d\n", ans);
        }
    }
    return 0;
}