[BZOJ 1085][SCOI 2005]骑士精神(IDA*搜索)

题目链接:http://www.lydsy.com:808/JudgeOnline/problem.php?id=1085

考虑到深度不超过15,IDA*搜索可做。

估价函数h()=当前不在目标位置的棋子个数。

然后其他细节就和普通的迭代加深一样了。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

using namespace std;

int xx[]={1,1,-1,-1,2,2,-2,-2};
int yy[]={2,-2,2,-2,1,-1,1,-1};
char map[6][6];
char goal[6][6]={
    {0,0,0,0,0,0},
    {0,'1','1','1','1','1'},
    {0,'0','1','1','1','1'},
    {0,'0','0','*','1','1'},
    {0,'0','0','0','0','1'},
    {0,'0','0','0','0','0'}
}; //目标棋盘

bool inMap(int x,int y)
{
    if(x<1||x>5||y<1||y>5) return false;
    return true;
}

int h() //估价函数
{
    int ans=0;
    for(int i=1;i<=5;i++)
        for(int j=1;j<=5;j++)
            ans+=(goal[i][j]!=map[i][j]);
    return ans;
}

bool IDAstar(int step,int maxdeep)
{
    if(step>maxdeep) return false;
    int predict=h(),bx,by; //空格坐标为(bx,by)
    if(!predict) return true; //达到目标状态
    if(predict-1+step>maxdeep) return false; //h()函数剪枝
    for(int i=1;i<=5;i++)
        for(int j=1;j<=5;j++)
            if(map[i][j]=='*')
                bx=i,by=j;
    for(int dir=0;dir<8;dir++)
    {
        int tx=bx+xx[dir],ty=by+yy[dir];
        if(!inMap(tx,ty)) continue;
        swap(map[bx][by],map[tx][ty]);
        if(IDAstar(step+1,maxdeep)) return true;
        swap(map[bx][by],map[tx][ty]);
    }
    return false;
}

int main()
{
    int T,maxdeep;
    scanf("%d",&T);
    while(T--)
    {
        for(int i=1;i<=5;i++)
            scanf("%s",map[i]+1);
        for(maxdeep=0;maxdeep<=15;maxdeep++)
        {
            if(IDAstar(0,maxdeep))
            {
                printf("%d\n",maxdeep);
                break;
            }
        }
        if(maxdeep>15) puts("-1");
    }
    return 0;
}



时间: 2024-08-04 15:26:02

[BZOJ 1085][SCOI 2005]骑士精神(IDA*搜索)的相关文章

BZOJ 1085 SCOI 2005 骑士精神 IDA*

题目大意:有一张5*5的棋盘,上面有12和黑棋还有12个白棋.问最少多步可以到达目标状态. 思路:搜索+剪枝.至于剪枝我就用ID+A*的组合了,因为都不难想,估价函数就是当前图和目标图有多少个方块不一样.如果当前步数+估价大于当前迭代加深的层数就退出. CODE: #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std;

[BZOJ 1085] [SCOI2005] 骑士精神 [ IDA* 搜索 ]

题目链接 : BZOJ 1085 题目分析 : 本题中可能的状态会有 (2^24) * 25 种状态,需要使用优秀的搜索方式和一些优化技巧. 我使用的是 IDA* 搜索,从小到大枚举步数,每次 DFS 验证在当前枚举的步数之内能否到达目标状态. 如果不能到达,就枚举下一个步数,重新搜索,即使某些状态在之前的 DFS 中已经搜索过,我们仍然搜索. 并且在一次 DFS 中,我们不需要判定重复的状态. 在 IDA* 中,重要的剪枝优化是 估价函数 ,将一些不可能存在可行解的枝条剪掉. 如果估价函数写得

【BZOJ 1085】 [SCOI2005]骑士精神

