[CQOI2015]标识设计

Luogu3170 128MB过不去

LOJ2099 256MB能卡过

BZOJ3934 512MB怎么都过的去

求在\(30*30\)的方格上放\(3\)个\(L\)的方案 , 有障碍

拓展这条路的时候只能向下或向右走 , 可以设出\(F[x][y][re][s][ty]\)
表示到了\((x,y)\) , 还剩下\(re\)个\(L\)没有放 , 状态为\(s\) , 当前路径是否正在向右走

由于可能的转移只能是路径向下或向右延伸，因此我们可以推出转移方式（以下可以直接看代码）：
若当前格子在一条向下走的路径上，那么他有向下和向右两种转移。
若当前格子在一条向右走的路径上，那么他有向右和停止两种转移。
若当前格子不在路径上，并且\(res>0\)&&\(y≠m\)，那么他可以作为一条路径的起点。
若当前格子是障碍格，并且处在一条路径上，那么返回\(0\)。
若当前格子同时在一条向右走的路径和向下走的路径上，那么返回\(0\)。
若当前\(y>m\)，跳到下一行。
若当前\(x>n\)，但还有\(L\)没放或者还有路径在向下走，那么返回\(0\)，否则返回\(1\)。

总状态数实测只有\(4150\)以下,可以离散化一下 , 记忆化搜索比较方便

原始题解及代码
\(263MB\)只能在\(BZOJ\)上过

// luogu-judger-enable-o2
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#define N 32
#define M 5000
#define ll long long
using namespace std;
ll n,m,F[N][N][4][M][2];
char G[N][N];
map<ll,ll>Q;
ll R[M],cnt;
//插头&轮廓线的搜索写法
ll DP(ll x,ll y,ll re,ll s,ll ty)//讨论到(x,y)，还剩下 res个L没放，当前状态是s，表示向下的路径的位置，ty表示是否处在向右的路径上 
//其实t才是2进制的状态,s是状态t对应的id
{
    ll i,j,k,tmp=0,t=R[s];//离散化回来 
    if(F[x][y][re][s][ty]>-1)return F[x][y][re][s][ty];//记忆化搜索 
    if(x>n)
    {
        if((!re)&&(!t))return F[x][y][re][s][ty]=1;//L已经放完并且都已经完成了向右走，返回1 
        return F[x][y][re][s][ty]=0;//否则返回0 
    }
    if(y>m)
    {
        if(ty)return F[x][y][re][s][ty]=0;//如果当前处在向右的路径上，返回0 
        return F[x][y][re][s][ty]=DP(x+1,1,re,s,0);//否则跳到下一行继续dp 
    }
    if((1<<(y-1))&t)//如果当前格子在一条向下的路径上 
    {
        if(G[x][y]=='#'||ty)return F[x][y][re][s][ty]=0;//如果他同时在一条向右的路径上，或者是障碍，返回0 
        return F[x][y][re][s][ty]=DP(x,y+1,re,s,0)+DP(x,y+1,re,Q[t^(1<<(y-1))],1);//否则返回这条路径向右走和向下走的方案和（如果开始向右走，那么不能再向下走，记变状态） 
                                                         //由1变成0,不再往下走
    }
    if(ty)//如果当前格子在一条向右的路径上 
    {
        if(G[x][y]=='#')return F[x][y][re][s][ty]=0;//如果当前格子是障碍，返回0 
        return F[x][y][re][s][ty]=DP(x,y+1,re,s,1)+DP(x,y+1,re,s,0);//否则返回这条路径终止和向右走的方案和 
    }
    tmp=DP(x,y+1,re,s,ty);//什么也不做，讨论下一格 
    if(re>0&&G[x][y]=='.'&&y<m)tmp+=DP(x,y+1,re-1,Q[t|(1<<y-1)],ty);//如果当前格子可以作为一条路径的起点，那么新增一条路径 
    return F[x][y][re][s][ty]=tmp;//返回当前的方案数 
}
int main()
{
    memset(F,-1,sizeof(F));
    ll i,j,k,t,tt,ttt;
    scanf("%lld%lld",&n,&m);
    for(i=1;i<=n;i++)scanf("%s",&G[i][1]);

    Q[0]=++cnt;R[cnt]=0;//离散化状态 
    for(i=1;i<=m;i++)
    {
        t=1<<(i-1);
        Q[t]=++cnt;R[cnt]=t;
        for(j=i+1;j<=m;j++)
        {
            tt=t|(1<<(j-1));
            Q[tt]=++cnt;R[cnt]=tt;
            for(k=j+1;k<=m;k++)
            {
                ttt=tt|(1<<(k-1));
                Q[ttt]=++cnt;
                R[cnt]=ttt;
            }
        }
    }

    ll ans=DP(1,1,3,0,0);
    cout<<ans;
}

可以卡到\(247MB\)的代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
map<int,int> P;
char a[32][32];
int n,m,num[4327],cnt=0;
ll f[31][31][4][4327][2];//最大开这么多,254MB了
ll dfs(int x,int y,int re,int s,bool r){
    ll& res=f[x][y][re][s][r];
    if(~res)return res;
    int S=num[s];
    if(x==n){
        if(!re&&!S)return res=1;
        return res=0;
    }
    if(y==m){
        if(r)return res=0;
        return res=dfs(x+1,0,re,s,0);
    }
    if(S&(1<<y)){
        if(a[x][y]=='#'||r)return res=0;
        return res=dfs(x,y+1,re,s,0)+dfs(x,y+1,re,P[S^(1<<y)],1);
    }
    if(r){
        if(a[x][y]=='#')return res=0;
        return res=dfs(x,y+1,re,s,1)+dfs(x,y+1,re,s,0);
    }
    res=dfs(x,y+1,re,s,r);
    if(a[x][y]=='.'&&re>0&&y<m-1)res+=dfs(x,y+1,re-1,P[S|(1<<y)],r);
    return res;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;++i)scanf("%s",a[i]);
    P[0]=++cnt,num[cnt]=0;
    for(int i=0,s1,s2,s3;i<m-1;++i){
        s1=1<<i,P[s1]=++cnt,num[cnt]=s1;
        for(int j=i+1;j<m-1;++j){
            s2=s1|(1<<j),P[s2]=++cnt,num[cnt]=s2;
            for(int k=j+1;k<m-1;++k)
                s3=s2|(1<<k),P[s3]=++cnt,num[cnt]=s3;
        }
    }
    memset(f,-1,sizeof(f));
    printf("%lld\n",dfs(0,0,3,1,0));
    return 0;
}

\(254MB\)记录

转载于:https://www.cnblogs.com/lizehon/p/10643891.html