状压dp做题记录（总结用材料）

1.铺方格（统计方案数）

#include<vector>

#include<map>

#include<ctime>

#define ll long long

using namespace std;

long long dp[12][3000];//最后结果要用long long

bool judge1(int x,int len)//第一行是否合法

{

    for(int i=0;i<len;++i)

    {

        if((x>>i)&1)

        {

            if(i==len-1)return 0;

            if((x>>(i+1))&1)

            {

                i++;

                continue;

            }

            else return 0;

        }

        else continue;

    }

    return 1;

}

bool judge2(int x,int y,int len)//两行状态是否能共存

{

    for(int i=0;i<len;++i)

    {

        if((y>>i)&1)//分类讨论，要理清分类依据：当前行为1或0，上一行对应为，，，

        {               //小细节，判断某位是否为1，别忘了&1

            if(!((x>>i)&1))continue;

            else

            {

                if(i==len-1)return 0;

                if((x>>(i+1))&1)

                {

                    if((y>>(i+1))&1)

                    {

                        i++;

                        continue;

                    }

                    else return 0;

                }

                else return 0;

            }

        }

        else

        {

            if((x>>i)&1)

            {

                continue;

            }

            else

            {

                return 0;

            }

        }

    }

    return 1;

 

}

int main()

{

    int h,w;

    while(cin>>h>>w&&h+w)

    {

        memset(dp,0,sizeof(dp));

        if(h<w)swap(h,w);

        for(int i=0;i<(1<<w);++i)

            if(judge1(i,w))dp[1][i]=1;

        for(int i=2;i<=h;++i)

        {

            for(int j=0;j<(1<<w);++j)

            {

                for(int k=0;k<(1<<w);++k)

                {

                    if(i==2)

                    {

                        if(judge2(k,j,w)&&judge1(k,w))dp[i][j]+=dp[i-1][k];

                    }

                    else

                        if(judge2(k,j,w))dp[i][j]+=dp[i-1][k];

                }

            }

        }

        long long ans=0;

        ans=dp[h][(1<<w)-1];

        cout<<ans<<endl;

 

 

    }

    return 0;

}

 

 

 

 

3.炮兵阵地（三维状压+空间复杂度优化）

#include<ctime>

#define ll long long

using namespace std;//为什么要开三维数组，因为二维无法表示对应状态限制下的子解

int a[600];

int num[600];

int sta[110];

long long dp[110][65][65];

int getNum(int x,int n)

{

    int ans=0;

    for(int i=0;i<n;++i)

    {

        if((x>>i)&1)ans++;

    }

    return ans;

}

int init(int n)

{

    memset(a,0,sizeof(a));

    memset(num,0,sizeof(num));

    int tot=0;

    for(int i=0;i<(1<<n);++i)

    {

        if((i&(i>>1))||(i&(i>>2)))continue;

        else

        {

            a[++tot]=i;

            num[i]=getNum(i,n);

        }

 

    }

    return tot;

}

 

int main()

{

    int n,m;

    while(cin>>n>>m)

    {

        memset(sta,0,sizeof(sta));

        memset(dp,0,sizeof(dp));

        getchar();

        for(int i=1;i<=n;++i)

        {

            for(int j=1;j<=m;++j)

            {

                char ch;

                ch=getchar();

                if(ch=='P')sta[i]+=(1<<(m-j));

            }

            if(i!=n)getchar();

            sta[i]=~sta[i];

        }

        int tot=init(m);

        long long maxx=0;

        for(int i=1;i<=tot;++i)//第一行

        {

            if(n==1)//只有一行的情况要特判

            {

                if(!(sta[1]&a[i]))maxx=max(maxx,(long long)getNum(a[i],m));

                continue;

            }

            for(int j=1;j<=tot;++j)//第二行

            {

                if( !(sta[1]&a[i]) && !(sta[2]&a[j]) && !(a[i]&a[j]) )

                {

                    dp[2][j][i]=num[a[j]]+num[a[i]];

                    maxx=max(maxx,dp[2][j][i]);

                }

            }

        }

 

        for(int i=3;i<=n;++i)

        {

            for(int j=1;j<=tot;++j)//当前

            {

                for(int k=1;k<=tot;++k)//上一

                {

                    for(int l=1;l<=tot;++l)//上二

                    {

                        if( !(a[j]&sta[i])&& !(a[k]&sta[i-1])&&!(a[l]&sta[i-2]) &&!(a[j]&a[k]) &&!(a[j]&a[l]) &&!(a[k]&a[l]) )

                        {

                            dp[i][j][k]=max(dp[i][j][k],dp[i-1][k][l]+num[a[j]]);

                            maxx=max(maxx,dp[i][j][k]);

                        }

                    }

                }

            }

        }

        cout<<maxx<<endl;

 

    }

    return 0;

}

 

 

 

 

4.（TSP弗洛伊德+状压）

using namespace std;

const ll INF=999999999;

int f[12][12];

void floyed(int n)

{

 

    for(int k=0;k<=n;++k)//弗洛伊德从0/1开始的差别：有无0点

    {

        for(int i=0;i<=n;++i)

        {

            for(int j=0;j<=n;++j)

            {

                f[i][j]=min(f[i][j],f[i][k]+f[k][j]);//直接在构建的图上更新

            }

        }

    }

}

int dp[1500][12];

int main()

{

    int n;

    while(cin>>n&&n)

    {

        memset(f,0,sizeof(f));

        for(int i=0;i<=n;++i)

            for(int j=0;j<=n;++j)

                cin>>f[i][j];

        floyed(n);

 

        for(int i=0;i<(1<<n);++i)

            for(int j=0;j<=n;++j)dp[i][j]=INF;

 

        for(int i=0;i<n;++i)dp[1<<i][i+1]=f[0][i+1];//处理边界

 

        for(int i=1;i<(1<<n);++i)//error：状态描述中此状态不包含j

        {

            for(int j=1;j<=n;++j)

            {

                if(i&(1<<(j-1)))

                {

                    for(int k=1;k<=n;++k)

                    {

                        if((i-(1<<(j-1)))&(1<<(k-1)))

                            dp[i][j]=min(dp[i][j],dp[i-(1<<(j-1))][k]+f[k][j]);

                    }

                }

            }

        }

        int ans=INF;

        for(int i=1;i<=n;++i)

        {

            ans=min(ans,dp[(1<<n)-1][i]+f[i][0]);

        }

        cout<<ans<<endl;

 

 

    }

    return 0;

}

 

错题思路（或者未实现的思路）：

#define ll long long

using namespace std;

const ll INF=999999999;

int f[12][12];

void floyed(int n)

{

 

    for(int k=1;k<=n;++k)

    {

        for(int i=1;i<=n;++i)

        {

            for(int j=1;j<=n;++j)

            {

                f[i][j]=min(f[i][j],f[i][k]+f[k][j]);

            }

        }

    }

}

int dp[1500][12];

int main()

{

    int n;

    while(cin>>n)

    {

        memset(f,0,sizeof(f));

        for(int i=0;i<=n;++i)

            for(int j=0;j<=n;++j)

                cin>>f[i][j];

        floyed(n);

 

        for(int i=0;i<(1<<n);++i)

            for(int j=0;j<=n;++j)dp[i][j]=INF;

 

        for(int i=0;i<=n;++i)dp[0][i]=f[0][i];

 

        for(int i=0;i<(1<<n);++i)

        {

            for(int j=1;j<=n;++j)

            {

                if(dp[i][j])

                {

                    for(int k=1;k<=n;++k)

                    {

                        if((i+(1<<(j-1)))&&(1<<(k-1)))continue;

                        else

                            dp[i+(1<<(j-1))][k]=min(dp[i+(1<<(j-1))][k],dp[i][j]+f[j][k])

                    }

                }

            }

        }

        int ans=INF;

        for(int i=1;i<=n;++i)

        {

            ans=min(ans,dp[((1<<n)-1)-(1<<(i-1))][i]+f[i][0]);

        }

        cout<<ans<<endl;

 

    }

    return 0;

}

修改正确后：

#include <iostream>

#include<cstdio>

#include<algorithm>

#define ll long long

using namespace std;

const ll INF=999999999;

int f[12][12];

void floyed(int n)

{

 

    for(int k=0;k<=n;++k)

    {

        for(int i=0;i<=n;++i)

        {

            for(int j=0;j<=n;++j)

            {

                f[i][j]=min(f[i][j],f[i][k]+f[k][j]);

            }

        }

    }

}

int dp[1500][12];

int main()

