Java 生成任意k，m的数字置换

我的任务是生成存储在k数组中的数字排列。对于k=3和m=3，第一个元组是（arr0[0]，arr1[0]，arr2[0]），最后一个元组是（arr0[2]，arr1[2]，arr2[2]）。它必须适用于任何k和m，其中k通常介于1和4之间。k=3，m=3的输出示例：

首先是一些java代码。run方法有3个嵌套循环，因为k=3

package-perm；
导入java.util.array；
公共类循环{
私人终审法院；
私人终审法院；
公共循环（int m，int k）{
这个，m=m；
这个。k=k；
}
公共空元组（int l，int j，int i）{
//todo元组必须具有动态大小k
int[]t=新的int[3]；
t[0]=l；
t[1]=j；
t[2]=i；
System.out.println（Arrays.toString（t））；
}
公开募捐{
for（int i=0；i

使用一个简单的递归算法来实现这一点

private static void permute(int[][] arrays)
{
    permute(arrays, 0, new int[arrays.length]);
}

private static void permute(int[][] arrays, int arrayBeingModified, int[] tmp)
{
    if(arrayBeingModified >= arrays.length)
    {
        System.out.println(Arrays.toString(tmp));
    }
    else
    {
        for(int v : arrays[arrayBeingModified])
        {
            tmp[arrayBeingModified] = v;
            permute(arrays, arrayBeingModified + 1, tmp);
            tmp[arrayBeingModified] = 0;
        }
    }
}

public static void main(String[] args)
{
    int[] arr0 = {2,4,8};
    int[] arr1 = {3,6,9,12};
    int[] arr2 = {5,10,15};
    permute(new int[][]{arr0, arr1, arr2});
}

这里的关键概念如下：

• 如果有1个数组，则使用单个循环
• 如果只有2个数组，则将使用双嵌套循环
• 等

无论何时，当您感到自己处于类似的情况时，请考虑递归。 递归是一种替换任意嵌套for循环的方法

在这个特定的示例中，递归代码将跟踪临时数组（称为tmp），该临时数组由每个对应数组中的数字填充

---

在第一步中，我们依次将tmp的第一个元素设置为数组[0]的每个元素。设置完成后，递归调用permute来设置第二个元素。

你能告诉我们你到目前为止做了什么吗？请告诉我们你到目前为止做了什么。在哪所大学他们让你这么做？@Xentros你不会相信Mehanks！我想我将能够使用你的解决方案。理论上，每个递归都可以转化为迭代解。我想知道，在这种情况下这是可能的，当然是可能的。例如，在m=3和k=3的简单情况下，你知道总共有m^k（m为k的幂）输出。假设您希望输出位于位置N。这可以计算为arr0[N/9]、arr1[（N/9）%3]、arr2[N%3]。类似地，可以找到一个通用公式来处理任意m和k。

package perm;

import java.util.Arrays;

public class Loop {

    private final int m;
    private final int k;

    public Loop(int m, int k) {
        this.m = m;
        this.k = k;
    }

    public void tuple(int l, int j, int i) {
        //todo tuple must have dynamic size k
        int[] t = new int[3];
        t[0] = l;
        t[1] = j;
        t[2] = i;
        System.out.println(Arrays.toString(t));
    }

    public void run() {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                for (int l = 0; l < m; l++) {
                    tuple(l, j, i);
                }
            }
        }
    }

    public static void main(String[] args) {
        new Loop(3, 4).run();
    }

}

private static void permute(int[][] arrays)
{
    permute(arrays, 0, new int[arrays.length]);
}

private static void permute(int[][] arrays, int arrayBeingModified, int[] tmp)
{
    if(arrayBeingModified >= arrays.length)
    {
        System.out.println(Arrays.toString(tmp));
    }
    else
    {
        for(int v : arrays[arrayBeingModified])
        {
            tmp[arrayBeingModified] = v;
            permute(arrays, arrayBeingModified + 1, tmp);
            tmp[arrayBeingModified] = 0;
        }
    }
}

public static void main(String[] args)
{
    int[] arr0 = {2,4,8};
    int[] arr1 = {3,6,9,12};
    int[] arr2 = {5,10,15};
    permute(new int[][]{arr0, arr1, arr2});
}