dfs剪枝

已于 2024-03-22 18:01:29 修改
阅读量915 收藏 26
点赞数 24
分类专栏： 搜索 文章标签： 深度优先 剪枝 算法
于 2024-03-18 20:13:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68738523/article/details/136817519
版权

1.可行性剪枝

木棒

首先思考搜索的过程：遍历可能的所有长度，dfs判断能否拼出。

在dfs的过程中，如果当前已经拼成的木棒数量等于长度下对应的木棒数量，则返回true，如果无法拼出，则返回false。

接下来开始剪枝。

首先思考搜索顺序：我们应该优先放置长度较长的木棒。

比较关键的剪枝是可行性剪枝，比较难想：

①如果一根木棒放在某个位置不成功，那么和它等长的所有木棒放在该位置都不会成功。

②如果一根木棒放在某根木棍的第一个位置不成功，那么接下来无论它放在哪个位置都不可能成功。因为当它放在第一个位置不成功时，说明后面的所有木棒的组合都无法和它拼出一条木棍，而我们越往后选择木棒，可以选择的木棒只会变少，更不可能和它组合拼出一条木棍了。

③如果一根木棒放在某根木棍的最后一个位置成功，但是接下来的某一根木棍无法拼出，那么接下来它无论放在哪个位置都不可能拼出答案。可以用反证法证明，假设它放在最后一个位置是成功的，我们可以用两根更短的木棒x、y替代当前木棒i，如果可以得出一种成功的方案，在这种方案中，因为i和x+y是等长的，我们一定可以通过交换把i换到某根木棍的最后一个位置，这和已知的一定不成功矛盾了。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=70;
int a[N];
int n;
bool st[N];
bool cmp(int x,int y)
{
    return x>y;
}
bool dfs(int u,int curlen,int taglen,int tagcnt)
{
    if(curlen==taglen) return dfs(u+1,0,taglen,tagcnt);
    if(u>=tagcnt) return true;
    for(int i=1;i<=n;i++)
    {
        if(st[i]) continue;
        if(curlen+a[i]<=taglen)
        {
            st[i]=1;
            if(dfs(u,curlen+a[i],taglen,tagcnt)) return true;
            st[i]=0;
            if(curlen+a[i]==taglen) return false;
            int j=i;
            while(a[i]==a[j]) j++;
            i=j-1;
            if(curlen==0) return false;
        }
    }
    return false;
}
int main()
{
    while(cin>>n&&n!=0)
    {
        int sum=0;
        memset(st,0,sizeof(st));
        for(int i=1;i<=n;i++) 
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        sort(a+1,a+1+n,cmp);
        for(int i=a[1];i<=sum;i++)
        {
            if(sum%i==0)
            {
                if(dfs(0,0,i,sum/i))
                {
                    printf("%d\n",i);
                    break;
                }
            }
        }
    }
}

生日蛋糕

168. 生日蛋糕 - AcWing题库

首先拆解题目，我们需要通过枚举r和h，找到能够达成固定的体积n，同时使s最小的组合。在搜索的时候有一个限制：r(i)<r(i+1)，h(i)<h(i+1)。

然后确定我们的搜索顺序，

①从大蛋糕往小蛋糕搜。

如果先搜索大蛋糕，我们可以更快地发现体积不够地情况，及时return。

②先r后h，从大到小搜。

v=r*r*h，s=r*h。r对v的影响程度比h要大，因此我们先枚举r；而从大到小搜的原因和①一样。

depth<=r<=min(\sqrt{n-v},r(depth+1)-1);

depth<=h<=min((n-v)/r/r,r(depth+1)-1)

③估价函数

每一层至少用到的体积为depth*depth*depth，面积为depth*depth*2，当当前体积/面积+估价体积/面积>总体积/当前最小面积时，可以直接返回。

④可行性剪枝

#include<iostream>
#include<cmath>
using namespace std;
const int N=25;
const int INF=1e9;
int R[N],H[N];
int n,m;
int res=INF;
int minv[N],mins[N];
void dfs(int u,int s,int v)
{
    
    if(s+mins[u]>=res) return;
    if(v+minv[u]>n) return;
    if(2*(n-v)/R[u+1]+s>=res) return;
    if(!u) 
    {
        if(n==v) res=s;
        return ;
    }
    for(int r=min(R[u+1]-1,(int)sqrt(n-v));r>=u;r--)
        for(int h=min(H[u+1]-1,(n-v)/r/r);h>=u;h--)
        {
            int t=0;
            if(u==m) t=r*r;
            R[u]=r,H[u]=h;
            dfs(u-1,s+2*r*h+t,v+r*r*h);
        }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++) minv[i]=minv[i-1]+i*i*i,mins[i]=mins[i-1]+2*i*i;
    R[m+1]=H[m+1]=INF;
    dfs(m,0,0);
    printf("%d",res==INF?0:res);
}

2.迭代加深

加成序列

170. 加成序列 - AcWing题库

简言之，就是找到一个单调递增的序列，其中最大的数字是n，且每个数字由它及它之前的任意两个数字相加而成。

按照最暴力的方式搜索，我们的树是这样的：

左边的两棵树明显不是最优答案，但是我们一定会将它搜到底，再去搜索其他的方案，我们在完全不可能的子树中浪费了很多时间。

对于这样的情况，我们可以用迭代加深来进行优化。

在每一次搜索时，我们提前设置好本次搜索最多搜到哪一层，如果在当前层搜到了，就不需要往下一层走。

#include<iostream>
using namespace std;
const int N=110;
int n;
int path[N];
bool dfs(int u,int depth)//在填path第u个位置上的数，当前最大层数depth
{
    if(path[u-1]==n) return true;
    if(u>depth) return false;
    bool st[N]={0};
    for(int i=u-1;i>=1;i--)
        for(int j=i;j>=1;j--)
        {
            int t=path[i]+path[j];
            if(t>path[u-1]&&u<=n)
            {
                path[u]=t;
                st[u]=1;
                if(dfs(u+1,depth)) return true;
            }
        }
    return false;
}
int main()
{
    while(cin>>n&&n!=0)
    {
        path[1]=1;
        int depth=1;
        while(!dfs(2,depth)) depth++;
        for(int i=1;i<=depth;i++) printf("%d ",path[i]);
        printf("\n");
    }
}

3.双向dfs

送礼物

171. 送礼物 - AcWing题库

这一题乍一眼看是01背包，但是w范围太大了。

考虑dfs，一共有2^{n}种状态，这里n是46，时间复杂度超了。

这里可以双向dfs，我们先求出前n/2个物品中合理的所有可能（记录在a数组中），再对后n/2个物品进行组合，当组合出的情况合理时，我们找到a数组中加上当前值离w最近的值，也就是说，在a数组中找到小于（w-当前值）的最大值，这个过程可以用二分。最后的时间复杂度就是2*2^{\frac{n}{2}}*log(n/2)。

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=50;
int w,n,k;
int a[N];
int weight[1<<24],cnt=1;
ll res=0;
void dfs1(int u,ll s)
{
    if(u>k) 
    {
        weight[cnt++]=s; 
        return;
    }
    dfs1(u+1,s);
    if((ll)s+a[u]<=w) dfs1(u+1,(ll)s+a[u]);
}
void dfs2(int u,ll s)
{
    if(u>n)
    {
        int l=0,r=cnt-1;
        while(l<r)
        {
            int mid=(l+r+1)>>1;
            if(weight[mid]<=w-s) l=mid;
            else r=mid-1;
        }
        res=max(res,s+weight[l]);
        return;
    }
    dfs2(u+1,s);
    if((ll)a[u]+s<=w) dfs2(u+1,(ll)s+a[u]);
}
int main()
{
    scanf("%d%d",&w,&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    k=n/2;
    dfs1(1,0);
    cnt=unique(weight,weight+cnt)-weight;
    sort(weight,weight+cnt);
    dfs2(k+1,0);
    printf("%lld",res);
}

4.IDA*

排书

180. 排书 - AcWing题库

IDA*其实是可行性剪枝和迭代加深的结合，在迭代加深的基础上，加上一个类似于A*的代价函数就好了。

在本题中，我们可以发现，当我们每次执行插入操作时，会改变三对相邻结点的顺序。

也就是说，每次进行插入操作，我们最多使当前状态向前走三步。于是，我们的代价函数可以是，计算当前距离终点还差几步tot，则至少还需要（tot+2）/3，即（tot/3）向上取整的代价。

#include<iostream>
#include<cstring>
using namespace std;
const int N=20;
int n;
int a[N];
int w[5][N];
int f()
{
    int tot=0;
    for(int i=1;i<n;i++)
        if(a[i+1]!=a[i]+1) tot++;
    return (tot+2)/3;
}
bool dfs(int u,int depth)
{
    if(u>depth||f()+u>depth) return false;
    if(f()==0) return true;
    for(int len=1;len<=n;len++)
        for(int l=1;l+len-1<=n;l++)
        {
            int r=l+len-1;
            
            for(int k=r+1;k<=n;k++)
            {
                memcpy(w[u],a,sizeof(a));
                int y=l,x;
                for(x=r+1;x<=k;x++,y++) a[y]=w[u][x];
                for(x=l;x<=r;x++,y++) a[y]=w[u][x];
                if(dfs(u+1,depth)) return true;
                memcpy(a,w[u],sizeof(a));
            }
        }
    return false;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        int depth=0;
        while(depth<5&&dfs(0,depth)==0) depth++;
        if(depth>=5) printf("5 or more\n");
        else printf("%d\n",depth);
    }
}

回转游戏

181. 回转游戏 - AcWing题库

因为棋盘的形状比较奇怪，我们可以用一个8*7的数组来记录每一个操作改变的对应行。

int g[N][N]={
    {1,3,7,12,16,21,23},
    {2,4,9,13,18,22,24},
    {11,10,9,8,7,6,5},
    {20,19,18,17,16,15,14},
    {24,22,18,13,9,4,2},
    {23,21,16,12,7,3,1},
    {14,15,16,17,18,19,20},
    {5,6,7,8,9,10,11}
};

我们的代价函数可以是，统计一下当前中心8个数中出现最多的数字出现了几次，则我们还需要的最少代价就是8-最大出现次数。

int f()
{
    int cnt[4]={0};
    for(int i=0;i<8;i++) 
        cnt[q[center[i]]]++;
    sort(cnt,cnt+4);
    return 8-cnt[3];
}

这题比较困扰我的是数据的处理上，在用数组打表了之后，我们操作时，每一行在棋盘上对应的编号是不变的，但是编号对应的数字需要改变，因此是将某一行的数字进行移动。

也就是说，每次操作是将某一行的q值进行改变，而不是g值。

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=8;
int g[N][N]={
    {1,3,7,12,16,21,23},
    {2,4,9,13,18,22,24},
    {11,10,9,8,7,6,5},
    {20,19,18,17,16,15,14},
    {24,22,18,13,9,4,2},
    {23,21,16,12,7,3,1},
    {14,15,16,17,18,19,20},
    {5,6,7,8,9,10,11}
};
int opposite[N]={5,4,7,6,1,0,3,2};
int center[N]={7,8,9,12,13,16,17,18};
int q[3*N+5];
vector<int> path;
int f()
{
    int cnt[4]={0};
    for(int i=0;i<8;i++) 
        cnt[q[center[i]]]++;
    sort(cnt,cnt+4);
    return 8-cnt[3];
}
void operate(int x)
{
    int t=q[g[x][0]];
    for(int i=0;i<6;i++) q[g[x][i]]=q[g[x][i+1]];
    q[g[x][6]]=t;
}
bool dfs(int u,int depth,int last)
{
    if(u>depth||u+f()>depth) return false;
    
    if(f()==0) return true;
    for(int i=0;i<8;i++)
    {
        if(last==opposite[i]) continue;
        operate(i);
        path.push_back(i);
        if(dfs(u+1,depth,i)) return true;
        operate(opposite[i]);
        path.pop_back();
    }
    return false;
}
int main()
{
    while(cin>>q[1]&&q[1]!=0)
    {
        for(int i=2;i<=24;i++) cin>>q[i];
        path.clear();
        int depth=0;
        while(dfs(0,depth,-1)==0) depth++;
        if(!depth) printf("No moves needed");
        else 
            for(int i=0;i<path.size();i++) 
            {
                char c=path[i]+'A';
                cout<<c;
            }
        printf("\n%d\n",q[7]);
    }
}

mlww-
关注
  • 24
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ3373-Changing Digits【DFS+强剪枝】
08-19
北大POJ3373-Changing Digits【DFS+强剪枝】 解题报告+AC代码
POJ3733-Changing Digits【DFS+强剪枝】
08-18
北大POJ3733-Changing Digits【DFS+强剪枝】 解题报告+AC代码
DFS剪枝
m0_52711790的博客
01-17 914
本文主要讲了剪枝的概念、类别与DFS的一些例题。
DFS剪枝例题
weixin_45724872的博客
11-09 1067
常见的剪枝方式 一、优化搜索顺序 大部分情况下，我们应该优先搜索分支较少的结点； 在没有剪枝的情况下，因为最终都会枚举完全部的点，所以是一样的； 但是在有剪枝的情况下，走分支较少的点，剪枝的效果更明显； 如下图所示，红色勾起来的代表剪枝处； 二、排除等效冗余 简单来说，如果不考虑顺序，那么优先考虑组合，而不要考虑排列； 即不要搜索重复状态； 比如现在有<1,2>和<2,1><1,2>和<2,1><1,2>和<2,1>，不考虑顺序的话，
DFS剪枝技巧
qq_45832461的博客
04-03 1294
DFS剪枝技巧 剪枝，就是为了减小搜索树的规模，尽早排除搜索树中不必要的分支的一种手段。 搜索树的概念：==所有点(问题空间中的状态)与成功发生递归的边(访问两个状态之间的移动)==构成的树。 在DFS中，常用的搜索方法如下： 1.优化搜索顺序 在一些搜索问题中，搜索树的各个层次、各个分支之间的顺序不是固定的。不同的搜索顺序会产生不同的搜索树形态，其规模大小也想相差甚远。 2.排除等效冗余 在搜索过程中，如果我们能够判定从搜索树的当前节点上沿着几条不同分支到达的子树是等效的，那么只需要对其中的一条分支执行搜
【DFS剪枝】
he_Microsoft的博客
10-18 823
对于求最优解的一类问题,通常可以用最优性剪枝,比如在求解迷宫最短路的时候,如果发现当前的步数已经超过了当前最优解,那从当前状态开始的搜索都是多余的,因为这样搜索下去永远都搜不到更优的解。如果搜索方法是每次从剩下的数里选一个数,一共搜到第k层,那么1,2,3这个选取方法能被搜索到6次,这是没必要的,因为我们只关注选出来的数的和,而根本不会关注选出来的数的顺序,所以这里可以用重复性剪枝。此外,在搜索是否有可行解的过程中,一旦找到了一组可行解,后面所有的搜索都不必再进行了,这算是最优性剪枝的一个特例。
九、DFS剪枝优化
qq_63747498的博客
11-15 295
首先把起点到终点的最短距离当作估值函数，因为无论其他怎么走到终点，都会使得路径长度>=最短距离。虽然bfs里没有剪枝操作，但是A*算法通过它独有的贪心，来做出一些预测，尽可能的使操作缩短。在bfs问题中，所有边权都是非负的，那么就可以使用启发函数来优化bfs过程。
dfs 剪枝
goto_1600的博客
03-22 330
dfs在剪枝的时候需要先确定搜索的顺序，为了减少复杂度我们选择叶节点较少的点。可行性剪枝优化，需要满足题目的意思，最优性剪枝，如果该节点的值比已有搜索的最优解要差那么直接返回。 翰翰和达达饲养了N只小猫，这天，小猫们要去爬山。 经历了千辛万苦，小猫们终于爬上了山顶，但是疲倦的它们再也不想徒步走下山了（呜咕>_<）。 翰翰和达达只好花钱让它们坐索道下山。 索道上的缆车最大承重量为W，而N...
DFS剪枝初步
qq_43414301的博客
07-13 207
剪枝经典例题： Tempter of the Bone http://acm.hdu.edu.cn/showproblem.php?pid=1010 题目描述： 一个迷宫有N*M格，有一些格子是地板能走，有一些格子是障碍不能走。给一个起点S和一个终点D。一只小狗从S出发，每步走一块地板，在每个地板不能停留，而且走过的地板都不能再走。给定一个T，问小狗能正好走T步到达D吗？ 输入输出：有很多测试样例，每个测试中，第1行是整数N，M，T， 1 < N, M < 7, 0 < T < 5
dfs之剪枝
PBomb的博客
03-06 750
优化搜索顺序 排除等效冗余 可行性剪枝 最优性剪枝
dfs剪枝的应用以及bfs
心雨
02-28 318
dfs剪枝的应用以及bfs
dfs剪枝优化
不管风雨有多少丶的博客
04-15 256
#include<cstdio>//”剪枝 “优化后的dfs算法！非极端情况下有很好的表现！ const int maxn=30; int n,v,maxvalue=0; int w[maxn],c[maxn]; void dfs(int index,int sumw,int sumc){ if(index==n){ return ; } dfs(index+1,sumw,...
POJ3009-Curling 2.0【DFS+Vector+回溯+剪枝】
07-31
北大POJ3009-Curling 2.0【DFS+Vector+回溯+剪枝】 解题报告+AC代码
acm-ICPC 搜索算法DFS和BFS文件格式（ppt）经典算法“剪枝”等算法
09-11
acm-ICPC 搜索算法DFS和BFS文件格式（ppt）经典算法“剪枝”等算法，深度优先搜索和广度优先搜索。
数据结构-DFS and BFS-PPT
02-04
(剪枝) for (遍历所有可能的情况) { if (used[i] == 0) { used[i] = 1; dfs(层数 + 1, 其他参数); used[i] = 0; } } return; } ``` BFS是一种广度优先的搜索算法，它的基本思想是从图的某个顶点开始，探索...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5106
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
论文阅读笔记：DepGraph: Towards Any Structural Pruning
最新发布
HollowKnightz的博客
06-15 1388
论文阅读笔记：DepGraph: Towards Any Structural Pruning
【递归、搜索与回溯】穷举vs暴搜vs深搜vs回溯vs剪枝
fight_p的博客
06-11 1273
管他什么深搜、回溯还是剪枝，画出决策树就完事了~~~
端侧模型带来的三个新思考：剪枝、蒸馏、量化
数据猿
06-11 650
大数据产业创新服务媒体——聚焦数据· 改变商业端侧化是指将人工智能模型部署到终端设备上，直接在数据产生和处理的源头进行智能计算。随着人工智能技术的飞速发展，大型模型（大模型）在诸多领域取得了显著的成果，例如自然语言处理、计算机视觉和语音识别等。然而，大模型的部署和应用面临着诸多挑战，如计算资源消耗大、数据传输延迟、隐私保护等问题。因此，端侧化成为大模型落地的重要方式。首先，端侧化能够有效降低计算...
dfs 剪枝 动态规划 贪心算法
10-19
DFS（深度优先搜索）是一种常见的图遍历算法，...综上所述，DFS、剪枝、动态规划和贪心算法在算法设计和问题求解中都发挥着重要的作用。具体使用哪种算法取决于问题的性质和要求，需要在实际应用中进行综合考虑和选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值