{

    int n;

    while(cin>>n&&n)

    {

        memset(f,0,sizeof(f));

        for(int i=0;i<=n;++i)

            for(int j=0;j<=n;++j)

                cin>>f[i][j];

        floyed(n);

 

        for(int i=0;i<(1<<n);++i)

            for(int j=0;j<=n;++j)dp[i][j]=INF;

 

        for(int i=0;i<n;++i)dp[1<<i][i+1]=f[0][i+1];

 

        for(int i=0;i<(1<<n);++i)

        {

            for(int j=1;j<=n;++j)

            {

                if(dp[i][j]&&(i&(1<<(j-1))))

                {

                    for(int k=1;k<=n;++k)

                    {

                        if(i&(1<<(k-1)))continue;

                        else

                            dp[i+(1<<(k-1))][k]=min(dp[i+(1<<(k-1))][k],dp[i][j]+f[j][k]);

                    }

                }

            }

        }

        int ans=INF;

        for(int i=1;i<=n;++i)

        {

            ans=min(ans,dp[((1<<n)-1)][i]+f[i][0]);

        }

        cout<<ans<<endl;

 

    }

    return 0;

}

5.顺路A，概率类题目（注意精度）

题解地址：https://blog.csdn.net/zhenlingcn/article/details/76021104?locationNum=5&fps=1

#include<ctime>

#define ll long long

using namespace std;

double a[50];

int main()

{

    int n;

    int cas=0;

    while(cin>>n&&n)

    {

        char ch[110];

        for(int i=1;i<=n;++i)

        {

            scanf("%s",&ch);

            a[i]=atof(ch);

        }

        int num=0;

        for(int i=0;i<strlen(ch);++i)

        {

            if(ch[i]=='.')

            {

                num=strlen(ch)-1-i;

                break;

            }

        }

        int ans=0;

        for(int i=1;i<=10000;++i)

        {

            int minn=0,maxx=0;

            for(int j=1;j<=n;++j)

            {

                 minn+=ceil( 1.0*i*(a[j]*pow(10,num)-0.5000)/100/pow(10,num) );//精度

                 maxx+=floor( 1.0*i*(a[j]*pow(10,num)+0.4999)/100/pow(10,num) );

            }

            if(i>=minn&&i<=maxx)

            {

                ans=i;

                break;

            }

        }

        if(ans)cout<<"Case "<<++cas<<": "<<ans<<endl;

        else cout<<"Case "<<++cas<<": "<<"error"<<endl;

    }

    return 0;

}

 

 

6.哈密尔顿路径求最大权值：

/*

Wa：n==1没特判、数组开的太大超内存限制（1<<14,20,20）、减法状态转移数组下溢；

PS：这题的结果处理上也是个亮点；

*/

 

#include<bits/stdc++.h>

#define ll long long

using namespace std;

int v[20];

int g[20][20];

int dp[9000][15][15];

ll num[9000][15][15];

bool judge(int i,int j,int k,int l)

{

    if(l==j||j==k||k==l)return 0;

    if(!g[j][k]||!g[k][l])return 0;

 

    if(  !((i&(1<<(j-1)))&&(i&(1<<(k-1)))&&(i&(1<<(l-1)))) )return 0;

    if(dp[i-(1<<(l-1))][j][k]==-1)return 0;//减法运算注意数组下溢；

    return 1;

 

}

int main()

{

    /*区别上面弗洛依德算法+状压dp解决旅行商问题：

        分析：

            *状压dp与图联系，一般情况下用二维【sta】【停驻点】数组，但因为 所求的路径权值有三个来源：

              点的权值相加、边的权值相加（端点的乘积）、额外三角形权值，为求得第三个权值来源，

              需要记录下2个点的状态，因此，开三维数组，【sta】【停驻点上一点】【停驻点】。

              时间复杂度：

                    o(1024*8* 13*13*13==2e7)；

              空间复杂度：

                    16384*20*20==6e6,完全ok。

        处理步骤：

            *n点数，m边数，v[]存点权值， g[][]构图（无向图），dp存最大权值，num[]存路径数；

            *变量初始化：因为求最大权值，数组均初始化为0即可；

            *边界处理：三维一般用两层循环初始化边界，本题中即含两点的状态：权值即点权值和+边权值和，

              路径数目即初始化为1。

            *状态转移：dp【sta+k点】【j】【k】=max dp【sta】【i】【j】+v【k】+v【k】*v【j】+（三角形判断）

              上式执行的条件：sta中有i点、j点，无k点；i与j相连，j与k相连，dp【】【i】【j】

              已经赋值（没赋值的即该状态不满足所有为1的点全被访问过），（保证由已知推算未知）；

                **另外附加判断三角形，，，（略）

                **若新值>原来值，更新dp，同时num更新为新的哈密尔顿路径数

                **若新值==原来值，原来的哈密路径数+新的哈密路径数

            *答案选择，dp【二的n次方-1】【i随机】【j随机】中取max作为 哈密路径最大权值，同时对应

            num【】【】【】为路径数，又因为题目要求 一条路径的反向与正向味同一条路，所以所取路径数/2作为

            最终答案。

            *输出哈密尔顿路径最大权值，哈密尔顿路径数；

    */

    int t;

    cin>>t;

    while(t--)

    {

        memset(g,0,sizeof(g));

        memset(v,0,sizeof(v));

        memset(dp,-1,sizeof(dp));

        memset(num,0,sizeof(num));

        int n,m;

        cin>>n>>m;

        for(int i=1;i<=n;++i)cin>>v[i];

        if(n==1)//对于1的情况要特判

        {

            cout<<v[1]<<" 1"<<endl;

            continue;

        }

        for(int i=1;i<=m;++i)

        {

            int x,y;

            cin>>x>>y;

            g[x][y]=g[y][x]=1;

        }

        for(int j=1;j<=n;++j)

            for(int k=1;k<=n;++k)

            {

                if(g[j][k])

                {

                    int sta=(1<<(j-1))+(1<<(k-1));

                    dp[sta][j][k]=v[j]+v[k]+v[j]*v[k];

                    num[sta][j][k]=1;

                }

            }

 

        for(int i=0;i<(1<<n);++i)

        {

            for(int j=1;j<=n;++j)

            {

                for(int k=1;k<=n;++k)

                {

                    for(int l=1;l<=n;++l)

                    {

                        if(judge(i,j,k,l))

                        {

                            int temp=dp[i-(1<<(l-1))][j][k]+v[l]+v[l]*v[k];

                            if(g[j][l])temp+=v[j]*v[k]*v[l];

                            if(temp>dp[i][k][l])

                            {

                                dp[i][k][l]=temp;

 

                                num[i][k][l]=num[i-(1<<(l-1))][j][k];

                            }

                            else if(temp==dp[i][k][l])

                            {

                                num[i][k][l]+=num[i-(1<<(l-1))][j][k];

                            }

                        }

                    }

                }

            }

        }

        ll ans=0,res=0;

        for(int i=1;i<=n;++i)

        {

            for(int j=1;j<=n;++j)

            {

                if(dp[(1<<n)-1][i][j]>ans)

                {

                    ans=dp[(1<<n)-1][i][j];

                    res=num[(1<<n)-1][i][j];

                }

                else if(ans==dp[(1<<n)-1][i][j])

                {

                    res+=num[(1<<n)-1][i][j];

                }

            }

        }

        cout<<ans<<" "<<res/2<<endl;

 

 

    }

    return 0;

}

 

 

7.旅行团参观景点，难点权值的预处理（暴力枚举法）

#include <cstdio>

#include <cmath>

#include <cstring>

#define ll long long

using namespace std;

const ll INF=999999999;

int like[15][15];

int cost[15];

int cp[15][15];

int dp[1500][15];

int v[1500][15];

void init(int n,int m)

{

    memset(v,0,sizeof(v));

    for(int i=1;i<=m;++i)

    {

        for(int j=0;j<(1<<n);++j)

        {

            for(int k=1;k<=n;++k)

            {

                if(j&(1<<(k-1)))//满足这个if才能继续下面的语句，WA：下面那个for放在了if外面；

                {

                    v[j][i]+=like[k][i]-cost[i];

                    for(int l=k+1;l<=n;++l)

                    {

                        if(j&(1<<(l-1)))v[j][i]+=cp[k][l];

                    }

                }

            }

        }

 

    }

}

void DP(int n,int m)

{

    for(int i=0;i<(1<<n);++i)

        for(int j=1;j<=m;++j)dp[i][j]=-INF;//有负解，所以全部初始化为极小值，不能是0；

    for(int i=0;i<(1<<n);++i)dp[i][1]=v[i][1];

    for(int i=2;i<=m;++i)

    {

        for(int j=0;j<(1<<n);++j)

        {

            for(int k=j;k<(1<<n);++k)

            {

                if((j&k)==j)

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

            }

        }

    }

}

int main()

{

    /*

        问题分析：

                n个游客，m个景点，每个游客对不同景点有不同的喜爱度like[1~n][1~m],不同景点不通花费cost[1~m]，n个人中某两个人在一起时会产生附加权值cp【1~n】【1~n】（正的）。游客们按顺序依次参观景点，参观过程可删掉某一游客且不能再次加入，问怎样安排 能使最后的权值最大，最大为多少。

                状态dp【sta】【当前景点】；

                转移方程：dp【sta1】【当前景点】=max{dp【sta包含于,,,,,,sta2】【上一景点】+v【sta】【当期景点】}

        步骤描述：

            *数组初始化 ：求最大值，初始化为0即可，dp也可初始化为-1，具体看情况。

            *输入：n，m，like（n，m），cost（m），cp,

            *边界处理：dp【all sta】【1】=v【sta】【1】；

                **v【】【】的预处理：

                    循环：景点、状态、数位/人员1、数位2；  o（10*1024*10*10）

            *状态转移：循环：景点、状态1、状态2，转移条件：状态1含于状态二；

                                                                    o（10*1024*1024）；

            *答案处理，dp【各种sta】【m】中选最大值，据题意输出答案。

 

    */

    int n,m;

    while(cin>>n>>m&&n+m)

    {

        memset(like,0,sizeof(like));

        memset(cost,0,sizeof(cost));

        memset(cp,0,sizeof(cp));

     for(int i=1;i<=m;++i)cin>>cost[i];

        for(int i=1;i<=n;++i)

            for(int j=1;j<=m;++j)cin>>like[i][j];

 

        for(int i=1;i<=n;++i)

            for(int j=1;j<=n;++j)cin>>cp[i][j];

        init(n,m);

        DP(n,m);

        int ans=-1;

        for(int i=0;i<(1<<n);++i)ans=max(ans,dp[i][m]);

        if(ans>0)cout<<ans<<endl;

        else cout<<"STAY HOME"<<endl;

 

    }

    return 0;

}

8.二傻补作业，一定补不完（亮点：输出方案路径），，，

#include <cstdio>

#include <cmath>

#include <cstring>

#define ll long long

using namespace std;

const int INF=999999999;

string name[20];

int limit[20],cost[20];

int day[40000];

int dp[40000];

int memor[40000];

void init(int n)

{

    memset(day,0,sizeof(day));

    for(int i=0;i<(1<<n);++i)

    {

        int sum=0;

        for(int j=0;j<n;++j)

        {

            if(i&(1<<j))

            {

                sum+=cost[j+1];

            }

        }

        day[i]=sum;

 

    }

}

void print(int sta)

{

    if(sta==0)return ;

    print(sta-(1<<(memor[sta]-1)));

    cout<<name[memor[sta]]<<endl;

}

int main()

{

    /*

    分析：

        dp【sta】表示在sta状态（已做完的科目用1表示）下扣除的分数；

        状态转移方程：dp【sta】=min{dp【sta-k】+（sta-k）代表的天数+k所需要的天数-k的限制时间}；

        其中 【状态】对应的天数可以暴力枚举预处理 day【sta】，循环：状态、数位，o（32768*15）复杂度不超时限。

    处理步骤：

    *数据输入：n科目数、string【1~n】科目名、limit【1~n】科目时限、cost【1~n】科目花费时间、time【sta】预处理不同状态所对应的天数；

    *状态转移：

        循环：状态、科目；

        转移条件：状态中含有该科目；转移过程同时记录 状态最优值对应的最后一门科目meor【sta】=k；

        注意：减法注意数组下溢；

    *输出最优解：即目标状态dp【sta】，方案递归输出；

   

    */

    int t;

    cin>>t;

    while(t--)

    {

        memset(limit,0,sizeof(limit));

        memset(cost,0,sizeof(cost));

 

        int n;

        cin>>n;

        for(int i=1;i<=n;++i)cin>>name[i]>>limit[i]>>cost[i];

        init(n);

        memset(memor,0,sizeof(memor));

        for(int i=1;i<(1<<n);++i)

        {

            dp[i]=INF;

            for(int j=n;j>=1;--j)//正向WA，这里逆向考虑，因为小状态到大状态转移时不是每次从最小的选起，例如选最后一门科目时，应该最大序的科目，而按正向考虑，选择的是最小序的科目。

            {

                if(i&(1<<(j-1)))

                {

                    int temp=day[i-(1<<(j-1))]+cost[j]-limit[j];

                    if(temp<0)temp=0;

                    if(dp[i-(1<<(j-1))]+temp<dp[i])

                    {

                        dp[i]=dp[i-(1<<(j-1))]+temp;

                        memor[i]=j;

                    }

                }

            }

        }

        cout<<dp[(1<<n)-1]<<endl;

        print((1<<n)-1);

 

    }

    return 0;

 

}

 

9.方格取数（这么高的复杂度能水过？）

没啥说的就这么几步：

/*

         *输入数据

         *缩减可行状态数，（不然数组会爆，时间也会爆）

*打表预处理权值

*状态转移

*选择最优解输出数据

*/

#include <cstdio>

#include <cmath>

