关于c＃：生成集合的排列（最有效）


Generating permutations of a set (most efficiently)

我想生成集合(集合)的所有排列，如下所示：

1
2
3
4
5
6
7
Collection: 1, 2, 3
Permutations: {1, 2, 3}
              {1, 3, 2}
              {2, 1, 3}
              {2, 3, 1}
              {3, 1, 2}
              {3, 2, 1}

一般来说，这不是一个"如何"的问题，而是关于如何最有效的问题。另外，我不希望生成所有排列并返回它们，但一次只生成一个排列，并且仅在必要时继续(很像迭代器——我也尝试过，但结果效率较低)。

我已经测试了许多算法和方法，并提出了这一代码，这是我尝试过的最有效的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public static bool NextPermutation<T>(T[] elements) where T : IComparable<T>
{
    // More efficient to have a variable instead of accessing a property
    var count = elements.Length;

    // Indicates whether this is the last lexicographic permutation
    var done = true;

    // Go through the array from last to first
    for (var i = count - 1; i > 0; i--)
    {
        var curr = elements[i];

        // Check if the current element is less than the one before it
        if (curr.CompareTo(elements[i - 1]) < 0)
        {
            continue;
        }

        // An element bigger than the one before it has been found,
        // so this isn't the last lexicographic permutation.
        done = false;

        // Save the previous (bigger) element in a variable for more efficiency.
        var prev = elements[i - 1];

        // Have a variable to hold the index of the element to swap
        // with the previous element (the to-swap element would be
        // the smallest element that comes after the previous element
        // and is bigger than the previous element), initializing it
        // as the current index of the current item (curr).
        var currIndex = i;

        // Go through the array from the element after the current one to last
        for (var j = i + 1; j < count; j++)
        {
            // Save into variable for more efficiency
            var tmp = elements[j];

            // Check if tmp suits the"next swap" conditions:
            // Smallest, but bigger than the"prev" element
            if (tmp.CompareTo(curr) < 0 && tmp.CompareTo(prev) > 0)
            {
                curr = tmp;
                currIndex = j;
            }
        }

        // Swap the"prev" with the new"curr" (the swap-with element)
        elements[currIndex] = prev;
        elements[i - 1] = curr;

        // Reverse the order of the tail, in order to reset it's lexicographic order
        for (var j = count - 1; j > i; j--, i++)
        {
            var tmp = elements[j];
            elements[j] = elements[i];
            elements[i] = tmp;
        }

        // Break since we have got the next permutation
        // The reason to have all the logic inside the loop is
        // to prevent the need of an extra variable indicating"i" when
        // the next needed swap is found (moving"i" outside the loop is a
        // bad practice, and isn't very readable, so I preferred not doing
        // that as well).
        break;
    }

    // Return whether this has been the last lexicographic permutation.
    return done;
}

它的用法是发送一个元素数组，并返回一个布尔值，指示这是否是最后一个词典编纂排列，以及将数组更改为下一个排列。

使用实例：

1
2
3
4
5
6
7
8
var arr = new[] {1, 2, 3};

PrintArray(arr);

while (!NextPermutation(arr))
{
    PrintArray(arr);
}

问题是我对代码的速度不满意。

遍历大小为11的数组的所有排列大约需要4秒钟。虽然可以认为这是令人印象深刻的，因为一组11号的可能排列的数量是11!，接近4000万。

从逻辑上讲，对于一个12大小的数组，它将花费大约12倍的时间，因为12!是11! * 12，而对于13大小的数组，它将花费大约13倍于12大小的时间，依此类推。

因此，您可以很容易地理解，对于大小为12或更多的数组，执行所有排列确实需要很长的时间。

我有一种强烈的预感，我可以以某种方式将时间缩短很多(不用切换到C语言以外的语言)，因为编译器优化确实非常好地优化了，我怀疑我可以在汇编中手动优化。

有没有人知道其他更快的方法？你知道如何使当前算法更快吗？

请注意，我不想使用外部库或服务来实现这一点——我想拥有代码本身，我希望它尽可能地高效。

相关讨论

