51nod 1411 矩阵取数问题 V3

给定一个m行n列的矩阵，你可以从任意位置开始取数，到达任意位置都可以结束，每次可以走到的数是当前这个数上下左右的邻居之一，唯一的限制是每个位置只能经过一次，也就是说你的路径不自交。所经过的数的总作为你的得分，求最大的得分。

Input

第一行两个整数m, n (0 < m, n < 10)，表示矩阵的行数和列数。
后面m行，每行n个整数表示矩阵里的数，整数范围[-10000000, +10000000]。

Output

一个整数表示最大得分。

插头dp，状态可以用滚动数组存

#include<cstdio>
#include<cstring>
int n,m;
int v[][];
int s0[+],s1[+];
bool po[];
const int v0=-;
inline void maxs(int&a,int b){if(a<b)a=b;}
inline int _l(int x,int w){
    int t=,a;
    do{
        w-=;
        a=x>>w&;
        t+=(a>>)-(a&);
    }while(t);
    return w;
}
inline int _r(int x,int w){
    int t=,a;
    do{
        w+=;
        a=x>>w&;
        t-=(a>>)-(a&);
    }while(t);
    return w;
}
int main(){
    scanf("%d%d",&n,&m);
    int ans=v0;
    for(int i=;i<=n;++i){
        for(int j=;j<=m;++j){
            scanf("%d",v[i]+j);
            if(v[i][j]>ans)ans=v[i][j];
        }
    }
    if(ans<=)return printf("%d\n",ans),;
    int mx=<<*(m+);
    for(int i=;i<mx;++i){
        int t=;
        for(int j=;j<=m;++j)t+=((i>>j*&)==);
        po[i]=(t<=);
    }
    for(int i=;i<mx;++i)s1[i]=v0;
    s1[]=;
    for(int i=;i<=n+;++i){
        for(int j=;j<=m;++j){
            for(int p=;p<mx;++p){
                s0[p]=s1[p];
                s1[p]=v0;
            }
            for(int p=;p<mx;++p)if(s0[p]!=v0&&po[p]){
                int tt=;
                for(int t=;t<=m;++t)tt+=(p>>t*&)+(p>>t*+&);
                bool is=(tt==);
                if(is)maxs(ans,s0[p]);
                int p1=j*-,p2=j*;
                int a=p>>p1&,b=p>>p2&,c=s0[p]+v[i][j],d1=~(<<j*-),d2=~(<<j*);
                switch(a){
                    case :{
                        switch(b){
                            case :{
                                maxs(s1[p],s0[p]);
                                maxs(s1[p|<<p2],c);
                                maxs(s1[p|<<p1],c);
                                maxs(s1[p|<<p1|<<p2],c);
                                break;
                            }
                            case :{
                                maxs(s1[p],c);
                                maxs(s1[p&d2|<<p1],c);
                                maxs(s1[p&d1&d2|<<_r(p,p2)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p],c);
                                maxs(s1[p&d2|<<p1],c);
                                maxs(s1[p&d1&d2|<<_l(p,p1)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p],c);
                                maxs(s1[p&d2|<<p1],c);
                                break;
                            }
                        }
                        break;
                    }
                    case :{
                        switch(b){
                            case :{
                                maxs(s1[p&d1|<<p2],c);
                                maxs(s1[p],c);
                                maxs(s1[p&d1|<<_r(p,p2)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2^<<_r(p,p2)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2|<<_r(p,p2)],c);
                                break;
                            }
                        }
                        break;
                    }
                    case :{
                        switch(b){
                            case :{
                                maxs(s1[p&d1|<<p2],c);
                                maxs(s1[p],c);
                                maxs(s1[p&d1|<<_l(p,p1)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2^<<_l(p,p1)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2|<<_l(p,p1)],c);
                                break;
                            }
                        }
                        break;
                    }
                    case :{
                        switch(b){
                            case :{
                                maxs(s1[p&d1|<<p2],c);
                                maxs(s1[p],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2|<<_r(p,p2)],c);
                                break;
                            }
                            case :{
                                maxs(s1[p&d1&d2|<<_l(p,p1)],c);
                                break;
                            }
                            case :{
                                if(tt==)maxs(ans,c);
                                break;
                            }
                        }
                        break;
                    }
                }
            }
            if(i==n+)break;
        }
        for(int a=mx-;a>=;a-=){
            s1[a+]=s1[a+]=s1[a+]=v0;
            s1[a]=s1[a>>];
        }
    }
    printf("%d",ans);
    return ;
}