devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

搜索（4）dfs的剪枝与优化_dfs算法优化

作者：我家小花儿 | 2024-04-07 01:00:33

赞

踩

dfs算法优化

目录

一、剪枝方法概述

1.优化搜索顺序

2.排除等效冗余

3.可行性剪枝

4.最优化剪枝

5.记忆化搜索

二、例题

1.小猫爬山

二、数独问题

三、木棒

四、生日蛋糕

总结

 

一、剪枝方法概述

1.优化搜索顺序

1如在小猫爬山中，按照猫的重量递减的顺序来搜索

2在数独问题中，优先搜索能填的合法数字最少的位置。

2.排除等效冗余

在搜索过程中，如果我们能够判定从搜索树的当前节点上沿着某几条不同的分支的子树是等价的，那么我们只需要对一条子树进行搜索。

3.可行性剪枝

在搜索过程中及时对当前状态进行检查，如果发现分支已经到达递归边界，就执行回溯。

4.最优化剪枝

记录当前已经搜到的最优值，如果目前花费的代价超过了最优值，则直接剪枝

5.记忆化搜索

二、例题

1.小猫爬山

直觉：遍历所有猫，深搜过程记录当前已经开的车数量，记录已经搜过了几只猫。

深搜过程中，由于猫的重量不可能每次掐好填满某辆缆车，因此先遍历之前的缆车看能不能放下，若可以就放，不行就新开一辆。每次dfs下一层之后都需要回溯，因为不确定放到哪个缆车才是最优方案

剪枝：如果已经开的车的数量大于要求，就剪枝（可行性）

       如果当前开的车的数量大于目前最优解，剪枝（最优化）

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. using namespace std;
  5.  
  6. const int N =20;
  7.  
  8. int n;
  9. int w;
  10. int c[N];
  11. int cab[N];//记录某条缆车装了多少重量
  12. int ans=N;
  13.  
  14. //对于每一只猫有两种决策 放入已租用的缆车 和 直接新开一个缆车
  15. void dfs(int now,int cnt)//已经搜索了几只猫   当前用了多少个缆车
  16. {
  17.     if(cnt>=ans) return ;
  18.     if(now==n)
  19.     {
  20.         ans=cnt;
  21.         return;
  22.     }
  23.  
  24.     for(int i=1;i<=cnt;i++)//分配到已租用的缆车
  25.     {
  26.         if(cab[i]+c[now]<=w)
  27.         {
  28.             cab[i]+=c[now];
  29.             dfs(now+1,cnt);
  30.             cab[i]-=c[now];
  31.         }
  32.     }
  33.     //新开
  34.     cab[cnt+1]+=c[now];
  35.     dfs(now+1,cnt+1);
  36.     cab[cnt+1]-=c[now];
  37.  
  38. }
  39.  
  40.  
  41. int main()
  42. {
  43.     cin>>n>>w;
  44.     for(int i=0;i<n;i++)
  45.         cin>>c[i];
  46.     sort(c,c+n,greater<int>());
  47.     dfs(0,0);
  48.     cout<<ans;
  49.     return 0;
  50. }
  51.  
  52. 作者：yankai
  53. 链接：https://www.acwing.com/activity/content/code/content/4221289/
  54. 来源：AcWing
  55. 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、数独问题

 先看看简单版数独

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. using namespace std;
  5. const int N =11;
  6. bool row[N][N],col[N][N],cell[N][N][N];
  7. char g[N][N];
  8.  
  9.  
  10. bool dfs(int x,int y)
  11. {
  12.     if(y==9)  x++,y=0;
  13.     if(x==9)
  14.     {
  15.         for(int i=0;i<9;i++)
  16.             cout<<g[i]<<endl;
  17.         return true;
  18.     }
  19.     if(g[x][y]!='.')  return dfs(x,y+1);
  20.     
  21.     
  22.     for(int i=0;i<9;i++)
  23.     {
  24.         if(!row[x][i]&&!col[y][i]&&!cell[x/3][y/3][i])   
  25.         {
  26.             g[x][y]=i+'1';
  27.             row[x][i]=col[y][i]=cell[x/3][y/3][i]=true;
  28.             if(dfs(x,y+1))  return true;
  29.             row[x][i]=col[y][i]=cell[x/3][y/3][i]=false;
  30.             g[x][y]='.';
  31.         }
  32.     }
  33.     
  34.     return false;
  35.     
  36. }
  37.  
  38. int main()
  39. {
  40.     for(int i=0;i<9;i++)  
  41.     {
  42.         cin>>g[i];
  43.         for(int j=0;j<9;j++)
  44.         {
  45.             if(g[i][j]!='.') 
  46.             {
  47.                 int t=g[i][j]-'1';
  48.                 row[i][t]=col[j][t]=cell[i/3][j/3][t]=true;
  49.             }
  50.         }
  51.         
  52.     }
  53.     
  54.     
  55.     dfs(0,0);
  56.     return 0;
  57. }

