HDU-4539 郑厂长系列故事——排兵布阵 状态压缩DP Or 最大团

题意：给定一个方格，然后告诉你一些规则，这些规则下方格中的有些位置是相冲突的。问在方格中最多能够放置多少个士兵。

分析：比赛时一开始就想着用状态压缩DP来搞，不过忘了相邻三行产生关系同样可以通过添加状态的维数来解，于是想着旋转45度之后再DP，这样就只有两行发生关系，不过写起来应该不太好写。后面就用二分匹配写了该题，结果一直WA，知道比赛之后才明白原来这题不能够进行拆点构图，因为从一个点引出去的边的端点相互之间是可以连边的，这就相当于一个成环了，而有环的图又怎么划分出两个内部没有边的二分图呢？其实拆点是用求树的最小路径覆盖的问题上的，这题显然不满足。

正确的解法是状态压缩DP或者是求反建图的最大团问题。DP解法与POJ1185相似。

代码如下：

状态压缩DP

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

int N, M, idx;
int sta[175], num[175];
int cnt[15], mp[105];
int f[105][175][175];

void print(int x) {
    int rec[50] = {0}, p = 0;
    while (x) {
        rec[p++] = x % 2;
        x /= 2;
    }
    for (int i = 9; i >= 0; --i) {
        printf(i == 0 ? "%d\n" : "%d", rec[i]);
    }
}

inline bool legal(int x) {
    if (x & (x << 2)) return false;
    return true;
}

void init() {
    int lim;
    idx = 1;
    for (int k = 1; k <= 10; ++k) {
        lim = 1 << k;
        for (int i = 1<<(k-1); i < lim; ++i) {
            if (legal(i)) {
                sta[idx] = i;
                for (int j = 0; j < k; ++j) {
                    if (i & (1 << j)) ++num[idx];
                }
                idx++;
            }
        }
        cnt[k] = idx;
    }
}

inline bool place(int x, int y) {
    return (x & y) == x;
}

inline bool judge_1(int x, int y) { // 判断是否斜线冲突 
    if ((x << 1) & y || (x >> 1) & y) return false;
    return true;
}

inline bool judge_2(int x, int y) { // 判定是否直线冲突 
    if (x & y) return false;
    return true;
}

int solve() {
    int ret = 0;
    memset(f, 0, sizeof (f));
    if (N == 1) {
        for (int i = 0; i < cnt[M]; ++i) {
            if (place(sta[i], mp[1])) {
                ret = max(ret, num[i]);
            }
        }
        return ret;
    }
    for (int i = 0; i < cnt[M]; ++i) {
        if (!place(sta[i], mp[2])) continue;
        for (int j = 0; j < cnt[M]; ++j) {
            if (!place(sta[j], mp[1])) continue;
            if (judge_1(sta[i], sta[j])) {
                f[2][i][j] = num[i] + num[j];
            }
        }
    }
    for (int i = 3; i <= N; ++i) {
        for (int j = 0; j < cnt[M]; ++j) {
            if (!place(sta[j], mp[i])) continue;
            for (int k = 0; k < cnt[M]; ++k) {
                if (!place(sta[k], mp[i-1]) || !judge_1(sta[j], sta[k])) continue;
                for (int h = 0; h < cnt[M]; ++h) {
                    if (!place(sta[h], mp[i-2]) || !judge_1(sta[k], sta[h])) continue;
                    if (judge_2(sta[j], sta[h])) {
                        f[i][j][k] = max(f[i][j][k], f[i-1][k][h] + num[j]);    
                    }
                }
            }
        }    
    }
    for (int i = 0; i < cnt[M]; ++i) {
        for (int j = 0; j < cnt[M]; ++j) {
            ret = max(ret, f[N][i][j]);
        }
    }
    return ret;
}

int main() {
    init();
    int c;
    while (scanf("%d %d", &N, &M) != EOF) {
        memset(mp, 0, sizeof (mp));
        for (int i = 1; i <= N; ++i) {
            for (int j = 1; j <= M; ++j) {
                scanf("%d", &c);
                mp[i] <<= 1;
                mp[i] |= c;
            }
        }
        printf("%d\n", solve());
    }
    return 0;    
}

 

最大团

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

int N, M, idx, nd[1005];
char G[1005][1005];

void check(int a, int b) {
    int x1 = nd[a]/M, y1 = nd[a]%M, x2 = nd[b]/M, y2 = nd[b]%M;
    if (abs(x1-x2) + abs(y1-y2) == 2) {
        G[a][b] = G[b][a] = 1;
    }
}

void build() { // 对有冲突的点集构一个反图，0视为有边，1视为没有边 
    memset(G, 0, sizeof (G));
    for (int i = 0; i < idx; ++i) {
        for (int j = i+1; j < idx; ++j) {
            check(i, j);
        }    
    }
}

int cnt[1005], ret;
int opt[1005], st[1005];

void dfs(int x, int num) {
    int flag;
    for (int i = x+1; i < idx; ++i) {
        if (G[x][i]) continue;
        if (num + cnt[i] <= ret) return; // 可行性剪枝，就算后面完全子图全部加入进来也不会超过已知极大团 
        flag = true;
        for (int j = 0; j < num; ++j) {
            if (G[i][st[j]]) { // 如果没有边
                flag = false;
                break;
            }
        }
        if (flag) { // 说明该点能够并入正在搜查的完全子图
            st[num] = i;
            dfs(i, num + 1);
        }
    }
    if (num > ret) { // 只会在最里面一层进行更新
        ret = num;
        for (int i = 0; i < num; ++i) {
            opt[i] = st[i];
        }
    }
}

