迭代启发式搜索 IDA*

本章聚集了一些做了的迭代启发式搜索的题目

为什么只打了迭代启发式搜索?

因为它很好打，有些类似迭代的时候加的最优化剪枝

[因为这个最优化剪枝其实就是你算的估价函数了...]

BZOJ 1085 骑士精神

比较经典的一题，特别是题目中还说了在15步内走完...看上去就是迭代的样子

估价函数->指棋盘上不符合规定的骑士数目...每次移动最多让一名骑士回到自己的位置，由此来剪枝

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

 using namespace std;

 int maxd,sx,sy;
 char ch[][];
 int x[]={,,-,-,,,-,-};
 int y[]={,-,,-,,-,,-};
 int ans[][]={{,,,,},{,,,,},{,,,,},{,,,,},{,,,,}};

 struct Node{
     int a[][];
     int illegal(){
     int cnt=;
         for(int i=;i<;i++)
             for(int j=;j<;j++)
                 if(a[i][j]!=ans[i][j]) cnt++;
         return cnt;
     }
 };

 inline bool judge(int a[][]){
     for(int i=;i<;i++)
         for(int j=;j<;j++)
             if(a[i][j]!=ans[i][j]) return false;
     return true;
 }

 inline bool inmap(int x,int y){
     if(x>= || x< || y>= || y<) return false;
     return true;
 }

 bool dfs(int level,Node s,int bx,int by){
     if(!level){
         if(judge(s.a)) return true;
         return false;
     }
     int newx,newy;
     for(int i=;i<;i++){
         newx=bx+x[i],newy=by+y[i];
         if(inmap(newx,newy)){
             swap(s.a[bx][by],s.a[newx][newy]);
             if(s.illegal()<=level)
                 if(dfs(level-,s,newx,newy)) return true;
             swap(s.a[bx][by],s.a[newx][newy]);
         }
     }
     return false;
 }

 int main(){
 #ifndef ONLINE_JUDGE
     freopen("1085.in","r",stdin);
     freopen("1085.out","w",stdout);
 #endif
     int kase;
     Node s;
     scanf("%d",&kase);
     while(kase--){
         for(int i=;i<;i++){
             scanf("%s",ch[i]);
             for(int j=;j<;j++)
             if(ch[i][j]=='*') s.a[i][j]=,sx=i,sy=j;
             else if(ch[i][j]=='') s.a[i][j]=;
             else s.a[i][j]=;
         }
         if(!s.illegal()) {puts("");continue;}
         for(maxd=;maxd<=;maxd++)
             if(dfs(maxd,s,sx,sy)) break;
         if(maxd<=)
             printf("%d\n",maxd);
         else
             puts("-1");
     }
     return ;
 }

codevs1288 埃及分数

强行把从某个状态之后的最小值看做估价函数也是可以的...紫书例题

不过有一些坑点，看codevs题解的第一篇吧(...我写的)。

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

 using namespace std;

 typedef long long ll;

 const int maxn=;
 const int INF=0x7f7f7f7f;

 int a,b,d;
 ll res[maxn],rec[maxn];

 ll gcd(ll a,ll b){
     ll t;
     while(b)
         t=b,b=a%b,a=t;
     return a;
 }

 inline bool better(ll a[]){
     if(a[]>=res[]) return false;
     else return true;
     for(int i=;i<=d;i++)
         if(a[i]<res[i]) return true;
         else if(a[i]>res[i]) return false;
     return false;
 }

 bool dfs(int level,ll last,ll aa,ll bb){
     if(level==){
         if(bb%aa) return false;
         rec[]=bb/aa;
         if(better(rec))
             for(int i=;i<=d;i++) res[i]=rec[i];
         return true;
     }
     bool ok=false;
     last=max(last+,(bb/aa)+!(bb%aa==));
     for(int i=last;;i++){
         if(aa*i>=bb*level) break;
         ll b1=bb*i,a1=aa*i-bb,Gcd;
         Gcd=gcd(a1,b1);
         a1/=Gcd,b1/=Gcd;rec[level]=i;
         if(dfs(level-,i,a1,b1)) ok=true;
     }
     return ok;
 }

 int main(){
     scanf("%d%d",&a,&b);
     memset(res,0x7f,sizeof(res));
     for(d=;!dfs(d,,a,b);d++);
     for(int i=d;i>=;i--)
         printf("%lld ",res[i]);

     return ;
 }

