暴力递归

最新推荐文章于 2025-03-04 07:00:00 发布
最新推荐文章于 2025-03-04 07:00:00 发布
阅读量233 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： java 动态规划 递归算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LoveLSD/article/details/116502194
本文介绍了暴力递归的概念，并通过汉诺塔问题、逆序栈实现、并查集合并用户以及字符串子序列的打印算法进行了详细阐述。示例代码涵盖了Java实现，包括打印n层汉诺塔的全过程、使用递归反转栈、处理用户合并以及打印字符串的所有子序列（包括不重复的子序列）和排列。这些例子展示了递归和数据结构在解决复杂问题中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

暴力递归

暴力递归

思想：

  • 暴力递归就是尝试
    • 把问题转化为规模缩小的同类问题的子问题
    • 有明确的不需要进行继续递归的条件
    • 有当得到了子问题结果之后的决策过程
    • 不记录每个子问题的解

记录每个问题的解是动态规划，不记录每个过程的解是暴力递归

汉诺塔

打印n层汉诺塔从最左边移动到最右边的全部过程
假设数字为3个

  • 项目
    • 1,2左->中间
      • 1左->右
      • 2左->中间
      • 1右->中间
    • 3左->右边
    • 1,2中间->右边
      • 1中间->左边
      • 2中间->右边
      • 1左边-右边

代码实现如下：

package Digui;
public class prim1 {
	public static void hao(int n){
		if (n>0) {
			fun(n,"left","right","mid");
		}
	}
	public static void fun(int N, String from,String to, String other){
		if (N==1) {
			System.out.println("move 1 from"+" "+from+" "+"to"+" "+to);	
		}
		else {
			fun(N-1, from, other, to);
			System.out.println("move"+ N +"from"+" "+from+" "+"to"+" "+to);
			fun(N-1, other, to, from);
		}
	}
	public static void main(String[] args) {
		int n=3;
		hao(n);
	}
}
/*move 1 from left to right
move2from left to mid
move 1 from right to mid
move3from left to right
move 1 from mid to left
move2from mid to right
move 1 from left to right*/

逆序栈

给你一个栈，请你逆序这个栈，不能申请额外的数据结构，只能使用递归函数

给123的栈，
把栈的元素去到底，并返回
在这里插入图片描述
在这里插入图片描述代码如下：

package Digui;
import java.util.Stack;
public class ReverseStack {
	public static void Reverse(Stack<Integer> stack){
		if (stack.isEmpty()) {
			return;
		}
		int i=fun(stack);
		Reverse(stack);
		stack.push(i);
	}
	public static int fun(Stack<Integer> stack){
		int result=stack.pop();
		if(stack.isEmpty()){
			return result;
		}else {
			int last=fun(stack);
			stack.push(result);
			return last;
		}
	}
	public static void main(String[] args) {
		Stack<Integer> test=new Stack<>();
		test.push(1);
		test.push(2);
		test.push(3);
		test.push(4);
		test.push(5);
		test.push(6);
		Reverse(test);
		while(!test.isEmpty()){
			System.out.print(test.pop()+" ");
		}	
	}
}

并查集合并user

如果两个user，a字段一样，或者b字段一样，或者c字段一样，就认为是一个人，请合并user，返回合并之后的用户数量

package Digui;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Stack;
public class Mergeusers {
	public static class Node<V> {
		V value;

		public Node(V v) {
			value = v;
		}
	}
	public static class UnionFind<V> {
		public HashMap<V, Node<V>> nodes = new HashMap<>();
		public HashMap<Node<V>, Node<V>> parents = new HashMap<>();
		public HashMap<Node<V>, Integer> sizeMap = new HashMap<>();

		public UnionFind(List<V> values){
			for(V cur:values){
				Node<V> node = new Node<>(cur);
				nodes.put(cur, node);
				parents.put(node, node);
				sizeMap.put(node, 1);
			}
		}

