dfs剪枝与迭代加深与双向dfs

一、做题顺序：
1.考虑如何能正确搜索出所有的方案
2.再考虑剪枝

1.优化搜索顺序
大部分情况下，我们应该优先搜索分支较少的节点。
2.排除等效冗余
比如不考虑顺序的话用组合方式来搜索
3.可行性剪枝
如果某种方案不合法就不进行搜索
4.最优性剪枝
比如搜索最小值，若搜到的值已经比答案多，那就停止
5.记忆化搜索

二、迭代加深：
某些搜索的节点特别的深，但是它的答案却是在比较短的层数上
定义一个max_deepth，如果搜索的层数大于这个值就直接return;
max_deeepth一般从0开始，一次一次的增加，防止进入无底洞。
与宽搜的区别：使用的空间不像bfs那么大，空间复杂度为O(h)；

适合问题：某些搜索层数深，但是答案在浅层。
问题：前面的节点会重复搜索，但是问题不大，因为第i+1层的节点数等于前i层节点数-1，相较于答案来讲是可以忽略不计的。

例题：加成序列
当n=100时，搜索深度最多可以100层，可是如果要构造一个到128的序列，答案最短可以为1 2 4 8 16 32 64 128，仅需8层，因此，比较适合用迭代加深来写。

加入剪枝：
1.优化搜索顺序：每次搜索先搜索大的值
2.排除等效冗余：不同的两个数的和是一样的，所以1+4和2+3是一样的，只用枚举其中一组数就可以了。开一个bool数组判断这个数有没有被枚举过。
代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N = 110;
int n;
int path[N]; //存储答案
bool dfs(int u,int k)
{
    if(u==k)//当前已经搜过了k层了，path[0]就是第一层
    {
        return path[u-1] == n;
    }
    bool st[N] = {0};//这个是用来防止同一层的答案重复搜索，比如前面为 1 2 3，下一个为4的话可以选1 3 也可以选2 2
    for(int i = u-1;i>=0;i--)
    {
        for(int j=i;j>=0;j--)
        {
            //这一步优化搜索顺序，从大的元素优先进行搜索，序列是递增的，所以需要倒着搜
            int s = path[i]+path[j];
            if(s>n||s<=path[u-1]||st[s]) continue;
            st[s] = true;
            path[u] = s;
            if(dfs(u+1,k)) return true;
        }
    }
    return false;
}
int main()
{
    path[0] = 1;//因为第一个无论如何都是1
    while(cin>>n,n)
    {
        int maxdepth=1;//表示当前可以搜索的层数
        while(!dfs(1,maxdepth)) maxdepth++; //如果说搜索到maxdepth这一层都没有找到答案，那么最大深度要++
        for(int i=0;i<maxdepth;i++)
        {
            cout<<path[i]<<" ";
        }
        cout<<"\n";
        
    }
    return 0;
}

三、双向dfs

上面点是起点，下面点是终点，如果是普通搜索，需要搜索广泛的点，但是如果同时从起点和终点一起搜，只需要搜索绿色部分的就可以了，剪掉了红色部分的搜索时间。
例题：送礼物
用空间换时间。由前n/2和物品凑出来的所有重量的集合是多少？在搜索后半集合的时候就可以和前一个答案里面查找答案。
剪枝：1.优化搜索顺序，先搜索大重量物品。
解题思路：
1.将所有物品按重量从大到小排序
2.先将前k件物品能凑出来的所有重量打表，然后排序并判重
3.搜索剩下的N-k件物品的选择方式，然后在表中二分出不超过W的最大值。

代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 50;
int n,maxw,k;
int w[N];
int weight[1<<24],cnt;
int ans;
void dfs1(int u,int s)
{
    if(u == k)
    {
        weight[cnt++] = s;
        return;
    }
    if((LL)s + w[u] <= maxw) dfs1(u+1,s+w[u]);
    dfs1(u+1,s);
}
void dfs2(int u,int s)
{
    if(u==n)
    {
        //二分进行和前面的集合进行匹配，查找最大值
        int l=0,r = cnt-1;
        while(l<r)
        {
            int mid = l+r+1 >> 1;
            if(weight[mid]+(LL)s <= maxw) l=mid;
            else r = mid-1;
        }
        if((LL)s+weight[l] <= maxw) ans = max(ans,s+weight[l]);
        return;
    }
    if((LL)s+w[u]<=maxw) dfs2(u+1,s+w[u]);
    dfs2(u+1,s);
}
int main()
{
    cin>>maxw>>n;
    for(int i=0;i<n;i++) cin>>w[i];
    sort(w,w+n);
    reverse(w,w+n);//优化搜索顺序，从大的开始进行搜索
    
    k = n/2;
    dfs1(0,0);
    
    //进行后半部分的搜索
    sort(weight,weight+cnt);
    cnt = unique(weight,weight+cnt)-weight;
    
    //cout<<cnt<<endl;
    dfs2(k,0);
    cout<<ans<<endl;
    return 0;
    
}

四、IDA*
预估一下这个点最少需要多少步能够得到答案。也是一圈一圈来进行搜索。如果最少步数已经大于maxdepth，那就退出。估价函数<=真实值。
配合迭代加深一起使用
例题：排书
解题思路：
迭代加深过程中，当前的书的排列情况到排好序的情况需要的步数。

每次操作会更改这三个点的后继关系。
后继关系是指 1-2 2-3 3-4…这种，出现了一个玄学的估价函数就是
(tot+2)/3，tol是指错误后继的数量，比如 1 3 2 4 5 ,tot = 3.
代码如下：

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

using namespace std;

const int N = 15;

int n;
int q[N], w[5][N];

int f()
{
    int res = 0;
    for (int i = 0; i + 1 < n; i ++ )
        if (q[i + 1] != q[i] + 1)
            res ++ ;
    return (res + 2) / 3;
}

bool check()
{
    for (int i = 0; i < n; i ++ )
        if (q[i] != i + 1)
            return false;
    return true;
}

bool dfs(int depth, int max_depth)
{
    if (depth + f() > max_depth) return false;
    if (check()) return true;

    for (int l = 0; l < n; l ++ )
        for (int r = l; r < n; r ++ )
            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];
                for (x = l; x <= r; x ++, y ++ ) q[y] = w[depth][x];
                if (dfs(depth + 1, max_depth)) return true;
                memcpy(q, w[depth], sizeof q);
            }
    return false;
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T -- )
    {
        scanf("%d", &n);
        for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

        int depth = 0;
        while (depth < 5 && !dfs(0, depth)) depth ++ ;
        if (depth >= 5) puts("5 or more");
        else printf("%d\n", depth);
    }

    return 0;
}

作者：yxc
链接：https://www.acwing.com/solution/content/4050/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。