codevs2495 水叮当的舞步

这题估价函数居然就是一个颜色?...我其实有想过什么连通块个数的估价然而没有什么用...

其实这题关键还是在于给左上角染色的过程，每次给变色的地方染1，变色的周围染2，然后每次的颜色只要扩展2中相同的就好...比每次dfs快上很多的样子...

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

 using namespace std;

 int maxd,n;
 int mp[][],mark[][];
 int xx[]={,-,,};
 int yy[]={,,-,};
 bool used[];
 bool ans;

 int get(){
     int cnt=;
     memset(used,,sizeof(used));
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             if(!used[mp[i][j]] && mark[i][j]!=)
                 used[mp[i][j]]=,cnt++;
     return cnt;
 }

 void dfs(int a,int b,int x){
     mark[a][b]=;
     for(int i=;i<;i++){
         int nowx=a+xx[i],nowy=b+yy[i];
         if(nowx<||nowy<||nowx>n||nowy>n||mark[nowx][nowy]==) continue;
         mark[nowx][nowy]=;
         if(mp[nowx][nowy]==x)dfs(nowx,nowy,x);
     }
 }

 int fill(int x){
     int cnt=;
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             if(mark[i][j]==&&mp[i][j]==x)
                 cnt++,dfs(i,j,x);
     return cnt;
 }

 bool search(int level){
     int v=get();
     if(!v) return true;
     if(v>level) return false;
     int temp[][];
     for(int i=;i<=;i++){
         memcpy(temp,mark,sizeof(mark));
         if(fill(i)) if(search(level-)) return true;
         memcpy(mark,temp,sizeof(mark));
     }
     return false;
 }

 int main(){

     while(~scanf("%d",&n)){
         if(!n) break;
         memset(mark,,sizeof(mark));
         ans=;
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
                 scanf("%d",&mp[i][j]);
         dfs(,,mp[][]);
         for(maxd=;!search(maxd);maxd++);
         printf("%d\n",maxd);
     }
     return ;
 }

UVa11212 编辑书稿

估价函数比较精妙，每次最多让三个元素的后继正确。

为什么是后继呢？因为这个操作的本质就是改变后继...

 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<algorithm>

 using namespace std;

 const int maxn=;

 struct Node{
     int v[maxn];
 };

 int n,maxd;

 inline int get_h(int a[]){
     int cnt=;
     for(int i=;i<n;i++)
         if(a[i+]!=a[i]+) cnt++;
     return cnt;
 }

 void move(Node &Start,Node &Next,int I,int J,int K){
     for(int i=;i<=K-J-;i++)
         Next.v[i+I]=Start.v[J++i];
     for(int i=;i<=J-I;i++)
         Next.v[K-J+I+i]=Start.v[i+I];
 }

 bool dfs(int level,Node s){
     if(get_h(s.v)>*level) return false;
     if(get_h(s.v)==) return true;

     Node next;
     for(int i=;i<=n;i++)
         for(int j=i;j<=n;j++)
             for(int k=j+;k<=n;k++){
                 memcpy(next.v,s.v,sizeof(s.v));
                 move(s,next,i,j,k);
                 if(dfs(level-,next)) return true;
             }
     return false;
 }

 int main(){
 #ifndef     ONLINE_JUDGE
     freopen("11212.in","r",stdin);
     freopen("11212.out","w",stdout);
 #endif

     int kase=;
     Node a0;

     while(~scanf("%d",&n)){
         if(!n) break;
         for(int i=;i<=n;i++)
             scanf("%d",&a0.v[i]);
         if(!get_h(a0.v)){
             printf("Case %d: 0\n",++kase);
             continue;
         }

         for(maxd=;!dfs(maxd,a0);maxd++);
         printf("Case %d: %d\n",++kase,maxd);
     }

     return ;
 }