现在考虑剪枝：

优化搜索顺序：当有几个空位的数字确定时，由于数独的特性，会导致其他很多空位的选择变少，因此我们要从可选择数字最少的地方开始深搜。

排除等效冗余:任意一个状态下,我们只需要找一个位置填数即可,而不是找所有的位置和可填的数字.
位运算:很明显这里面check判定很多,我们必须优化这个check,所以我们可以对于,每一行,每一列,每一个九宫格,都利用一个九位二进制数保存,当前还有哪些数字可以填写.

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. using namespace std;
  5.  
  6. const int N =9,M=1<<N;
  7.  
  8. int ones[M],map[M];//某个状态能填的数的个数  lowbit出的该填的数
  9. int row[N],col[N],cell[3][3];
  10. char str[100];
  11.  
  12. void init()
  13. {
  14.     for(int i=0;i<N;i++) row[i]=col[i]=(1<<N)-1;
  15.     for(int i=0;i<3;i++)
  16.         for(int j=0;j<3;j++)
  17.             cell[i][j]=(1<<N)-1;
  18. }
  19.  
  20. void draw(int x,int y,int t,bool is_set)//在某个位置填入或是删除t 更新插入这个数带来的影响
  21. {
  22.     if(is_set) str[x*N+y]='1'+t;
  23.     else str[x*N+y]='.';
  24.     
  25.     int v=1<<t;
  26.     if(!is_set) v=-v;//如果是删除  下面就要加上v
  27.     
  28.     row[x]-=v;
  29.     col[y]-=v;
  30.     cell[x/3][y/3]-=v;
  31. }
  32.  
  33. int lowbit(int x)
  34. {
  35.     return x&-x;
  36. }
  37.  
  38. int get(int x,int y)
  39. {
  40.     return row[x]&col[y]&cell[x/3][y/3];
  41. }
  42.  
  43. bool dfs(int cnt)
  44. {
  45.     if(!cnt) return true;
  46.     
  47.     int minv=10;
  48.     int x,y;
  49.  
  50.     for(int i=0;i<N;i++)
  51.         for(int j=0;j<N;j++)
  52.             if(str[i*N+j]=='.')
  53.             {
  54.                 int state=get(i,j);
  55.                 if(ones[state]<minv)
  56.                 {
  57.                     minv=ones[state];
  58.                     x=i,y=j;
  59.                 }
  60.             }
  61.             
  62.     int state=get(x,y);
  63.     for(int i=state;i;i-=lowbit(i))
  64.     {
  65.         int t=map[lowbit(i)];
  66.         draw(x,y,t,true);
  67.         if(dfs(cnt-1)) return true;
  68.         draw(x,y,t,false);
  69.     }
  70.     return false;
  71.             
  72. }
  73.  
  74.  
  75.  
  76. int main()
  77. {
  78.     for(int i=0;i<N;i++) map[1<<i]=i;
  79.     for(int i=0;i<1<<N;i++)
  80.         for(int j=0;j<N;j++)
  81.             ones[i]+=i>>j&1;
  82.     
  83.     while(cin>>str,str[0]!='e')
  84.     {
  85.         init();//初始化为每个位置每个数都可以填
  86.         
  87.         int cnt=0;
  88.         for(int i=0,k=0;i<N;i++)//i,j是坐标 k是字符串下标
  89.             for(int j=0;j<N;j++,k++)
  90.                 if(str[k]!='.')
  91.                 {
  92.                     int t=str[k]-'1';
  93.                     draw(i,j,t,true);
  94.                 }
  95.                 else cnt++;//可填的空位数
  96.         dfs(cnt);
  97.         puts(str);
  98.     }
  99. }

