DFS题目

持续更新 ing~~~

1.洛谷P1434 [SHOI2002]滑雪(dfs+记忆化搜索

链接:P1434 [SHOI2002]滑雪 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

 思路:

dfs+记忆化搜索(有一点类似于dp)

不能写暴力的dfs,多余的搜索次数太多了,会直接超时,将已经搜索过的路径存下来,下一次走过的路就不用搜索了。

AC代码:

#include <bits/stdc++.h>
using namespace std;
int dir[4][2]={-1,0,1,0,0,1,0,-1};
int arr[105][105],vis[105][105],cnt[105][105];
int n,m,ans=-1;
int dfs(int sx,int sy){
	vis[sx][sy]=1;
	int nx,ny,maxlen=1;
	for(int i=0;i<4;i++){
		nx=sx+dir[i][1];
		ny=sy+dir[i][0];
		if(nx<1||ny<1||nx>n||ny>m||arr[nx][ny]>=arr[sx][sy]){  
			continue;
		}
			if(vis[nx][ny]==0)
			 maxlen=max(dfs(nx,ny)+1,maxlen);
			else
			 maxlen=max(cnt[nx][ny]+1,maxlen);
	}
	cnt[sx][sy]=maxlen;
	 ans=max(ans,maxlen);
	return maxlen;
}
int main(){
	std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>arr[i][j];
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(vis[i][j]==0) dfs(i,j);
		}
	}
	cout<<ans<<endl;
	return 0;
}

2.P2196 [NOIP1996 提高组] 挖地雷(依旧是DFS+记忆化搜索)

链接:P2196 [NOIP1996 提高组] 挖地雷 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

 DFS思路:

   我用的是dfs暴搜,题目规定只能从上往下走,DFS并记录最大值时候的路径。

DFSAC代码:

#include <iostream>
using namespace std;
const int N=25;
int arr[N][N],val[N],pre[N],vis[N],temp[N];//arr[i][j]表示i到j是否有路径,val表示地雷数
int n,ans=-1,num;
bool check(int j){
	for(int i=1;i<=n;i++){
		if(vis[i]==0&&arr[j][i]==1) return true;
	}
	return false;
}
void dfs(int now,int step,int sum){
	
	if(check(now)==false) {
        if(sum>ans){
        	ans=sum;
        	num=step;
	      	for(int i=1;i<=num;i++)
	      		pre[i]=temp[i];
	    }
		return ;
	}
	for(int i=now+1;i<=n;i++){
		if(arr[now][i]==1){
	     	vis[i]=1;
	     	temp[step+1]=i;
	     	dfs(i,step+1,sum+val[i]);
	     	vis[i]=0;
		}
	}
}

int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>val[i];
	}
	for(int i=1;i<n;i++){
		for(int j=i+1;j<=n;j++){
			cin>>arr[i][j];
		}
	}
	for(int i=1;i<=n;i++){
		vis[i]=1;
		temp[1]=i;
		dfs(i,1,val[i]);
		vis[i]=0;
	}
	for(int i=1;i<=num;i++){
		cout<<pre[i]<<" ";
	}
	cout<<endl<<ans;
	return 0;
}

DP思路:(以后再想)

这道题目还可以用dp来想,

用dp[i]表示以第i个地窖结尾的最大值

                      dp[i]=max(dp[j]+val[i],dp[i])

3.AcWing 92. 递归实现指数型枚举 

原题链接92. 递归实现指数型枚举 - AcWing题库

DFS全排列:

AC代码

#include <iostream>
using namespace std;
const int N=20;
int vis[N],arr[N],temp[N];
int n;
void dfs(int start,int step,int num){
//	cout<<step<<"   "<<num<<endl;
	if(step==num) {
		if(step==1)
		cout<<arr[1]<<endl;
		else{
			cout<<arr[1];
			for(int i=2;i<=step;i++){
	    	    cout<<" "<<arr[i];
		    }
		    cout<<endl;
		}
	    return ;
   } 
	for(int i=start+1;i<=n;i++){
		if(i<=n && vis[i]==0) {
			vis[i]=1;
			arr[step+1]=i;
			dfs(i,step+1,num);
			vis[i]=0;
		}
	}
}
int main(){
	cin>>n;
	cout<<endl;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			arr[1]=j;
			vis[j]=1;
			dfs(j,1,i);
			vis[j]=0;
		}
	}
	return 0;
}

