如何判断一个题目用“贪心/动态规划“还是用“BFS/DFS”方法解决
1 总结
1.1 贪心、动态规划和BFS/DFS题解的关系
一般能使用贪心、动态规划解决一个问题时，使用BFS，DFS也能解决这个题，但是反之不能成立。
1.2
2 贪心 -> BFS/DFS
2.1 跳跃游戏1和3的异同
这两道题，“跳跃游戏”（题号 55）和“跳跃游戏 III”（题号 1306），虽然都是关于跳跃问题的，但它们的规则和解题策略有显著的不同。下面是它们的主要异同点：
2.1.1 跳跃游戏（题号 55）
-
问题描述：给定一个非负整数数组
nums，你最初位于数组的第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。需要判断是否能够到达最后一个下标。 -
跳跃规则：从任意位置
i，可以向前跳跃0到nums[i]的任意步数。 -
目标：到达数组的最后一个下标。
-
解题策略：通常使用贪心算法。从左到右遍历数组，更新能够到达的最远位置。如果最远位置超过或等于最后一个下标，则返回
true。
2.1.2 跳跃游戏 III（题号 1306）
-
问题描述：这里有一个非负整数数组
arr，你最开始位于该数组的起始下标start处。当你位于下标i处时，你可以跳到i + arr[i]或者i - arr[i]。 -
跳跃规则：从任意位置
i，只能向前跳到i + arr[i]或向后跳到i - arr[i]。 -
目标：跳到任何一个元素值为
0的下标处。 -
解题策略：通常使用深度优先搜索（DFS）或广度优先搜索（BFS）。由于跳跃方向可以正向也可以反向，需要记录访问过的位置以防止无限循环。
2.1.3 它们的异同点
-
跳跃方向和范围：
- 在“跳跃游戏”中，跳跃只能向前，且范围在
0到nums[i]之间。 - 在“跳跃游戏 III”中，跳跃可以向前或向后，且步数固定为
arr[i]。
- 在“跳跃游戏”中，跳跃只能向前，且范围在
-
目标不同：
- “跳跃游戏”的目标是到达数组的最后一个下标。
- “跳跃游戏 III”的目标是到达任一元素值为
0的下标。
-
解题策略：
- “跳跃游戏”通常用贪心算法解决。
- “跳跃游戏 III”则更适合使用DFS或BFS，因为它涉及到多个可能的跳跃方向和回溯。
这两个问题虽然在表面上看起来类似，但实际上涉及到的算法思维和解决方法有很大的区别。
2.2 LC55. 跳跃游戏（贪心）
public boolean canJump(int[] nums) {
int n=nums.length;
int e=0;
boolean res=true;
for(int i=0;i<n;i++){
if(i>e){
res=false;
break;
}
e=Math.max(e, i+nums[i]);
}
return res;
}
2.3 LC1306. 跳跃游戏 III
class Solution {
public boolean canReach(int[] arr, int start) {
int n=arr.length;
boolean[]vis=new boolean[n];
return dfs(arr,start,vis);
}
boolean dfs(int[] arr, int start,boolean[]vis){
vis[start]=true;
if(arr[start]==0){
return true;
}
int rm=arr[start]+start;
int lm=start-arr[start];
boolean l=false;
boolean r=false;
if(rm<arr.length&&!vis[rm])
l=dfs(arr,arr[start]+start,vis);
if(lm>=0&&!vis[lm])
r=dfs(arr,start-arr[start],vis);
return l||r;
}
// bfs方法解题
public boolean canReach2(int[] arr, int start) {
int n=arr.length;
Deque<Integer>st=new LinkedList<>();
st.addLast(start);
boolean[]vis=new boolean[n];
while(!st.isEmpty()){
int poll=st.pollLast();
vis[poll]=true;
if(arr[poll]==0){
return true;
}
if(poll+arr[poll]<n&&!vis[poll+arr[poll]])
st.addLast(poll+arr[poll]);
if(poll-arr[poll]>=0&&!vis[poll-arr[poll]])
st.addLast(poll-arr[poll]);
}
return false;
}
}
2.4 LC1345. 跳跃游戏 IV
2.4.1 答案：为什么minJumps2超时了？
class Solution {
public int minJumps(int[] arr) {
Map<Integer, List<Integer>> idxSameValue = new HashMap<Integer, List<Integer>>();
for (int i = 0; i < arr.length; i++) {
idxSameValue.putIfAbsent(arr[i], new ArrayList<Integer>());
idxSameValue.get(arr[i]).add(i);
}
Set<Integer> visitedIndex = new HashSet<Integer>();
Queue<int[]> queue = new ArrayDeque<int[]>();
queue.offer(new int[]{0, 0});
visitedIndex.add(0);
while (!queue.isEmpty()) {
int[] idxStep = queue.poll();
int idx = idxStep[0], step = idxStep[1];
if (idx == arr.length - 1) {
return step;
}
int v = arr[idx];
step++;
if (idxSameValue.containsKey(v)) {
for (int i : idxSameValue.get(v)) {
if (visitedIndex.add(i)) {
queue.offer(new int[]{i, step});
}
}
idxSameValue.remove(v);
}
if (idx + 1 < arr.length && visitedIndex.add(idx + 1)) {
queue.offer(new int[]{idx + 1, step});
}
if (idx - 1 >= 0 && visitedIndex.add(idx - 1)) {
queue.offer(new int[]{idx - 1, step});
}
}
return -1;
}
public int minJumps2(int[] arr) {
int n=arr.length;
Map<Integer,List<Integer>>mp=new HashMap<>();
for(int i=0;i<n;i++){
List<Integer>ls=mp.getOrDefault(arr[i],new ArrayList<>());
ls.add(i);
mp.put(arr[i],ls);
}
Deque<Integer>q=new LinkedList<>();
q.offerLast(0);
int ans=0;
boolean[]vis=new boolean[n];
while(!q.isEmpty()){
int size=q.size();
for(int i=0;i<size;i++){
int poll=q.pollFirst();
if(poll==n-1){
return ans;
}
if(poll+1<n&&!vis[poll+1]){
vis[poll+1]=true;
q.offerLast(poll+1);
}
if(poll-1>=0&&!vis[poll-1]){
vis[poll-1]=true;
q.offerLast(poll-1);
}
List<Integer>t=mp.get(arr[poll]);
for(int j=0;j<t.size();j++){
if(!vis[t.get(j)]&&t.get(j)!=poll){
vis[t.get(j)]=true;
q.offerLast(t.get(j));
}
}
}
ans++;
}
return -1;
}
}
让我们分析这两个方法 minJumps 和 minJumps2 的不同之处，以了解为什么 minJumps2 会超时。
2.4.2 方法 minJumps
- 数据结构：使用
HashMap和HashSet来存储相同值的索引和已访问的索引。使用Queue来进行广度优先搜索（BFS）。 - 访问控制：通过
visitedIndex（一个HashSet）控制访问，一旦访问过某个索引，就不会再访问。 - 优化处理：在访问完所有相同值的索引后，使用
idxSameValue.remove(v)来移除这个值，从而减少后续的无效搜索。
2.4.3 方法 minJumps2
- 数据结构：使用类似的
HashMap来存储相同值的索引。使用Deque（双端队列）进行BFS。 - 访问控制：通过一个
boolean数组vis控制访问，记录已访问的索引。 - 重复检查：方法中没有移除已经访问过的值的索引集合，这意味着即使某个值的所有索引都已经被访问，它们仍然会在后续的搜索中被重复检查。
2.4.4 为什么 minJumps2 超时
原因可能在于 minJumps2 没有像 minJumps 那样有效地减少搜索空间。在 minJumps 中，一旦一个值的所有可能的跳跃位置都被探索过，这个值就会从 idxSameValue 中移除，从而避免了对这些位置的重复搜索。而 minJumps2 没有这样的优化，因此在遇到具有大量相同值的数组时，它会进行许多不必要的重复检查，这可能导致超时。
另外，虽然 minJumps 和 minJumps2 都是BFS实现，但由于对搜索空间的处理方式不同，两者在面对大规模数据时的性能表现会有显著差异。在这种情况下，减少无效的重复搜索是优化算法和避免超时的关键。
2.5 方法二改进
public int minJumps(int[] arr) {
int n=arr.length;
Map<Integer,List<Integer>>mp=new HashMap<>();
for(int i=0;i<n;i++){
List<Integer>ls=mp.getOrDefault(arr[i],new ArrayList<>());
ls.add(i);
mp.put(arr[i],ls);
}
Deque<Integer>q=new LinkedList<>();
q.offerLast(0);
int ans=0;
boolean[]vis=new boolean[n];
while(!q.isEmpty()){
int size=q.size();
for(int i=0;i<size;i++){
int poll=q.pollFirst();
if(poll==n-1){
return ans;
}
if(poll+1<n&&!vis[poll+1]){
vis[poll+1]=true;
q.offerLast(poll+1);
}
if(poll-1>=0&&!vis[poll-1]){
vis[poll-1]=true;
q.offerLast(poll-1);
}
if(mp.containsKey(arr[poll])){
List<Integer>t=mp.get(arr[poll]);
for(int j=0;j<t.size();j++){
if(!vis[t.get(j)]&&t.get(j)!=poll){
vis[t.get(j)]=true;
q.offerLast(t.get(j));
}
}
mp.remove(arr[poll]);
}
}
ans++;
}
return -1;
}