三、木棒

 直觉想法：设定原始木棒长度len，当前正在拼的木棒长度cab，当前正在拼第stick个原始木棒，接下来该从哪个木棒开始选，上次选了第i根，则last=i+1，拼新一根时last=0）。当cab==len时，拼下一根。从last开始枚举，试探将别的木棒拼入，能拼入的要求是：没被选择过、cab+这根木棒的长度小于len。拼入之后就继续dfs，没有木棒可以拼入就return false

剪枝：

1.最优性剪枝：从小到大枚举长度，如果成功就直接break了。

2.可行性剪枝：可以预先知道在len长度下将有多少根木棒，如果当前已经拼好的木棒超过这个数，直接返回false：当该木棍在开头和结尾都不可以使用的时候,那么该方案就失败了

3.排除等效冗余：如果长度为l的木棒已经被尝试过，回溯之后继续枚举时，也不需要在枚举长度为l的其他木棒，因为子树都是等价的。

补充：

如果木棍在第一个位置不合法的话：假设我们把该木棍用在其他的位置合法了，那么我们就可以把顺序颠倒一下，把该木棒放到第一个也是合法的，该假设与条件不符。
同理：如果木棍在最后一个位置不合法的话：假设我们把该木棍用在其他的位置合法了，那么我们就可以把顺序颠倒一下，把该木棒放到最后一个也是合法的，该假设与条件不符。

但是，放到中间的木棍就不一样了，因为这种情况也可能是该木棍和前面组成该木棒的某一个木棍不合适，所以才造就了他的不合法。在这种情况下，可能换一种方法就合适了

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. using namespace std;
  5.  
  6. const int N =70;
  7.  
  8. int a[N];
  9. int n;
  10. int len;
  11. int cnt;
  12. bool st[N];
  13.  
  14.  
  15. //正在拼第stick根原始木棒
  16. //cab当前在拼的原始木棒的长度
  17. //接下来该从那个木棒开始选择（上一次选了i,last=i+1,拼新一根时last=0）
  18. bool dfs(int stick,int cab,int last)
  19. {
  20.     if(stick>cnt) return true;
  21.     if(cab==len) return dfs(stick+1,0,0); //拼新一根 last置为0;
  22.     
  23.     int fail=0;//剪枝2
  24.     for(int i=last;i<n;i++)
  25.     {
  26.         if(!st[i]&&cab+a[i]<=len&&fail!=a[i])
  27.         {
  28.             st[i]=true;
  29.             if(dfs(stick,cab+a[i],i+1)) return true;
  30.             fail=a[i];
  31.             st[i]=false;
  32.             if(cab==0||cab+a[i]==len) return false;
  33.         }
  34.     }
  35.     return false;
  36. }
  37.  
  38.  
  39.  
  40. int main()
  41. {
  42.     while(cin>>n,n!=0)
  43.     {
  44.         int val=0,sum=0;
  45.         for(int i=0;i<n;i++)
  46.         {
  47.             cin>>a[i];
  48.             sum+=a[i];val=max(val,a[i]);
  49.         }
  50.         sort(a,a+n);
  51.         reverse(a,a+n);
  52.         
  53.         for(len=val;len<=sum;len++)
  54.         {
  55.             if(sum%len) continue;
  56.             
  57.             cnt=sum/len; //该有多少根原始木棒
  58.             memset(st,false,sizeof st);
  59.             if(dfs(1,0,0)) break;
  60.         }
  61.         cout<<len<<endl;
  62.     }
  63. }

四、生日蛋糕

  外表面：侧面积加上表面

搜索框架：从下往上搜索，枚举每层蛋糕的半径和高度，本题蛋糕层数的计数从上往下