		// 给你一个节点，请你往上到不能再往上，把代表返回
		public Node<V> findFather(Node<V> cur) {
			Stack<Node<V>> path = new Stack<>();
			while (cur != parents.get(cur)) {
				path.push(cur);
				cur = parents.get(cur);
			}
			while (!path.isEmpty()) {
				parents.put(path.pop(), cur);
			}
			return cur;
		}
		public boolean isSameSet(V a, V b) {
			return findFather(nodes.get(a)) == findFather(nodes.get(b));
		}
		public void union(V a, V b) {
			Node<V> aHead = findFather(nodes.get(a));
			Node<V> bHead = findFather(nodes.get(b));
			if (aHead != bHead) {
				int aSetSize = sizeMap.get(aHead);
				int bSetSize = sizeMap.get(bHead);
				Node<V> big = aSetSize >= bSetSize ? aHead : bHead;
				Node<V> small = big == aHead ? bHead : aHead;
				parents.put(small, big);
				sizeMap.put(big, aSetSize + bSetSize);
				sizeMap.remove(small);
			}
		}
		public int sets() {
			return sizeMap.size();
		}
	}
	public static class  User{
		public String a;
		public String b;
		public String c;
		
		public User(String a,String b,String c){
			this.a=a;
			this.b=b;
			this.c=c;
		}
		@Override
		public String toString(){
			return "a:" + a + " b:" + b + " c:" + c;
		}	
	}
	public static int mergeuse(List<User> users){
		UnionFind<User> userfind=new UnionFind<>(users);
		HashMap<String, User> mapA=new HashMap<>();
		HashMap<String, User> mapB=new HashMap<>();
		HashMap<String, User> mapC=new HashMap<>();
		for(User user:users){
			if (mapA.containsKey(user.a)) {
				userfind.union(user, mapA.get(user.a));
			}
			else{
				mapA.put(user.a, user);
			}
			if (mapB.containsKey(user.b)) {
				userfind.union(user, mapB.get(user.b));
			}
			else{
				mapB.put(user.b, user);
			}
			if (mapC.containsKey(user.c)) {
				userfind.union(user, mapC.get(user.c));
			}
			else{
				mapC.put(user.c, user);
			}
		}
		//向并差集询问还有多少user
		return userfind.sets();
	}
	public static void main(String[] args) {
		User user1=new User("1","10","13");
		User user2=new User("2","10","37");
		User user3=new User("100","200","37");
		List<User> users=new ArrayList<>();
		users.add(user1);
		users.add(user2);
		users.add(user3);
		for(User user:users){
			System.out.println(user);
		}
		System.out.print(mergeuse(users));
	} 
}

打印字符串子序列

打印一个字符串的全部子序列
子序列：把一个位置的字符彻底地要或是不要

package Digui;
import java.util.List;
import java.util.ArrayList;
public class PrintAllSubsquences {
	public static List<String> subs(String s){
		char[] str=s.toCharArray();
		String path=" ";
		List<String> ans=new ArrayList<>();
		process1(str, 0, ans, path);
		return ans;
	}
	//str固定，不变
	//index此时来到的位置，要或者不要
	//如果index来到str的终止位置，将沿途路径所形成的答案放入ans中
	//之前作出的选择就是path
	public static void process1(char[] s,int index,List<String> ans,String path){
		if (index==s.length) {
			ans.add(path);
			return;
		}
		String no=path;
		process1(s, index+1, ans, no);
		
		String yes=path+String.valueOf(s[index]);
		process1(s, index+1, ans, yes);
		
	}
	public static void main(String[] args) {
		String s="abcd";
		System.out.println(subs(s));
	}
}
//[ ,  d,  c,  cd,  b,  bd,  bc,  bcd,  a,  ad,  ac,  acd,  ab,  abd,  abc,  abcd]

打印字符串子序列（不重复）

打印一个字符串的全部子序列,要求不要出现重复字面值的子序列

