dfs专题:个人debug+理解

搜索间断的：‘

https://leetcode.com/problems/partition-to-k-equal-sum-subsets/description/

 public boolean canPartitionKSubsets(int[] nums, int k) {
        int _sum=0;
        for(int num:nums)_sum+=num;
        if(_sum%k==1){
            System.out.println("1\n");
            return false;
        }

        else{
            int len=nums.length-1;
            boolean[] vis=new boolean[len+10];

            flag=false;
            Arrays.sort(nums);
            dfs(0,k,len,vis,_sum/k,nums);
            if(flag)return true;
            else{
                System.out.println("2\n");
                return false;
            }


        }
    }
    boolean dfs(int curSum,int k,int sta,boolean[] vis,int tar,int[] num){
       if(flag) return true;
       if(k==1) {
           flag=true;return true;
       }
       int len=num.length-1;
       if(curSum==tar) dfs(0,k-1,len,vis,tar,num);
       for (int i=sta;i>=0;i--){
           if(vis[i]&&curSum+num[i]<=tar){
               vis[i]=true;
               dfs(curSum+num[i],k,i-1,vis,tar,num);
               vis[i]=false;
           }
       }
       return false;
    }

’回溯当时发现是vis条件判断忘记加!，printf false地方发现问题，呵呵。选择性必定包含回溯，这里是2层搜索，一层搜索数字和，另一层搜索k。属于正交的，即满足分治思想，那么就可以把数值的，如果反复迭代，一定是从一个肯定的地方反复搜索，至于回溯是避免下次发现不对，及时返回树上。对于这题回溯的理解，可以先模糊点，以后搞清楚也可以。

蓝桥杯：

 

7.剪邮票

借鉴：

一、5层for,映射选择数字，放置到a数组

dfs用来（本质是for循环简化）：访问合法周边数字，满足if条件的，需要设定边界

vis【】用来最后统计5个选择出来的数字是否全部访问，即在dfs毗邻条件限制下是否完全访问了。

 

//knkwtyej
#include<cstdio>
#include<iostream>
#include<cmath>

#include<sstream>
#include<cstring>

#include<algorithm>

#include<vector>
#include<set>
#include <queue>
#include <map>
#include <stack>



using namespace std;
typedef long long ll;
//const ll N=1000000000000000+10;
const int N=1000000+10;
const int INF = 0x3f3f3f3f;
const int M=10+5;
const int BUF =1024 ;

#define UP(i,x,y) for(i=x;i<=y;i++)
#define DOWN(i,x,y) for(i=x;i>=y;i--)
#define MEM(a,x) memset(a,x,sizeof(a))
#define W(a) while(a)
const double PI=acos(-1.0);
int mp[12]={1,2,3,4,6,7,8,9,11,12,13,14};
bool vis[M];
int a[M];
int dir[4]={-1,1,5,-5};
void dfs(int num ){
    int i,j;
    UP(i,0,3){

        int t=num+dir[i];
         if(t<1||t>14||t==5||t==10) continue;
        if(vis[t]){
            vis[t]=0;
            dfs(t);
        }
    }
}
int main()
{
    #ifdef LOCAL_DEBUG
    freopen("1.txt","r",stdin);
//    freopen("out_my.txt","w",stdout);
    #endif // LOCAL_DEBUG
    int i,i1,i2,i3,i4,i5,j,n,cnt=0;
    UP(i1,0,7){
        UP(i2,i1+1,8){
            UP(i3,i2+1,9){
                UP(i4,i3+1,10){
                    UP(i5,i4+1,11){
                        MEM(vis,0);
                        a[0]=mp[i1];
                        a[1]=mp[i2];
                        a[2]=mp[i3];
                        a[3]=mp[i4];
                        a[4]=mp[i5];
                        UP(i,0,4)
                        vis[a[i]]=1;

                        vis[a[0]]=0;
                        dfs(a[0]);
                        bool jud=1;
                        UP(i,0,4){
                            if(vis[a[i]]==1){
                                jud=0;break;
                            }
                        }
                        if(jud){
                            cnt++;
                        }

                    }
                }
            }
        }
    }
    printf("%d\n",cnt);


    return 0;
}

https://www.jisuanke.com/course/1797/121077

标程对幂次预处理，节约计算时间；leetcode上，凡是组合数，幂次，都可以预处理，先

 

搜索树：