IDA*例题 & IDA* 与 A*使用时机

引入

思想类似于A*算法；

一般配合迭代加深使用；

---

主要思想是，引入一个估价函数，看看当前状态距离答案最少还需要多少步；

如果当前的深度加上预估的步数已经超过当前的max_depth；

那么就可以剪枝掉；

估价函数怎么取

估价函数也和A*类似，取一个无论如何都要付出的最小代价即可；

---

保证正确性

和A*算法一样，只需要保证预估值小于等于真实值即可；

简单来说

简单来说，IDA*就是在迭代加深的时候，增加了一个额外的剪枝；

这个剪枝就是加上估价值来判断是否超过max_depth

IDA* 与 A*使用时机

• 需要最小字典序时，状态表示很大，指数增长较快时，使用IDA∗

• 若状态容易表示，指数增长较慢时，使用A∗

例题

排书

题面

传送门

思路

最终排好序的数组肯定是这样；

1,2,3...,n;

也就是满足$a(i)+1=a(i+1)$；

我们定义满足以上条件的前后序，称为合法的后继关系；

---

不难发现，我们移动一叠书，会改变三个点的后继关系；

这三个点是

1. $k$(将$[x,y]$插到$k$之后)
2. $x-1$($k$被推上来了)
3. $y$(后面是$k+1$了)

假设非法的后继关系总和为$sum$个；

我们一次至多处理掉$3$个，因此最理想的情况下；

我们也需要$\lceil \frac{sum}{3}\rceil$次；

因此这就是我们估价函数的来源(无论如何都必须满足的花费)

---

搜索顺序我们可以考虑枚举要搬书的长度，然后枚举左端点以及插入点，进行dfs；

---

考虑常规剪枝，优化搜索顺序，我们期望搜索分支少的话，应该先枚举长度大的搬书方案；

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e1 + 10;

int a[N],n;

//估价函数
int f(){
    int ret = 0;
    for(int i=1;i<n;++i){
        if(a[i] + 1 != a[i+1]) ++ret;
    }
    //向上取整
    return (ret+2)/3;
}
//当前层数、最大层数
bool dfs(int u,int dep){
    if(u + f() > dep) return false;
    if(f() == 0) return true; //把书排好了
    //常规剪枝、优化搜索顺序
    for(int len = n;len >= 1; --len){
        for(int l=1;l+len-1<=n;++l){
            int r = l + len - 1;
            //枚举决策 看看插到哪个数后面
            //因为往前插和往后插是一样的，因此我们选定一个方向即可
            for(int k=r+1;k<=n;++k){
                int tmp[N];
                //dest,src,size
                memcpy(tmp,a,sizeof a);
                //插入移动过程
                int x,y;
                //交换[l,r] 与 [r+1,k]
                for(x=r+1,y=l;x<=k;++x,++y){
                    a[y] = tmp[x];
                }
                for(x=l;x<=r;++x,++y){
                    a[y] = tmp[x];
                }
                if(dfs(u+1,dep)) return true;
                memcpy(a,tmp,sizeof tmp); //回溯
            }
        }
    }
    return false;
}

void solve(){
    cin >> n;
    for(int i=1;i<=n;++i) cin >> a[i];
    int dep = 0;
    while(dep < 5 && !dfs(0,dep)) ++dep;
    if(dep >= 5) cout << "5 or more\n";
    else cout << dep << '\n';
}

int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t;
    cin >> t;
    while(t--)
        solve();
    return 0;
}

回转游戏

回转游戏

思路

因为这种是不规则的图形，我们人为的给他编个号，方便我们写代码；

操作$A到H$依次对应$0到7$，中间的是下标；

---

因为题目要求最少操作次数，那么我们不可能对上一次操作进行逆操作；

比如不可能你先拉了一下$A$，下一轮去拉$F$，这相当于啥都没干；

---

因为我们最终期望中间的八个格子是相同的数；

那么假设现在在这八个格子中出现最多的数，出现的次数为$k$;

那么我们还需要$8-k$个这样的数拉进格子；

因此我们的估价函数就是这个；

真是最优到极致的情况

因为我们只需要保证预估值小于等于真实值即可；

完事开搜即可；

Code

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e2 + 10;
//按照题目意思编号
int opt[8][7]={
    {0,2,6,11,15,20,22},
    {1,3,8,12,17,21,23},
    {10,9,8,7,6,5,4},
    {19,18,17,16,15,14,13},
    {23,21,17,12,8,3,1},
    {22,20,15,11,6,2,0},
    {13,14,15,16,17,18,19},
    {4,5,6,7,8,9,10}
};
//逆操作
int _reverse[8] = {5,4,7,6,1,0,3,2};

int a[N],path[N];

int center[8] = {6,7,8,11,12,15,16,17};