#define ll long long

using namespace std;

const int INF=999999999;

int g[25][25];

ll dp[20000][25];

ll sta[20000];

ll v[20000][25];

int  pre(int n)//缩减可行解&&预处理权值打表

{

    memset(sta,0,sizeof(sta));

    memset(v,0,sizeof(v));

    int tot=0;

    for(int i=0;i<(1<<n);++i)

    {

        if(i&(i>>1)){}

        else sta[++tot]=i;

    }

 

 

    for(int k=1;k<=n;++k)//权值打表；

        for(int i=1;i<=tot;++i)

        {

            int sum=0;

            for(int j=0;j<n;++j)

            {

                if(sta[i]&(1<<j))sum+=g[k][j+1];

            }

            v[i][k]=sum;

        }

 

    return tot;//max<20000

}

void init(int n)

{

    memset(g,0,sizeof(g));

    for(int i=1;i<=n;++i)

        for(int j=1;j<=n;++j)cin>>g[i][j];

}

void solve(int n,int tot)

{

    memset(dp,0,sizeof(dp));

    for(int i=1;i<=tot;++i)dp[i][1]=v[i][1];

    for(int i=2;i<=n;++i)

    {

        for(int j=1;j<=tot;++j)

        {

            for(int k=1;k<=tot;++k)

            {

                if(!(sta[j]&sta[k]))

                {

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

                }

            }

        }

    }

}

int main()

{

    int n;

    while(cin>>n)

    {

 

        init(n);

        int tot=pre(n);

        solve(n,tot);

        ll ans=0;

        for(int i=1;i<=tot;++i)ans=max(ans,dp[i][n]);

        cout<<ans<<endl;

 

    }

}

10.删除回文串最少次数（玄学，dp过程子集合正向枚举不行，for不做小技巧不行）

#include <cstdio>

#include <cmath>

#include <cstring>

#define ll long long

using namespace std;

const int INF=999999999;

bool mark[(1<<16)+100];

int dp[70000];

char ch[20];

void pre(string str)//回文串判断预处理；

{

    memset(mark,0,sizeof(mark));

    int n=str.length();

    for(int i=0;i<(1<<n);++i)

    {

        int tot=0;

        for(int j=0;j<n;++j)

        {

            if(i&(1<<j))ch[++tot]=str[j];

        }

        bool flag=1;

        for(int j=1;j<=tot/2;++j)

            if(ch[j]!=ch[tot-j+1])flag=0;

        mark[i]=flag?1:0;

    }

}

void DP(string str)//DP过程不是很好处理，也可能是感冒，，，

{

    int n=str.length();

    for(int i=0;i<(1<<n);++i)dp[i]=INF;

    dp[0]=0;

    /*for(int i=1;i<(1<<n);++i)//母状态

    {

        for(int j=1;j<=i;(++j)&=i)//删去的子状态

        {

            if(mark[j])

                dp[i]=min(dp[i],dp[i-j]+1);

        }

    }*/

    for(int i=1;i<(1<<n);i++)

    {

        for(int j=i;j>0;(--j)&=i)//枚举j状态下的子集

        {

            if(mark[j])//如果该子集合法则列入方程计算

            {

                dp[i]=min(dp[i],dp[i-j]+1);

            }

        }

    }

}

int main()

{

    /*

 

        分析：容易想到方程dp【sta-子sta】=min{ dp【sta-子状态】+1 }；

        条件：被减的子状态应当是回文串；

 

    */

    int t;

    cin>>t;

    while(t--)

    {

        string str;

        cin>>str;

        pre(str);

        DP(str);

        cout<<dp[(1<<str.length())-1]<<endl;

    }

    return 0;

}

 

 

 

11.哈密尔顿回路（选定首尾点、计数问题一般用long long）；

题意：给n个珠子，以及构图规则（无向图），求其中哈密尔顿回路的数目，正向与反向不一样。

#define ll long long

using namespace std;

ll dp[270000][20];

int g[20][20];

int main()

