深度优先-DFS剪枝

吃奶酪
https://www.luogu.com.cn/problem/P1433
纯暴力DFS

#include<bits/stdc++.h>
using namespace std;

struct point{
	double x,y;
	bool visit;
}ps[16];
int n;
double curDis,ans=DBL_MAX;
double dis(point p1,point p2){
	return sqrt((p1.x-p2.x)*(p1.x-p2.x) +(p1.y-p2.y)*(p1.y-p2.y));
}
void dfs(point p,int step){
	if(step==n){
		if(curDis<ans)
			ans=curDis;
		return;
	}
	for(int i=0;i<n;i++){
		if(ps[i].visit)	continue;
		ps[i].visit=true;
		curDis+=dis(ps[i],p);
		dfs(ps[i],step+1);
		curDis-=dis(ps[i],p);
		ps[i].visit=false;
	}
}

int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>ps[i].x>>ps[i].y;
		ps[i].visit=false;
	}
	point p={0,0,false};
	dfs(p,0);
	printf("%.2f",ans);
	return 0;
}

状态压缩剪枝

#include<bits/stdc++.h>
using namespace std;

struct point{
	double x,y;
	bool visit;
	int num;
}ps[16];
int n;
//f[16][3300] 通过后面对应一组蛋糕后到底第16蛋糕 
double curDis,ans=DBL_MAX,f[16][33000];
double dis(point p1,point p2){
	return sqrt((p1.x-p2.x)*(p1.x-p2.x) +(p1.y-p2.y)*(p1.y-p2.y));
}
void dfs(point p,int step,int mark){
	if(step==n){
		if(curDis<ans)
			ans=curDis;
		return;
	}
	for(int i=0;i<n;i++){
		if(ps[i].visit)	continue;
		
		int tmp=mark + (1<<i);//代表几个数用二进制对应十进制表示
		//如果通过mark集合点 走到i 本次有更新的值 则赋值 
		if(f[i][tmp]==0 || f[i][tmp]>f[p.num][mark]+dis(ps[i],p)){
			f[i][tmp]=f[p.num][mark]+dis(ps[i],p);
			ps[i].visit=true;
			curDis+=dis(ps[i],p);
			dfs(ps[i],step+1,tmp);
			curDis-=dis(ps[i],p);
			ps[i].visit=false;
		}
	}
}

int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>ps[i].x>>ps[i].y;
		ps[i].visit=false;
		ps[i].num=i;//编号 
	}
	point p={0,0,false};
	dfs(p,0,0);
	printf("%.2f",ans);
	return 0;
}

小木棍
https://www.luogu.com.cn/problem/P1120

优化
优化1：按木棍从长到短拼接

优化2：根据优化1，将输入的木棍从大到小排好序后，当用木棍i拼合原始长棍时，从第i+1根木棍开始往后搜。

优化3：拼接木棍时，如果本长度小木棍的无法拼装当前木棍，也无法拼装下一个
当dfs返回拼接失败，需要更换当前使用的木棍时，不要再用与当前木棍的长度相同的木棍，因为当前木棍用了不行，改成与它相同长度的木棍一样不行。这里我预处理出了排序后每根木棍后面的最后一根与这根木棍长度相等的木棍（程序中的next数组），它的下一根木棍就是第一根长度不相等的木棍了。

优化4：只找小木棍长度小于rest的拼装
只找木棍长度不大于未拼长度rest的所有木棍。我看其他大部分人的做法（包括书上的啊）都是直接在循环中判断，但我认为可以根据木棍长度的单调性来二分找出第一个木棍长度不大于未拼长度rest。它后面的木棍一定都满足这个条件。
优化5： 使用过的不在不能再使用
用vis数组标记每根木棍是否用过。另外在dfs回溯的时候别忘了去掉这些标记，这样就不用每次dfs之前memset了（memset用多的话速度可TM慢了）！
优化5的习惯可以沿用到各种竞赛

优化6：拼装后所有木棍立即退出
由于是从小到大枚举 原始长度，因此第一次发现的答案就是最小长度。dfs中只要发现所有的木棍都凑成了若干根原长度的长棍（容易发现 凑出长棍的根数=所有木棍的长度之和/原始长度），立刻一层层退出dfs，不用滞留，退到dfs外后直接输出原始长度并结束程序。

