Question

随机shuffling数组可以轻松解决。我想做一个随机播放，但增加了限制，任何元素的移位都被限制在一个范围内。因此，如果最大允许移位= n，则由于随机播放，任何方向都不能移动任何元素超过n步。

所以给定这个数组，并且n = 3：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

这将是一个有效的洗牌：

[2, 3, 4, 0, 1, 6, 5, 8, 9, 7]

虽然这些都是无效的：

[2, 3, 4, 7, 1, 6, 5, 8, 9, 0]
[2, 3, 4, 6, 1, 7, 5, 8, 9, 0]

（注意范围不是旋转的）

我们正在寻找一种简单有效的方法来实现这一目标。最好是就地执行，但是如果它提供了一个很好的解决方案，那么使用第二个数组是可以的。

一个天真的入门解决方案是，使用第二个阵列：

for element in array1:
  get legal index range
  filter out indexes already filled
  select random index i from filtered range
  array20[i] = element

修改：

这是关于@ruakh引发的概率失真问题，如果算法首先以相同的概率处理终端元素：

我乍一看，随着阵列大小的增加，概率方差会减小，但事实似乎并非如此。下面的一些快速测试（我急忙编造，所以可能有错误）。由于概率变形很大，我不认为这是可以接受的作为一般情况，但对于我自己的应用程序，我可以像我在评论中所说的那样忍受它。

import itertools

n = 2

def test(arlen):
    ar = range(arlen)
    lst = list(itertools.permutations(ar))
    flst = [l for l in lst if not illegal(l)]

    print 'array length', arlen
    print 'total perms: ', len(lst)
    print 'legal perms: ', len(flst)

    frst = [0] * (n+1)
    for l in flst:
        frst[l[0]] +=1

    print 'distribution of first element: ',frst

def illegal(l):
    for i in range(len(l)):
        if abs(l[i]-i)>n: return True

if __name__=="__main__":
    arlen = range(4,10)
    for ln in arlen:
        test(ln)

------------ n=2
array length 4
total perms:  24
legal perms:  14
distribution of first element:  [6, 4, 4]
array length 5
total perms:  120
legal perms:  31
distribution of first element:  [14, 10, 7]
array length 6
total perms:  720
legal perms:  73
distribution of first element:  [31, 24, 18]
array length 7
total perms:  5040
legal perms:  172
distribution of first element:  [73, 55, 44]
array length 8
total perms:  40320
legal perms:  400
distribution of first element:  [172, 128, 100]
array length 9
total perms:  362880
legal perms:  932
distribution of first element:  [400, 300, 232]

------------ n=4
array length 4
total perms:  24
legal perms:  24
distribution of first element:  [6, 6, 6, 6, 0]
array length 5
total perms:  120
legal perms:  120
distribution of first element:  [24, 24, 24, 24, 24]
array length 6
total perms:  720
legal perms:  504
distribution of first element:  [120, 96, 96, 96, 96]
array length 7
total perms:  5040
legal perms:  1902
distribution of first element:  [504, 408, 330, 330, 330]
array length 8
total perms:  40320
legal perms:  6902
distribution of first element:  [1902, 1572, 1296, 1066, 1066]
array length 9
total perms:  362880
legal perms:  25231
distribution of first element:  [6902, 5836, 4916, 4126, 3451]

Answer 1

有可能将此视为一个确切的覆盖问题，并且可能（我没有测试它，但我会证明这个说法合理）可以通过ZDD有效地解决。

精确覆盖问题将具有布尔决策变量，用于将每个元素放入结果的每一种方式，因此如果n = 0，将存在与n = 1元素一样多的变量除了结尾之外，每个元素都有三个变量，每个元素都有两个变量，等等。

如果n明显小于数组的大小，则意味着“远离”的决策变量不会直接相互影响。这应该保持ZDD的大小合理，因为它在结构上与例如小瓦片的平铺问题相当。

编辑：实际上我现在对此不太了解，尤其是对平铺的可比性似乎越来越令人怀疑，但我仍然怀疑ZDD的尺寸可以控制。

在合理大小的ZDD上，可以有效地生成无偏差（即每个解具有相同概率）的随机解（对应于“不要移动超过n个位置”的有效排列） - 规则）。

这可能不是最好的方式，但它表明可以毫不蛮力地做到这一点。

Answer 2

输入InputArray：数组整数
输入NumberCount：InputArray中的整数数
输入ShuffleRange：允许跳过的有效范围
ShuffleWindowSize：处理发生交换的窗口。其值为ShuffleRange +1
ShuffleIndexArray：随机播放窗口中输入数字的索引，无效索引将为 INT_MIN

初始化ShuffleIndexArray

for (idx =0; idx < ShuffleWindowSize; idx++) {
  ShuffleIndexArray[idx] = idx;
}

处理InputArray

for (idx = 0; idx < NumberCount; idx++) {

    shuffleIdx = idx % ShuffleWindowSize;

    /* 1. Check if the Element has been moved from it's Original Position
     * 1.1 IF it was swapped already then move to next element
     * 1.2 ELSE perform shuffling within available window
     */
    if (idx != ShuffleIndexArray[shuffleIdx]) { /* was swapped already */
        goto LOOP_CONTINUE;
    }
    /* Get a random Index in the range [0, shuffleWinSize) */
    randomSwapIdx = rand() % shuffleWinSize; /* OffSet */

    /* Skip Invalid Indexes */
    if (INT_MIN == shuffleIndexArray[randomSwapIdx]) {
        for (jdx = randomSwapIdx + shuffleWinSize - 1; jdx > randomSwapIdx; jdx--) {
            if (INT_MIN != shuffleIndexArray[jdx % shuffleWinSize]) {
                randomSwapIdx = jdx % shuffleWinSize;
                break;
            }
        }
    }

    /* Get the actual index into InputArray */
    randomSwapIdx = ShuffleIndexArray[randomSwapIdx]; /*Actual Index*/

    /* Check if number gets to stay in original position */
    if (idx == randomSwapIdx) { /* Lucky Bugger */
        goto LOOP_CONTINUE;
    }

    /* Swapping of two numbers in InputArray */
    swapInt = inputArr[idx];
    inputArr[idx] = inputArr[randomSwapIdx];
    inputArr[randomSwapIdx] = swapInt;

    /* Update indexes in Shuffle-Window Array */
    ShuffleIndexArray[randomSwapIdx % ShuffleWindowSize] = idx;

    LOOP_CONTINUE:
    /* InputArray[idx] was processed.
     * Update ShuffleIndexArray */
    ShuffleIndexArray[shuffleIdx] =
            ((idx + ShuffleWindowSize) < NumberCount) ?
                    (idx + ShuffleWindowSize) : INT_MIN;
}

这是一个就地改组，除了我们需要另一个大小为ShuffleWindowSize的数组来跟踪索引。

Answer 3

听起来你对于每种可能的输出具有相同的概率并不太挑剔。一个简单的解决方案可能是做相当于n冒泡排序的过程，而不是对元素进行排序，只需随机选择是否在每一步交换两个元素。这种方法也可以让你进行随机化。你可以这样做：

import random
def shuffle_list(list, n):
    for ipass in xrange(n):
        for ielt in xrange(len(list) - 1):
            if random.randrange(2):
                temp = list[ielt]
                list[ielt] = list[ielt + 1]
                list[ielt + 1] = temp

编辑：抱歉，我应该考虑更多。我描述的方法不起作用 - 在第一次传递中，第一个元素一直冒到列表末尾的非零概率。不知怎的，我错过了。

我想我现在真的没有答案，但至少这是一个想法：为原始列表中的每个元素分配一个等于ii + random.uniform(-n/2., n/2.)的代理值，其中ii是元素的索引在原始列表中;然后根据此代理值对原始列表进行排序。然后，最后一个元素ii可以出现在最终列表中的位置是ii-n：这只会在元素收到代理值ii-n/2.并且每个元素以元素ii-n开头时发生收到的代理值至少为ii-n/2.。上限的参数相同。

在实践中，您希望使用稍宽的范围，可能类似于random.uniform(-n/2. - 0.49, n/2. + 0.5)。我还没有仔细研究过这个数学，但我认为这可以保持距离约束。我也不完全确定可能列表的最终分布是什么。 @Basel，我认为你对原始建议是正确的，似乎更有可能让每个元素移动少量而不是大量。我认为这个解决方案应该更好，但我不能发誓。： - ）

在限制元素移位范围的同时改组列表

3 个答案: