Question

您将获得排列＆＃39; S＆＃39; [1 ... N]具有一个自由点，因此序列的总长度为N + 1.

在一次移动中，您可以将置换的任何元素与自由点交换。

你需要找到最小的动作来自＆＃39; S＆＃39;排序的排序顺序。

Answer 1

如果我理解正确的话，huck_cussler的解决方案需要一个先行来搜索空白所在位置的数字位置。

这是一种替代解决方案，不需要前瞻，最多使用2N交换。

static void swapperSort(int[] arr)
{
    int n = arr.length-1;
    for(int i=0, pos=0, space=n; i<n-1;)
    {
        System.out.print(pos + " " + space + " " + Arrays.toString(arr));
        if(arr[pos] == pos+1)
        {
            pos = ++i;
        }
        else 
        {
            System.out.print(" SWAP");
            int idx = arr[pos]-1;
            swap(arr, idx, space); 
            swap(arr, pos, idx);

            int tmp = space;
            space = pos;
            pos = tmp;
        }
        System.out.println();
    }
    System.out.println(Arrays.toString(arr));
}

以下是DAle测试用例的输出：

0 6 [2, 1, 4, 3, 6, 5, 0] SWAP
6 0 [0, 2, 4, 3, 6, 5, 1] SWAP
0 6 [1, 2, 4, 3, 6, 5, 0]
1 6 [1, 2, 4, 3, 6, 5, 0]
2 6 [1, 2, 4, 3, 6, 5, 0] SWAP
6 2 [1, 2, 0, 4, 6, 5, 3] SWAP
2 6 [1, 2, 3, 4, 6, 5, 0]
3 6 [1, 2, 3, 4, 6, 5, 0]
4 6 [1, 2, 3, 4, 6, 5, 0] SWAP
6 4 [1, 2, 3, 4, 0, 6, 5] SWAP
4 6 [1, 2, 3, 4, 5, 6, 0]
[1, 2, 3, 4, 5, 6, 0]

Answer 2

首先，我们需要找到排列的所有permutation cycles。

置换周期是排列的子集，其元素彼此交换位置。例如，在置换组{4,2,1,3}中，(143)是3个周期，(2)是1个周期。这里，符号(143)表示从原始排序{1,2,3,4}开始，第一个元素被第四个元素替换，第四个元素被第三个元素替换，第三个元素被第一个元素替换，即{{1} }。

置换周期不相交，我们可以独立计算每个周期的交换次数。具有多个元素的每个置换周期1 -> 4 -> 3 -> 1可以转换为带有C交换的带有空格的排序状态（空格将返回到其末尾的初始位置）。因此，我们问题的答案是具有多个元素的所有周期中的元素总数加上这样的周期数。请注意，“具有多个元素的所有循环中的元素总数”仅仅是排列中不在其位置的元素数。

示例：

|C| + 1

我们不需要考虑一个元素的第三个周期。

p = [3, 4, 1, 6, 5, 2, 8, 7] 
cycles = [1, 3], [2, 4, 6], [5], [7, 8]

所有排列周期都可以在answer = 7 + 3 = 10中找到，算法的整体复杂度为O(n)。

Answer 3

使用列表中的第一个无序元素交换空白。

虽然列表仍未排序：

将空白与当前空格所在的数字交换。

您永远不需要超过O(N)掉期。

e.g。鉴于S=[3,2,4,1,_]，3是第一个乱序元素，因此将其与空格交换以获得S=[_,2,4,1,3]。现在，只需继续将空白与当前空格所在的数字进行交换，即S=[1,2,4,_,3] -> S=[1,2,_,4,3] -> S=[1,2,3,4,_]。

对于4元素，最糟糕的情况是，所有元素都不合适，因此您需要1交换才能将空白置于第一个位置，然后再添加4交换以将所有元素放在适当的位置。一般情况下，在N元素的最坏情况下，您最需要进行N+1次互换，因此O(N)。

正如评论中所指出的，实际问题是要找到某些给定列表所需的最小交换数量。如果项目已经有序，当然需要0交换。否则（至少有两个不合适）你将需要为最初不合适的每个元素进行一次交换{/ 1}}。

从源排列移动到目的地的最小数量

3 个答案: