DFS题集（一）

迷宫

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

const int N = 110;

const int dx[4] = {1,0,-1,0};
const int dy[4] = {0,-1,0,1};

char g[N][N];
bool st[N][N];

int T, n;
int sx, sy, gx, gy;

bool dfs(int x, int y)
{
	if(g[x][y] == '#') return false;
	
	if(x == gx && y == gy) return true;
	
	st[x][y] = true;
	
	for(int k = 0; k < 4; k++)
	{
		int nx = x + dx[k], ny = y + dy[k];
		
		if(nx >= 0 && nx < n && ny >= 0 && ny < n)
		{
			if(g[nx][ny] == '.' && !st[nx][ny])
			{
				if(dfs(nx,ny)) return true;
			}
		}
	}
	
	return false;
}

int main()
{
	cin >> T;
	
	while(T -- )
	{
		
		cin >> n;
		
		for(int i = 0; i < n; i++) cin >> g[i];
		
		cin >> sx >> sy >> gx >> gy;
		
		memset(st,0,sizeof st);
		
		if(dfs(sx,sy)) cout << "YES\n";
		else cout << "NO\n";
		
		
	}
	return 0;
} 

红与黑

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

const int N = 25;
const int dx[4] = {1,0,-1,0};
const int dy[4] = {0,-1,0,1};

char g[N][N];
int n, m;
int sx,sy;
bool st[N][N];

int dfs(int x,int y)
{
	int res = 1;
	
	st[x][y] = true;
	
	for(int k = 0; k < 4; k++)
	{
		int nx = x + dx[k], ny = y + dy[k];
		
		if(nx >= 0 && nx < n && ny >= 0 & ny < m)
		{
			if(g[nx][ny] == '.' && !st[nx][ny])
			{
				res += dfs(nx,ny);
			}
		}
	}
	
	return res;
}

int main()
{
	while(cin >> m >> n && n && m)
	{
		memset(st,0,sizeof st);
		
		for(int i = 0; i < n; i++)
		{
			for(int j = 0; j < m; j++)
			{
				cin >>g[i][j];
				if(g[i][j] == '@')
				{
					sx = i, sy = j;
				}
			}
		}
		
		cout << dfs(sx,sy) << endl;
		
	}
	return 0;
}

马走日

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

const int N = 10;
const int dx[8] = {2,1,-1,-2,-2,-1,1,2};
const int dy[8] = {-1,-2,-2,-1,1,2,2,1};

bool st[N][N];
int T, n, m;
int ans;
int sx,sy;


void dfs(int x,int y,int cnt)
{

	if(cnt == n * m)
	{
		ans ++;
		return;
	}
	
	for(int k = 0; k < 8; k++)
	{
		int nx = x + dx[k], ny = y + dy[k];
		
		if(nx >= 0 && nx < n && ny >= 0 && ny < m)
		{
			if(!st[nx][ny])
			{
				st[nx][ny] = true;
				
				dfs(nx,ny,cnt+1);
				
				st[nx][ny] = false;
			}
		}
	}
}

int main()
{
	cin >> T;
	
	while(T -- )
	{
		memset(st,0,sizeof st);
		ans = 0;
		
		cin >> n >> m >> sx >> sy;
		
		st[sx][sy] = true;
		
		dfs(sx,sy,1);
		
		cout << ans << endl;
		
	}
	
	return 0;
}

单词接龙

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

const int N = 25;

string words[N];
int com[N][N];
int used[N];
int res;
int n;

void dfs(string drangon, int u)
{
	res = max(res,(int)drangon.size());
	
	used[u] ++;
	
	for(int i = 0; i < n; i++)
	{
		if(com[u][i] && used[i] < 2)
		{
			dfs(drangon+words[i].substr(com[u][i]),i);
		}
	}
	
	used[u]--;
}

int main()
{
	cin >> n;
	
	for(int i = 0; i < n; i++) cin >> words[i];
	
	char start;
	cin >> start;
	
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < n; j++)
		{
			for(int k = 1; k < min(words[i].size(),words[j].size());k++)
			{
				if(words[i].substr(words[i].size()-k,k) == words[j].substr(0,k))
				{
					com[i][j] = k;
					break;
				}
			}
		}
	}
	
	for(int i = 0; i < n; i++)
	{
		if(words[i][0] == start)
		{
			dfs(words[i],i);
		}
	}
	
	cout << res << endl;
	
	return 0;
}

分成互质组

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

const int N = 15;

int a[N];
int res = 15;
vector<int> group[N];
int n;

int gcd(int a,int b)
{
	return b ? gcd(b, a % b) : a;
}

void dfs(int u, int cnt)
{
	if(cnt >= res) return;
	
	if(u > n) 
	{
		res = cnt;
		return;
	}
	
	//从当组里找 
	bool success = false;
	
	for(int i = 0; i < cnt; i++)
	{
		bool flag = true;
		
		for(int j = 0; j < group[i].size(); j++)
		{
			if(gcd(a[u],group[i][j]) > 1)
			{
				flag = 0;
				break;
			}
		}
		
		//找到了 
		if(flag)
		{
			success = true;
			group[i].push_back(a[u]);
			dfs(u + 1, cnt);
			group[i].pop_back(); 
		}
	}
	
	//一组都没找到 
	if(!success)
	{
		group[cnt].push_back(a[u]);
		dfs(u+1,cnt+1);
		group[cnt].pop_back();
	} 
}
int main()
{
	cin >> n;
	
	for(int i = 1; i <= n; i++) cin >> a[i];
	
	dfs(1,0);
	
	cout << res << endl;
	
	return 0;
}