zoj3777(状态压缩)

题目阐述：

给定n个座位，n个人，每个人可以做n个位置中的任意一个，P[i][j]代表第i个人做第j个位置获得的分数，求有多少种排列方式使得获得的分数大于等于M。

这道题跟数位dp的思想很像，都是穷举可能的方式，不过数位DP由于前缀的影响可以记忆化，这道题由于n较小，可以直接状态压缩.

定义状态d[i][s][t]代表已经放了i个座位，放的人数集合为s，获得分数为t的排列的数量。

然后每次暴力枚举每个位置可能会放的人

d[i][s | (1 << j)][t+ p[j][i]] +=d[i-1] [s] [t];

重点是如何实现：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#define maxn 13
using namespace std;
int d[<<(maxn)][]; //表示到达状态s时产生的最大能量
int n,m;
int P[maxn][maxn];
int ans;
void init()
{
    ans=;
    memset(d,,sizeof(d));
}
//GCD
//求最大公约数
//O(logn)
int gcd(int a, int b)
{
    if (b == )
    return a;
    else
    return gcd(b, a%b);
}
int isok(int i)
{
    int t=;
    while(i)
    {
        if(i&) t++;
        i>>=;
    }
    return t;
}
void solve()
{
    int tot=(<<n)-;
     d[][]=; //其实可以理解成d[-1][0][0]，否则下面就需要特殊处理i等于0
    for(int i=;i<n;i++)   //代表第i个位置
     {
         for(int s=;s<=tot;s++)  //遍历所有状态
            {
                    if(isok(s)!=i)   continue ;//检测哪些是前i-1个位置的状态
                    for(int t=;t<=m;t++)  //遍历所有获得的分数
                    {
                       if(!d[s][t])  continue; //检测哪些是前i-1个位置获得的分数
                      for(int j=;j<n;j++)  //枚举第i个位置可能放的人
                     {
                         if( s & (<<j) ) //检测前i-1个位置是否放过
                            continue;
                         int state= s | (<<j);
                         int MM=min(m,t+P[j][i]);
                         d[state][MM]+=d[s][t];
                     }
                    }
            }
     }
     ans=d[tot][m];
}

int main()
{
   // freopen("test.txt","r",stdin);
    int fac[maxn];
    fac[]=;
    for(int i=;i<maxn;i++)
        fac[i]=fac[i-]*i;
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=;i<n;i++)
        for(int j=;j<n;j++)
        {
           scanf("%d",&P[i][j]);
        }
        solve();
        int d = gcd(fac[n], ans);
        if (ans == )
            printf("No solution\n");
        else
            printf("%d/%d\n", fac[n]/d, ans/d);
    }
    return ;
}

bfs实现：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#define maxn 13
using namespace std;
int d[<<(maxn)][]; //表示到达状态s时产生的最大能量
int n,m;
int P[maxn][maxn];
int ans;
int gcd(int a, int b)
{
    if (b == )
    return a;
    else
    return gcd(b, a%b);
}

int bit(int i)
{
    int t=;
    while(i)
    {
        if(i&) t++;
        i>>=;
    }
    return t;
}
struct node
{
    int s,t,cnt=;
};
int  visit[<<maxn][];
void   bfs()
{
     queue  < node > que;
     memset(visit,,sizeof(visit));
     int tot=(<<n)-;
     node start,last;
     start.s=; start.t=;
     start.cnt=;
     que.push(start);
     visit[start.s][start.t]=;
     d[][]=;
     while(!que.empty())
     {
         node cur=que.front();
         que.pop();
         for(int i=;i<n;i++)
         {
             if(cur.s & (<<i))
                continue;
             node next  ;
             next.s= cur.s | (<<i);
             next.cnt=cur.cnt+;
             next.t= min(m,cur.t+P[i][cur.cnt]); //将第i个人放在当前位置，然后才会加1
             d[next.s][next.t] += d[cur.s][cur.t];
             if(visit[next.s][next.t])  //保证只进队一次
                continue;
             que.push(next);
             visit[next.s][next.t]=;
         }
     }
     ans=d[tot][m];
}

int main()
{
  // freopen("test.txt","r",stdin);
    int fac[maxn];
    fac[]=;
    for(int i=;i<maxn;i++)
        fac[i]=fac[i-]*i;
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
         ans=;
         memset(d,,sizeof(d));;
        for(int i=;i<n;i++)
        for(int j=;j<n;j++)
        {
           scanf("%d",&P[i][j]);
        }
        bfs();
        int d = gcd(fac[n], ans);
        if (ans == )
            printf("No solution\n");
        else
            printf("%d/%d\n", fac[n]/d, ans/d);
    }
    return ;
}