[luogu7740]机器人游戏

考虑容斥，令$f(S)$为要求$forall pin S,p$可以作为起点的方案数，答案即$sum_{Ssubseteq[0,n)}(-1)^{|S|}f(S)$

关于计算$f(S)$，对于第$i$个机器人而言，$p$可以作为起点实际上即给出了$X_{i}$和$Y_{i}$每一位上的一种限制，限制共有四种（令两者分别为$x$和$y$，即$y=0,y=1,x=y$和$x e y$）

对每种限制预处理出第$i$个机器人以$p$为起点第$j$位上是否存在该限制，并用unsigned int存储，即可$o(n)$合并限制，进而对每一个位置分别求出满足此限制下的方案数，全部相乘即为$f(S)$

（另外需要注意如果会超出范围，仍存在全为空位的一组解）

预处理复杂度为$o(n^{2}m)$，求$f(S)$的复杂度为$o(nm)$，时间复杂度为$o(nm2^{n})$，无法通过

进一步的，预处理出子集并，再简单分类讨论即可快速求出方案数（一个unsigned int的2的位数可以将其前后的16位拆开分别处理），时间复杂度降为$o(m2^{n})$，仍无法通过

考虑优化，设第$i$个机器人有$r_{i}$个'R'，那么若$r_{i}+max_{xin S}xge n$即会导致其对答案没有贡献

接下来，考虑暴力枚举$max_{xin S}x$并对其分类讨论：

1.若$max_{xin S}x<lceilfrac{n}{2} ceil$，直接暴力枚举$S$即可，时间复杂度为$o(m2^{frac{n}{2}})$

2.若$max_{xin S}xge lceilfrac{n}{2} ceil$，那么若$r_{i}+xge n$其对答案也没有贡献，不需要考虑

换言之，此时即有$0le r_{i}<x$，那么一个位置对答案是否有贡献仅取决于其之前$x$个格子的起点状态以及再之前是否存在起点（即要求相同）

由此，记录这些状态即可状压dp，通过预处理也可以做到$o((n^{2}+m)2^{frac{n}{2}})$

综上，总复杂度为$o((n^{2}+m)2^{frac{n}{2}})$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 35
#define M 1005
#define L (1<<16)
#define mod 1000000007
#define inv2 500000004
#define inv3 333333336
#define inv5 400000003
#define ll long long
#define ui unsigned int
int n,m,R,nn,ans,mi2[N],mi3[N],cnt[L],r[M];
char s[105];
ui o=1,lim[M][N][4],Lim[L][4];
int lowbit(int k){
    return (k&(-k));
}
void get(int k){
    int nn=(n+1>>1);
    for(int i=0;i<nn;i++)memcpy(Lim[1<<i],lim[k][i],sizeof(lim[k][i]));
    for(int S=1;S<(1<<nn);S++)
        for(int i=0;i<4;i++)Lim[S][i]=(Lim[lowbit(S)][i]|Lim[S^lowbit(S)][i]);
}
namespace Subtask1{
    int sum[L];
    int count(ui k){
        return cnt[k>>16]+cnt[k&(L-1)];
    }
    void calc(){
        nn=(n+1>>1);
        for(int S=1;S<(1<<nn);S++)sum[S]=1;
        for(int i=1;i<=m;i++){
            get(i);
            for(int S=1;S<(1<<min(n-r[i],nn));S++){
                ui p0=Lim[S][0],p1=Lim[S][1];
                ui p2=Lim[S][2],p3=Lim[S][3];
                ui P0=((p0&p1)|(p2&p3));
                if (n<32)P0^=(o<<n)-1;
                else P0^=(ui)(-1);
                ui P1=((p0|p1)&(p2|p3)&P0);
                sum[S]=(ll)mi2[count(P1)]*mi3[count(P0^P1)]%mod*sum[S]%mod;
            }
        }
        for(int S=1;S<(1<<nn);S++)
            if (cnt[S]&1)ans=(ans+sum[S])%mod;
            else ans=(ans-sum[S]+mod)%mod;
    }
}
namespace Subtask2{
    int id[M],g[L][2],f[2][L][2];
    bool cmp(int x,int y){
        return r[x]<r[y];
    }
    void calc(){
        for(int i=1;i<=m;i++)id[i]=i;
        sort(id+1,id+m+1,cmp);
        nn=(n>>1);
        for(int S=0;S<(1<<nn);S++)g[S][0]=g[S][1]=1;
        for(int x=n-1,k=1;x>=n-nn;x--){
            while ((k<=m)&&(r[id[k]]+x<n)){
                get(id[k]);
                for(int S=0;S<(1<<nn);S++){
                    int p0=((Lim[S][0]>>nn-1)&1),p1=((Lim[S][1]>>nn-1)&1);
                    int p2=((Lim[S][2]>>nn-1)&1),p3=((Lim[S][3]>>nn-1)&1);
                    if ((p0&p1)||(p2&p3))continue;
                    if ((p0|p1)&&(p2|p3))g[S][0]=2*g[S][0]%mod;
                    else{
                        if (p0|p1|p2|p3)g[S][0]=3LL*g[S][0]%mod;
                        else g[S][0]=5LL*g[S][0]%mod;
                    }
                    p2=1;
                    if ((p0&p1)||(p2&p3))continue;
                    if ((p0|p1)&&(p2|p3))g[S][1]=2*g[S][1]%mod;
                    else g[S][1]=3LL*g[S][1]%mod;
                }
                k++;
            }
            memset(f[0],0,sizeof(f[0]));
            f[0][0][0]=1;
            for(int i=0;i<x;i++){
                int ii=(i&1);
                memset(f[ii^1],0,sizeof(f[ii^1]));
                for(int S=0;S<(1<<nn);S++){
                    int p=(S&1),SS=(S>>1);
                    f[ii^1][SS][p]=(f[ii^1][SS][p]+(ll)g[SS][1]*f[ii][S][0])%mod;
                    f[ii^1][SS][1]=(f[ii^1][SS][1]+(ll)g[SS][1]*f[ii][S][1])%mod;
                    SS|=(1<<nn-1); 
                    f[ii^1][SS][p]=(f[ii^1][SS][p]-(ll)g[SS][1]*f[ii][S][0]%mod+mod)%mod;
                    f[ii^1][SS][1]=(f[ii^1][SS][1]-(ll)g[SS][1]*f[ii][S][1]%mod+mod)%mod;
                }
            }
            for(int S=0;S<(1<<nn);S++){
                int p=(S&1),SS=((S>>1)|(1<<nn-1)),s=f[x&1][S][0];
                for(int j=x;j<n;j++){
                    s=(ll)s*g[SS][p]%mod;
                    p|=(SS&1),SS>>=1;
                }
                ans=(ans+s)%mod;
                SS=((S>>1)|(1<<nn-1)),s=f[x&1][S][1];
                for(int j=x;j<n;j++){
                    s=(ll)s*g[SS][1]%mod;
                    SS>>=1;
                }
                ans=(ans+s)%mod;
            }
        } 
    }
} 
int main(){
    mi2[0]=mi3[0]=1;
    for(int i=1;i<N;i++){
        mi2[i]=2*mi2[i-1]%mod;
        mi3[i]=3LL*mi3[i-1]%mod;
    }
    for(int i=1;i<L;i++)cnt[i]=cnt[i^lowbit(i)]+1;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%s",s);
        for(int j=0;s[j];j++)
            if (s[j]=='R')r[i]++;
        for(int j=0;j<n-r[i];j++){
            for(int k=0;k<j;k++)lim[i][j][2]|=(o<<k);
            for(int k=j+r[i]+1;k<n;k++)lim[i][j][2]|=(o<<k);
            int pos=j,lst=2;
            for(int k=0;s[k];k++){
                if (s[k]=='R'){
                    lim[i][j][lst]|=(o<<pos);
                    pos++,lst=2;
                }
                else{
                    if (s[k]=='*')lst^=1;
                    else lst=s[k]-'0';
                }
            }
            lim[i][j][lst]|=(o<<pos);
        }
    }
    Subtask1::calc();
    Subtask2::calc();
    printf("%d
",ans);
    return 0;
}