DFS剪枝与优化

buqiming不起名

于 2023-07-20 14:11:34 发布

阅读量185

点赞数 1

分类专栏：搜索文章标签：深度优先剪枝算法

本文链接：https://blog.csdn.net/qq_69908563/article/details/131813477

版权

搜索专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一：概述

DFS是我们常用的一种算法，但我们通常会因为它的高复杂度而却步。这时，合理利用剪枝就可以大大提高DFS的速度。

二：常见DFS优化策略

1：优化搜索顺序

ex：N个人同时过河，每条船载重M，问最少要几条船？

正常的DFS是大约搜索 $N^{M}$ ,但我们考虑一下搜索顺序，如果我们从重量最大的人开始搜索，那搜索分支就会减少许多。

2：最优性剪枝

ex：我们搜索一种状态，搜索出答案为100，但是之前已经搜出了答案为50的状态，那当前这个状态就可以被剪枝。

3：可行性剪枝：

ex：当前这种状态已经不能再持续下去，则对其剪枝。

4：排除等效冗余：

ex：有多种情况等效，则剪枝。

三：实战演练：

（一）：题目传送门

一般化思路：考虑优化搜索顺序：将小猫质量从最大到最小排序，以此搜索。

最优性剪枝：当前遍历出的船数多于之前所找最优解，则剪枝。

AC代码：

#include<iostream>
#include<algorithm>

using namespace std;
const int N=1e3+10;
int w[N],num[N],ans=0x3f3f3f3f,W,n;

void dfs(int u,int k)
{
    if(k>=ans) return;
    if(u==n)
    {
        ans=k;
        return;
    }
    
    for(int i=0;i<k;i++)
    {
        if(w[u]+num[i]<=W)
        {
            num[i]+=w[u];
            dfs(u+1,k);
            num[i]-=w[u];
        }
    }
    
    num[k]=w[u];
    dfs(u+1,k+1);
    num[k]=0;
}

int main()
{
    //int n;
    cin>>n>>W;
    
    for(int i=0;i<n;i++) cin>>w[i];
    
    sort(w,w+n);
    reverse(w,w+n);
    
    dfs(0,0);
    cout<<ans<<endl;
}

（二）.数独问题：

9*9数独

详见题：题目传送门

根据正常的dfs搜索来看，时间复杂度是指数型增长的，估算一下时间复杂度，不出意外是要超时的。故想一些优化策略。

优化1：优化搜索顺序：每次都可以遍历出来很多要填的空格，但为了分支数最少，我们将优先遍历分支数最少的点。故先填充一个可以填的待选数字最少的格子。

优化2：剪枝：对于这样一个庞大的搜索树，剪枝在所难免。我们不难想到，将不能填充的数字直接剪去，就会节省很大的时间和空间。

优化3：二进制数表示状态。我们可以大致推测一下，如果按照正常的枚举，每个能填数字的格点都将被枚举1-9这9个数字，但这里我们用二进制优化，每一位表示能否填相对应的数。为方便起见，这里笔者令1为可以填充，0为不可以填充。例如：101000011，将表示该格点可以填充1,2,7,9这四个数字。

注意：数独要求每行，每列，每个九宫格都不出现重复数字，所以我们可以设定三个变量，用row[]表示每行的状态，用col[]表示每列的状态，用cell[][]表示每个九宫格的状态。

那么如何求每个格点的状态呢？

我们使用按位与即可求解。

大体思路如上，具体见代码：

#include<iostream>

using namespace std;

const int N=9;
int row[N],col[N],cell[3][3];//行，列，九宫格状态
int ones[1<<N],map[1<<N];//每个数有几个1，每个1代表的二进制数
string str;

void init()
{
    for(int i=0;i<N;i++) row[i]=col[i]=(1<<N)-1;//初始化所有格子都可以填
    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)
            cell[i][j]=(1<<N)-1;
}

int get(int x,int y)
{
    return row[x] & col[y] & cell[x/3][y/3];//返回每个格点状态
}

int lowbit(int x)
{
    return x&-x;//lowbit()运算，求最低位1
}

void draw(int x,int y,int t,bool f)
{
    if(f) str[x*N+y]='1'+t;
    else str[x*N+y]='.';
    
    int v=1<<t;
    if(!f) v=-v;
    row[x]-=v;
    col[y]-=v;
    cell[x/3][y/3]-=v;
}

bool dfs(int u)
{
    if(!u) return 1;
    
    int x,y;
    int minn=10;
    for(int i=0;i<N;i++)//找可以填充数情况最少的格点
    {
        for(int j=0;j<N;j++)
        {
            if(str[i*N+j]=='.') 
            {
                int state=get(i,j);
                
                if(ones[state]<minn)
                {
                    x=i,y=j;
                    minn=ones[state];
                }
            }
        }
    }
    
    int state=get(x,y);
    
    for(int i=state;i;i-=lowbit(i))
    {
        int t=map[lowbit(i)];
        draw(x,y,t,1);
        if(dfs(u-1)) return 1;
        draw(x,y,t,0);//复原现场
    }
    return 0;
}

int main()
{
    for(int i=0;i<N;i++) map[1<<i]=i;
    for(int i=0;i<1<<N;i++)
        for(int j=0;j<N;j++)
            ones[i]+=i>>j&1;//初始化每个数的1的个数，将以后求1的个数操作变为O（1）

    while(cin>>str,str[0]!='e')
    {
        init();
        
        int cnt=0;
        for(int i=0,k=0;i<N;i++)
        {
            for(int j=0;j<N;j++,k++)
            {
                if(str[k]!='.')
                {
                    int t=str[k]-'1';
                    draw(i,j,t,1);
                }
                else cnt++;
            }
        }
        
        dfs(cnt);
        cout<<str<<endl;
    }
}