【双向广搜+逆序数优化】【HDU1043】【八数码】

HDU上的八数码 数据强的一B


首先:双向广搜

先处理正向搜索,再处理反向搜索,直至中途相遇


visit 和 队列都是独立的。 可以用一个过程来完成这2个操作,减少代码量。(一般还要个深度数组)

优化效率很强


逆序数优化

在忽略空格的情况,会发现 空格无论怎么变,1-8的排列的逆序数始终要为偶数,才能有解(空格无视)

而且证明得出:如果满足逆序条件,必定有解!

拓展

N*N的情况

N×N的棋盘,N为奇数时,与八数码问题相同。

N为偶数时,空格每上下移动一次,奇偶性改变。称空格位置所在的到目标空格所在的行步数为空格的距离(不计左右距离),若两个状态的可相互到达,则有,两个状态的逆序奇偶性相同且空格距离为偶数,或者,逆序奇偶性不同且空格距离为奇数数。否则不能。




>推广到三维N×N×N

其实,三维的结论和二维的结论是一样的。

考虑左右移动空格,逆序不变;同一层上下移动空格,跨过N-1个格子;上下层移动空格,跨过N^2-1个格子。

当N为奇数时,N-1和N^2-1均为偶数,也就是任意移动空格逆序奇偶性不变。那么逆序奇偶性相同的两个状态可相互到达。

当N为偶数时,N-1和N^2-1均为奇数,也就是令空格位置到目标状态空格位置的y z方向的距离之和,称为空格距离。若空格距离为偶数,两个逆序奇偶性相同的状态可相互到达;若空格距离为奇数,两个逆序奇偶性不同的状态可相互到达。


