Java 嵌套 for 循环怎么用递归实现？

递归展开哪家强，打开百度搜黑马。

先处理结束条件并返回
然后一次只处理一层
最后尾递归

不格式化的代码谁会给你看.
就算有人看了,谁看谁傻...

你这个循环还是不要用递归了吧.
也没多少层. 递归开销要比你这个循环大...

没必要用递归啊

recursive combinations

@holyghost
?不先打 230 到 [email protected] 吗

超过两层循环 , 一般不往下看 , 一律重写 .

参考这个？
https://www.v2ex.com/t/374395

int count = 0;

void dfs(int x,int deep,int sum){
for(int i=x+1;i<arr.length();i++){
if(deep==4){
count++;
System.out.println(sum+arr[i]);
}else{
dfs(i,deep+1,sum+arr[i]);
}
}
}

void solve(){
dfs(-1,0,0);
System.out.println(count);
}

@Chaos11

你先打 2300 过来！（楼主打 230

private static int count(int[] array) {
return count1(array, array.length, 0, 0);
}

private static int count1(int[] array, int length, int count, int i0) {
if (i0 == length) {
return count;
}
count = count2(array, length, count, i0, i0 + 1);
return count1(array, length, count, i0 + 1);
}

private static int count2(int[] array, int length, int count, int i0, int i1) {
if (i1 == length) {
return count;
}
count = count3(array, length, count, i0, i1, i1 + 1);
return count2(array, length, count, i0, i1 + 1);
}

private static int count3(int[] array, int length, int count, int i0, int i1, int i2) {
if (i2 == length) {
return count;
}
count = count4(array, length, count, i0, i1, i2, i2 + 1);
return count3(array, length, count, i0, i1, i2 + 1);
}

private static int count4(int[] array, int length, int count, int i0, int i1, int i2, int i3) {
if (i3 == length) {
return count;
}
count = count5(array, length, count, i0, i1, i2, i3, i3 + 1);
return count4(array, length, count, i0, i1, i2, i3 + 1);
}

private static int count5(int[] array, int length, int count, int i0, int i1, int i2, int i3, int i4) {
if (i4 == length) {
return count;
}
System.out.println(String.format(
"%d %d %d %d %d",
array[i0],
array[i1],
array[i2],
array[i3],
array[i4]
));
return count5(array, length, count + 1, i0, i1, i2, i3, i4 + 1);
}

#7 楼正解。。。

不过应该吧 sum 改成 String 类型。。

在#7 上 完善了一下，去除全局。
public static int dfs(int[] arr,int count,int x,int deep,String before){
for(int i=x+1;i<arr.length;i++){
if(deep==4){
count++;
System.out.println(before + arr[i]);
}else{
count = dfs(arr,count,i,deep+1,before+arr[i]+" ");
}
}
return count;
}
public static void solve(int[] arr){
int count = dfs(arr,0,-1,0,"");
System.out.println(count);
}

@Chaos11 这是什么梗

不需要递归并且一层循环就能搞定
只需要非常基础的数论知识
码农和软件工程师的区别

@qien 请问有何高见
我能想到的是分组然后把复杂度降低到 2 层循环
或者用 4 进制单循环表示
是否还有其他高见？

@Chaos11 233

@dphdjy 在模 arr.length 的剩余类上做输出

可以把这个问题抽象一下：求一个算法，输入模 m 和维度 n，输出所有模 m 下的 n 维向量(a1, a2, ..., an)，满足 a1<a2<...<an

搜‘数组 排列组合’

不格式化的代码没法看

@qien 你这个，只能得出结果。而 system.out.println 的输出就消失了。

结果是 C(4,n)

@pagxir 狗屁不通，跟 system.out.println 有个 jb 关系
先搞清楚什么叫模 n 的剩余类再跟我说话

@qien 错了就错了，何必爆粗口？

@Lonely 别人不仅智商厉害，口才更是一绝。

system.out.println 说的是输出顺序。只考虑总组合数，解法当然可以多变。

楼主这个是组合排序算法的暴力实现吧，没必要这样搞，真与黑马差距不大了。Groovy 程序设计中，专门讲了用记忆化改善性能，就是你这个的优化版