这可能是你要找的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    private static bool NextPermutation(int[] numList)
    {
        /*
         Knuths
         1. Find the largest index j such that a[j] < a[j + 1]. If no such index exists, the permutation is the last permutation.
         2. Find the largest index l such that a[j] < a[l]. Since j + 1 is such an index, l is well defined and satisfies j < l.
         3. Swap a[j] with a[l].
         4. Reverse the sequence from a[j + 1] up to and including the final element a[n].

         */
        var largestIndex = -1;
        for (var i = numList.Length - 2; i >= 0; i--)
        {
            if (numList[i] < numList[i + 1]) {
                largestIndex = i;
                break;
            }
        }

        if (largestIndex < 0) return false;

        var largestIndex2 = -1;
        for (var i = numList.Length - 1 ; i >= 0; i--) {
            if (numList[largestIndex] < numList[i]) {
                largestIndex2 = i;
                break;
            }
        }

        var tmp = numList[largestIndex];
        numList[largestIndex] = numList[largestIndex2];
        numList[largestIndex2] = tmp;

        for (int i = largestIndex + 1, j = numList.Length - 1; i < j; i++, j--) {
            tmp = numList[i];
            numList[i] = numList[j];
            numList[j] = tmp;
        }

        return true;
    }
相关讨论

Update 2018-05-28:

  • A new multithreaded version (lot faster) is available below as another answer.
  • Also an article about permutation: Permutations: Fast implementations and a new indexing algorithm allowing multithreading

有点晚了…

根据最近的测试(更新日期：2018-05-22)

  • 最快的是我的，但不是按字典顺序
  • 对于最快的词典编纂顺序，sani singh huttunen解决方案似乎是可行的方法。

10项(10！)在我的机器上释放(毫秒)：

  • Ouellet：29
  • SimpleVar：95
  • 埃雷兹·罗宾逊：156
  • 萨尼·辛格·胡特宁：37岁
  • 彭阳：45047

13项(13！)在我的机器上释放(秒)：

  • 欧勒特：48.437
  • 单工：159.869
  • 埃雷兹·罗宾逊：327.781
  • 萨尼·辛格·胡特宁：64.839

我的解决方案的优点：

  • 堆算法(每排列一次交换)
  • 没有乘法(就像在网络上看到的一些实现一样)
  • 内联交换
  • 通用的
  • 无不安全代码
  • 到位(内存使用率非常低)
  • 无模(仅第一位比较)

我对堆算法的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;

namespace WpfPermutations
{
    /// <summary>
    /// EO: 2016-04-14
    /// Generator of all permutations of an array of anything.
    /// Base on Heap's Algorithm. See: https://en.wikipedia.org/wiki/Heap%27s_algorithm#cite_note-3
    /// </summary>
    public static class Permutations
    {
        /// <summary>
        /// Heap's algorithm to find all pmermutations. Non recursive, more efficient.
        /// </summary>
        /// <param name="items">Items to permute in each possible ways</param>
        /// <param name="funcExecuteAndTellIfShouldStop"></param>
        /// <returns>Return true if cancelled</returns>
        public static bool ForAllPermutation<T>(T[] items, Func<T[], bool> funcExecuteAndTellIfShouldStop)
        {
            int countOfItem = items.Length;

            if (countOfItem <= 1)
            {
                return funcExecuteAndTellIfShouldStop(items);
            }

            var indexes = new int[countOfItem];
            for (int i = 0; i < countOfItem; i++)
            {
                indexes[i] = 0;
            }

            if (funcExecuteAndTellIfShouldStop(items))
            {
                return true;
            }

            for (int i = 1; i < countOfItem;)
            {
                if (indexes[i] < i)
                { // On the web there is an implementation with a multiplication which should be less efficient.
                    if ((i & 1) == 1) // if (i % 2 == 1)  ... more efficient ??? At least the same.
                    {
                        Swap(ref items[i], ref items[indexes[i]]);
                    }
                    else
                    {
                        Swap(ref items[i], ref items[0]);
                    }

                    if (funcExecuteAndTellIfShouldStop(items))
                    {
                        return true;
                    }

                    indexes[i]++;
                    i = 1;
                }
                else
                {
                    indexes[i++] = 0;
                }
            }

            return false;
        }

        /// <summary>
        /// This function is to show a linq way but is far less efficient
        /// From: StackOverflow user: Pengyang : http://stackoverflow.com/questions/756055/listing-all-permutations-of-a-string-integer
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> list, int length)
        {
            if (length == 1) return list.Select(t => new T[] { t });

            return GetPermutations(list, length - 1)
                .SelectMany(t => list.Where(e => !t.Contains(e)),
                    (t1, t2) => t1.Concat(new T[] { t2 }));
        }

        /// <summary>
        /// Swap 2 elements of same type
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="a"></param>
        /// <param name="b"></param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static void Swap<T>(ref T a, ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }

        /// <summary>
        /// Func to show how to call. It does a little test for an array of 4 items.
        /// </summary>
        public static void Test()
        {
            ForAllPermutation("123".ToCharArray(), (vals) =>
            {
                Console.WriteLine(String.Join("", vals));
                return false;
            });

            int[] values = new int[] { 0, 1, 2, 4 };

            Console.WriteLine("Ouellet heap's algorithm implementation");
            ForAllPermutation(values, (vals) =>
            {
                Console.WriteLine(String.Join("", vals));
                return false;
            });

            Console.WriteLine("Linq algorithm");
            foreach (var v in GetPermutations(values, values.Length))
            {
                Console.WriteLine(String.Join("", v));
            }

            // Performance Heap's against Linq version : huge differences
            int count = 0;

            values = new int[10];
            for (int n = 0; n < values.Length; n++)
            {
                values[n] = n;
            }

            Stopwatch stopWatch = new Stopwatch();

            ForAllPermutation(values, (vals) =>
            {
                foreach (var v in vals)
                {
                    count++;
                }
                return false;
            });

            stopWatch.Stop();
            Console.WriteLine($"Ouellet heap's algorithm implementation {count} items in {stopWatch.ElapsedMilliseconds} millisecs");

            count = 0;
            stopWatch.Reset();
            stopWatch.Start();

            foreach (var vals in GetPermutations(values, values.Length))
            {
                foreach (var v in vals)
                {
                    count++;
                }
            }

            stopWatch.Stop();
            Console.WriteLine($"Linq {count} items in {stopWatch.ElapsedMilliseconds} millisecs");
        }
    }
}

A这是我的测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
Task.Run(() =>
            {

                int[] values = new int[12];
                for (int n = 0; n < values.Length; n++)
                {
                    values[n] = n;
                }

                // Eric Ouellet Algorithm
                int count = 0;
                var stopwatch = new Stopwatch();
                stopwatch.Reset();
                stopwatch.Start();
                Permutations.ForAllPermutation(values, (vals) =>
                {
                    foreach (var v in vals)
                    {
                        count++;
                    }
                    return false;
                });
                stopwatch.Stop();
                Console.WriteLine($"This {count} items in {stopwatch.ElapsedMilliseconds} millisecs");

                // Simple Plan Algorithm
                count = 0;
                stopwatch.Reset();
                stopwatch.Start();
                PermutationsSimpleVar permutations2 = new PermutationsSimpleVar();
                permutations2.Permutate(1, values.Length, (int[] vals) =>
                {
                    foreach (var v in vals)
                    {
                        count++;
                    }
                });
                stopwatch.Stop();
                Console.WriteLine($"Simple Plan {count} items in {stopwatch.ElapsedMilliseconds} millisecs");

                // ErezRobinson Algorithm
                count = 0;
                stopwatch.Reset();
                stopwatch.Start();
                foreach(var vals in PermutationsErezRobinson.QuickPerm(values))
                {
                    foreach (var v in vals)
                    {
                        count++;
                    }
                };
                stopwatch.Stop();
                Console.WriteLine($"Erez Robinson {count} items in {stopwatch.ElapsedMilliseconds} millisecs");
            });

使用实例：

1
2
3
4
5
6
7
8
9
10
11
12
ForAllPermutation("123".ToCharArray(), (vals) =>
    {
        Console.WriteLine(String.Join("", vals));
        return false;
    });

int[] values = new int[] { 0, 1, 2, 4 };
ForAllPermutation(values, (vals) =>
        {
            Console.WriteLine(String.Join("", vals));
            return false;
        });
相关讨论

好吧，如果你能用C语言处理，然后翻译成你选择的语言，你就不能比这快得多，因为时间将由print支配：

1
2
3
4
5
6
7
8
9
10
11
12
13
void perm(char* s, int n, int i){
  if (i >= n-1) print(s);
  else {
    perm(s, n, i+1);
    for (int j = i+1; j<n; j++){
      swap(s[i], s[j]);
      perm(s, n, i+1);
      swap(s[i], s[j]);
    }
  }
}

perm("ABC", 3, 0);
相关讨论

