IDA* Algorithm 用四道例题教会你IDA*算法

最新推荐文章于 2024-03-25 10:28:53 发布
最新推荐文章于 2024-03-25 10:28:53 发布
阅读量1.3k 收藏 8
点赞数 2
分类专栏： Algorithm 文章标签： 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wizzy_Ang/article/details/122918847
版权

IDA*

一、概念

简单的说，IDA算法就是迭代加深版的A算法。

二、分析

设计一个估价函数 f ( s t a t e ) < = 真 实 步 数 f(state)<=真实步数 f(state)<=真实步数
若 当 前 步 数 + f ( s t a t e ) > 上 界 当前步数 + f(state) > 上界 当前步数+f(state)>上界 真实步数必然大于上界，可以提前退出。

三、模板代码

bool dfs()
{
    if(now_depth + f() > max_depth) return false;
}
int depth=0;
while(!dfs(0,depth)) depth++;

四、实例代码

Question:AcWing 180.排书
Question Link:acwing.com/problem/content/182
Question Analysis:

连续选择k个书，一共有 n − k + 1 n - k + 1 n−k+1 种选法，总共有 n − k n - k n−k种放法，那么一共有 ( 15 ∗ 14 + 14 ∗ 13 + . . . + 2 ∗ 1 ) / 2 = 560 (15*14 + 14*13 + ... + 2*1)/2 = 560 (15∗14+14∗13+...+2∗1)/2=560 种操作
暴力最坏时间复杂度 O ( 56 0 4 ) O(560^4) O(5604)
每次操作会断开三个连接，然后引入三个连接。即每次操作最多会将三个连接修正
判断 n − 1 n - 1 n−1个连接中有多少个错误的连接，记为 t o t tot tot，若全部修正至少需要 [ t o t / 3 ] [tot/3] [tot/3]次操作。(’[ ]'为上取正符号)
那么我们可以设计出估价函数，在当前状态之下，最少进行多少次操作，才可以变成有序序列，即 f ( s t a t e ) = [ t o t / 3 ] f(state)=[tot/3] f(state)=[tot/3]

Diagram:

0.初始
请添加图片描述

1.将 [ L , R ] 抽出来
请添加图片描述
2.把[ R + 1 , K ]补到前面去
请添加图片描述

3.把[ L , R ]插入位置
请添加图片描述

Code：
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=15;
int n,q[N];
int w[5][N];//辅助数组(交换用)
int f()
{
    int tot=0;
    for (int i = 0; i+1 < n; i++)
    {
        if(q[i+1]!=q[i]+1) tot++;
    }
    return (tot+2)/3; //即(tot/3)的上取整
}
bool check()
{
    for (int i = 0; i < n; i++)
    {
        if(q[i]!=i+1) return false;//q[0]=1
    }
    return true;
}
bool dfs(int depth,int max_depth)
{
    if(depth + f() > max_depth) return false;
    if(check()) return true;
    //拓展状态,搜索每个分支
    for (int len = 1; len <= n; len++)//枚举长度
    {
        for (int l = 0; l+len-1 < n; l++)//枚举起点
        {
            int r=l+len-1;
            for (int k = r+1; k < n; k++)
            //枚举放置位置(因为放在前面和后面对称等价，故规定放在后面)
            {
                memcpy(w[depth],q,sizeof q);
                int x,y;
                for(x=r+1,y=l;x<=k;x++,y++) q[y]=w[depth][x];//Diagram 2
                for(x=l;x<=r;x++,y++) q[y]=w[depth][x];//Diagram 3
                if(dfs(depth+1,max_depth)) return true;
                memcpy(q,w[depth],sizeof q);
            }
            
        }
        
    }
    return false;
}
int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        cin >> n;
        for (int i = 0; i < n; i++)
        {
            cin >> q[i] ;
        }
        int depth=0;
        while(depth<5&&!dfs(0,depth)) depth++;//迭代加深
        if(depth>=5) puts("5 or more");
        else cout << depth << endl; 
    }
}

代码思路与分析来自于y总视频

Question:AcWing 181.回转游戏
Question Link:acwing.com/problem/content/183
Question Analysis:

