迭代加深：

搜索范围一层一层扩大，可以快速某些分支比较深，但是答案比较浅的问题。

https://www.acwing.com/problem/content/172/

通过观察可以发现：

1.搜索时最坏情况可能搜到100层，比较深，但是答案应该比较浅，于是考虑迭代加深。

2.剪枝：

（1）搜索顺序：我们从后往前枚举

（2）等效冗余：枚举前面选2个，等值的不用重复算。

AC代码：

#include<bits/stdc++.h>
using namespace std;
int path[110];
int n;
int dfs(int c,int len){
    if(path[c]==n&&c==len) return 1;
    if(c>=len) return 0;
    bool st[500]={0};
    for(int i=c;i>=1;i--){
        for(int j=i;j>=1;j--){
            int ck=path[i]+path[j];
            if(ck>n) continue;
            if(st[ck]) continue;
            if(ck<=path[c]) continue;
            st[ck]=1;
            path[c+1]=ck;
            if(dfs(c+1,len)) return 1;
        }
    }
    return 0;
}
int main(){
    while(cin>>n,n){
        path[1]=1;
        int len=1;
        while(dfs(1,len)==0) len++;
        for(int i=1;i<=len;i++){
            cout<<path[i]<<" ";
        }
        cout<<endl;
    }
}

双向DFS：

https://www.acwing.com/problem/content/173/

我们先想想直接DFS，那么差不多是1e12多的级别，于是我们对于考虑枚举前个，对于剩下的个我们枚举一个再二分一下前个中与它最接近W的值即可。

我们考虑复杂度：，我们考虑选取合适的K来最小化复杂度即可（一般直接对半开即可）

AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll w1,n;
const int N=(1<<24);
ll a[101];
ll w[N];
ll cnt=0;
ll ans=0;
void dfs1(ll u,ll len,ll fk){
    if(u==len+1){
        w[++cnt]=fk;
        return;
    }
    dfs1(u+1,len,fk);
    if(fk+a[u]<=w1) dfs1(u+1,len,fk+a[u]);
}
void dfs2(ll u,ll len,ll fk){
    if(u==len+1){
        ll l=0,r=cnt-1;
        while(l<r){
            int mid=(l+r+1)/2;
            if(fk+w[mid]<=w1) l=mid;
            else r=mid-1;
        }
        ans=max(ans,fk+w[l]);
        return;
    }
    dfs2(u+1,len,fk);
    if(fk+a[u]<=w1) dfs2(u+1,len,fk+a[u]);
}
int main(){
    cin>>w1>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    sort(a+1,a+n+1);
    reverse(a+1,a+n+1);
    ll len=n/2;
    dfs1(1,len,0);
    sort(w+1,w+cnt+1);
    cnt=unique(w+1,w+cnt+1)-w;
    //for(int i=1;i<=cnt-1;i++) cout<<w[i]<<" "; 
    dfs2(len+1,n,0);
    cout<<ans;
}

IDA*:

其实就是迭代加深上加了个评估函数，假如预估到最深层还是不行就退出。

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

整体就是一个迭代加深，现在我们考虑构造评估函数：

类似逆序对，我们考虑连接对（每一个后继点为前一个+1视为正确），每一次操作一共断开3个连接点，因此最多一次矫正3个。

于是我们设当前错误的连接对有个，那么评估函数就是：。

下面是AC代码：

#include<bits/stdc++.h>
using namespace std;
int t,n;
int a[16];
int dep[6][16];
int f()
{
    int res = 0;
    for (int i = 1; i + 1 <= n; i ++ )
        if (a[i + 1] != a[i] + 1)
            res ++ ;
    return (res + 2) / 3;
}

bool check()
{
    for (int i = 1; i <= n; i ++ )
        if (a[i] != i)
            return false;
    return true;
}
int dfs(int d,int len){
    if(d+f()>len) return 0;
    if(check()) return 1;
    for(int l=1;l<=n;l++){
        for(int r=l;r<=n;r++){
            for(int k=r+1;k<=n;k++){
                memcpy(dep[d], a, sizeof a);
                int x,y;
                for(x=r+1,y=l;x<=k;x++,y++) a[y]=dep[d][x];
                for(x=l;x<=r;x++,y++) a[y]=dep[d][x];
                if(dfs(d+1,len)) return 1;
                memcpy(a, dep[d], sizeof a);
            }
        }
    }
    return 0;
}
int main(){
    cin>>t;
    while(t--){
        cin>>n;
        for(int i=1;i<=n;i++) cin>>a[i];
        int len=0;
        while(len<5&&!dfs(0,len)) len++;
        if(len>=5) cout<<"5 or more"<<endl;
        else cout<<len<<endl;
    }
}

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

和上一题类似，我们直接考虑评估函数的构造：

我们发现，假如中间8个里出现次数最多的是个，那么我们最少通过来实现。

同时，为了操作的方便，我们采用打表的方式：

具体来说，我们人为的对这个“容器”的位置标号（从上到下，从左到右），同时我们把每一次操作对应的编号记下来，这样每次操作都可以快速找到进行操作位置的下标了。

AC代码：

/*
      0     1
      2     3
4  5  6  7  8  9  10
      11    12
13 14 15 16 17 18 19
      20    21
      22    23
*/
#include<bits/stdc++.h>
using namespace std;
const int N = 24;
int q[N];
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 center[8] = {6, 7, 8, 11, 12, 15, 16, 17};
int opposite[8] = {5, 4, 7, 6, 1, 0, 3, 2};
int path[100];
int f()
{
    int sum[4]={0};
    for (int i = 0; i < 8; i ++ ) sum[q[center[i]]] ++ ;
    int s = 0;
    for (int i = 1; i <= 3; i ++ ) s = max(s, sum[i]);
    return 8 - s;
}
void operation(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)
{
    if (depth + f() > max_depth) return false;
    if (f()==0) return true;
    for (int i = 0; i < 8; i ++ )
    {
        if (opposite[i] == last) continue;
        operation(i);
        path[depth] = i;
        if (dfs(depth + 1, max_depth, i)) return true;
        operation(opposite[i]);
    }
    return false;
}

int main()
{
    while (scanf("%d", &q[0]), q[0])
    {
        for (int i = 1; i < N; i ++ ) scanf("%d", &q[i]);
        int depth = 0;
        while (!dfs(0, depth, -1)) depth ++ ;
        if (!depth) printf("No moves needed");
        for (int i = 0; i < depth; i ++ ) printf("%c", 'A' + path[i]);
        printf("\n%d\n", q[6]);
    }
}