我所知道的最快置换算法是快速置换算法。这里是实现，它使用yield-return，因此您可以根据需要一次迭代一次。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public static IEnumerable<IEnumerable<T>> QuickPerm<T>(this IEnumerable<T> set)
    {
        int N = set.Count();
        int[] a = new int[N];
        int[] p = new int[N];

        var yieldRet = new T[N];

        List<T> list = new List<T>(set);

        int i, j, tmp; // Upper Index i; Lower Index j

        for (i = 0; i < N; i++)
        {
            // initialize arrays; a[N] can be any type
            a[i] = i + 1; // a[i] value is not revealed and can be arbitrary
            p[i] = 0; // p[i] == i controls iteration and index boundaries for i
        }
        yield return list;
        //display(a, 0, 0);   // remove comment to display array a[]
        i = 1; // setup first swap points to be 1 and 0 respectively (i & j)
        while (i < N)
        {
            if (p[i] < i)
            {
                j = i%2*p[i]; // IF i is odd then j = p[i] otherwise j = 0
                tmp = a[j]; // swap(a[j], a[i])
                a[j] = a[i];
                a[i] = tmp;

                //MAIN!

                for (int x = 0; x < N; x++)
                {
                    yieldRet[x] = list[a[x]-1];
                }
                yield return yieldRet;
                //display(a, j, i); // remove comment to display target array a[]

                // MAIN!

                p[i]++; // increase index"weight" for i by one
                i = 1; // reset index i to 1 (assumed)
            }
            else
            {
                // otherwise p[i] == i
                p[i] = 0; // reset p[i] to zero
                i++; // set new index value for i (increase by one)
            } // if (p[i] < i)
        } // while(i < N)
    }
相关讨论

下面是我最后得到的最快的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
public class Permutations
{
    private readonly Mutex _mutex = new Mutex();

    private Action<int[]> _action;
    private Action<IntPtr> _actionUnsafe;
    private unsafe int* _arr;
    private IntPtr _arrIntPtr;
    private unsafe int* _last;
    private unsafe int* _lastPrev;
    private unsafe int* _lastPrevPrev;

    public int Size { get; private set; }

    public bool IsRunning()
    {
        return this._mutex.SafeWaitHandle.IsClosed;
    }

    public bool Permutate(int start, int count, Action<int[]> action, bool async = false)
    {
        return this.Permutate(start, count, action, null, async);
    }

    public bool Permutate(int start, int count, Action<IntPtr> actionUnsafe, bool async = false)
    {
        return this.Permutate(start, count, null, actionUnsafe, async);
    }

    private unsafe bool Permutate(int start, int count, Action<int[]> action, Action<IntPtr> actionUnsafe, bool async = false)
    {
        if (!this._mutex.WaitOne(0))
        {
            return false;
        }

        var x = (Action)(() =>
                             {
                                 this._actionUnsafe = actionUnsafe;
                                 this._action = action;

                                 this.Size = count;

                                 this._arr = (int*)Marshal.AllocHGlobal(count * sizeof(int));
                                 this._arrIntPtr = new IntPtr(this._arr);

                                 for (var i = 0; i < count - 3; i++)
                                 {
                                     this._arr[i] = start + i;
                                 }

                                 this._last = this._arr + count - 1;
                                 this._lastPrev = this._last - 1;
                                 this._lastPrevPrev = this._lastPrev - 1;

                                 *this._last = count - 1;
                                 *this._lastPrev = count - 2;
                                 *this._lastPrevPrev = count - 3;

                                 this.Permutate(count, this._arr);
                             });

        if (!async)
        {
            x();
        }
        else
        {
            new Thread(() => x()).Start();
        }

        return true;
    }

    private unsafe void Permutate(int size, int* start)
    {
        if (size == 3)
        {
            this.DoAction();
            Swap(this._last, this._lastPrev);
            this.DoAction();
            Swap(this._last, this._lastPrevPrev);
            this.DoAction();
            Swap(this._last, this._lastPrev);
            this.DoAction();
            Swap(this._last, this._lastPrevPrev);
            this.DoAction();
            Swap(this._last, this._lastPrev);
            this.DoAction();

            return;
        }

        var sizeDec = size - 1;
        var startNext = start + 1;
        var usedStarters = 0;

        for (var i = 0; i < sizeDec; i++)
        {
            this.Permutate(sizeDec, startNext);

            usedStarters |= 1 << *start;

            for (var j = startNext; j <= this._last; j++)
            {
                var mask = 1 << *j;

                if ((usedStarters & mask) != mask)
                {
                    Swap(start, j);
                    break;
                }
            }
        }

        this.Permutate(sizeDec, startNext);

        if (size == this.Size)
        {
            this._mutex.ReleaseMutex();
        }
    }

