POJ-1768:Hang or not to hang(bfs+一些特殊优化)

最新推荐文章于 2018-08-27 17:11:31 发布

呜喵汪

最新推荐文章于 2018-08-27 17:11:31 发布

阅读量654

点赞数

分类专栏：搜索---bfs 文章标签： bfs 特殊优化

本文链接：https://blog.csdn.net/f2935552941/article/details/77663088

版权

搜索---bfs 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

题目链接：点击打开链接

题目大意：

主人公写了一段程序，这些程序会对一些迭代器进行操作，使迭代器的值发生变化，问你最后程序能否结束，如果能结束，输出最小步数。

解题思路：

淦，这道题坑了我整整一天。刚开始写出来以后，各种wa，后来发现了一个超级严重的bug，改了以后继续wa，然后wa了一上午加一下午后，突然队友发现每个迭代器的初始值是随机的，我= = ，tm比赛的时候队友还问我这道题有没有什么坑，我看了看题说注意迭代器初始值随机结果补题的时候就他喵忘了。。。说一下自己解这道题的思路历程（其实是wa的历程），希望对大家有所帮助。

首先这道题的迭代器有32个，当时比赛的时候就卡在了这里，不知道怎么优化内存。知道题目上说的最多16个步骤肯定有用就是不知道哪有用。赛后就发现了，我他喵一共16步，那么多迭代器有屁用。然而这里就犯下了一个严重的错误

因为刚开始我默认所有迭代器的值都是0，所以我上来是默认只有a迭代器是有用的，所以我状态里只存了a迭代器，理论上来说如果所有迭代器的初始值都是0的话其实这种思路应该是对的，然而迭代器默认值并不是0，遂wa了将近一天。

发现初始值的问题后，就意识到貌似有点问题，因为初始值随机的话，意味着bfs过程中你的初始状态要将所有的可能状态加入队列，那么就要考虑b迭代器了，那么我存的迭代器数量就可能大大增加，最坏情况貌似还是32个。刚开始还抱着侥幸心理，以为说不定a，b迭代器合起来也就那么多，结果一次RE，一次MLE告诉我，我想多了。

然后就迷茫了，感觉这道题又回到了起点。不知道该怎么做，实在没办法了，去查了大神的博客，然后我真是膜拜了。

其实这道题优化的关键点在于JZ，因为JZ那一步的跳跃是跟a迭代器有关的，其他的步骤除了跟（a迭代器或者间接跟a迭代器有关的迭代器）相关的步骤需要进行操作，其他无关的迭代器直接走就是了，管你的值是多少，程序跟你又没有关系，语文太烂了，表述不清，举个例子，例如

AND a b

XOR b c(理论上来说应该是写成 a，b形式的，这里b，c指迭代器的种类)

SET d 0

JZ 1 a

STOP

大家看上面这个例子，整个程序的运行步骤跟d迭代器的值有关吗？d迭代器值是多少对程序怎么运行应该没影响吧，相反a迭代器跟JZ能否跳跃相关，那么跟a迭代器相关的迭代器比如 b c的值都是有用的，就这样就可以做到只把需要的迭代器取出来储存状态进行操作，遇到没有用的迭代器直接进入下一步骤即可。

做到这一步的话其实就是用vector建个树，先将所有JZ的迭代器先存入，然后再和他们相关的迭代器建个有向边，其实就是类似树的结构，深搜一遍得到所有有用的迭代器即可。而且这些迭代器和起来不会很多，为啥呢，大家自己想吧，

因为之前写过错误的程序，所以稍微就这样修改了一下最终终于AC，这道题简直了，感动到QAQ。。。

写这么多也是希望大家其实最好自己写，毕竟这种代码繁琐的题每个人都有自己的写法，一味看别人代码的话很可能会看不懂吧，毕竟东西太多了，这道题实现也比较复杂，感觉我自己的代码都丑到不行（逃~，