void maxclique() {
    ret = 0;
    for (int i = idx-1; i >= 0; --i) {
        st[0] = i;
        dfs(i, 1);
        cnt[i] = ret;
    }
}

int main() {
    int c;
    while (scanf("%d %d", &N, &M) != EOF) {
        idx = 0;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < M; ++j) {
                scanf("%d", &c);
                if (c) {
                    nd[idx++] = i*M+j;
                }
            }
        }
        build();
        maxclique();
        printf("%d\n", cnt[0]);
    }
    return 0;        
}

 

四进制TLE代码留念：

View Code

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

/*
每一个空格使用两个二进制位进行表示：
00 代表当前行和上一行都没有士兵
01 代表当前行有士兵，而上一行没有
10 代表当前行没有士兵，而上一行有
11 代表当前行和上一行都有士兵
*/

int N, M, LIM, idx, mp[105];
int sta[4000], num[4000], cnt[15];
const int hmask = 0x55555555; // 该掩码能够将2个二进制位的高位1赋值为0 
const int lmask = 0xaaaaaaaa;

int f[105][1050];

void print(int x) {
    int rec[50] = {0}, idx = 0;
    while (x) {
        rec[idx++] = x % 2;
        x /= 2;
    }
    for (int i = 19; i >= 0; i-=2) {
        printf(i == 1 ? "%d\n" : "%d", rec[i]);
    }
    for (int i = 18; i >= 0; i-=2) {
        printf(i == 0 ? "%d\n" : "%d", rec[i]);
    }
}

void ppt(int x) {
    int rec[50] = {0}, idx = 0;
    while (x) {
        rec[idx++] = x % 2;
        x /= 2;
    }
    for (int i = 18; i >= 0; i-=2) {
        printf(i == 0 ? "%d\n" : "%d", rec[i]);
    }
    puts("");    
}

bool judge(int cur, int pre) { // cur代表当前状态，pre代表上一行的综合状态
    // 首先判定低位的1是否合法
    int lcur = cur & hmask, hcur = cur & lmask;
    int lpre = pre & hmask, hpre = pre & lmask;
    if ((hcur >> 1) != lpre) { // 如果当前状态表示上一层有士兵，那么询问第i-1层的格子是否真有士兵 
        return false;    
    }
    if ((lcur << 1) & hpre) { // 如果当前图不能够满足放置的条件或者第i-2层放置了士兵与之冲突 
        return false;
    }
    if ((lcur << 2) & lpre || (lcur >> 2) & lpre) { // 如果当前行状态和第i-1行放置情况冲突
        return false;
    }
    return true; 
}

// legal用来判定一行是否合法，其中包括用来表示上一行的高位和低位本行以及互相不能冲突 
bool legal(int x) {
    int lx = x & hmask, hx = x & lmask;
    if ((x << 4) & x || (lx << 3) & hx || (lx >> 1) & hx) {
        return false;
    }
    return true;
}

void solve() {
    memset(f, 0, sizeof (f));
//    printf("idx = %d\n", idx);
    for (int i = 1; i <= N; ++i) {
        for (int j = 0; j < cnt[M]; ++j) { // 求解当前行的状态
            if (((sta[j]&hmask) & mp[i]) != (sta[j]&hmask)) continue;
        //    print(sta[j]);
        //    printf("i = %d, j = %d\n", i, j);
        //    getchar();
            for (int k = 0; k < cnt[M]; ++k) { // 遍历上一行的所有状态来生成这一行的状态
                if (judge(sta[j], sta[k])) {
                    f[i][j] = max(f[i][j], f[i-1][k] + num[j]);
                /*    if (j == 9) {
                        printf("f[%d][%d] = %d\n", i, j, f[i][j]);
                        getchar();
                    }*/
                }
            }
        }
    }    
}

void init() {
    idx = 1;
    for (int k = 1; k <= 10; ++k) {
        LIM = (1 << 2*k) - 1; // 每一个位需要2个二进制位来存储状态
        for (int i = 1<<2*(k-1); i <= LIM; ++i) {
            if (legal(i)) {
                num[idx] = 0;
                sta[idx] = i;
                for (int j = 0; j < M; ++j) {
                    if (i & (1 << j*2)) {
                        ++num[idx];
                    }
                }
                ++idx;
            //    print(i);
            //    printf("%d\n", num[i]);
            }
        }
        cnt[k] = idx;
    //    printf("idx = %d\n", idx);
    }
}

int main() {
    
/*    for (int i = 0; i <= 1024; ++i) {
        if (!legal(i)) continue;
        for (int j = 0; j <= 1024; ++j) {    
            if (!legal(j)) continue;
            if (judge(i, j)) {
                print(j), ppt(i);
                getchar();
                puts("__________________");
            }
        }
    }
    */
    while (scanf("%d %d", &N, &M) != EOF) {
        init();
        int c, Max = 0;
        memset(mp, 0, sizeof (mp));
        for (int i = 1; i <= N; ++i) {
            for (int j = 1; j <= M; ++j) {
                scanf("%d", &c);
                mp[i] <<= 2;
                if (c) mp[i] |= 1;
            }
        }
    //    printf("__%d\n", num[9]);
        solve();
        for (int i = 0; i < cnt[M]; ++i) {
            Max = max(Max, f[N][i]);    // 允许第N行以任意合法状态结束，没有更新的状态贡献为0 
        }
        printf("%d\n", Max);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/Lyush/archive/2013/04/01/2994258.html