查找所有可能的排列而不重复值

Question

假设我有这组数组作为输入：

[
 0 => [1,2,4,5],
 1 => [2,3,4],
 2 => [1,3],
]

我想找到所有可能的排列，从每个数组中选择一个值。该值在最终结果中将是唯一的，因此不会重复。例如，我不能在结果中出现两次1。

输入上的数组计数与输出上的数组计数相同。

想要的组合示例（键=>值）：

[0 => 1,1 => 2,2 => 3]
[0 => 2,1 => 3,2 => 1]
[0 => 5,1 => 2,2 => 1]
[0 => 1,1 => 3,2 => null]

错误的结果

[0 => 1,1 => 2,2 => 1]

或

[0 => 2,1 => 2,2 => 3]

---

我想使用 PHP 获得所有可能的排列组合。我该怎么做？

我附上了真实的数据集http://pastebin.com/U6Hyawm4 但是，我不知道可能有多少排列。

Answer 1

这是一个经过优化的非递归版本

/**
 * Generates all the possible unique N-tuples from an array of N arrays of integers
 *
 * @param array $input
 * @return array
 */
function generateCombinations(array &$input) {
    // since the example results included [1, 3, null] I have assumed that
    // null is a possible value of each set.
    $sets = [];
    foreach($input as $set) {
        if(!in_array(null, $set)) {
            $set[] = null;
        }
        $sets[] = $set;
    }

    // by working on the iterators of each array this loop
    // linearizes the entire set of possible combinations
    // and iterates it (skipping as many as it can).
    $output = [];
    $setCount = count($sets);
    while(current($sets[0]) !== false) {
        $testCombo = [];
        for($setIdx = 0; $setIdx < $setCount; $setIdx++) {
            if(!in_array(current($sets[$setIdx]), $testCombo)) {
                $testCombo[] = current($sets[$setIdx]);
            }
            else {
                // when a combination is thrown out as duplicate
                // iterate to skip any other combo's that would also
                // contain that duplicate
                iterateSets($sets, $setIdx);
                break;
            }
        }
        // if there were no duplicates add it to the output and iterate
        if(count($testCombo) == $setCount) {
            $output[] = $testCombo;
            iterateSets($sets, $setCount - 1);
        }
    }
    return $output;
}

/**
 * Iterates to the next potentially valid combination. I think of
 * this like doing long-hand addition. Add 1 and carry is akin to
 * next and reset.
 *
 * @param array $sets
 * @param $index
 */
function iterateSets(array &$sets, $index) {
    // reset iterators of all sets past the current one to skip
    // combos that cannot be valid
    for($i = $index + 1, $ic = count($sets); $i < $ic; $i++) {
        reset($sets[$i]);
    }
    // always move one on current set
    next($sets[$index]);
    while($index > 0 && current($sets[$index]) === false) {
        // wrap if current set is at the end
        reset($sets[$index]);
        $index--;
        // move one for the preceding set
        next($sets[$index]);
        // then repeat
    }
}

得到的数组是：

[
    [1,2,3]
    [1,2,null]
    [1,3,null]
    [1,4,3]
    [1,4,null]
    [1,null,3]
    [2,3,1]
    [2,3,null]
    [2,4,1]
    [2,4,3]
    [2,4,null]
    [2,null,1]
    [2,null,3]
    [4,2,1]
    [4,2,3]
    [4,2,null]
    [4,3,1]
    [4,3,null]
    [4,null,1]
    [4,null,3]
    [5,2,1]
    [5,2,3]
    [5,2,null]
    [5,3,1]
    [5,3,null]
    [5,4,1]
    [5,4,3]
    [5,4,null]
    [5,null,1]
    [5,null,3]
    [null,2,1]
    [null,2,3]
    [null,3,1]
    [null,4,1]
    [null,4,3]
]

Answer 2

这是一个低效的版本：

$input = array(
    [1,2,4,5],
    [2,3,4],
    [1,3]
);

function appendUnique($subs, $i) {
    global $input;
    if ($i == count($input)) {
        return $subs;
    }

    $output = array();
    foreach ($subs as $sub) {
        foreach ($input[$i] as $v) {
            $new_sub = array_values($sub);
            if (in_array($v, $sub)) {
                $new_sub[] = null;
            } else {
                $new_sub[] = $v;
            }
            $output[] = $new_sub;
        }
    }
    return appendUnique($output, $i+1);
}

$output = appendUnique([[]], 0);
$output_json = array();
foreach ($output as $row) {
    $output_json[] = json_encode($row);
}
$output_json = array_unique($output_json);
$deduped = array();
foreach ($output_json as $json) {
    $deduped[] = json_decode($json);
}
print_r($deduped);

输出：

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 
        )

    [1] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

    [2] => Array
        (
            [0] => 1
            [1] => 3
            [2] => 
        )

    [3] => Array
        (
            [0] => 1
            [1] => 4
            [2] => 
        )

    [4] => Array
        (
            [0] => 1
            [1] => 4
            [2] => 3
        )

    [5] => Array
        (
            [0] => 2
            [1] => 
            [2] => 1
        )

    [6] => Array
        (
            [0] => 2
            [1] => 
            [2] => 3
        )

    [7] => Array
        (
            [0] => 2
            [1] => 3
            [2] => 1
        )

    [8] => Array
        (
            [0] => 2
            [1] => 3
            [2] => 
        )

    [9] => Array
        (
            [0] => 2
            [1] => 4
            [2] => 1
        )

    [10] => Array
        (
            [0] => 2
            [1] => 4
            [2] => 3
        )

    [11] => Array
        (
            [0] => 4
            [1] => 2
            [2] => 1
        )

    [12] => Array
        (
            [0] => 4
            [1] => 2
            [2] => 3
        )

    [13] => Array
        (
            [0] => 4
            [1] => 3
            [2] => 1
        )

    [14] => Array
        (
            [0] => 4
            [1] => 3
            [2] => 
        )

    [15] => Array
        (
            [0] => 4
            [1] => 
            [2] => 1
        )

    [16] => Array
        (
            [0] => 4
            [1] => 
            [2] => 3
        )

    [17] => Array
        (
            [0] => 5
            [1] => 2
            [2] => 1
        )

    [18] => Array
        (
            [0] => 5
            [1] => 2
            [2] => 3
        )

    [19] => Array
        (
            [0] => 5
            [1] => 3
            [2] => 1
        )

    [20] => Array
        (
            [0] => 5
            [1] => 3
            [2] => 
        )

    [21] => Array
        (
            [0] => 5
            [1] => 4
            [2] => 1
        )

    [22] => Array
        (
            [0] => 5
            [1] => 4
            [2] => 3
        )

)