搜索面对的状态：正在枚举第dep层，当前外表面积s，当前体积v和第dep+1层的高度和半径。因此我们可以用 h 和r 两个数组记录每层的高度和半径

在搜索过程中，上表面的面积之和等于最低层的圆面积，因此可以在第M层直接累加到s中，这样在第M-1层之前的搜索中，只需要计算侧面积

剪枝：

1.上下界剪枝：取极限情况，在枚举第dep层时，r一定要大于等于dep，因为r递增且为正整数。考虑极限情况，r一定要小于dep+1层的半径-1，取极限情况：当前是最后一层且H最小=1，则r最大值一定小于sqrt（N-v）。因为\pi R^2H=\pi (N-v).

        其次，h的取值要在dep到dep+1层的H再-1。同样的还要小于（N-v）/R^2.

2.优化搜索顺序：R为平方项，对体积影响大，所以先枚举R，在枚举H

3.可行性剪枝：

可以预处理从上往下前i层的最小侧面积和体积。

如果当前体积v加上1~dep-1的最小体积大于N，则剪枝

4.最优化剪枝：如果当前表面积s大于当前最优值，则剪枝

5.最优化剪枝：利用h和r数组， 1~dep-1层的体积可以表示出来，表面积也可以表示出来。

n-v=\sum _{k=1}^{dep-1} h(k)*r(k)^2

S=2\sum _{k=1}^{dep-1}h(k)*r(k)

S=\frac{2}{r(dep)}*\sum _{k=1}^{dep-1} h(k)*r(k)*r(dep)\geq \frac{2}{r(dep)}*\sum h(k)*r(k)^2

\geqslant \frac{2(n-v)}{r(dep)}

所以当\frac{2(n-v)}{r(dep)}+s大于已经搜到的答案时，剪枝

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstring>
  4. #include<cmath>
  5. using namespace std;
  6.  
  7. const int N=25,INF=1e9;
  8.  
  9. int n,m;
  10. int minv[N],mins[N];
  11. int H[N],R[N];
  12. int ans=INF;
  13.  
  14. void dfs(int u,int v,int s)
  15. {
  16.     if(v+minv[u]>n) return ;
  17.     if(s+mins[u]>=ans) return ;
  18.     if(s+2*(n-v)/R[u+1]>ans) return ;
  19.  
  20.     if(u==0)
  21.     {
  22.         if(v==n) ans=s;
  23.         return;
  24.     }
  25.     for(int r=min(R[u+1]-1,(int)sqrt(n-v));r>=u;r--)
  26.         for(int h=min(H[u+1]-1,n-v/r/r);h>=u;h--)
  27.         {
  28.             int t=0;
  29.             if(u==m) t=r*r;
  30.             R[u]=r,H[u]=h;
  31.             dfs(u-1,v+r*r*h,s+2*r*h+t);
  32.         }
  33. }
  34.  
  35.  
  36.  
  37. int main()
  38. {
  39.     cin>>n>>m;
  40.  
  41.     for(int i=1;i<=m;i++)
  42.     {
  43.         minv[i]=minv[i-1]+i*i*i;
  44.         mins[i]=mins[i-1]+2*i*i;
  45.     }
  46.  
  47.     if(minv[m]>n)//无解
  48.     {
  49.         puts("0");
  50.         return 0;
  51.     }
  52.  
  53.     R[m+1]=H[m+1]=1e9;//  因为R,H的搜索范围  且dfs用到R[m+1]
  54.  
  55.     dfs(m,0,0);
  56.     cout<<ans<<endl;
  57. }
  58.  
  59. 作者：yankai
  60. 链接：https://www.acwing.com/activity/content/code/content/4231379/
  61. 来源：AcWing
  62. 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

总结

来自《算法竞赛进阶指南》：
搜索算法面对的状态可以看做一个多元组，其中每一元都是问题中的一个维度。一定要注意提取这些信息，构建合适的搜索框架

剪枝过程实际就是针对每个维度与该维度的边界条件，加以推导，得到一个相应的不等式来减少搜索树分支的扩张。

为了进一步提高搜索的效率，除了当前花费的代价外，还可以计算未来至少需要花费的代价进行预算。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/375403
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号