估价函数：把中间 8 8 8个数中出现最多次数的出现次数记为 k k k ，每次操作最多会加入一个相同的数，即最多 8 − k 8 - k 8−k 次。 f ( s t a t e ) = 8 − k f(state) = 8 - k f(state)=8−k;
剪枝：避免枚举和上次相反的操作
最小字典序：按照字典序进行搜索
打表设计：编号，把八种操作对应的这一列数存下
在这里插入图片描述
题目例图
在这里插入图片描述

Code:
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=24;
int op[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 opposite[8]={5,4,7,6,1,0,3,2};//记录反操作
int center[8]={6,7,8,11,12,15,16,17};
int q[N];
int path[100];
int f()
{
    static int sum[4];
    memset(sum ,0 ,sizeof sum);
    for (int i = 0; i < 8; i++) sum[q[center[i]]]++;
    int s=0;
    for (int i = 1; i < 4; i++) s=max(s,sum[i]);
    return 8-s;
}
bool check()
{
    for (int i = 1; i < 8; i++)
    {
        if(q[center[i]]!=q[center[0]]) return false;
    }
    return true;
}
void operate(int x)
{
    int t=q[op[x][0]];
    for (int i = 0; i < 6; i++) q[op[x][i]]=q[op[x][i+1]];
    q[op[x][6]]=t;
}
bool dfs(int depth,int max_depth,int last)//last:last op
{
    if(depth+f()>max_depth) return false;
    if(check()) return true;
    //拓展其他分支
    for (int i = 0; i < 8; i++)
    {
        if(opposite[i]==last) continue;//剪枝
        operate(i);
        path[depth]=i;
        if(dfs(depth+1,max_depth,i)) return true;
        operate(opposite[i]);//返回状态
    }
    return false;
}
int main()
{
    while(cin >> q[0],q[0])
    {
        for (int i = 1; i < N; i++) cin >> q[i];
        int depth=0;
        while(!dfs(0,depth,-1)) depth++;
        if(!depth) printf("No moves needed");//一步也不需要做
        else 
        {
            for (int i = 0; i < depth; i++) printf("%c",path[i]+'A');
        }
        cout << endl << q[6] << endl;
    }
    return 0;
}

代码思路与分析来自于y总视频

Question:AcWing 182.破坏正方形
Question Link:acwing.com/problem/content/184
Question Analysis:

对于初始状态：
边长为1的正方形：n^2
边长为2的正方形：(n-1)^2
…
边长为n的正方形：1^2
一共有 (n*(n+1)*(2n+1))/6 个正方形
一共 2n(n+1) 根火柴
Target：从现有的火柴中，最少选择多少根火柴，可以使得每个正方形中都被至少选择了一根火柴
重复覆盖问题 一般用 Dancing Links 数据结构解决。
图形化
在这里插入图片描述

问题转换：
至少选择多少行，可以使得每一列至少有一个1(选择一根火柴)
搜索顺序：
每次选择一个还没有被覆盖的正方形(选择最小的一个)(优化)，枚举选择它上面的哪一根火柴。
估价函数：
枚举每个正方形，如果当前正方形还是完整的，那么删掉它的所有边，但是只记删除一次。（估价函数>=真实值）
正方形边的序号:
在这里插入图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=61;
vector<int> square[N];//每个正方形所有的边
bool st[N];//每条边是否被用过
int n,m;
bool check(vector<int> &sq)//检测正方形是否是完整的
{
    for (int i = 0; i < sq.size(); i++)
    {
        if(st[sq[i]]) return false;
    }
    return true;
}
int f()
{
    static bool state[N];//全局变量，只会被开辟一次
    memcpy(state,st,sizeof st);//由于要修改st的值，先保存到另一个
    int res=0;
    for (int i = 0; i < m; i++)
    {
        vector<int> &sq=square[i];
        if(check(sq))
        {
            res++;
            for (int j = 0; j < sq.size(); j++) st[sq[j]]=true;
        }
    }
    memcpy(st,state,sizeof st);
    return res;
}
bool dfs(int depth,int max_depth)
{
    if(depth+f()>max_depth) return false;
    for (int i = 0; i < m; i++)
    {
        vector<int> &sq=square[i];
        if(check(sq))
        {
            for (int j = 0; j < sq.size(); j++)
            {
                int x=sq[j];//枚举选择第x个
                st[x]=true;
                if(dfs(depth+1,max_depth)) return true;
                st[x]=false;//状态回溯
            } 
            return false;
        }
    }
    return true;
}
int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        cin >> n ;
        memset(st,0,sizeof st);
        //得所有正方形的所有边的序号
        m=0;
        for (int len = 1; len <= n; len++)//长度
        {
            for (int a = 1; a+len-1 <= n; a++)//枚举起点
            {
                for (int b = 1; b+len-1 <= n; b++)
                {
                    //得到该正方形的所有边的序号
                    square[m].clear();
                    int d=2*n+1;//公差
                    for (int i = 0; i < len; i++)//枚举每条边,得到正方形的所有边的序号
                    {
                        square[m].push_back(1+(a-1)*d+b-1+i);
                        square[m].push_back(1+(a+len-1)*d+b-1+i);
                        square[m].push_back(n+1+(a-1)*d+b-1+i*d);
                        square[m].push_back(n+1+(a-1)*d+b-1+i*d+len);
                    }
                    m++;
                }
            }
        }
        //PreDestroy
        int k=0;
        cin >> k;
        while (k--)
        {
            int x;
            cin >> x;
            st[x]=true;
        }
        int depth=0;
        while(!dfs(0,depth)) depth++;
        cout << depth << endl;
    }
}

