[状压DP][BFS][哈希]JZOJ 3243 Cube

Description

你被困在一个密室里。经过一轮摸索,你在密室里有所发现:

1.密室是一个呈m×n网格的长方形,地面有六个格子被上了色;

2.密室地面部分格子可能有障碍物;

3.密室的某一格有一个六面都没上色的立方体;

4.当立方体滚动到相邻无障碍物的格子,如果立方体接触地面的一面没有颜色而地面有颜色,则该颜色会从地面转移到立方体上;如果立方体接触地面的一面有颜色而地面没有颜色,则该颜色会从立方体转移到地面上;如果立方体接触地面的一面和地面都有颜色,则两者的颜色都不会转移。

5.当立方体滚动到密室的指定地点,如果立方体六面都被涂上了颜色,则传送门就会开启,让你逃离这个密室。

由于时间紧迫,你必须借助计算机的力量,算出立方体最少滚动几次就可以让你逃离这个密室。
 

Input

输入的第一行是用空格分隔的两个正整数m和n(2<=m<=20,2<=n<=20),分别代表密室的高和宽。接下来的m行,每行有n个字符,含义如下:

‘.’:该格子是空白的;

‘#’:该格子有障碍物;

‘P’:该格子是上色的;

‘C’:立方体就在这个格子;

‘G’:能让你逃离密室的指定地点。

整个密室保证正好有6个格子是‘P’,1个格子是‘C’,1个格子是‘G’,‘.’的格子不超过12个。

Output

输出仅一个整数,代表立方体最少滚动的次数。我们保证每个密室场景都有解。

对以下第一个样例,立方体最少只需要滚动10次(下右右上右右下左右左)。
 

Sample Input

输入1:
2 5
C.PPP
PPPG.

输入2:
4 5
C....
G##.P
.##PP
..PPP

输入3:
3 3
PPP
PCP
PG.

输入4:
2 10
.PPPCPPP..
....G.....

Sample Output

输出1:
10

输出2:
23

输出3:
15

输出4:
21
 

Data Constraint

2<=m<=20,2<=n<=20

分析

今日最难,一个旗鼓相当的对手

首先别被总点数迷惑了,总点数400个,但输入要求告诉我们,能走的点包括起点和终点及颜色,加起来不超过20个

那么我们可以考虑状压,给每个点标号,状态表示哪些点有颜色

这仅仅是图上的状态而已!因为立方体会带走颜色,所以另设一个6位状态,表示立方体当前每个面是否有颜色,建议在写的时候用记事本记着,忘掉了的话转移转死了

两种状态需要放在一起,所以整个状态26位,后6位位立方体状态,前20位为图上状态

然后我们考虑到,会有重复的状态,可是光是这个状态重复不够,有时图上和立方体一样,但是立方体位置不一样!

重复的状态可用哈希加邻接表(或指针)解决

最恶心的部分就是当你的立方体移动时,你的6位颜色状态全部要变一波,一坨位运算堆在一起

同时注意判断一下,当颜色状态中的下面状态与当前立方体在图上位置的状态不一样(一个有颜色一个没颜色)时,需要给他们变状态

空间别开爆了,我12Wkb刚好卡过去

 

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int N=4e2+10;
const int P=388211;
struct SS {
    int u,S;
};
struct QS {
    SS s;
    int dep;
};
struct Graph {
    int v,nx;
}e[10000000];
int cnt;
int n,m;
char c[N][N];
int id[N][N],icnt,g[21][4];
int sx,sy,tx,ty,sS;
queue q;
int p[21][517619];

bool Query(SS a) {
    int i=a.S%P;
    for (int j=p[a.u][i];j;j=e[j].nx)
        if (e[j].v==a.S) return 1;
    return 0;
}

void Insert(SS a) {
    int i=a.S%P;
    e[++cnt]=(Graph){a.S,p[a.u][i]};p[a.u][i]=cnt;
}

int Roll(int S,int type) {
    switch (type) {
        case 0:return (S&48)|((S&3)<<2)|((S&4)>>1)|((S&8)>>3);
        case 1:return (S&48)|((S&1)<<3)|((S&2)<<1)|((S&12)>>2);
        case 2:return ((S&3)<<4)|(S&12)|((S&16)>>3)|((S&32)>>5);
        case 3:return ((S&1)<<5)|((S&2)<<3)|(S&12)|((S&48)>>4);
    }
}

void Solve(int u,int bS,int cS,int dep) {
    if ((cS&1)^((bS>>u-1)&1)) cS^=1,bS^=(1<1);
    if (!bS&&u==id[tx][ty]) {
        printf("%d",dep-1);
        exit(0);
    }
    int S=bS|(cS<<icnt);
    if (Query((SS){u,S})) return;
    q.push((QS){(SS){u,S},dep});
    Insert((SS){u,S});
}

void BFS() {
    q.push((QS){(SS){id[sx][sy],sS},1});
    Insert((SS){id[sx][sy],sS});
    while (!q.empty()) {
        QS a=q.front();q.pop();
        int u=a.s.u,bS=a.s.S&((1<1),cS=a.s.S>>icnt,dep=a.dep;
        for (int i=0;i<4;i++)
            if (g[u][i]) {
                int scS=Roll(cS,i);
                Solve(g[u][i],bS,scS,dep+1);
            }
    }
}

int main() {
    scanf("%d%d",&m,&n);
    for (int i=1;i<=m;i++) scanf("%s",c[i]+1);
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++) {
            if (c[i][j]!='#') id[i][j]=++icnt;
            if (c[i][j]=='C') sx=i,sy=j;
            if (c[i][j]=='G') tx=i,ty=j;
            if (c[i][j]=='P') sS|=(1<1);
        }
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++)
            if (c[i][j]!='#') {
                if (i>1&&c[i-1][j]!='#') g[id[i][j]][0]=id[i-1][j];
                if (i1][j]!='#') g[id[i][j]][1]=id[i+1][j];
                if (j>1&&c[i][j-1]!='#') g[id[i][j]][2]=id[i][j-1];
                if (j1]!='#') g[id[i][j]][3]=id[i][j+1];
            }
    BFS();
}
View Code

 

转载于:https://www.cnblogs.com/mastervan/p/11117931.html

你可能感兴趣的:([状压DP][BFS][哈希]JZOJ 3243 Cube)