八数码与IDA*问题 HDU1043&&POJ1077

HDU1043&&POJ1077

题意：将八数码还原成原位

做法（参照各种神牛牪犇）

1.判断是否有解，原位时八数码的逆序对一定是0，细心的人就会发现每次移动的逆序对是偶数次变换的，所以只用判断初始情况的逆序对是否为偶数即可

2.强力剪枝：1.用H最优估计剩余步数（曼哈顿距离） 2.限制深度deep，每次加一 3.判断与上一步是否反向

3.IDA*  每次限制层数加一，逐层搜索。

注意：在算H的时候直接将原位设为设为标准位置即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int goal[10][2]={{2,2},{0,0},{0,1}, {0,2},{1,0},{1,1},{1,2},{2,0},{2,1},{2,2}};
const char op[4] = {'r', 'd', 'u', 'l'};
const int dir[4][2] = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
char path[100];

int abs(int x)
{
   return x<0? -x:x;
}
int inv(int *a)
{
    int ans=0;
    for(int i=0;i<9;++i)
    {
        if(a[i]==0) continue;
        for(int j=i+1;j<9;++j)
        {
            if(a[i]>a[j]&&a[j]) ans++;
        }
    }
   return ans;
}

int geth(int *num)
{
    int cost=0;
    for(int i=0;i<9;++i)
    {
        cost+= abs(goal[num[i]][0]-i/3) + abs(goal[num[i]][1]-i%3);
    }
    return cost;
}

bool dfs(int *a,int x,int y,int len, int pre,int deep)
{
   for(int i=0;i<4;++i)
   {
       int xx=x+dir[i][0],yy=y+dir[i][1];
       if(pre+i==3 || xx<0|| xx>2|| yy<0|| yy>2) continue;

       a[3*x+y]=a[3*xx+yy]; a[3*xx+yy]=0;
       int h=geth(a);
       if(h==0)
       {
           path[len] = op[i];
           path[len+1]= '\0'; return 1;
       }
       if(h+len<=deep)
       {
           path[len]=op[i];
           if(dfs(a,xx,yy,len+1,i,deep)) return 1;
       }
       a[3*xx+yy]=a[3*x+y]; a[3*x+y]=0;
   }
   return 0;
}
int main()
{
    char str[10];
    while(scanf(" %c",&str[0])!=EOF)
    {
        for(int i=1;i<9;++i) scanf(" %c",&str[i]);

        int a[10],sx,sy;
        for(int i=0;i<9;++i)
        {
            if(str[i]=='x')
            {
                sx=i/3; sy=i%3; a[i]=0;
            }
            else a[i]=str[i]-'0';
        }
        if(inv(a)%2==1)
        {
            printf("unsolvable\n");
        }
        else
        {
            int ans=geth(a);
            if(ans==0) printf("\n");
            else
            {
                int deep=0;
                while(++deep)
                {
                    if(dfs(a,sx,sy,0,-1,deep)) break;
                }
                puts(path);
            }
        }
    }
    return 0;
}

HDU 3567

题意描述：经典八数码问题，给定起始状态和目标状态，经过d、l、r、u移动，求解如何移动能使起始状态到达目标状态？
1、移动的次数尽可能少
2、如果移动次数相同，求解移动序列的最小字典序？

解题思路：典型的IDA*题目
1.估值函数：从当前状态移动到目标状态所需的最小步数（我们可以通过曼哈顿距离进行估值），用于剪枝
2.迭代：此处我们不再使深度每次加1（会TLE），而是在搜索过程当中，记录大于len（len表示此次搜索的限制深度）的所有值中的最小值，作为下次迭代的限制深度。

3.判重:使用康拓展开，将目标状态存为标准情况，同时用vis来判重。

4.计算h的时候也是以目标状态为标准。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
const int maxn=4e5+5;
int vis[maxn];
int st[9], goal[9];
const int dir[][2] = {1,0, 0,-1, 0,1, -1,0};
const char op[] = {'d','l','r','u'};
int fact[9], loc[9];

int getkt(int *a)
{
    int code = 0;
    for(int i = 0; i < 9; ++i)
    {
        int cnt = 0;
        for(int j = i + 1; j < 9; ++j) if(a[j] < a[i]) cnt++;
        code += fact[8 - i] * cnt;
    }
    return code;
}

int geth(int *a)
{
    int cnt = 0;
    for(int i = 0; i < 9; ++i)
    {
        if(a[i] == 0 || i == loc[a[i]]) continue;
        int x=i/3, y=i%3;
        int n=loc[a[i]];
        int px=n/3,py=n%3;
        cnt+=abs(x - px)+abs(y - py);
    }
    return cnt;
}

char ans[50];
int deep, nextdeep;
int dfs(int*a,int step, int pos)
{
    int h = geth(a);
    if(h == 0)
    {
        printf("%d\n", step);
        ans[step] = '\0';  printf("%s", ans);
        return 1;
    }
    if(step + h > deep)
    {
        nextdeep = min(nextdeep, step + h); return 0;
    }
    int x=pos/3, y =pos%3;
    for(int i = 0; i < 4; ++i)
    {
        int xx=x+dir[i][0], yy=y+dir[i][1];
        if(xx<0||yy<0||xx>2||yy>2) continue;
        swap(a[pos], a[xx*3+yy]);
        int code = getkt(a);
        if(vis[code])
        {
            swap(a[pos], a[xx*3+yy]);
            continue;
        }
        vis[code]=1;  ans[step]=op[i];
        if(dfs(a,step+1, xx*3+yy)) return 1;
        vis[code] = 0;
        swap(a[pos], a[xx*3+yy]);
    }
    return 0;
}

int main()
{
    fact[0] = 1;
    for(int i = 1; i < 9; ++i) fact[i] = fact[i - 1] * i;
    char str[50];   int  T, kase = 1;
    scanf("%d", &T);
    while(T--)
    {
        int pos;
        scanf("%s",str);
        for(int i = 0; i < 9; ++i)
        {
            if(str[i] == 'X')
            {   pos = i;
                st[i] = 0;
            }
            else st[i] = str[i] - '0';
        }


        scanf("%s",str);
        for(int i = 0; i < 9; ++i)
        {
            if(str[i] == 'X') goal[i] = 0;
            else goal[i] = str[i] - '0';
        }
        for(int i = 0; i < 9; ++i)  loc[goal[i]] = i;

        printf("Case %d: ", kase++);
        int code = getkt(st);

        for(deep = geth(st);;)
        {
            nextdeep=1<<30;
            memset(vis,0,sizeof(vis));
            vis[code]=1;
            if(dfs(st,0, pos)) break;
            deep = nextdeep;
        }
        printf("\n");
    }
    return 0;
}