状态压缩DP

萌新第一题：POJ3524 注释都写了，转移方程那里没写

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <string>
#include <algorithm>
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf = 0x3f3f3f3f;
const int maxn = 13;
const int maxk = 1<<maxn;
const int mod = 100000000;

int stage[maxk],map[maxn];    //一共N列，所以可表示的二进制数的范围是1<<N，其中没有相邻1的数字记录在stage中
int dp[maxn][maxk];
int N, M, top;

inline bool ok(int x)
{ return !(x&(x<<1)); }        //一个数字x的二进制表示中，如果有相邻的1则返回false

inline bool fit(int i, int x)            //因为map[i]的二进制中，1代表不能放牧
{ return !(map[i]&stage[x]); }            //而stage[x]的二进制,1代表可以放牧，
                                        //所以当1&1=1时，即代表在不可放牧的格子上放牧了

void init()
{
    memset( stage, 0, sizeof(stage) );
    memset( map, 0, sizeof(map) );
    memset( dp, 0, sizeof(dp) );

    top = 0;
    int tot = 1 << N;                    //数字最多只能到1 << N(二进制)
    for ( int i = 0; i < tot; i++ )        //且不能等于1<<N
        if (ok(i))                        //若这个数字的二进制表示没有相邻的1(满足放牧规则)
            stage[top++] = i;            //则将其存在stage中
}

int main()
{
    
    while ( ~scanf("%d %d", &M, &N) )
    {
        init();

        int x;
        for ( int i = 1; i <= M; i++ )
            for ( int j = 1; j <= N; j++ )
            {
                scanf( "%d", &x );
                if (!x)                
                    map[i] += (1<<(j-1));    //每次改变一位二进制数字，且1代表该位置不能放牧(方便判断)
            }

        for ( int i = 0; i < top; i++ )
            if (fit(1, i))
                dp[1][i] = 1;

        for ( int i = 2; i <= M; i++ )
            for ( int j = 0; j < top; j++ )
            {
                if (!fit(i,j))    continue;
                for ( int k = 0; k < top; k++ )
                {
                    if (!fit(i - 1, k)) continue;
                    if (!(stage[j]&stage[k]))
                        dp[i][j] += dp[i-1][k];
                }
            }
        int ans = 0;
        for ( int i = 0; i < top; i++ )
            { ans += dp[M][i]; ans %= mod; }
        printf( "%d", ans );
    }

    return 0;
}

 萌新第二题：POJ1185 本来不难的题，结果遇到了一个语言底层的神秘bug！！！！！调试了4个小时以上才发现是g数组才开了15个，可是g数组作为全局变量的时候并没有越界报错！？甚至输了超过N组数据程序能够在底层把N修改了？？？？太神秘了

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <math.h>
#include <string>
#include <algorithm>
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const int inf = 0x3f3f3f3f;
const int maxn = 102;
const int maxk = 200;
const int mod = 100000000;

char str[15];
int stage[maxk], g[maxn], num[maxk];
int dp[maxn][maxk][maxk];

inline bool ok(int x)
{ if ( (x&(x<<1))!=0 || (x&(x<<2))!=0 ) return false; return true; }        //相容返回true

inline bool check( int i, int j )        //相容返回true
{ return !(g[i]&stage[j]); }

int main()
{
    int ans = 0;
    int N, M, top;
    while (~scanf("%d %d", &N, &M))
    {
        //ReadAndInit();

        for (int i = 1; i <= N; i++)
        {
            scanf("%s", str);
            for (int j = 0; j < M; j++)
                if ( str[j] == 'H' )
                    g[i] += (1<<j);
        }

        top = 0;
        int tot = 1<<M;
        for ( int i = 0; i < tot; i++ )
            if (ok(i))
            {
                stage[top] = i;
                int cnt= 0, tmp = i;
                while(tmp)
                { cnt++; tmp = tmp&(tmp-1); }
                num[top++] = cnt;
            }

        //if(n==1)
        for ( int i = 0; i < top; i++ )
            if ( check(1, i) )
            {
                dp[1][i][0] = num[i];
                ans = max(ans, dp[1][i][0]);
            }
        if (N==1) break;


        for ( int i = 0; i < top; i++ )
        {
            if (!check(2,i)) continue;
            for ( int j = 0; j < top; j++ )
                if ( check(1,j) )
                {
                    if (stage[i]&stage[j]) continue;

                    dp[2][i][j] = num[i]+num[j];
                    ans = max(ans,dp[2][i][j]);
                }
        }
        if(N==2) break;


        for ( int i = 3; i <= N; i++ )
            for ( int j = 0; j < top; j++ )
                if ( check(i, j) )
                    for ( int a = 0; a < top; a++ )
                        if ( check(i-1, a) && !(stage[j]&stage[a]) )
                            for ( int b = 0; b < top; b++ )
                                if ( check(i-2, b) && !(stage[j]&stage[b])
                                    && !(stage[b]&stage[a]) )
                                {
                                    dp[i][j][a] = max(dp[i-1][a][b]+num[j], dp[i][j][a]);
                                    ans = max(dp[i][j][a],ans);
                                }
        break;
    }
    printf("%d
",ans);
    return 0;
}