{

    int n,m;

    while(cin>>n>>m)

    {

        memset(dp,0,sizeof(dp));

        memset(g,0,sizeof(g));

        for(int i=1;i<=m;++i)

        {

            int x,y;

            cin>>x>>y;

            g[x][y]=g[y][x]=1;

        }

 

        //for(int i=1;i<=n;++i)dp[1<<(i-1)][i]=1;//WA

        dp[1][1]=1;//设定环的规则，从一开始到一结束，因此其他单个珠子2,3...在起点时无法形成环项链，因此初值为0

        for(int i=2;i<(1<<n);++i)

        {

            for(int j=1;j<=n;++j)//当前

            {

                for(int k=1;k<=n;++k)//上一个

                {

                    if((i&(1<<(j-1)))&&(i&(1<<(k-1)))&&g[j][k])//没加dp！=-1的原因，无其他附加权值，+0对结果无影响，（区别哈密尔顿路径那个地方）；

                    {

                        dp[i][j]+=dp[i-(1<<(j-1))][k];

                    }

                }

            }

        }

        ll ans=0;

        for(int i=1;i<=n;++i)//上文边界处理呼应

        {

            if(g[1][i])ans+=dp[(1<<n)-1][i];

        }

        cout<<ans<<endl;

 

    }

    return 0;

}

 

 

13.（连连看，难想，状态上限和n混淆，思路较新颖）

#include <cstdio>

#include <cmath>

#include <cstring>

#define ll long long

using namespace std;

int dp[2050][1500];

int a[1500];

int main()

{

   /*

    思路：dp不太好想，这里考虑每个点可操作的其他点为该点往下的9个点，为什么不是5个点呢，因为该点上面的点至多可操作该点下的第1、2、3、4个点；

所以，状态可以用10位二进制表示，因此dp【sta】【i】表示当前判断以i为首状态为sta时第i个数是否可消除，状态转移关系dp【sta】【i】=（i+1~i+9逐个判断权值是否相同）

并且距离小于等于“逻辑6”，若可消除，生成新的状态dp【new sta】【i+1】。

    处理步骤：

    *输入：n存数据个数，a【1~n】存元素，dp【1<<10】【1000】，初始化0，表示状态不存在;

    *边界处理：i=1时，只有“实际距离”6之内的可能被消除，按条件处理状态。

    *状态转移：从第二层开始转移，转移条件：这一层有这一状态.

    *目标状态：dp【0】【n+1】是否存在，原因：若序列可以完全消除，到最后一个数据时，其比特位必定为1，否则不可消除。进而转移

到dp【0】【n+1】=1.

    *输出答案

 

    */

 

   int n;

   while(cin>>n)

   {

       memset(a,0,sizeof(a));

       memset(dp,0,sizeof(dp));

       for(int i=n;i>=1;--i)cin>>a[i];

 

       for(int i=1;i<=5;++i)

       {

           if(a[1]==a[i+1])

           {

               dp[1<<(i-1)][2]=1;

           }

       }

 

       for(int i=2;i<=n;++i)

       {

           for(int j=0;j<(1<<10);++j)//WA cao，这里是10，不是n，，，，，，

           {

               if(dp[j][i])

               {

                   if(j&1)

                   {

                       dp[j>>1][i+1]=1;

                       continue;

                   }

                   else

                   {

                       int tt=0;

                       for(int k=1;k<=9&&i+k<=n;++k)//

                       {

                           if(!(j&(1<<k))&&(a[i]==a[i+k])&&(k-tt<=5))

                           {

                               dp[(j>>1)+(1<<(k-1))][i+1]=1;

                           }

                           else if(j&(1<<k))tt++;

                       }

                   }

               }

           }

       }

       if(dp[0][n+1]==1)cout<<"1"<<endl;

       else cout<<"0"<<endl;

 

   }

   return 0;

 

}

 

14.射击外星人（难度较大思路很好想：难点在于优化，核心运用贪心的思想，状态转移过程也需要细节优化，删减无用状态在这里不好用，另外数组开小TLE了好久）

#include <cstdio>

#include <cmath>

#define ll long long

using namespace std;

const double INF=999999999;

struct point

{

    double x,y;

}a[50];

double v[50][50];

double dp[1100000];

int sta[600000];

double getDis(point a,point b)

{

    double ans=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

    return ans;

}

bool cmp(point a,point b)

{

    point p;

    p.x=0,p.y=0;

    return getDis(a,p)<getDis(b,p);

}

void init(int n,point s)

{

    for(int i=1;i<=n*2;++i)

    {

        for(int j=1;j<=n*2;++j)

        {

            v[i][j]=getDis(s,a[i])+getDis(a[i],a[j]);

        }

    }

 

 

}

int main()