package Digui;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet;
public class PrintAllSubsquences1 {
		public static List<String> SubNoRepeat(String s){
			char[] str=s.toCharArray();
			String path=" ";
			HashSet<String> ans=new HashSet<>();
			process2(str, 0, ans, path);
			List<String> ans1=new ArrayList<>();
			for(String cur:ans){
				ans1.add(cur);
			}
			return ans1;
		}
		//str固定，不变
		//index此时来到的位置，要或者不要
		//如果index来到str的终止位置，将沿途路径所形成的答案放入ans中
		//之前作出的选择就是path
		public static void process2(char[] s,int index,HashSet<String> ans,String path){
			if (index==s.length) {
				ans.add(path);
				return;
			}
			String no=path;
			process2(s, index+1, ans, no);
			
			String yes=path+String.valueOf(s[index]);
			process2(s, index+1, ans, yes);
			
		}
		public static void main(String[] args) {
			String s="aaa";
			System.out.println(SubNoRepeat(s));
		}
	}
//[ ,  aa,  a,  aaa]

打印字符串全部排列

打印一个字符串的全部排列

package Digui;
import java.util.ArrayList;
public class printallPermutation {
	public static ArrayList<String> Permutation(String str){
		ArrayList<String> res=new ArrayList<>();
		if(str==null||str.length()==0){
			return res;
		}
		char[] chs=str.toCharArray();
		process(chs, 0, res);
		return res;
	}
	//str[0...i]已经是做好决定的
	//str[i...]都有机会来到i位置
	//i终止位置，就是str当前样子，就是一种结果->ans
	public static void process(char[] str,int i,ArrayList<String>ans ){
		if (i==str.length) {
			ans.add(String.valueOf(str));
		}
		for (int j = i; j < str.length; j++) {
			swap(str,i,j);
			process(str, i+1, ans);
			swap(str,i,j);
		}
	}
	public static void swap(char[] arr,int i,int j){
		char temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	public static void main(String[] args) {
		String s="123";
		System.out.println(Permutation(s));
	}
}
//[123, 132, 213, 231, 321, 312]

打印字符串全部排列(不重复）

打印一个字符串的全部排列

package Digui;
import java.util.HashSet;
public class printallPermutationNorepeat {
	public static HashSet<String> Permutation(String str){
		HashSet<String> res=new HashSet<>();
		if(str==null||str.length()==0){
			return res;
		}
		char[] chs=str.toCharArray();
		process(chs, 0, res);
		return res;
	}
	//str[0...i]已经是做好决定的
	//str[i...]都有机会来到i位置
	//i终止位置，就是str当前样子，就是一种结果->ans
	public static void process(char[] str,int i,HashSet<String>ans ){
		if (i==str.length) {
			ans.add(String.valueOf(str));
		}
		for (int j = i; j < str.length; j++) {
			swap(str,i,j);
			process(str, i+1, ans);
			swap(str,i,j);
		}
	}
	public static void swap(char[] arr,int i,int j){
		char temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	public static void main(String[] args) {
		String s="1233";
		System.out.println(Permutation(s));
		//[1233, 1233, 1323, 1332, 1332, 1323, 2133, 2133, 2313, 2331, 2331, 2313, 3213, 
		//3231, 3123, 3132, 3312, 3321, 3231, 3213, 3321, 3312, 3132, 3123] 
		
		//不重复的结果
		//[1323, 2313, 1233, 1332, 3213, 3312, 2133, 2331, 3123, 3321, 3231, 3132]
	}
}

另外一种版本

package Digui;
import java.util.ArrayList;
public class printallPermutationNorepeat1 {
	public static ArrayList<String> Permutation(String str){
		ArrayList<String> res=new ArrayList<>();
		if(str==null||str.length()==0){
			return res;
		}
		char[] chs=str.toCharArray();
		process(chs, 0, res);
		return res;
	}
	//str[0...i]已经是做好决定的
	//str[i...]都有机会来到i位置
	//i终止位置，就是str当前样子，就是一种结果->ans
	public static void process(char[] str,int i,ArrayList<String>ans ){
		if (i==str.length) {
			ans.add(String.valueOf(str));
		}
		boolean[] visit=new boolean[26];
		for (int j = i; j < str.length; j++) {
			if (!visit[str[j]-'a']) {
				visit[str[j]-'a']=true;
				swap(str,i,j);
				process(str, i+1, ans);
				swap(str,i,j);
			}
		}
	}
	public static void swap(char[] arr,int i,int j){
		char temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	public static void main(String[] args) {
		String s="aaa";
		System.out.println(Permutation(s));
	}
}
【软考】数据结构与算法基础 - 常见的算法设计思想（递归与暴力递归）
本本本添哥
08-13 155
递归是一种算法设计思想。
动态规划之二—— 从暴力递归到动态规划_背包问题
xinran0703的专栏
07-22 728
所以做出这样的修改，当bag < 0 时，返回-1， 即一个错误值，然后每次选择“要”这个货物时，要预判一下如果“要了”这个货物是否会返回错误值，只有在返回值合法的情况的，才可以选择要这个index的货物。因为当bag == 0 时，但如果依然有货物，且货物的重量为0，但价值不为0，依然是可以放入背包的，因为根据题目要求，重量和价值仅仅是不为负，所以为零的可能性还是有的。（例图中 n == 3）1. 根据暴力递归可知，当index == 4，即index == W.size() 时， 返回值为0；
算法基础--第八章--暴力递归
INFINITE POSSIBILITIES
03-22 520
-- 常见的递归问题 -- 几种常见的尝试类型 介绍递归和动态规划 暴力递归： 1，把问题转化为规模缩小了的同类问题的子问题 2，有明确的不需要继续进行递归的条件(base case) 3，有当得到了子问题的结果之后的决策过程 4，不记录每一个子问题的解 动态规划 1，从暴力递归中来 2，将每一个子问题的解记录下来，避免重复计算 3，把暴力递归的过程，抽象成了状态表达 4，并且存在化简状态...
暴力递归的理解
qq_43224197的博客
08-30 620
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 递归是程序中很接近于数学语言的一种写法，使用递归编程在阅读代码易于理解，但是往往会带来效率低下的问题，效率问题暂且按下不表，本章主要讲讲对于递归的理解 提示：以下是本篇文章正文内容，下面案例可供参考 一、递归是什么？ 百度解释：程序调用自身的编程技巧称为递归（ recursion）。在百度还有更细致的解释，我
【算法学习笔记】暴力递归
qq_40296661的博客
04-02 269
暴力递归的关键点在于尝试的思路，思路对了，尝试自然就能成功。而且优秀的尝试，或者说递归思路是之后用动态规划优化递归的前置条件，递归思路越优秀——可变参数形式越简单、数量越少，越容易用动态规划来优化。
入门—暴力递归
Ljj262420的博客
11-30 191
对于暴力递归的题目的注意点 一、要注意base。不同题目要求不同。 （1）、对于求有多少种方法的题目，往往是返回1，然后递归累加所有可能性。 （2）、对于求最值的题目，往往是返回0、 （3）、 二、递归过程中，要注意分清楚，不同条件的状态转换，注意当前状态发生转换时，是否要受到前一状态的转换（例如n皇后问题） 三、暴力递归过程中是，默认后一状态的结果是已经可知的，不许要太在一后过程的细节 四-、递归过程有点理解苦难时，应该借助于递归i树，进行辅助...
0/1背包问题：从暴力递归到动态规划详解
Mr.Ayao's blog
12-31 1870
题目： 有一组数量为 n 个物品，每个物品都有重量w 和价值v 给定一个背包bag，背包装的物品不能超过背包最大载重容量返回背包bag 能装下的最大价值1. 物品的重量和价值：2. 背包的容量：暴力解法的核心是递归，通过逐一决策每个物品是否放入背包，最终找到最优解。状态定义：递归逻辑：递归终止条件： 动态规划解法 递归的暴力解法有重复子问题，导致了大量的重复计算。为了解决这个问题，我们可以使用动态规划来优化。状态定义：状态转移：边界条件： 测试方法 示例解析 假设：我们希望找到在容量为
数字字符串转化问题：从暴力递归到动态规划详解
Mr.Ayao's blog
01-02 820
给定一个仅包含数字字符的字符串，我们需要计算这个字符串能够被转化为多少种字母组合。那么一个数字字符串比如"111”就可以转化为:"AAA”、"KA"和“AK”动态规划解法的思想是通过状态转移来计算每个位置的转换方式数。给定一个只有数字字符组成的字符串str，返回有多少种转化结果。规定1和A对应、2和B对应、3和C对应…因此，任务是计算所有可能的转换结果的数量。个字符能够转化的不同的方式数。
C++暴力递归
qq_46897935的博客
05-03 191
C++暴力递归相关题目 #include<iostream> #include<vector> #include<string> #include<list> #include<algorithm> #include<stack> using namespace std; //1.汉诺塔问题 //2.打印一个字符串的全部子序列 //3.打印一个字符串的全部排列(要求不出现重复的排列) //4.聪明人游戏：给定一个整数数组，代表数值不同的
算法补天系列之——暴力递归
weixin_51529433的博客
07-22 619
首先补充一下之前的迪杰斯特拉算法，也可以用堆的形式来实现，不过这个是肯定不能用系统提供的堆来实现的，因为这里有一个新发现的更小的路径，要修改堆的数据。所以自己写堆的本领是必须要的，堆的底层结构是一个数组，然后最好我们设置一个node和数组位置的map、...
算法入门篇九 暴力递归
CHYabc123456hh的博客
06-16 842
牛客网左程云老师的算法入门课 暴力递归 原则 汉诺塔问题 问题 打印n层汉诺塔从左边移动到最右边的过程 思想 一共六个过程，左到右、左到中，中到左，中到右，右到左，右到中，互相嵌套使用 左到右 将1-》N-1移动到中间的那个杆上 将N从最左边移动到最右边 将1》-N-1移动到最右边的那个杆上 左到中 将1-N-1从左移动到右 N从左移动到中 将1-》N-1从右移动到中 。。。。。。 代码 package class08; public class Code01_Ha...
【算法入门】暴力递归：从“简单粗暴”到“化繁为简”的算法基石
xiaoyu❅的博客
03-04 346
暴力递归是算法设计的起点，也是理解动态规划的基础。本文将通过经典案例解析暴力递归的核心思想、实现方法及优化方向，助你掌握这一“简单却强大”的算法思维！
12.暴力递归
Harrison的学习博客
11-12 747
暴力递归 暴力递归就是尝试 1）把问题转化为规模缩小了的同类问题的子问题 2）有明确的不需要继续进行递归的条件(basecase) 3）有当得到了子问题的结果之后的决策过程 4）不记录每一个子问题的解 熟悉什么叫尝试? 打印n层汉诺塔从最左边移动到最右边的全部过程 打印一个字符串的全部子序列 打印一个字符串的全部子序列，要求不要出现重复字面值的子序列 打印一个字符串的全部排列 打印一个字符串的全部排列，要求不要出现重复的排列 汉诺塔 打印n层汉诺塔从最左边移动到最右边的全部过程 package co
详解暴力递归
weixin_73936404的博客
06-12 809
给定两个长度都为N的数组weights和values，weights[i]和values[i] 分别表示 i 号 物品的 重量和 价值。给定一个正数bag，表示一个载重为bag的袋子，你装的的物品不能超过这个重量。给你一个栈，请你逆序这个栈，不能申请额外的数据结构，只能使用递归函数。// 暴力递归时的原则：找到可变参数形式最简单，可变参数个数最少的方法。打印字符串的全部排列： （不能出现重复的排列）但是每个玩家每次只能拿走最左或最右的纸牌。返回你能装下的的最大价值是多少？规定玩家A先拿，玩家B后拿。
[算法入门笔记] 8. 暴力递归
欢迎光临~
09-30 430
暴力递归入门~
暴力递归详解
m0_72674633的博客
11-14 602
用最通俗易懂的语言阐释数据结构与算法
算法-暴力递归
qq_42373007的博客
04-25 245
暴力递归 public class HanNuoTa { public static void hannuo(int n) { if(n>0) { function(n,"左","右","中"); } } public static void function(int i, String start, String end, String other) { if(i==1) { System.out.println("Move 1 from"+start+"t
递归（二）—— 初识暴力递归
xinran0703的专栏
07-02 1144
函数leftToRight 就是按照冰箱三步法的思路写的，当n == 1时，表示只有一个盘子，不用纠结，直接放到目的地最右侧即可，当n>1 时，将1~n-1的盘子放到中间柱子，即函数leftToMid, 然后将第n个盘子放在最后侧，最后将中间柱子上的盘子放在最右侧，函数midToRight。汉诺塔是典型的利用递归思想解决的问题。假设当前的汉诺塔是3层，叠放在最左边的柱子上，目标是大小顺序不变的叠放在最右边的柱子上。-1 移到辅助柱子，此时的辅助柱子是左侧柱子，此时需要midToLeft函数，第二部，将第。
java暴力递归动态规划
最新发布
03-10
### Java 实现从暴力递归到动态规划的优化 #### 暴力递归实现 对于某些问题，如零钱兑换问题，在最初阶段可以采用暴力递归的方法解决。然而这种方法存在大量重复计算的问题，效率低下。 ```java public int coinChange(int[] coins, int amount) { if (amount < 0) { return -1; } if (amount == 0) { return 0; } int minCount = Integer.MAX_VALUE; for (int i = 0; i < coins.length; i++) { int res = coinChange(coins, amount - coins[i]); if (res >= 0 && res < minCount) { minCount = 1 + res; } } return minCount == Integer.MAX_VALUE ? -1 : minCount; } ``` 此代码展示了最基础的递归逻辑[^1]。当金额 `amount` 小于零返回 `-1` 表示无法组合；等于零表示正好匹配成功，不需要任何硬币参与运算。遍历每种面额尝试减少当前总金额并递归求解剩余部分所需的最少数量直到找到最小值或者确认无解为止。 #### 添加记忆化搜索（Memoization） 为了改善上述算法性能，可以在原有基础上引入缓存机制保存已经计算过的结果防止不必要的重复工作： ```java private static final Map<Integer, Integer> memo = new HashMap<>(); public int coinChangeWithMemo(int[] coins, int amount) { if (amount < 0) { return -1; } if (amount == 0) { return 0; } // Check cache first before computing. if (!memo.containsKey(amount)) { int minCount = Integer.MAX_VALUE; for (int i = 0; i < coins.length; ++i) { int res = coinChangeWithMemo(coins, amount - coins[i]); if (res >= 0 && res < minCount) { minCount = 1 + res; } } memo.put(amount, (minCount == Integer.MAX_VALUE) ? -1 : minCount); } return memo.get(amount); } ``` 这段改进后的版本利用哈希表作为外部存储器记录之前遇到过的输入及其对应输出以便快速检索已知答案从而大大减少了时间复杂度[^3]。 #### 完全转换成自底向上的动态规划方案 最终目标是从完全依赖函数调用来构建表格形式的数据结构逐步填充直至获得全局最优解的过程称为“自底向上”。这种方式不仅消除了显式的栈空间消耗还进一步提高了程序运行速度。 ```java public int dpCoinChange(int[] coins, int amount) { int max = amount + 1; int[] dp = new int[max]; Arrays.fill(dp, max); dp[0] = 0; for (int i = 1; i <= amount; i++) { for (int j = 0; j < coins.length; j++) { if (coins[j] <= i) { dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1); } } } return dp[amount] > amount ? -1 : dp[amount]; } ``` 这里定义了一个长度为 `max` 的数组 `dp` 来保存不同数额所需最少硬币数目，并初始化所有元素为最大整数值代表未知状态。接着按照从小到大顺序更新每一个位置处的最佳选择结果直到处理完毕整个范围内的数据项。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值