int f(){
    int sum[4] = {0};
    for(int i=0;i<8;++i){
        int idx = center[i];
        ++sum[a[idx]];
    }
    int mx = 0;
    for(int i=1;i<=3;++i){
        mx = max(mx,sum[i]);
    }
    return 8 - mx; //最优情况下都要滑动的次数
}

void slide(int op){ //操作A~H
    //一路交换到最后一位
    for(int i=0;i<6;++i){
        int x = opt[op][i];
        int y = opt[op][i+1];
        swap(a[x],a[y]);
    }
}

//当前层数、最大层数、上一次的操作
//注意last一开始是-1 不要去当数组下标
bool dfs(int u,int dep,int last){
    if(u + f() > dep) return false;
    if(f() == 0) return true;
    //尝试拉A~H方向
    for(int i=0;i<8;++i){
        if(last != _reverse[i]){
            slide(i);
            path[u] = i;
            if(dfs(u+1,dep,i)) return true;
            slide(_reverse[i]);//回溯
        }
    }
    return false;
}

void solve(){
    int dep = 0;
    while(!dfs(0,dep,-1)) ++dep;
    if(dep == 0) cout << "No moves needed\n";
    else{
        for(int i=0;i<dep;++i){
            cout << (char)(path[i] + 'A');
        }
        cout << '\n';
    }
    //随便输出八个中的一个即可
    cout << a[7] << '\n';
}

int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    while(cin >> a[0],a[0]){
        for(int i=1;i<24;++i) cin >> a[i];   
        solve();
    }
    return 0;
}

十五数码

题面

传送门

思路

思路和A*的八数码是一样的；

首先我们考虑无解的情况；

将空格上下滑动，可以发现，每次滑动改变的逆序对为-1,1,3,-3；

那么我们的空格要移动3 - i/4 行；

如果是偶数，那么不难想到改变的逆序对也是偶数；

否则改变的逆序对数就是奇数；

---

这道题我用A*写爆空间了，因此这里用IDA*来写；

---

首先估价函数直接取曼哈顿距离即可（必不可少的代价）；

因为时间有限，所以先左边滑动一下，再右边滑动一下是没有意义的；

---

需要注意的是，这道题好像没有spj，所以顺序按照我下面写的顺序来(RDUL)

Code

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e1 + 10;

string opt = "RDUL";
int dx[] = {0,1,-1,0};
int dy[] = {1,0,0,-1};

int _reverse[] = {3,2,1,0}; //逆操作 比如L的逆操作是R

vector<int> over;

char path[110];

vector<int> now;

int f(){ //估价函数
    int ret = 0;
    for(int i=0;i<now.size();++i){
        if(now[i] != 0){
            int tarx = (now[i]-1)/4,tary = (now[i]-1)%4;
            int nowx = i/4,nowy = i%4;
            ret += abs(tarx-nowx) + abs(tary-nowy);
        }
    }
    return ret;
}

//空格位置、上一次操作、当前深度、最深深度
bool dfs(int space,int last,int u,int dep){
    if(u + f() > dep) return false;
    if(u == dep) return now == over;
    int sx = space / 4,sy = space % 4; //空格的x、y坐标
    for(int i=0,xx,yy,nspace;i<4;++i){
        xx = sx + dx[i];
        yy = sy + dy[i];
        nspace = 4 * xx + yy; //移动后空格位置
        if(xx < 0 || xx >= 4 || yy < 0 || yy >= 4) continue;
        if(last == _reverse[i]) continue;
        swap(now[xx*4+yy],now[space]);
        path[u] = opt[i];
        if(dfs(nspace,i,u+1,dep)) return true;
        swap(now[xx*4+yy],now[space]); //回溯
    }
    return false;
}


bool ok()
{
    int cnt = 0;
    int row = 0;
    for(int i = 0; i < 16; ++i){
        if(now[i] == 0)
            row = 3 - i / 4;
        else{
            for(int j = 0; j < i; ++j)
                if(now[j] && now[j] > now[i])
                    cnt++;
        }
    }
    if(row&1) return cnt&1;
    return !(cnt&1);
}

void solve(){
    int idx = 0;
    now.clear();
    for(int i=0,u;i<16;++i){
        cin >> u;
        if(u == 0) idx = i;
        now.push_back(u);
    }
    if(ok()){
        int dep = 0;
        while(!dfs(idx,-1,0,dep)){
            ++dep;
        }
        for(int i=0;i<dep;++i){
            cout << path[i];
        } 
        cout << '\n';
    }
    else{
        cout << "No Solution\n";
    }
}

int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    for(int i=1;i<=15;++i) over.push_back(i);
    over.push_back(0);
    int t;
    cin >> t;
    while(t--)
        solve();
    return 0;
}