Question

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

(0,0 1,0 2,0) 
(0,0 1,0 2,1) 
(0,0 1,0 2,2)
(0,0 1,1 2,0)
(0,0 1,1 2,1)
(0,0 1,1 2,2)
(0,0 1,2 2,0)
(0,0 1,2 2,1)
(0,0 1,2 2,2)

(0,1 1,0 2,0) 
(0,1 1,0 2,1) 
(0,1 1,0 2,2)
(0,1 1,1 2,0)
(0,1 1,1 2,1)
(0,1 1,1 2,2)
(0,1 1,2 2,0)
(0,1 1,2 2,1)
(0,1 1,2 2,2)

(0,2 1,0 2,0) 
(0,2 1,0 2,1) 
(0,2 1,0 2,2)
(0,2 1,1 2,0)
(0,2 1,1 2,1)
(0,2 1,1 2,2)
(0,2 1,2 2,0)
(0,2 1,2 2,1)
(0,2 1,2 2,2)

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

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

}

Answer 1

使用简单的递归算法来执行此操作。

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

这里的关键概念如下：

如果您有一个阵列，则使用单个循环
如果您只有2个数组，则使用双嵌套循环
等

每当你觉得自己陷入类似情况时，请考虑递归。递归是一种替换任意嵌套for循环的方法。

在这个特定的例子中，递归代码将跟踪临时数组（称为tmp），该数组将填充来自每个相应数组的数字。

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

生成任何k，m的数字排列

1 个答案: