随机播放元素，使得任何元素都不应出现在其原始索引处

Question

我有一个对象元素列表

SourceList    ResultList (Expected)

Obj_A                 Obj_F

Obj_B                 Obj_C

Obj_C                 Obj_G

Obj_D                 Obj_B

Obj_E                 Obj_A

Obj_F                 Obj_B

Obj_G                 Obj_E

随机播放 SourceList 中的元素，这样，任何元素都不应出现在其原始索引处（在 SourceList 中）在结果列表中。

例如，在 SourceList 中，C 位于索引 2 处，因此它不能位于 ResultList 中的索引 2 处强>

到目前为止，我已经研究了Dearrangement Wiki，但算法给了我可能的安排，我只需要一个。

Answer 1

您可以将fisher-yates shuffle 用作黑匣子，并反复打乱您的数组，直到您的结果是重新排列。

伪代码：

while true:
     arr = [1,2,...,n]
     shuffle(arr)
     flag = true
     for i from 0 to n:
        if arr[i] == i: //not a dearrangement
           flag = false 
     if flag == true: //it's a dearrangement
        break

shuffle(arr): //fisher yates
    for i from 0 to n:
       j = rand(i,n)
       swap(arr,i,j)

这种方法的性质：

• 这保证是一致且一致的，因为每个有效的重排 在每次迭代中获得完全相同的赔率。
• 由于 Fisher-Yates 生成所有排列，并且我们仅使去排列无效 - 每个去排列都是可实现的。
• 得到重新排列的概率是 1/e¹，这意味着在平均情况下您将需要 (1-1/e)^-1 ~=1.56 shuffle，这意味着该算法以 O(n) 预期时间复杂度运行。

---

(1) The number of dearrangements 是 int(n!/e + 1/2)，这意味着对于较大的 n 值，数组成为去排列的概率是 (n!/e + 1/2)/n! ~= 1/e。

Answer 2

这对我有用：

var SourceList = new List<string>()
{
    "Obj_A", "Obj_B", "Obj_C", "Obj_D", "Obj_E", "Obj_F", "Obj_G",
}; 

var rnd = new Random();

var ResultList =
    Enumerable
        // create an exceedingly long sequence for retries
        .Repeat(0, int.MaxValue)
        // select and randomly order all of the indices of `SourceList`
        .Select(_ => Enumerable.Range(0, SourceList.Count)
            .OrderBy(x => rnd.Next())
            .ToArray())
        // Discard the indices if they have any matching positions
        .Where(x => !x.Where((y, i) => y == i).Any())
        // only take one successful set of indices
        .Take(1)
        // flatten the list of lists to a list
        .SelectMany(x => x)
        // select the elements from `SourceList` from their index positions
        .Select(x => SourceList[x])
        // convert to list
        .ToList();

.OrderBy(x => rnd.Next()) 的使用产生了统一的排序（无偏见）——我过去已经证实了这一点。

Answer 3

进行洗牌，让所有索引不变的元素，然后旋转所有这些错误元素的位置。