Class & Homework - DFS

入门：城堡问题 // oj 2815

基本的启示：先构造骨架，再补充细节；另外对二进制的使用要熟练一点

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int m,n;
int castle[52][52],visited[52][52]; 
int cntRoom,maxArea,cntArea;
void dfs(int i,int j){
	if(visited[i][j]) return;
	if(i<1||i>m||j<1||j>n) return; //删掉也能过，但会慢一点，相当于一个微小的剪枝
	visited[i][j]=1;
	++cntArea;
	if((castle[i][j]&1)==0) dfs(i,j-1);
	if((castle[i][j]&2)==0) dfs(i-1,j);
	if((castle[i][j]&4)==0) dfs(i,j+1);
	if((castle[i][j]&8)==0) dfs(i+1,j);
}
int main() {
	scanf("%d%d",&m,&n);
	for(int i=1;i<=m;++i) for(int j=1;j<=n;++j) scanf("%d",castle[i]+j);
	memset(visited,0,sizeof(visited));
	cntRoom=0; maxArea=0;
	for(int i=1;i<=m;++i)
	for(int j=1;j<=n;++j)
		if(!visited[i][j]){
			++cntRoom;
			cntArea=0;
			dfs(i,j);
			maxArea=max(maxArea,cntArea);
		}
	cout<<cntRoom<<endl<<maxArea<<endl; //用printf会慢一点
    return 0;
}

进阶：ROADS // oj 1724

骨架：注意这种多路径搜索，对于同级结点，需要及时将相关变量恢复。

剪枝：由于N最大为100，R最大为10000，容易TLE。剪枝的思路是统计到达 i 城时，若路费为 j，此时的最小路程。

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
struct road{
	int D,L,T; 
	road(int d,int l,int t):D(d),L(l),T(t){}
};
int K,N,R;
vector<vector<road> > myCity; //由城市 i 出发的所有路径 
int cntToll, cntLen, minLen, visited[105];
int myMin[105][10100]; //走到i城路费为j时的最小路程 

void dfs(int i){ 
	if(i==N) {
		minLen=min(minLen,cntLen);
		return;
	}
	for(int j=0;j<myCity[i].size();++j){
		int d = myCity[i][j].D; //相应的目标城市
		if(!visited[d]){
			int t1=cntToll+myCity[i][j].T;
			int t2=cntLen+myCity[i][j].L;
			if(t1>K) continue;
			if(t2>=minLen || t2>=myMin[d][t1]) continue;
			cntToll=t1;cntLen=t2;
			myMin[d][t1]=t2;
			visited[d]=1;
			dfs(d);  //完成 dfs 后，及时恢复相关变量，以备下一个同级结点使用
			visited[d]=0; 
			cntToll-=myCity[i][j].T;
			cntLen-=myCity[i][j].L;
			}
	}
}

int main() {
	scanf("%d%d%d",&K,&N,&R);
	myCity.reserve(N+1); 
	while(R--) {
		int S,d,l,t; scanf("%d%d%d%d",&S,&d,&l,&t);
		myCity[S].push_back(road(d,l,t));
	}
	memset(visited,0,sizeof(visited)); 
	for(int i=0;i<105;++i) for(int j=0;j<10100;++j) myMin[i][j]=(1<<30);
	cntLen=0; cntToll=0; minLen=(1<<30);
	dfs(1);
	if(minLen==(1<<30)) cout<<-1<<endl;
	else cout<<minLen<<endl;
    return 0;
}

相似问题：棋盘问题 // oj 1321

八皇后的延伸，自己写觉得由两点需要注意：

得到一种 solution 后不是 return，而是 continue；

剪枝真的很有用，比如这里一个小小的 if(k<n) 就实现了 21ms -> 4ms

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n,k;
bool board[8][8];
bool Try[8];
int cnt,sol;
void dfs(int i){ //第i行的选取 
	if(i>=n) return;
	for(int j=0;j<n;++j){
		if(board[i][j]&&!Try[j]) {
			if(cnt==k-1){
				++sol;
				continue;
			}
			++cnt; Try[j]=1;
			dfs(i+1); 
			//restore variables for nodes of the same level 
			--cnt; Try[j]=0;
		}
	}
	if(k<n) dfs(i+1); //还有可能本行不选 	
}
int main(){
	while(cin>>n>>k&&n>-1){
		char c;
		for(int i=0;i<n;++i)
		for(int j=0;j<n;++j){
			cin>>c;
			board[i][j]=(c=='#')?1:0;	 
		}	
		memset(Try,0,sizeof(Try));
		cnt=0; sol=0;
		dfs(0);
		cout<<sol<<endl;
	} 
	return 0;
}

剪枝：生日蛋糕 // oj 1190

剪枝1 2 3详见程序

以及一处隐蔽的优化：r 从大到小遍历

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
#define MAX (1<<30)
int N,M,S; //unit of N&S is π
int cntS;
void dfs(int i,int n,int r0,int h0){ //当前层数，当前体积
	if(i>M){
		if(n==N) S=min(S,cntS);
		return;
	}
	if(n>=N) return;
	if(cntS+2*(N-n)/r0>=S) return; //剪枝1：可能的表面积
	for(int r=r0-1;r>M-i;--r){
		if(n+r*r>N) continue; //剪枝2：可能的最小体积不能超过 N 
		for(int h=M-i+1;h<h0;++h){ 
			int t=cntS+(2*r*h);
			if(t>=S) break; //剪枝3：超过目前最优
			cntS=t; if(i==1) cntS+=(r*r);
			dfs(i+1,n+r*r*h,r,h);
			cntS-=(2*r*h); if(i==1) cntS-=(r*r);
		}		
	} 
}
int main(){
	scanf("%d%d",&N,&M);
	S=MAX;
	cntS=0;
	dfs(1,0,N+1,N+1);
	if(S<MAX) cout<<S<<endl;
	else cout<<0<<endl;
	return 0;
}