hdu 1565 方格取数(1) （网络流/状压dp）

Problem Description

给你一个n*n的格子的棋盘，每个格子里面有一个非负数。
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取的数所在的2个格子不能相邻，并且取出的数的和最大。

Input

包括多个测试实例，每个测试实例包括一个整数n 和n*n个非负数(n<=20)

Output

对于每个测试实例，输出可能取得的最大的和

Sample Input

3
75 15 21
75 15 28
34 70 5

Sample Output

188

题解

本题有两种方法，一是网络流，二是状压dp。注意为多组数据。
网络流
建图很简单，几乎是裸题。将方格中的点根据相邻异色染成黑白两色，黑色向源点连边，白色向汇点连边，权值为点权。黑色还要向白色连边，边权∞。跑最小割再用所有点的点权和减去最大流即可。
代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#define M 100010
#define oo 0x73f3f3f
using namespace std;

struct Edge {
    int v, f, next;
} edge[M];
int n, tot, num, head[M];
int s, tt, dis[M], queue[M];
bool vis[M];

void add(int u, int v, int f) {
    num ++;
    edge[num].v = v;
    edge[num].f = f;
    edge[num].next = head[u];
    head[u] = num;
    num ++;
    edge[num].v = u;
    edge[num].f = 0;
    edge[num].next = head[v];
    head[v] = num;
}

void zero() {
    memset(dis, 0, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(queue, 0, sizeof(queue));
}

void clear() {
    tot = 0, num = 1;
    memset(head, 0, sizeof(head));
}

bool bfs() {
    int h = 0, t = 1;
    dis[s] = 0; vis[s] = true; queue[1] = s;
    do {
        int u = queue[++ h];
        for(int i = head[u]; i; i = edge[i].next) {
            int v = edge[i].v;
            if(! vis[v] && edge[i].f) {
                vis[v] = true;
                queue[++ t] = v;
                dis[v] = dis[u] + 1;
            }
        }
    }while(h < t);
    if(vis[tt]) return true;
    return false;
}

int dfs(int u, int delta) {
    if(u == tt || ! delta) return delta;
    int ans = 0;
    for(int i = head[u]; i && delta; i = edge[i].next) {
        int v = edge[i].v;
        if(edge[i].f && dis[v] == dis[u] + 1) {
            int dd = dfs(v, min(edge[i].f, delta));
            edge[i].f -= dd;
            edge[i ^ 1].f += dd;
            ans += dd;
            delta -= dd;
        }
    }
    if(! ans) dis[u] = -1;
    return ans;
}

long long Maxflow() {
    long long ans = 0;
    while(1) {
        zero();
        if(! bfs()) break;
        ans += dfs(s, oo);
    }
    return ans;
}

int main() {
    while(~scanf("%d", &n)) {
        clear();
        long long sum = 0;
        s = 0; tt = n * n + 1;
        for(int i = 1; i <= n; i ++)
            for(int j = 1; j <= n; j ++) {
                int a;
                scanf("%d", &a);
                tot ++, sum += a;
                if((i + j) & 1) {
                    add(s, tot, a);
                    if(j > 1)
                        add(tot, tot - 1, oo);
                    if(j < n)
                        add(tot, tot + 1, oo);
                    if(i > 1)
                        add(tot, tot - n, oo);
                    if(i < n)
                        add(tot, tot + n, oo);
                }
                else add(tot, tt, a);
            }
        printf("%lld\n", sum - Maxflow());
    }
    return 0;
}

状压dp
首先预处理，先将横排中不可能出现的状态筛去（不可能出现相邻的1），还要计算每一排一种状态下取数之和。然后开始进行状态转移。需要for一遍这一排的状态和上一排的状态，如果上一排的状态不与这一排的状态冲突，就可行，并取出这一排该状态下取数之和，转移方程：

dp[i][j] = max(dp[i][j], dp[i - 1][k] + sum[i][j]);

其中i表示第i排，j表示这一排状态，k表示上一排状态，dp存当前最优取值，sum[i][j]就是该排取数之和。最后for一遍第n排的所有状态取出最大值。
代码

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

int ans, tot, N, cur[25][25], sum[25][18000], state[18000], dp[25][18000];

int check(int x) {
    return (x & (x << 1)) ? 0 : 1;
}

int count(int line, int x) {
    int cnt = 0;
    for(int i = 1; i <= N; i++)
        if(x >> (i - 1) & 1)
            cnt += cur[line][i];
    return cnt;
}

int main() {
    while(scanf("%d", &N) != EOF) {
        tot = 0;
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= N; i ++)
            for(int j = 1; j <= N; j ++)
                scanf("%d", &cur[i][j]);

        for(int i = 0; i < (1 << N); i ++)
            if(check(i)) state[++ tot] = i;

        for(int i = 1; i <= tot; i ++)
            sum[1][i] = dp[1][i] = count(1, state[i]);

        for(int i = 2; i <= N; i ++)
            for(int j = 1; j <= tot; j ++) {
                sum[i][j] = count(i, state[j]);
                for(int k = 1; k <= tot; k ++)
                    if(! (state[j] & state[k]))
                        dp[i][j] = max(dp[i][j], dp[i - 1][k] + sum[i][j]);
            }
        ans = -1;
        for(int i = 1; i <= tot; i ++)
            ans = max(ans, dp[N][i]);
        printf("%d\n", ans);
    }
    return 0;
}