{

 

    /*

    思路：

        状态：dp【sta】

        转移方程：dp【sta+j+k】=min{dp【sta】+v【j】【k】};

        目标状态：dp【满状态】

 

    步骤：

        *输入：n次射击、2*n组坐标point a[2n].x/y、dp【sta】初始化极大值；

        *边界处理：含有2个1的sta；

        *权值v【】【】预处理：

            调用计算两点间距离double getDis(point,point)

        *状态转移：

            转移条件：sta中不含j点、k点

 

        *输出结果

 

    */

    int t;

    cin>>t;

    int cas=0;

    while(t--)

    {

        int sx,sy;

        cin>>sx>>sy;

        point start;

        start.x=sx;

        start.y=sy;

        int n;

        cin>>n;

        for(int i=1;i<=2*n;++i)cin>>a[i].x>>a[i].y;

        sort(a+1,a+1+2*n,cmp);//这里最关键，贪心优化

        for(int i=0;i<(1<<(2*n));++i)dp[i]=INF;

        init(n,start);

        dp[0]=0;

        for(int i=0;i<(1<<(2*n));++i)

        {

            if(dp[i]==INF)continue;//这里很关键

            int j=0;

            while(((i>>j)&1) &&(j<2*n-1))j++;//贪心优化

            for(int k=j+1;k<n*2;++k)

            {

                if(!(i&(1<<j))&&!(i&(1<<k))&&j!=k)

                {

                    double temp=min(dp[i]+v[j+1][k+1],dp[i]+v[k+1][j+1]);

                    dp[i+(1<<k)+(1<<j)]=min(dp[i+(1<<j)+(1<<k)],temp);

                }

 

            }

        }

        printf("Case #%d: %.2lf\n",++cas,dp[(1<<(2*n))-1]);

    }

    return 0;

}

17.郑厂长排兵布阵

（直接套炮兵阵地的模板，主要改动的地方：状态之间的关系、筛选状态的条件;WA原因：筛选状态的数组开小、统计可行状态中1数量的数组开小、行之间状态的关系判断少步骤（区分自身有误相邻的判断））。

#include <cstdio>

#include <cmath>

#include <cstring>

#define ll long long

using namespace std;//为什么要开三维数组，因为二维无法表示对应状态限制下的子解

int a[600];

int num[1000];

int sta[200];

int dp[110][200][200];

int getNum(int x,int n)//状态中1的个数

{

    int ans=0;

    for(int i=0;i<n;++i)

    {

        if((x>>i)&1)ans++;

    }

    return ans;

}

int init(int n)

{

    memset(a,0,sizeof(a));

    memset(num,0,sizeof(num));

    int tot=0;

    for(int i=0;i<(1<<n);++i)

    {

        if((i&(i>>2)))continue;

        else

        {

            a[++tot]=i;

            num[i]=getNum(i,n);

        }

 

    }

    return tot;

}

 

int main()

{

    int n,m;

    while(cin>>n>>m)//n行，m列

    {

        memset(sta,0,sizeof(sta));

        memset(dp,-1,sizeof(dp));

        for(int i=1;i<=n;++i)

        {

            for(int j=1;j<=m;++j)

            {

                int x;

                cin>>x;

                if(x==1)x=0;

                else x=1;

                sta[i]+=x*(1<<(m-j));

            }

            //sta[i]=~sta[i];

        }

        int tot=init(m);  //cout<<tot<<endl;

        int maxx=0;

        for(int i=1;i<=tot;++i)//第一行

        {

            if(n==1)//只有一行的情况要特判

            {

                if(!(sta[1]&a[i]))maxx=max(maxx,getNum(a[i],m));

                continue;

            }

            for(int j=1;j<=tot;++j)//第二行

            {

                if( !(sta[1]&a[i]) && !(sta[2]&a[j]) && !((a[i]>>1)&a[j]) &&!(a[i]&(a[j]>>1)))

                {

                    dp[2][j][i]=num[a[j]]+num[a[i]];

                    maxx=max(maxx,dp[2][j][i]);

                }

            }

        }

        for(int i=3;i<=n;++i)

        {

            for(int j=1;j<=tot;++j)//当前

            {

                if(a[j]&sta[i])continue;

                for(int k=1;k<=tot;++k)//上一

                {

                    if(a[k]&sta[i-1])continue;

                    if((a[j]&(a[k]>>1))||((a[j]>>1)&a[k]))continue;

                    for(int l=1;l<=tot;++l)//上二

                    {

                        //if(a[l]&sta[i-2])continue;

                        if(a[l]&a[j])continue;

                        if(dp[i-1][k][l]!=-1)

                        {

                            dp[i][j][k]=max(dp[i][j][k],dp[i-1][k][l]+num[a[j]]);

                            maxx=max(maxx,dp[i][j][k]);

                            //cout<<maxx<<endl;

                        }

                    }

                }

            }

        }

        cout<<maxx<<endl;

 

    }

    return 0;

}