### 关于 Java DFS 的编程题目和练习 #### 背景介绍 深度优先搜索 (Depth First Search, DFS) 是一种常见的图遍历算法,在解决许多实际问题时非常有用。对于学习者来说,掌握 DFS 不仅可以提升逻辑思维能力,还能帮助理解更复杂的算法。 以下是几个适合初学者到中级水平的 Java DFS 编程题目: --- #### 经典 DFS 题目推荐 1. **N皇后问题** N皇后问题是经典的回溯法应用之一,目标是在 \(n \times n\) 的棋盘上放置 \(n\) 个皇后,使得它们互不攻击。可以通过 DFS 来枚举可能的位置组合。 ```java public class NQueens { private int[] queens; private int count; public void solve(int n) { queens = new int[n]; placeQueen(0); System.out.println("Total solutions: " + count); } private void placeQueen(int row) { if (row == queens.length) { count++; return; } for (int col = 0; col < queens.length; col++) { if (isValid(row, col)) { queens[row] = col; placeQueen(row + 1); } } } private boolean isValid(int row, int col) { for (int i = 0; i < row; i++) { if (queens[i] == col || Math.abs(i - row) == Math.abs(queens[i] - col)) { return false; } } return true; } } ``` 这是一个典型的 DFS 应用案例[^2]。 2. **迷宫路径查找** 假设有一个二维数组表示的迷宫地图,其中 `'#'` 表示墙壁,`.` 表示可通行的道路。给定起点 `(sx, sy)` 和终点 `(ex, ey)`,判断是否存在一条从起点到终点的有效路径,并返回该路径。 ```java import java.util.ArrayList; import java.util.List; public class MazeSolver { private static final char WALL = '#'; private static final char PATH = '.'; private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; public List<String> findPath(char[][] maze, int sx, int sy, int ex, int ey) { int rows = maze.length; int cols = maze[0].length; boolean[][] visited = new boolean[rows][cols]; List<String> path = new ArrayList<>(); if (dfs(maze, sx, sy, ex, ey, visited, path)) { return path; } else { return null; } } private boolean dfs(char[][] maze, int x, int y, int ex, int ey, boolean[][] visited, List<String> path) { if (x < 0 || y < 0 || x >= maze.length || y >= maze[0].length || maze[x][y] == WALL || visited[x][y]) { return false; } path.add("(" + x + ", " + y + ")"); if (x == ex && y == ey) { return true; } visited[x][y] = true; for (int[] dir : DIRECTIONS) { int nx = x + dir[0], ny = y + dir[1]; if (dfs(maze, nx, ny, ex, ey, visited, path)) { return true; } } path.remove(path.size() - 1); // Backtrack return false; } } ``` 3. **岛屿数量统计** 给定一个由 `'1'`(陆地)和 `'0'`(水)组成的二维网格,计算岛屿的数量。岛屿被定义为一组相连的 '1',且四周都被 '0' 包围。 ```java public class NumberOfIslands { private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; public int numIslands(char[][] grid) { if (grid == null || grid.length == 0) return 0; int islands = 0; int m = grid.length, n = grid[0].length; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (grid[i][j] == '1') { islands++; markIsland(grid, i, j, m, n); } } } return islands; } private void markIsland(char[][] grid, int r, int c, int m, int n) { if (r < 0 || c < 0 || r >= m || c >= n || grid[r][c] != '1') return; grid[r][c] = '0'; // Mark as visited for (int[] d : DIRECTIONS) { markIsland(grid, r + d[0], c + d[1], m, n); } } } ``` --- #### 实践建议 为了更好地准备竞赛或面试中的 DFS 类型题目,可以从以下几个方面入手: - 多做类似的经典题目,比如 LeetCode 上的 “Combination Sum”, “Subsets”, 或者 “Permutations” 系列问题。 - 学习如何优化递归调用栈的空间复杂度,尤其是在处理大规模数据集时。 - 注意边界条件和特殊情况下的代码健壮性测试[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值