Question

我有和数组可以获取任意数量的点，并且这些点被赋予索引。

然后我运行一个非递归解决方案来创建所有排列

它贯穿1,2,3,4,5,6,7,8,9,0，以0,9,8,7,6,5,4,3,2,1结尾这有时间复杂性

现在，我想找到这些排列的中间点这样我就可以从头开始和中间运行模式来减少时间复杂度。

我如何找到中间点？。

在Java中：

    public Path QuickPerm(int[] points) {
       int N = points.length;
       int a[] = points ;
       int p[] = new int[N];
       Path shortest = null;
       Path current = null;
       int i;
       int j;
       int tmp; // Upper Index i; Lower Index j
       for(int i1 = 0; i1 < N; i1++) {  
          p[i1] = 0;       // p[i] == i controls iteration and index boundaries for i
       }
       //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;
                                 //save 
             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)
       }
       return shortest;// while(i < N)
    } // QuickPerm()

Answer 1

http://en.wikipedia.org/wiki/Lehmer_code描述了一种对排列进行编号的方法，以便您可以自行决定采取一半的方式，找出它是什么排列。

根据您的线程的不同，您可能会发现并非所有排列都花费相同的时间，因此将排列列表分开一半并不能完全平衡工作。人们处理这个问题的一种方法是将工作分成大量的小块，让你的线程随时随地挑选一小部分工作。然后，如果某些工作需要比其他工作更长的时间并不重要 - 那些被它们困住的线程将最终只能处理少量的工件，但需要花费相同的时间。

Answer 2

使用使用lexico-order的next-permutation算法会让这件事变得简单，例如，维基百科： http://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographic_order

（检查中间索引的n的几个值，你会立即看到模式，例如1234，零索引序列中的元素12将是1243，而对于12345，元素60将是12354。）

分割多任务Java的排列

2 个答案: