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 0x73f3f3fusing 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;}