洛谷P1379 八数码难题

传送门

1.先用dfs枚举9!的全排列，存到hash数组里（类似离散化），因为顺序枚举，就不需要排序了

2.朴素bfs，判重就用二分找hash；如果发现当前状态=要求状态，输出步数结束程序

上代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;

; 

long long hash[MAXHASH];
bool hashbook[MAXHASH];
;
];

;

void hinit(long long step,long long val){
    ){
        hn++;
        hash[hn]=val;
        return;
    }
    ;i<=;i++){
        ){
            hinit_book[i]=;
            hinit(step+,val*+i);
            hinit_book[i]=;
        }
    }
}

bool hashput(long long val){
    ,r=hn;
    for(;;){
        if(l==r){
            ){
                hashbook[l]=;
                ;
            }else{
                ;
            }
        }
        ;
        if(val>hash[mid]){
            l=mid+;
        }else{
            r=mid;
        }
    }
}

struct uct1{
    long long data;
    long long pos;
    long long step;
}que[];

long long mywap(long long data,long long pa,long long pb){
    long long ans=data;

    ,-pb+)-data%(,-pb);
    ans-=df;
    ans+=df/pow(,-pb)*pow(,-pa);

    df=data%(,-pa+)-data%(,-pa);
    ans-=df;
    ans+=df/pow(,-pa)*pow(,-pb);
    return ans;
}

,tail=;

int main() {
    hinit(,);
    long long pig;
    cin>>pig;

    int bap=pig;
    if(pig==end){
        cout<<;
        ;
    }
    int pigpos;
    ;bap>;pigpos--){
        ==){
            break;
        }
        bap=bap/;
    }
    ){
        pigpos=;
    }
    head=;
    tail=;
    que[tail].data=pig;
    que[tail].pos=pigpos;
    que[tail].step=;
    tail++;
    for(;head<tail;){
        int tdata;
        int tpos;
        ]={};
        for(;;){
            )%==&&flag[]==){
                tdata=mywap(que[head].data,que[head].pos,que[head].pos+);
                tpos=que[head].pos+;
                flag[]++;
            })%==&&flag[]<){
                ]==){
                    tdata=mywap(que[head].data,que[head].pos,que[head].pos+);
                    tpos=que[head].pos+;
                }else{
                    tdata=mywap(que[head].data,que[head].pos,que[head].pos-);
                    tpos=que[head].pos-;
                }
                flag[]++;
            })%==&&flag[]==){
                tdata=mywap(que[head].data,que[head].pos,que[head].pos-);
                tpos=que[head].pos-;
                flag[]++;
            }&&que[head].pos<=&&flag[]==){
                tdata=mywap(que[head].data,que[head].pos,que[head].pos+);
                tpos=que[head].pos+;
                flag[]++;
            }&&que[head].pos<=&&flag[]<){
                ]==){
                    tdata=mywap(que[head].data,que[head].pos,que[head].pos+);
                    tpos=que[head].pos+;
                }else{
                    tdata=mywap(que[head].data,que[head].pos,que[head].pos-);
                    tpos=que[head].pos-;
                }

                flag[]++;
            }&&que[head].pos<=&&flag[]==){
                tdata=mywap(que[head].data,que[head].pos,que[head].pos-);
                tpos=que[head].pos-;
                flag[]++;
            }else{
                break;
            }
            if(tdata==end){
                cout<<que[head].step+;
                ;
            }
            ){
                que[tail].data=tdata;
                que[tail].pos=tpos;
                que[tail].step=que[head].step+;
                tail++;
            }
        }
        head++;
    }
    ;
}

其实还可以用双向bfs优化，算hash数组可以用康托展开

但懒得写了（逃）