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

[codeInfinty]

int count=0;
for(int i=0;i<arr.length;i++){
for(int j1=i+1;j1<arr.length;j1++){
for(int j2=j1+1;j2<arr.length;j2++){
for(int j3=j2+1;j3<arr.length;j3++){
for (int j4 = j3+1; j4 < arr.length; j4++) {
count++;
System.out.println(arr[i]+" "+arr[j1]+" "+arr[j2]+" "+arr[j3]+" "+arr[j4]);

}
}
}
}
}
System.out.println(count);
}

[sagaxu]

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

[holyghost]

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

[sunsulei]

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

[xss]

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

[Lonely]

没必要用递归啊

[3pmtea]

recursive combinations

[Chaos11]

@holyghost
?不先打 230 到 [e-mail] 吗

[Ouyangan]

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

[jiangzhuo]

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

[qscqesze]

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);
}

[holyghost]

@Chaos11

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

[kzaemrio]

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);
}

[mosliu]

#7 楼正解。。。

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

[mosliu]

在#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);
}

[Lonely]

@Chaos11 这是什么梗

[qien]

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

[dphdjy]

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

[mxi1]

@Chaos11 233

[qien]

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

[maomo]

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