    private unsafe void DoAction()
    {
        if (this._action == null)
        {
            if (this._actionUnsafe != null)
            {
                this._actionUnsafe(this._arrIntPtr);
            }

            return;
        }

        var result = new int[this.Size];

        fixed (int* pt = result)
        {
            var limit = pt + this.Size;
            var resultPtr = pt;
            var arrayPtr = this._arr;

            while (resultPtr < limit)
            {
                *resultPtr = *arrayPtr;
                resultPtr++;
                arrayPtr++;
            }
        }

        this._action(result);
    }

    private static unsafe void Swap(int* a, int* b)
    {
        var tmp = *a;
        *a = *b;
        *b = tmp;
    }
}

使用和测试性能：

1
2
3
4
5
6
7
8
9
10
11
var perms = new Permutations();

var sw1 = Stopwatch.StartNew();

perms.Permutate(0,
                11,
                (Action<int[]>)null); // Comment this line and...
                //PrintArr); // Uncomment this line, to print permutations

sw1.Stop();
Console.WriteLine(sw1.Elapsed);

打印方法：

1
2
3
4
private static void PrintArr(int[] arr)
{
    Console.WriteLine(string.Join(",", arr));
}

深入：

我甚至很久没有考虑过这个问题，所以我只能解释我的代码，但总的来说：

  • 排列不是词典-这让我实际上可以在排列之间执行较少的操作。
  • 实现是递归的，当"视图"的大小为3时，它跳过复杂的逻辑，只执行6个交换来获取6个排列(或者子排列，如果愿意的话)。
  • 因为排列不在词典编纂的顺序中，我如何决定将哪个元素带到当前"视图"(子排列)的开头？在当前的子排列递归调用中，我保存了已经用作"启动器"的元素的记录，并简单地线性搜索数组尾部没有使用的元素。
  • 该实现仅用于整数，因此要对元素的一般集合进行排列，只需使用排列类来排列索引，而不是实际的集合。
  • 互斥对象的存在只是为了确保在异步执行时不会出错(请注意，您可以传递一个非安全参数，该参数将反过来获得指向排列数组的指针)。不能更改该数组(指针)中元素的顺序！如果您想，您应该将数组复制到tmp数组，或者只使用安全操作参数，它为您处理这个问题-传递的数组已经是一个副本)。

    • 注：

    我不知道这个实现到底有多好——我很久没接触过它了。单独测试和比较其他实现，如果您有任何反馈，请告诉我！

    享受。

    相关讨论

    这里是一个通用的排列查找工具，它将遍历集合的每个排列并调用一个计算函数。如果Evaluation函数返回true(它找到了它正在寻找的答案)，排列查找器将停止处理。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    public class PermutationFinder<T>
    {
        private T[] items;
        private Predicate<T[]> SuccessFunc;
        private bool success = false;
        private int itemsCount;

        public void Evaluate(T[] items, Predicate<T[]> SuccessFunc)
        {
            this.items = items;
            this.SuccessFunc = SuccessFunc;
            this.itemsCount = items.Count();

            Recurse(0);
        }

        private void Recurse(int index)
        {
            T tmp;

            if (index == itemsCount)
                success = SuccessFunc(items);
            else
            {
                for (int i = index; i < itemsCount; i++)
                {
                    tmp = items[index];
                    items[index] = items[i];
                    items[i] = tmp;

                    Recurse(index + 1);

                    if (success)
                        break;

                    tmp = items[index];
                    items[index] = items[i];
                    items[i] = tmp;
                }
            }
        }
    }

    下面是一个简单的实现：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    class Program
    {
        static void Main(string[] args)
        {
            new Program().Start();
        }

        void Start()
        {
            string[] items = new string[5];
            items[0] ="A";
            items[1] ="B";
            items[2] ="C";
            items[3] ="D";
            items[4] ="E";
            new PermutationFinder<string>().Evaluate(items, Evaluate);
            Console.ReadLine();
        }

        public bool Evaluate(string[] items)
        {
            Console.WriteLine(string.Format("{0},{1},{2},{3},{4}", items[0], items[1], items[2], items[3], items[4]));
            bool someCondition = false;

            if (someCondition)
                return true;  // Tell the permutation finder to stop.

            return false;
        }
    }
    相关讨论

    (P)Update 2018-05-28，a new version，the fasstest…(Multi-Threated)(p)(P)字母名称(p)字母名称(P)Need:Sani Singh Huttunen(Fastest Lexico)Solution and my new ouelletlexico3 which support indexing(p)(P)Indexing has 2 main advantages：(p)

    • Allows to get any permutation directly
    • Allows multi-threading(derived from the first advantage)

    (P)Article：互换交易：fast implementations and a new indexing algorithm allowing multithreading(p)(P)On my machine(6 hyperthreed cores：12 threads)Xeon [email protected]，tests algorithms running with empty studff to do for 13！Items(Time in Millises)：(p)

    • 53071：Ouellet(Implementation of Heap)
    • 65366:Sani Singh Huttunen(Fastest Lexico)
    • 11377：Mix Ouelletlexico3-Sani Singh Huttunen

    (P)a side note：using shares properties/variables between threads for permutation action will strongly impact performance if their usage is modification(read/write).这样做会在三个威胁之间产生"错误共享"。你不会得到预期的表现。我得到了这个行为while testing。我的经验所涉及的问题是，当我努力增加全球变量以计算总的兑换率时。(p)(P)USAGE：(p)字母名称(P)Code:(p)字母名称

    相关讨论

    这里是一个基于数组元素交换的复杂度为O(n * n!)1的递归实现。数组是用来自1, 2, ..., n的值初始化的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    using System;

    namespace Exercise
    {
    class Permutations
    {
        static void Main(string[] args)
        {
            int setSize = 3;
            FindPermutations(setSize);
        }
        //-----------------------------------------------------------------------------
        /* Method: FindPermutations(n) */
        private static void FindPermutations(int n)
        {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++)
            {
                arr[i] = i + 1;
            }
            int iEnd = arr.Length - 1;
            Permute(arr, iEnd);
        }
        //-----------------------------------------------------------------------------  
        /* Method: Permute(arr) */
        private static void Permute(int[] arr, int iEnd)
        {
            if (iEnd == 0)
            {
                PrintArray(arr);
                return;
            }

            Permute(arr, iEnd - 1);
            for (int i = 0; i < iEnd; i++)
            {
                swap(ref arr[i], ref arr[iEnd]);
                Permute(arr, iEnd - 1);
                swap(ref arr[i], ref arr[iEnd]);
            }
        }
    }
    }

    在每一个递归步骤中，我们将最后一个元素与for循环中局部变量指向的当前元素交换，然后通过增加for循环的局部变量和减少for循环的终止条件来表示交换的唯一性，该循环最初设置为num。数组中元素的误码率，当后者变为零时，我们终止递归。

    以下是助手函数：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
        //-----------------------------------------------------------------------------
        /*
            Method: PrintArray()

        */
        private static void PrintArray(int[] arr, string label ="")
        {
            Console.WriteLine(label);
            Console.Write("{");
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i]);
                if (i < arr.Length - 1)
                {
                    Console.Write(",");
                }
            }
            Console.WriteLine("}");
        }
        //-----------------------------------------------------------------------------

        /*
            Method: swap(ref int a, ref int b)

        */
        private static void swap(ref int a, ref int b)
        {
            int temp = a;
            a = b;
            b = temp;
        }

    1。要打印的n元素有n!排列。

    相关讨论

    Steven Skiena的算法设计手册(第二版第14.4章)中有一个关于算法和实现调查的可访问的介绍。

    斯基纳参考D.Knuth。计算机编程艺术，第4卷第2分册：生成所有元组和排列。Addison-Wesley，2005年。

    相关讨论

    如果真的有数量级的改进，我会感到惊讶。如果有，那么C需要根本性的改进。此外，对排列进行任何有趣的操作通常要比生成它花费更多的工作。因此，发电成本在总体方案中是微不足道的。

    也就是说，我建议尝试以下几点。您已经尝试了迭代器。但是您是否尝试过让一个函数接受一个闭包作为输入，然后为找到的每个排列调用这个闭包？根据C的内部力学，这可能更快。

    同样，您是否尝试过让一个函数返回一个将迭代特定排列的闭包？

    无论采用哪种方法，都可以进行许多微优化实验。例如，您可以对输入数组进行排序，然后始终知道它的顺序。例如，您可以有一个bools数组，指示该元素是否小于下一个元素，并且您可以只查看该数组而不进行比较。

    相关讨论

    我创建了一个比Knuth的算法稍快的算法：

    11 elements:

    mine: 0.39 seconds

    Knuth's: 0.624 seconds

    13 elements:

    mine: 56.615 seconds

    Knuth's: 98.681 seconds

    以下是我在Java中的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    public static void main(String[] args)
    {
        int n=11;
        int a,b,c,i,tmp;
        int end=(int)Math.floor(n/2);
        int[][] pos = new int[end+1][2];
        int[] perm = new int[n];

        for(i=0;i<n;i++) perm[i]=i;

        while(true)
        {
            //this is where you can use the permutations (perm)
            i=0;
            c=n;

            while(pos[i][1]==c-2 && pos[i][0]==c-1)
            {
                pos[i][0]=0;
                pos[i][1]=0;
                i++;
                c-=2;
            }

            if(i==end) System.exit(0);

            a=(pos[i][0]+1)%c+i;
            b=pos[i][0]+i;

            tmp=perm[b];
            perm[b]=perm[a];
            perm[a]=tmp;

            if(pos[i][0]==c-1)
            {
                pos[i][0]=0;
                pos[i][1]++;
            }
            else
            {
                pos[i][0]++;
            }
        }
    }

    问题是我的算法只适用于奇数个元素。我很快就写了这段代码，所以我很确定有更好的方法来实现我的想法以获得更好的性能，但我现在没有时间来优化它，并在元素数量相等时解决问题。

    它是每个排列的一个交换，它使用一种非常简单的方法来知道要交换哪些元素。

    我在我的博客上写了一个关于代码背后的方法的解释：http://antoinecomeau.blogspot.ca/2015/01/fast-generation-of-all-permutations.html

    相关讨论

    作为这个问题的作者，他问的是一个算法：

    [...] generating a single permutation, at a time, and continuing only if necessary

    我建议考虑Steinhaus–Johnson–Trotter算法。

    Steinhaus–Johnson–Trotter算法(维基百科)

    这里解释得很好

    现在是凌晨1点，我在看电视，想到了同样的问题，但用的是字符串值。

    给一个词，找出所有排列。您可以很容易地修改它来处理数组、集合等。

    我花了点时间想出来，但我想到的解决办法是：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    string word ="abcd";

    List<string> combinations = new List<string>();

    for(int i=0; i<word.Length; i++)
    {
        for (int j = 0; j < word.Length; j++)
        {
            if (i < j)
                combinations.Add(word[i] + word.Substring(j) + word.Substring(0, i) + word.Substring(i + 1, j - (i + 1)));
            else if (i > j)
            {
                if(i== word.Length -1)
                    combinations.Add(word[i] + word.Substring(0, i));
                else
                    combinations.Add(word[i] + word.Substring(0, i) + word.Substring(i + 1));
            }
        }
    }

    这里有与上面相同的代码，但是有一些注释

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    string word ="abcd";

    List<string> combinations = new List<string>();

    //i is the first letter of the new word combination
    for(int i=0; i<word.Length; i++)
    {
        for (int j = 0; j < word.Length; j++)
        {
            //add the first letter of the word, j is past i so we can get all the letters from j to the end
            //then add all the letters from the front to i, then skip over i (since we already added that as the beginning of the word)
            //and get the remaining letters from i+1 to right before j.
            if (i < j)
                combinations.Add(word[i] + word.Substring(j) + word.Substring(0, i) + word.Substring(i + 1, j - (i + 1)));
            else if (i > j)
            {
                //if we're at the very last word no need to get the letters after i
                if(i== word.Length -1)
                    combinations.Add(word[i] + word.Substring(0, i));
                //add i as the first letter of the word, then get all the letters up to i, skip i, and then add all the lettes after i
                else
                    combinations.Add(word[i] + word.Substring(0, i) + word.Substring(i + 1));

            }
        }
    }

    我在罗塞塔密码上找到了这个算法，它真的是我试过的最快的一个。http://rosettacode.org/wiki/permutations c

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    /* Boothroyd method; exactly N! swaps, about as fast as it gets */
    void boothroyd(int *x, int n, int nn, int callback(int *, int))
    {
        int c = 0, i, t;
        while (1) {
            if (n > 2) boothroyd(x, n - 1, nn, callback);
            if (c >= n - 1) return;
     
            i = (n & 1) ? 0 : c;
            c++;
            t = x[n - 1], x[n - 1] = x[i], x[i] = t;
            if (callback) callback(x, nn);
        }
    }
     
    /* entry for Boothroyd method */
    void perm2(int *x, int n, int callback(int*, int))
    {
        if (callback) callback(x, n);
        boothroyd(x, n, n, callback);
    }

    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    //+------------------------------------------------------------------+
    //|                                                                  |
    //+------------------------------------------------------------------+
    /**
     * http://marknelson.us/2002/03/01/next-permutation/
     * Rearranges the elements into the lexicographically next greater permutation and returns true.
     * When there are no more greater permutations left, the function eventually returns false.
     */

    // next lexicographical permutation

    template <typename T>
    bool next_permutation(T &arr[], int firstIndex, int lastIndex)
    {
        int i = lastIndex;
        while (i > firstIndex)
        {
            int ii = i--;
            T curr = arr[i];
            if (curr < arr[ii])
            {
                int j = lastIndex;
                while (arr[j] <= curr) j--;
                Swap(arr[i], arr[j]);
                while (ii < lastIndex)
                    Swap(arr[ii++], arr[lastIndex--]);
                return true;
            }
        }
        return false;
    }

    //+------------------------------------------------------------------+
    //|                                                                  |
    //+------------------------------------------------------------------+
    /**
     * Swaps two variables or two array elements.
     * using references/pointers to speed up swapping.
     */
    template<typename T>
    void Swap(T &var1, T &var2)
    {
        T temp;
        temp = var1;
        var1 = var2;
        var2 = temp;
    }

    //+------------------------------------------------------------------+
    //|                                                                  |
    //+------------------------------------------------------------------+
    // driver program to test above function
    #define N 3

    void OnStart()
    {
        int i, x[N];
        for (i = 0; i < N; i++) x[i] = i + 1;

        printf("The %i! possible permutations with %i elements:", N, N);

        do
        {
            printf("%s", ArrayToString(x));

        } while (next_permutation(x, 0, N - 1));

    }

    // Output:
    // The 3! possible permutations with 3 elements:
    //"1,2,3"
    //"1,3,2"
    //"2,1,3"
    //"2,3,1"
    //"3,1,2"
    //"3,2,1"

    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    // Permutations are the different ordered arrangements of an n-element
    // array. An n-element array has exactly n! full-length permutations.

    // This iterator object allows to iterate all full length permutations
    // one by one of an array of n distinct elements.

    // The iterator changes the given array in-place.

    // Permutations('ABCD') => ABCD  DBAC  ACDB  DCBA
    //                         BACD  BDAC  CADB  CDBA
    //                         CABD  ADBC  DACB  BDCA
    //                         ACBD  DABC  ADCB  DBCA
    //                         BCAD  BADC  CDAB  CBDA
    //                         CBAD  ABDC  DCAB  BCDA

    // count of permutations = n!

    // Heap's algorithm (Single swap per permutation)
    // http://www.quickperm.org/quickperm.php
    // https://stackoverflow.com/a/36634935/4208440
    // https://en.wikipedia.org/wiki/Heap%27s_algorithm


    // My implementation of Heap's algorithm:

    template<typename T>
    class PermutationsIterator
    {
        int b, e, n;
        int c[32];  /* control array: mixed radix number in rising factorial base.
                    the i-th digit has base i, which means that the digit must be
                    strictly less than i. The first digit is always 0,  the second
                    can be 0 or 1, the third 0, 1 or 2, and so on.
                    ArrayResize isn't strictly necessary, int c[32] would suffice
                    for most practical purposes. Also, it is much faster */

    public:
        PermutationsIterator(T &arr[], int firstIndex, int lastIndex)
        {
            this.b = firstIndex;  // v.begin()
            this.e = lastIndex;   // v.end()
            this.n = e - b + 1;

            ArrayInitialize(c, 0);
        }

        // Rearranges the input array into the next permutation and returns true.
        // When there are no more permutations left, the function returns false.

        bool next(T &arr[])
        {
            // find index to update
            int i = 1;

            // reset all the previous indices that reached the maximum possible values
            while (c[i] == i)
            {
                c[i] = 0;
                ++i;
            }

            // no more permutations left
            if (i == n)
                return false;

            // generate next permutation
            int j = (i & 1) == 1 ? c[i] : 0;    // IF i is odd then j = c[i] otherwise j = 0.
            swap(arr[b + j], arr[b + i]);       // generate a new permutation from previous permutation using a single swap

            // Increment that index
            ++c[i];
            return true;
        }

    };

    如果你只想计算可能的排列数目，你可以避免上面所有的艰苦工作，并使用类似的东西(在C中设计的)：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public static class ContrivedUtils
    {
        public static Int64 Permutations(char[] array)
        {
            if (null == array || array.Length == 0) return 0;

            Int64 permutations = array.Length;

            for (var pos = permutations; pos > 1; pos--)
                permutations *= pos - 1;

            return permutations;
        }
    }

    你这样称呼它：

    1
    2
    3
    4
    var permutations = ContrivedUtils.Permutations("1234".ToCharArray());
    // output is: 24
    var permutations = ContrivedUtils.Permutations("123456789".ToCharArray());
    // output is: 362880
    相关讨论