1.迭代加深

顾名思义说明迭代的层数逐渐加深，这样做法有点像bfs的做法层层突出，符合的题型是答案在层数较低的那一层里

加成序列

题目https://www.acwing.com/problem/content/description/172/

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int n;
int path[N];
bool dfs(int u,int depth)//第一个是元素个数，第二个是当前的深度
{
    if(u>depth) return  false;//假如元素大于深度，说明不可能了
    if(path[u-1]==n) return true;//假如元素个数达到深度，且最后一个是n，则说明符合条件
    bool st[N]={0};//用来标记那个数已经枚举过
    for(int i=u-1;i>=0;i--)//枚举前u个数，两两可以相加，相当于组合数
        for(int j=i;j>=0;j--)
        {
           int s=path[i]+path[j];//获取这两个数的值
           if(st[s]||s>n||s<=path[u-1]) continue;//假如已经枚举过或者和大于n或者不符合后一个数比前一个数小，则跳过
            st[s]=true;//标记这个数已经用过
            path[u]=s;//这个数放进数组里
           if(dfs(u+1,depth)) return true;//继续搜索下一个数
        }
    return false;
}
int main()
{
    path[0]=1;//规定第一个数是1
   while(cin>>n,n)
   {
       int depth=1;//枚举深度，大概知道答案在比较近的一层，所以不枚举宽度
       while(!dfs(1,depth)) depth++;//假如这个深度不符合，则加1
       for(int i=0;i<depth;i++) cout<<path[i]<<' ';//输出答案
       puts("");
   }
   return 0;
}

2.双向dfs

顾名思义就是分两段dfs，搜索前半段与后半段

送礼物

第一种使用了unique函数判重可能会超时 

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=110;
int n,k;
int cnt=1;
ll w[N],m,weight[1<<25],ans;
void dfs1(int u,ll s)
{
    if(s>m) return;//假如已经大于了，则直接返回
    if(u==k)//假如搜到了最后一个
    {
        weight[cnt++]=s;//把这个值放进数组里来
        return;//这里不能少
    }
    dfs1(u+1,s);//假如不选这个数
    if(s+w[u]<=m) dfs1(u+1,s+w[u]);//假如满足条件选这个数
}
void dfs2(int u,ll s)
{
   if(s>m) return;//假如已经大于了，则直接返回
   if(u==n)//假如搜到了最后一个
   {
       //下面二分有左边界，因为找刚好小于m的最大数
      int l=0,r=cnt-1;
      while(l<r)
      {
          int mid=l+r+1>>1;
          if(weight[mid]+s<=m) l=mid;
          else r=mid-1;
      }
     ans=max(ans,s+weight[l]);//更新一下答案
     return;//这里不能少
   }
    dfs2(u+1,s);//假如不选这个数
    if(s+w[u]<=m) dfs2(u+1,s+w[u]);//假如符合条件选这个数
}
int main()
{
    cin>>m>>n;
    for(int i=0;i<n;i++) cin>>w[i];
    //从大到小排序
    sort(w,w+n);
    reverse(w,w+n);
    k=n/2+1;//对半分开搜索
    dfs1(0,0);//搜索前半段，打表出来存进数组里头
    //去重
    sort(weight,weight+cnt);
    cnt=unique(weight,weight+cnt)-weight;
    dfs2(k,0);//搜索后半段
    cout<<ans<<endl;
   return 0;
}

第二种手写判重 

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=110;
int n,k;
int cnt=1;
ll w[N],m,weight[1<<25],ans;
void dfs1(int u,ll s)
{
    if(s>m) return;//假如已经大于了，则直接返回
    if(u==k)//假如搜到了最后一个
    {
        weight[cnt++]=s;//把这个值放进数组里来
        return;//这里不能少
    }
    dfs1(u+1,s);//假如不选这个数
    if(s+w[u]<=m) dfs1(u+1,s+w[u]);//假如满足条件选这个数
}
void dfs2(int u,ll s)
{
   if(s>m) return;//假如已经大于了，则直接返回
   if(u==n)//假如搜到了最后一个
   {
       //下面二分有左边界，因为找刚好小于m的最大数
      int l=0,r=cnt-1;
      while(l<r)
      {
          int mid=l+r+1>>1;
          if(weight[mid]+s<=m) l=mid;
          else r=mid-1;
      }
     ans=max(ans,s+weight[l]);//更新一下答案
     return;//这里不能少
   }
    dfs2(u+1,s);//假如不选这个数
    if(s+w[u]<=m) dfs2(u+1,s+w[u]);//假如符合条件选这个数
}
int main()
{
    cin>>m>>n;
    for(int i=0;i<n;i++) cin>>w[i];
    //从大到小排序
    sort(w,w+n);
    reverse(w,w+n);
    k=n/2+1;//对半分开搜索
    dfs1(0,0);//搜索前半段，打表出来存进数组里头
    
    // 判重 去重
    int t = 1;
    for (int i = 1; i < cnt; i++)
        if (weight[i] != weight[i - 1])
            weight[t++] = weight[i];
    cnt = t;

    dfs2(k,0);//搜索后半段
    cout<<ans<<endl;
   return 0;
}

3.IDA*

找估计函数，在枚举步数，用估计函数+当前步数来剪枝，大大提高效率，前提是答案的层数小

 1.排书

题目https://www.acwing.com/problem/content/182/

#include<bits/stdc++.h>
using namespace std;
const int N=20;
int n;
int q[N],w[5][N];
int f()//用来计算估计函数
{
    int totol=0;//算位置不符合的总个数
    for(int i=0;i<n-1;i++)
      if(q[i]!=q[i+1]-1)
         totol++;
    return (totol+2)/3;//因为每次交换能更改三个位置的后缀，我们算他改的都是正确的则就除以三，但是实际肯定是小了的
}
bool dfs(int depth,int max_depth)//depth是当前已执行的步数，max_depth是最大步数
{
    if(f()+depth>max_depth) return false;//假如当前步数加上估计函数大于最大步数了，说明不符合
    if(f()==0) return true;//假如估计函数为0，也就是正确答案了，则直接返回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=l;
                //下面进行这一段跟右边的位置交换
                for(int y=r+1;y<=k;y++,x++) q[x]=w[depth][y];
                for(int y=l;y<=r;y++,x++) q[x]=w[depth][y];
                //进行下一步，假如下一步可以符合答案，则链式返回true
                if(dfs(depth+1,max_depth)) return true;
                memcpy(q,w[depth],sizeof q);//把更改后的这一层q复制到w这一层中，供下一层使用
            }
        }
    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) cout<<depth<<endl;
       else puts("5 or more");
   }
   return 0;
}

 2.回转游戏

题目 https://www.acwing.com/problem/content/183/

#include<bits/stdc++.h>
using namespace std;
const int N=24;
int n;
int q[N],path[110];
//分别为八个方向的位置
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 unop[8]={5,4,7,6,1,0,3,2};//八个方向的反操作，避免往上拉了，又往下拉，等于没操作
int cenctr[8]={6,7,8,11,12,15,16,17};//中心的8个位置
int f()//算估计函数
{
    static int temp[4];//静态数组节省空间
    memset(temp,0,sizeof temp);//清空
    for(int i=0;i<8;i++) temp[q[cenctr[i]]]++;//记录中间那个数出现的最多
    int m=0;
    for(int i=1;i<=3;i++) m=max(m,temp[i]);//求一下出现最多的数的个数
    return 8-m;//返回最少需要操作的次数，也就是8-m
}
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)//depth是当前步数，max_depth是最大步数，last是上一步的操作
{
    if(depth+f()>max_depth) return false;//假如估计函数+目前步数已经大于最大步数了，则返回false
    if(f()==0) return true;//假如已经排好了，则返回true
    for(int i=0;i<8;i++)//枚举8个操作
        if(unop[i]!=last)//返回操作了上又操作下，等于没操作
        {
           operate(i);//操作i
           path[depth]=i;//把当前路径标记为i操作的
           if(dfs(depth+1,max_depth,i)) return true;//假如下一步操作是true，则返回true
           operate(unop[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');//输出路径
      }
      printf("
%d
",q[6]);//输出中心的数字
  }
   return 0;
}