十六宫格拼图（A*/IDA*）（曼哈顿距离）

传送门

迭代加深：通过单纯的深度优先搜索无法找出初始状态到最终状态的最短路径，但是重复进行限制最大深度的深度优先搜索（深度受限搜索）却可以。简单来说，就是在循环执行深度受限搜索的过程中逐步增加限制值limit，直到找到解为止，这种算法称为迭代加深（Iterative Deepending）

IDA*

在迭代加深中，通过推测值进行剪枝处理的算法称为迭代加深A*或者IDA*。这里的推测值又称为启发通常可以取完成目标所需要的下限值。

对于十六宫格来说，如果能预估出当前状态到最终状态的最小成本h，我们就可以对搜索范围进行剪枝了，也就是说，如果当前状态的深度g加上最小成本h(即“从这里开始至少还需要h次状态迁移)超过了限制深度d，就可以直接中断搜索。

A*

推测值同样适用于以含有优先级队列的迪克斯特拉（或者广度优先搜索）为基础的算法，这类算法称为A*算法，它用优先级队列管理状态，优先对”起点到当前成本+当前位置到目标状态的推测值“最小的状态进行状态迁移，可以更快的找到解。

曼哈顿距离

曼哈顿距离指的是”不进行任何斜向移动，仅仅进行上下左右移动所测出的2点之间的总距离

IDA*

#include<bits/stdc++.h>

using namespace std;

#define N 4
#define N2 16
#define LIMIT 100

const int dx[4]={0,-1,0,1};
const int dy[4]={1,0,-1,0};
const char dir[4]={'r','u','l','d'};

int MDT[N2][N2];

struct puzzle{
    int f[N2],space,MD;
};

puzzle state;
int limit;
int path[LIMIT];

int getALLMD(puzzle pz)
{
    int sum=0;
    for(int i=0;i<N2;i++){
        if(pz.f[i]==N2){
            continue;
        }
        sum+=MDT[i][pz.f[i]-1];
    }
    return sum;
}

bool dfs(int depth,int prev)
{
    if(state.MD==0){
        return true;
    }
    if(depth+state.MD>limit){
        return false;
    }
    int sx=state.space/N;
    int sy=state.space%N;
    puzzle tmp;
    for(int r=0;r<4;r++){
        int tx=sx+dx[r];
        int ty=sy+dy[r];
        if(tx<0||ty<0||tx>=N||ty>=N){
            continue;
        }
        //防止重复
        if(max(prev,r)-min(prev,r)==2){
            continue;
        }
        tmp=state;
        //计算曼哈顿距离的差值，同时交换拼图块
        state.MD-=MDT[tx*N+ty][state.f[tx*N+ty]-1];
        state.MD+=MDT[sx*N+sy][state.f[tx*N+ty]-1];
        swap(state.f[tx*N+ty],state.f[sx*N+sy]);
        state.space=tx*N+ty;
        if(dfs(depth+1,r)){
            path[depth]=r;
            return true;
        }
        state=tmp;
    }
    return false;
}

string iterative_deepening(puzzle in)
{
    in.MD=getALLMD(in);//初始状态的曼哈顿距离
    for(limit=in.MD;limit<=LIMIT;limit++){
        state=in;
        if(dfs(0,-100)){
            string ans="";
            for(int i=0;i<limit;i++){
                ans+=dir[path[i]];
            }
            return ans;
        }
    }
    return "unsolvable";
}

int main()
{
    for(int i=0;i<N2;i++){
        for(int j=0;j<N2;j++){
            //曼哈顿距离，此法太妙
            MDT[i][j]=abs(i/N-j/N)+abs(i%N-j%N);
        }
    }
    puzzle in;
    for(int i=0;i<N2;i++){
        cin>>in.f[i];
        if(in.f[i]==0){
            in.f[i]=N2;
            in.space=i;
        }
    }
    string ans=iterative_deepening(in);
//    for(int i=0;i<limit;i++){
//        cout<<path[i]<<" ";
//    }
    cout<<ans.size()<<endl;
    return 0;
}

A*

//A*
//优先对“起点到当前位置的成本+当前位置到目标状态的推测值”最小的状态进行状态迁移
#include<bits/stdc++.h>

using namespace std;

#define N 4
#define N2 16

const int dx[4]={0,-1,0,1};
const int dy[4]={1,0,-1,0};
const char dir[4]={'r','u','l','d'};
int MDT[N2][N2];

struct Puzzle{
    int f[N2],space,MD;
    int cost;
    bool operator < (const Puzzle &p)const{
        for(int i=0;i<N2;i++){
            if(f[i]==p.f[i]){
                continue;
            }
            return f[i]<p.f[i];
        }
        return false;
    }
};

struct state{
    Puzzle puzzle;
    int estimated;
    bool operator < (const state &s)const{
        return estimated>s.estimated;
    }
};

int getALLMD(Puzzle pz)
{
    int sum=0;
    for(int i=0;i<N2;i++){
        if(pz.f[i]==N2){
            continue;
        }
        sum+=MDT[i][pz.f[i]-1];
    }
    return sum;
}

int astar(Puzzle s)
{
    priority_queue<state>pq;
    s.MD=getALLMD(s);
    s.cost=0;
    map<Puzzle,bool>V;
    Puzzle u,v;
    state initial;
    initial.puzzle=s;
    initial.estimated=getALLMD(s);
    pq.push(initial);
    while(!pq.empty()){
        state st=pq.top();
        pq.pop();
        u=st.puzzle;
        if(u.MD==0){
            return u.cost;
        }
        V[u]=true;
        int sx=u.space/N;
        int sy=u.space%N;
        for(int r=0;r<4;r++){
            int tx=sx+dx[r];
            int ty=sy+dy[r];
            if(tx<0||ty<0||tx>=N||ty>=N){
                continue;
            }
            v=u;
            v.MD-=MDT[tx*N+ty][v.f[tx*N+ty]-1];
            v.MD+=MDT[sx*N+sy][v.f[tx*N+ty]-1];
            swap(v.f[sx*N+sy],v.f[tx*N+ty]);
            v.space=tx*N+ty;
            if(!V[v]){
                v.cost++;
                state news;
                news.puzzle=v;
                news.estimated=v.cost+v.MD;
                pq.push(news);
            }
        }
    }
    return -1;
}

int main()
{
    for(int i=0;i<N2;i++){
        for(int j=0;j<N2;j++){
            MDT[i][j]=abs(i/N-j/N)+abs(i%N-j%N);
        }
    }
//    for(int i=0;i<N2;i++){
//        for(int j=0;j<N2;j++){
//            cout<<MDT[i][j]<<" ";
//        }
//        cout<<endl;
//    }
    Puzzle in;
    for(int i=0;i<N2;i++){
        cin>>in.f[i];
        if(in.f[i]==0){
            in.f[i]=N2;
            in.space=i;
        }
    }
    cout<<astar(in)<<endl;
    return 0;
}