以下代码后面会附带一些数据，当然这些数据是我默认所有迭代器初始值为0做的，最后还会附一个迭代器初始值不是0的数据，希望大家都能成功AC。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <stack>
#include <set>
#include <functional>
#define retrun return
#define true ture
#define mian main
#define rank ra
#define next ne
#define pb push_back
#define hash haha
#define lson rt<<1
#define rson rt<<1|1
#define xlson xl,xmid,xt<<1
#define xrson xmid+1,xr,xt<<1|1
#define ylson yl,ymid,xt,yt<<1
#define yrson ymid+1,yr,xt,yt<<1|1
using namespace std;
typedef long long ll;
const int N=1<<16;
int n,scp,ans,g1,g2,g3;
char qu[20][10];    //存步骤
int p[20],q[20];    //存每一步对应的迭代器
int ch[40];         //存跟JZ直接相关的迭代器
int ma[40];         //存每个迭代器在二进制中的位置
bool v1[40];        //存哪些迭代器是有用的
vector<int> v[40];  //建树
bool vis[20][N+10]; //存bfs中的状态
struct node
{
    int dog;    //当前状态
    int dir;    //当前步骤
    int step;
};
void bfs()
{
    memset(vis,0,sizeof vis);
    queue<node> que;
    node st;
    st.dir=1;
    st.step=1;
    for(int i=0;i<=(1<<g1);i++) //将所有初始值的可能状态加入队列
    {
        st.dog=i;
        que.push(st);
        vis[1][st.dog]=1;
    }
    node k1;
    ans=-1;
    while(!que.empty())
    {
        node k=que.front();
        que.pop();
        if(k.dir>n) //超过步骤
            continue;
        if(qu[k.dir][0]=='S'&&qu[k.dir][1]=='T')    //结束状态
        {
            ans=k.step;
            break;
        }
        int a,b;
        int g=k.dir;
        if(qu[g][0]=='J'&&qu[g][1]=='M')    //无条件跳跃
        {
            k1.dir=p[g]+1;
            k1.dog=k.dog;
            k1.step=k.step+1;
            if(vis[k1.dir][k1.dog]==0)
            {
                que.push(k1);
                vis[k1.dir][k1.dog]=1;
            }
            continue;
        }
        if(qu[g][0]=='J'&&qu[g][1]=='Z')
        {
            a=((k.dog>>(ma[q[g]]))%2);
            if(a==0)
                k1.dir=p[g]+1;
            else
                k1.dir=k.dir+1;
            k1.dog=k.dog;
            k1.step=k.step+1;
            if(vis[k1.dir][k1.dog]==0)
            {
                que.push(k1);
                vis[k1.dir][k1.dog]=1;
            }
            continue;
        }
        if(v1[p[g]]==0)     //遇到无用迭代器直接下一步
        {
            k1.dir=k.dir+1;
            k1.dog=k.dog;
            k1.step=k.step+1;
            if(vis[k1.dir][k1.dog]==0)
            {
                que.push(k1);
                vis[k1.dir][k1.dog]=1;
            }
            continue;
        }
        if(qu[g][0]=='R')   //随机迭代器的值 注意位运算
        {
            k1.dir=k.dir+1;
            k1.step=k.step+1;
            a=scp^(1<<ma[p[g]]);
            k1.dog=k.dog&a;
            if(vis[k1.dir][k1.dog]==0)
            {
                que.push(k1);
                vis[k1.dir][k1.dog]=1;
            }
            k1.dog=k.dog|(1<<(ma[p[g]]));
            if(vis[k1.dir][k1.dog]==0)
            {
                que.push(k1);
                vis[k1.dir][k1.dog]=1;
            }
            continue;
        }
        a=((k.dog>>(ma[p[g]]))%2);  //得到当前对应的a b迭代器的值
        b=((k.dog>>(ma[q[g]]))%2);
        if(qu[g][0]=='A')
            a=(a&b);
        if(qu[g][0]=='O')
            a=(a|b);
        if(qu[g][0]=='X')
            a=a^b;
        if(qu[g][0]=='N')
            a=a^1;
        if(qu[g][0]=='M')
            a=b;
        if(qu[g][0]=='S'&&qu[g][1]=='E')
            a=q[g];
        if(a==0)
        {                           //注意位运算的过程
            a=scp^(1<<ma[p[g]]);
            k1.dog=k.dog&a;
        }
        if(a==1)
            k1.dog=k.dog|(1<<(ma[p[g]]));
        k1.dir=k.dir+1;
        k1.step=k.step+1;
        if(vis[k1.dir][k1.dog]==0)
        {
            que.push(k1);
            vis[k1.dir][k1.dog]=1;
        }
    }
    if(ans==-1)
        printf("HANGS\n");
    else
        printf("%d\n",ans);
}
void dfs(int k)     //深搜树
{
    for(int i=0;i<(int)v[k].size();i++)
    {
        if(v1[v[k][i]]==0)
        {
            v1[v[k][i]]=1;
            ma[v[k][i]]=g1++;
            dfs(v[k][i]);
        }
    }
}
void init()
{
    memset(v1,0,sizeof v1);
    g1=0;scp=(1<<17)-1;
    for(int i=1;i<=g3;i++)
    {
        if(v1[ch[i]]==0)
        {
            v1[ch[i]]=1;
            ma[ch[i]]=g1++;
            dfs(ch[i]);
        }
    }
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(p,-1,sizeof p);
        memset(q,-1,sizeof q);
        memset(ma,-1,sizeof ma);
        memset(qu,0,sizeof qu);
        for(int i=1;i<=40;i++)
            v[i].clear();
        g3=0;
        for(int i=1;i<=n;i++)
        {
            scanf(" %s",qu[i]);
            if(qu[i][0]=='S'&&qu[i][1]=='T')
                continue;
            if(qu[i][0]=='R'||qu[i][0]=='N'||(qu[i][0]=='J'&&qu[i][1]=='M'))
                scanf("%d",&p[i]);
            else
                scanf("%d%d",&p[i],&q[i]);
            if(qu[i][0]=='J'&&qu[i][1]=='M')
                continue;
            if(qu[i][0]=='J')
                ch[++g3]=q[i];  //存所有跟JZ直接相关的迭代器
            else if(qu[i][0]=='S'||qu[i][0]=='N'||qu[i][0]=='R');   //注意分号
            else
                v[p[i]].pb(q[i]);   //建立有向边
        }
        init();
        bfs();
    }
}       //运行答案应该是 13 18 2
/*
12
SET 0 0
SET 1 1
JZ 6 1
SET 2 1
RANDOM 1
JMP 2
SET 2 1
JZ 11 2
SET 0 1
RANDOM 2
JZ 7 2
STOP

16
SET 0 0
SET 1 0
SET 2 0
MOV 1 0
MOV 2 1
XOR 1 0
NOT 1
JZ 15 1
RANDOM 0
MOV 2 0
JZ 12 0
NOT 2
NOT 1
JZ 5 1
JMP 0
STOP

2
JZ 0 0
STOP
*/