代码:
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define oo 0x13131313
using namespace std;
struct node
{
    int operator[](int index) const {
        return A[index];
    }
    int& operator[](int index) {
        return A[index];
    }
    int A[10];
    int xnum;
    int deep;
    int Contor;
    void JSContor()
    {
        int temp=0,p=1;
        for(int i=8;i>=0;i--)
        {
            int tot=0;
            for(int j=0;j Q[2];
node start;
node End;

char AAA[20];
void init()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
}
void input()
{
    memset(visit,0,sizeof(visit));
    for(int i=0;i<9;i++)
    {
        if(AAA[i]=='x')
        {
            start[i]=9;
            start.xnum=i;
        }
        else start[i]=AAA[i]-'0';
        End[i]=i+1;
    }
    End.xnum=8;
    End.deep=0;
    start.deep=0;
}
void csh()
{
    while(Q[0].empty()!=1) Q[0].pop();
    start.JSContor();
    visit[0][start.Contor]=1;
    Q[0].push(start);

    while(Q[1].empty()!=1) Q[1].pop();
    End.JSContor();
    visit[1][End.Contor]=1;
    Q[1].push(End);
}
int GAN(int pos)
{
        node s,t;
        s=Q[pos].front();
        Q[pos].pop();
        if(visit[pos^1][s.Contor]==1) {
                                         return s.Contor;
                                      }
        s.deep++;
        //
        t=s;
        if(((t.xnum)/3)!=0)
        {
            swap(t[t.xnum],t[t.xnum-3]);
            t.xnum=t.xnum-3;
            t.JSContor();
            if(visit[pos][t.Contor]==0)
            {
                Q[pos].push(t);
                visit[pos][t.Contor]=1;
                dist[pos][t.Contor]=s.Contor;
                dANS[pos][t.Contor]=0;
                DEEP[pos][t.Contor]=t.deep;
            }
        }

        //
        t=s;
        if(((t.xnum)/3)!=2)
        {
            swap(t[t.xnum],t[t.xnum+3]);
            t.xnum=t.xnum+3;
            t.JSContor();
            if(visit[pos][t.Contor]==0)
            {
                Q[pos].push(t);
                visit[pos][t.Contor]=1;
                dist[pos][t.Contor]=s.Contor;
                dANS[pos][t.Contor]=1;
                DEEP[pos][t.Contor]=t.deep;
            }
        }
        //
        t=s;
        if(t.xnum%3!=0)
        {
            swap(t[t.xnum],t[t.xnum-1]);
            t.xnum--;
            t.JSContor();
            if(visit[pos][t.Contor]==0)
            {
                Q[pos].push(t);
                visit[pos][t.Contor]=1;
                dist[pos][t.Contor]=s.Contor;
                dANS[pos][t.Contor]=2;
                DEEP[pos][t.Contor]=t.deep;
            }
        }
        //
        t=s;
        if((t.xnum+1)%3!=0)
        {
            swap(t[t.xnum],t[t.xnum+1]);
            t.xnum++;
            t.JSContor();
            if(visit[pos][t.Contor]==0)
            {
                Q[pos].push(t);
                visit[pos][t.Contor]=1;
                dist[pos][t.Contor]=s.Contor;
                dANS[pos][t.Contor]=3;
                DEEP[pos][t.Contor]=t.deep;
            }
        }
        return 0;
}
void twobfs()
{
    void print(int ok1);
   csh();
   int ok1=0,ok2=0;
   while(Q[0].empty()!=1&&Q[1].empty()!=1)
   {
       ok1=GAN(0);
       if(ok1!=0) break;
       ok2=GAN(1);
       if(ok2!=0) {ok1=ok2;break;}
    }
     print(ok1);
}
char ANS[20];
void print(int ok1)
{
        int tot=1;
        for(int p=ok1;p!=start.Contor;p=dist[0][p])
        {
            ANS[tot]=f[dANS[0][p]];
            tot++;
        }
        for(int i=tot-1;i>=1;i--)
        printf("%c",ANS[i]);
        tot=1;
        for(int p=ok1;p!=End.Contor;p=dist[1][p])
        {
            ANS[tot]=f[dANS[1][p]^1];
            tot++;
        }
        for(int i=1;i

利用预处理稍微压缩一下BFS后(BFS多移动一般都可以用预处理压缩)

简化了一下BFS后 看起来就是舒服
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define oo 0x13131313
using namespace std;
struct node
{
    int operator[](int index) const {
        return A[index];
    }
    int& operator[](int index) {
        return A[index];
    }
    int A[10];
    int xnum;
    int deep;
    int Contor;
    void JSContor()
    {
        int temp=0,p=1;
        for(int i=8;i>=0;i--)
        {
            int tot=0;
            for(int j=0;j Q[2];
node start;
node End;

char AAA[20];
void init()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
}
void input()
{
    memset(visit,0,sizeof(visit));
    for(int i=0;i<9;i++)
    {
        if(AAA[i]=='x')
        {
            start[i]=9;
            start.xnum=i;
        }
        else start[i]=AAA[i]-'0';
        End[i]=i+1;
    }
    End.xnum=8;
    End.deep=0;
    start.deep=0;
}
void csh()
{
    while(Q[0].empty()!=1) Q[0].pop();
    start.JSContor();
    visit[0][start.Contor]=1;
    Q[0].push(start);

    while(Q[1].empty()!=1) Q[1].pop();
    End.JSContor();
    visit[1][End.Contor]=1;
    Q[1].push(End);
}
int GAN(int pos)
{
        node s,t;
        int x,y,p;
        s=Q[pos].front();
        Q[pos].pop();
        if(visit[pos^1][s.Contor]==1) {
                                         return s.Contor;
                                      }
        s.deep++;
        x=s.xnum/3;y=s.xnum%3;
        for(int i=0;i<=3;i++)
        {
            t=s;
            if(x+fx[i]<=2&&x+fx[i]>=0&&y+fy[i]<=2&&y+fy[i]>=0)
            {
                p=(x+fx[i])*3+y+fy[i];
                 swap(t[t.xnum],t[p]);
                 t.xnum=p;
                 t.JSContor();
                if(visit[pos][t.Contor]==0)
             {
                 Q[pos].push(t);
                 visit[pos][t.Contor]=1;
                 dist[pos][t.Contor]=s.Contor;
                 dANS[pos][t.Contor]=i;
                 DEEP[pos][t.Contor]=t.deep;
            }
            }
        }
        return 0;
}
void twobfs()
{
    void print(int ok1);
   csh();
   int ok1=0,ok2=0;
   while(Q[0].empty()!=1&&Q[1].empty()!=1)
   {
       ok1=GAN(0);
       if(ok1!=0) break;
       ok2=GAN(1);
       if(ok2!=0) {ok1=ok2;break;}
    }
     print(ok1);
}
char ANS[20];
void print(int ok1)
{
        int tot=1;
        for(int p=ok1;p!=start.Contor;p=dist[0][p])
        {
            ANS[tot]=f[dANS[0][p]];
            tot++;
        }
        for(int i=tot-1;i>=1;i--)
        printf("%c",ANS[i]);
        tot=1;
        for(int p=ok1;p!=End.Contor;p=dist[1][p])
        {
            ANS[tot]=f[dANS[1][p]^1];
            tot++;
        }
        for(int i=1;i



转载于:https://www.cnblogs.com/zy691357966/p/5480373.html

你可能感兴趣的:(【双向广搜+逆序数优化】【HDU1043】【八数码】)