优化7：还有一个难想却特别特别重要的优化：如果当前长棍剩余的未拼长度等于当前木棍的长度或原始长度，继续拼下去时却失败了，就直接回溯并改之前拼的木棍。有些人不太明白这个优化，这里简单说一下：

当前长棍剩余的未拼长度等于当前木棍的长度时，这根木棍在最优情况下显然是拼到这（如果用更多短木根拼完剩下的这段，把这根木棍留到后面显然不如把更多总长相等的短木棍扔到后面）。如果在最优情况下继续拼下去失败了，那肯定是之前的木棍用错了，回溯改即可。

当前长棍剩余的未拼长度等于原始长度时，说明这根原来的长棍还一点没拼，现在正在放入一根木棍。很明显，这根木棍还没有跟其它棍子拼接，如果现在拼下去能成功话，它肯定是能用上的，即自组或与其它还没用的木棍拼接。但继续拼下去却失败，说明现在这根木棍不能用上，无法完成拼接，所以回溯改之前的木棍。

做了这么多优化可以确保飞跑了……搜索题啊，每招优化都要学，学一招说不定竞赛的时候就能跑的快一点。

#include<bits/stdc++.h>
using namespace std;

int n,m,a[66],next1[66],cnt,sum,len;
bool used[66],ok; //used数组即优化5的vis数组，记录每根木棍是否用过；ok记录是否已找到答案。 
bool cmp(int a,int b){return a>b;}
void dfs(int k,int last,int rest){ //k为正在拼的木棍的编号，last为正在拼的木棍的前一节编号，rest为该木棍还未拼的长度
    int i;
    if(!rest){ //未拼的长度为0，说明这根原始长棍拼完了，准备拼下一个 
        if(k==m){ok=1; return;} //优化6，全部拼完并符合要求，找到答案，直接返回 
        
        for(i=1;i<=cnt;i++) //找一个还没用的最长的木棍打头即可。反正要想全都拼接成功，每根木棍都得用上 
            if(!used[i]) break;
        used[i]=1; 
        dfs(k+1,i,len-a[i]);
        used[i]=0;
        if(ok) return; //优化6，找到答案就退出 
    }
    //优化4，二分找第一个 木棍长度不大于未拼长度rest 的位置 
    int l=last+1, r=cnt, mid;
    while(l<r){
        mid=(l+r)>>1;
        if(a[mid]<=rest) r=mid;
        else l=mid+1;
    }
    for(i=l;i<=cnt;i++){
        if(!used[i]){ //优化5，判断木棍是否用过 
            used[i]=1;
            dfs(k,i,rest-a[i]);
            used[i]=0;
            if(ok) return; //优化6，找到答案就退出 
            
            if(rest==a[i] || rest==len) return; //优化7 
            i=next1[i]; //优化3 
            if(i==cnt) return;
        }
    }
    //到了这里，说明这时候拼不成当前这根原始木棍了，传回失败信息并修改之前拼的木棍 
}
int main(){
    cin>>n;
    int d;
    for(int i=1;i<=n;i++){
        cin>>d;
        if(d>50) continue;
        a[++cnt]=d;
        sum+=d;
    }
    sort(a+1,a+cnt+1,cmp); //优化1，木棍按长度从大到小排序 
    //优化3，预处理next数组 
    next1[cnt]=cnt;
    for(int i=cnt-1;i>0;i--){
        if(a[i]==a[i+1]) next1[i]=next1[i+1];
        else next1[i]=i;
    }
    for(len=a[1];len<=sum/2;len++){ //枚举原始长度 
        if(sum%len!=0) continue; //如果不能拼出整数根 就跳过 
        m=sum/len; //优化6中的那个计算 
        ok=0;
        used[1]=1;
        dfs(1,1,len-a[1]);
        used[1]=0;
        if(ok){printf("%d\n",len); return 0;} //优化6，输出答案，退 
    }
    printf("%d\n",sum); return 0;
}