代码思路与分析来自于y总视频

Question:AcWing 195.骑士精神
Question Link:acwing.com/problem/content/197
Question Analysis:

估价函数：位置不对的数量

Code:
#include<iostream>
#include<cstring>
using namespace std;
char str[5][5];
char tar[5][5]={'1','1','1','1','1',
                '0','1','1','1','1',
                '0','0','*','1','1',
                '0','0','0','0','1',
                '0','0','0','0','0'};//目标状态
int stari,starj;//初始空白位置坐标
pair<int,int> dire[8];//八种跳法
int f()//估价函数：位置不对的数量(除空白处)
{
    int res=0;
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if(str[i][j]!=tar[i][j]&&str[i][j]!='*') res++;
        }
    }
    return res;
}
bool check()
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if(str[i][j]!=tar[i][j]) return false;
        }
    }   
    return true; 
}
bool dfs(int depth,int depth_max,int x,int y)//x,y为当前空白处坐标
{
    if(depth+f()>depth_max) return false;
    if(check()) return true;
    for (int i = 0; i < 8; i++)
    {
        int tx=x+dire[i].first,ty=y+dire[i].second;
        if(tx>=5||tx<0||ty>=5||ty<0) continue;//剪枝
        swap(str[x][y],str[tx][ty]);
        if(dfs(depth+1,depth_max,tx,ty)) return true;
        swap(str[x][y],str[tx][ty]);//状态回溯
    }
    return false;
}                
int main()
{
    //跳法赋值
    dire[0].first=1;dire[0].second=2;
    dire[1].first=1;dire[1].second=-2;
    dire[2].first=-1;dire[2].second=2;
    dire[3].first=-1;dire[3].second=-2;
    dire[4].first=2;dire[4].second=1;
    dire[5].first=2;dire[5].second=-1;
    dire[6].first=-2;dire[6].second=1;
    dire[7].first=-2;dire[7].second=-1;
    int T;
    cin >> T;
    while (T--)
    {
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                cin >> str[i][j];
                if(str[i][j]=='*') 
                {
                    stari=i;
                    starj=j;
                }
            }
        }
        int depth=0;
        while(depth<=15&&!dfs(0,depth,stari,starj)) depth++;
        if(depth>15) cout << -1 << endl;
        else cout << depth << endl;
    }
}

如有疑问欢迎在评论区留言或者通过Email联系我

My Email:Wizzy-Ang@qq.com

欢迎大家关注我的个人公众号WizzyAngShare，(还有个人博客)

我会在这里分享编程语言语法，算法，及区块链的相关知识，还有各种奇奇怪怪的小知识等着你~

QRCode
虽然现在这个公众号有亿点草率 ，我会努力更新的~~~