Description 在一个5×5的棋盘上有12个白色的骑士和12个黑色的骑士, 且有一个空位.在任何时候一个骑士都能按照骑士的走法(它可以走到和它横坐标相差为1,纵坐标相差为2或者横坐标相差为2,纵坐标相差为1的格子)移动到空位上. 给定一个初始的棋盘,怎样才能经过移动变成如下目标棋盘: 为了体现出骑士精神,他们必须以最少的步数完成任务. Input 第一行有一个正整数T(T<=10),表示一共有N组数据.接下来有T个5×5的矩阵,0表示白色骑士,1表示黑色骑士,*表示空位.两组数据之间没有

SCOI 2005 骑士精神 &amp;&amp; FZU 骑士 搜索+剪枝

lydsy 1085 题目链接:点击打开链接 #include <cstdio> #include <cstring> #include <vector> #include <cmath> #include <iostream> #include <algorithm> using namespace std; const int dx[] = {1, 1, -1, -1, 2, 2, -2, -2}; const int dy[]

埃及分数&amp;&amp;The Rotation Game&amp;&amp;骑士精神——IDA*

IDA*:非常好用的搜索,可以解决很多深度浅,但是规模大的搜索问题. 估价函数设计思路:观察一步最多能向答案靠近多少. 埃及分数 题目大意: 给出一个分数,由分子a 和分母b 构成,现在要你分解成一系列互不相同的单位分数(形如:1/a,即分子为1),要求:分解成的单位分数数量越少越好,如果数量一样,最小的那个单位分数越大越好. 如: 19/45 = 1/3 + 1/12 + 1/180; 19/45 = 1/5 + 1/6 + 1/18; 以上两种分解方法都要3个单位分数,但下面一个的最小单位分

【BZOJ1085】【SCOI2005】骑士精神 [A*搜索]

骑士精神 Time Limit: 10 Sec  Memory Limit: 162 MB[Submit][Status][Discuss] Description 在一个5×5的棋盘上有12个白色的骑士和12个黑色的骑士, 且有一个空位. 在任何时候一个骑士都能按照骑士的走法(它可以走到和它横坐标相差为1,纵坐标相差为2或者横坐标相差为2,纵坐标相差为1的格子)移动到空位上. 给定一个初始的棋盘,怎样才能经过移动变成如下目标棋盘: 为了体现出骑士精神,他们必须以最少的步数完成任务. Input

bzoj 1085: [SCOI2005]骑士精神 IDA*

题目链接 给一个图, 目标位置是确定的, 问你能否在15步之内达到目标位置. 因为只有15步, 所以直接ida* #include<bits/stdc++.h> using namespace std; #define pb(x) push_back(x) #define ll long long #define mk(x, y) make_pair(x, y) #define lson l, m, rt<<1 #define mem(a) memset(a, 0, sizeof(

骑士精神——IDA*

不说了,这玩意就是个人生题,昨天晚上各种鬼,还有变量突然变成0的坑爹事情都出现了. 十五步以上算-1解... 总体思路,IDA*: 1.写个估值函数,这里我写的是和目标图的理想差异 2.枚举步数,根据步数和估值来决定剪枝. 3.一点经验,估值剪枝不要严格卡在步数上,可以适当放高上限,确保答案在搜索树上,换言之就是剪枝写的鲁棒一点,确保答案完整性,再去考虑效率. 黏上丑陋不堪的代码: 1 #include<iostream> 2 #include<cstdio> 3 #include

BZOJ 1087 SCOI 2005 互不侵犯King 状压DP

题目大意:一个国王可以攻击到旁边8个位置的格子,现在给出一个N*N的方格,向其中放k个国王,问有多少中摆放方法. 思路:状压DP,f[i][j][k],其中i是行数,j是状态,k是已经取了多少国王.然后暴力枚举状态,看相邻两行之间有没有冲突,若没有冲突,那么就转移. 注意要开long long CODE: #include <cstdio> #include <cstring> #include <iostream> #include <algorithm>