1Wizzy
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索算法——IDA*
Psychosocial的博客
09-15 1419
搜索算法——IDA∗IDA*IDA∗ 算法介绍 IDA∗IDA*IDA∗是基于深度优先搜索进行优化的一种算法，又被称作为迭代加深搜索，是一种启发式搜索算法。 什么叫做迭代加深呢？实际上深搜会搜索很多层，几乎是呈指数级增长的，但是实际上可以通过限制搜索深度来优化。在深度没有上限的情况下，先预先估计一个较小的深度kkk,首先搜索KKK层，如果没有找到解，深度加111，从头开始搜索到k+1k+1k+1...
搜索算法：IDA*算法
热门推荐
如果这是你所爱的，要坚持，并踏实。
09-01 2万+
今天学习了IDA*算法，在这里总结一下：IDA*算法是A*算法和迭代加深算法的结合。迭代加深算法是在dfs搜索算法的基础上逐步加深搜索的深度，它避免了广度优先搜索占用搜索空间太大的缺点，也减少了深度优先搜索的盲目性。它主要是在递归搜索函数的开头判断当前搜索的深度是否大于预定义的最大搜索深度，如果大于，就退出这一层的搜索，如果不大于，就继续进行搜索。这样最终获得的解必然是最优解。而在A*算法中，我们通过使用合理的估价函数，然后在获得的子节点中选择fCost最小的节点进行扩展，以此完成搜索最优解的目的。但是A*
C语言经典算法之介绍IDA*算法
weixin_56154577的博客
03-25 2287
IDA*（Iterative Deepening A*）算法是一种结合了A算法和深度优先搜索（DFS）思想的启发式搜索算法。它解决了A算法在面对深而窄的搜索空间时，可能因为需要存储大量节点而导致内存溢出的问题。IDA*通过迭代加深的方式逐步扩大搜索深度，每次只探索到当前设定的最大深度，没有找到解时就增加最大深度，继续搜索。
IDA*算法
qq_51699436的博客
02-17 1325
IDA*算法是迭代加深的A*算法，设计一个估价函数f(state)<=真实步数
IDA*算法 启发式搜索
十一.的博客
06-27 166
迭代加深的A*算法
IDA基本操作
desporado的博客
05-16 2183
当我们打开之后，IDA会提供3种不同的打开方式；New（新建），Go（运行），Previous（上一个）。当我们初次打开的时候选择GO就可以了。进入之后，选择左上角的file中的open打开文件。以凯撒密码为例，打开文件以后。主界面工作区显示IDA View-A是反汇编窗口，HexView-A是十六进制格式显示的窗口，Imports是导入表（程序中调用到的外面的函数），Functions是函数表（...
ida* 的一些题　ida*小结
weixin_30337251的博客
08-12 345
这些题都是http://www.cnblogs.com/ambition/archive/2011/07/25/search_plus.html　　里的。。我的一些代码也参考了里边的代码 HDU 1043 Eight 话说是一道涉及到人生完整不完整的题　八数码 判断有没有解：求出所给状态的逆序数m，如果同是奇数则无解，偶数则有解。　　why?...
迭代深度A*搜索算法
01-17
1. 含有优化步骤：（1）采用Iterative deepening A*算法，加速了A*算法记录路径的步骤，（2）采用部分全局变量，加速了计算过程； 2. Linux编译通过，含makefile和readme 3. 可以解决15数码的问题，比传统的8数码问题更广泛！
15 puzzle C语言IDA* 求解算法
10-23
使用纯C语言，IDA*搜索，求解15 puzzle（15数字谜题，移动空白方块恢复1-15顺序的一种游戏）的算法。
人工智能-IDA*算法解决15-puzzle问题（能优化的都优化了）
04-08
人工智能作业，使用迭代加深IDA*算法解决15-puzzle问题，经过了多次优化得到的最终版本。
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
07-05
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
A*以及迭代加深的A*算法（IDA*）
10-05
A*是对上面算法的一个改进,具体来说就是改变了代价函数,例如,目标是D,起始为A,首先的初始化将每个节点到D的直线距离赋给节点做代价函数,然后在访问了A之后,马上预测A的子节点BC,求得B的实际代价为A到B的花费加上B的原始代价.同理取得C的实际代价,之后在A的所有子节点中选择代价最小的节点进行扩展。上面的过程重复进行直到找到目标。 迭代加深（ID），有些许不同于上面的算法，ID算法将深度设置为dep，对于一个树做深度优先的遍历（节制条件：所有节点的深度不大于dep），如果没有找到目标，那么将dep++，重复上面的过程直到找到目标。 IDA*算法（也就是迭代深度优先算法），将上面的A*和ID算法结合起来，也就是，在进行搜索时，使用耗散值替代ID中的深度值（f=g+h）,也就是说，搜索的范围在那些不超过给定值的节点中进行深度优先搜索。如果搜索不成功，那么返回头节点，并且使限定的耗散值变大（具体为所有超过上次限定值节点中的最小耗散），也就是说，在迭代过程中我们需要纪录一下那些我们已经探知的，超过限定的节点的耗散函数值，然后挑选其中的最小值，再次进行搜索。（个人感觉，太浪费前面已经所作的工作了）。
IDA*数字拼图
11-21
修改了华都烟梦的代码，实现了数字图块的单个移动算法，从而加快了AI的速度，但是不是全局最优步数。
八数码的IDA*算法实现
03-17
(内附源码、详细代码注释、测试数据) 源码1：普通IDA*算法实现八数码 源码2：变相IDA*算法实现八数码，ACRush楼天成大牛的2005百度之星巨作，佩服佩服，CPU上平均跑0.0022S
IDA*（IDDFS+估价函数）
m0_61948547的博客
12-31 176
从数字1开始，用加减法，最少算多少次能得到n。2022最后一篇博客，2023新的开始，继续感受如此美妙吧。
A* 算法
ZhuRanCheng的博客
03-13 1006
A* 算法总结
IDA调试so文件基础篇
九天
10-11 1万+
我们前面学习了如何使用eclipse调试smali文件，今天我们一起来学习一下如何使用IDA调试so文件。今天我们讲述的重点放在成功调试so文件，讲得比较基础，因此我们使用前面eclipse建立的NDK项目hello3作为示例来讲解。想了解的同学，可以转战这里：http://blog.csdn.net/u012195899/article/details/52711524，这个示例非常的简单，就是
工具使用-IDA从入门到理解
07-11 4072
启动界面介绍: 1 2 3 4 NEW：打开IDA同时弹出对话框选择要打开的文件 Go：单独打开ida，打开界面将文件拖入 Previous，或者下面的列表项：快速打开之前的的文件 这里选择Go键，打开以后 这里选择Go键，打开以后 把我们要分析的文件拖到ida即可 这里按我们的默认选项点击OK即可。 选择中可能需要理解的为： 1 2 Manual Load：基地址重定向，..
A*算法和IDA*算法有什么区别？
最新发布
05-15
A*算法和IDA*算法都是启发式搜索算法，它们都是用于解决最短路径问题的常用算法。其中，A*算法在搜索时利用了启发式函数来估计从当前节点到目标节点的距离，从而选择最优的节点进行搜索。而IDA*算法则是在A*算法基础上做出的改进，其主要区别是不使用任何额外的内存空间，而是将估价函数的值作为深度限制，直到找到目标节点或者超过深度限制为止。 具体来说，A*算法维护一个open列表和一个closed列表。open列表中保存了待搜索的节点，closed列表中保存已经被搜索过的节点。每次从open列表中选择一个f值最小的节点进行扩展，并将其加入closed列表中。扩展时，对于当前节点的每个子节点计算估价函数值f(n)=g(n)+h(n)，其中g(n)是从起点到当前节点的实际代价，h(n)是从当前节点到目标节点的估计代价。这样，每次选择f值最小的节点进行扩展时，就能够尽可能地朝着目标节点前进。 IDA*算法则是将A*算法中的open列表替换成一个栈，在搜索时将当前搜索深度作为阈值，不断更新阈值来限制搜索深度。具体来说，每次从起点开始，将阈值设置为起点到目标节点的估价函数值，然后进行深度优先搜索。如果搜索到某个节点的f(n)>threshold，则将其返回，并将阈值更新为f(n)。这样，IDA*算法通过不断增加深度限制来逐步逼近最短路径，直到找到目标节点或者搜索到达最大深度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值