转成有序数组的最少交换次数

问题描述：

有一个1~n的数列的排列，但是这个数列已经被打乱了排列顺序，如果我们只是通过“交换任意两个元素”，那么，要实现元素从1~n的有序排列，“最少的交换次数是多少？”

解答过程：

首先我们纸上可以先写写简单的情况试试，比如排列：4 3 1 2， 交换次数=3；我们可以在多组测试中，边测试边想，真正的实现需要满足：4本该到2处， 2本该到3处， 3本该到1处， 1本该到4处，刚好一个循环。

于是，考虑：

引理：是否对于满足这种一个循环的排列，最少交换次数等于元素个数减去1呢？

可以考虑数学归纳法。

首先k=1,2,3时我们可以知道是成立的；

假设当 n <=k 时， 这种单循环排列的最少交换次数为n-1;

考虑n=k+1的情况： 这时，我们任意交换k+1个中的两个元素，会发现单循环分裂成了两个单循环（比如上述，4和1交换后，序列变成 1 3 4 2 此时 剩下了<1> 和 <3 4 2>两个子序列， <1>交换次数=0 <3 4 2>交换次数=2，那么总的交换是3次；如果我们交换1和2（本次交换没有任何一个元素归位），剩下的是序列4 3 2 1 ,是两个单循环序列<4 1>和<3 2>，总的交换还是1+（1+1) = 3  = 4 -1),那么接下来有两种做法：

方法1：对两个单循环序列分别执行递归调用，则最小交换次数为1 + （序列1的个数-1） + （序列2的个数-1） = 元素总数-1 

方法2：我们把分开的两个单循环序列进行合并交换，即序列1中的元素和序列2中元素交换，交换后新的合成序列出来了，这种交换将原始序列分开了又合并，白白交换了2次，剩下的序列还是k+1个单循环，这种交换显然不是最优的交换方式

由此看来，方法1的交换是通往最少交换的交换方式。

说明当n=k + 1时，我们按照方式1就可以更优的交换， 此时可以保证交换次数=k=n-1次

至此我们证明了：单循环序列，最少交换次数为n-1次。

考虑多个单循环序列的情况

由于不同的两个单循环序列合并交换称一个单循环序列时，有上述方法2可知其实是无效交换

所以，多个单循环序列的交换情况，就是每个单循环序列各自交换的次数的相加之和

比如 4 3 2 1 7 6 5

就是两个单循环序列<4 3 2 1> <7 6 5>的各自交换次数之和 = 3 + 2  = 5 = 7 - 单循环序列的个数

由此可知， 对于一个n长的互异序列， 通过交换实现有序的话，最优的交换次数是=n - n被分解成单循环的个数

明白了这个过程，代码自然都是浮云。。。

=============================================================

第一题：现在想通过交换相邻元素的操作把一个给定序列交换成有序，最少需要交换的次数是多少？比如3 1 2 4 5需要最少交换2次。

答案：需要交换的最少次数为该序列的逆序数。

证明：可以先将最大数交换到最后，由于是相邻两个数交换，需要交换的次数为最大数后面的数的个数（可以看做是最大数的逆序数），然后，交换过后，去除最大数，再考虑当前最大数也需要其逆序数次交换。则每个数都需要交换其逆序数次操作，则总最少交换次数为序列总体的逆序数。

第二题：现在想通过交换任意两个元素的操作把一个给定序列交换成有序，最少需要交换的次数是多少？

答案：我认为是数字的总个数减去循环节的个数。

循环节的求法是，先将数组排序，然后根据之前的坐标和排序之后的坐标，构建成一个有向图，然后在这个图上找到环

对于第二题有另一种方法：

http://blog.csdn.net/yysdsyl/article/details/4311031

e.g. { 2, 3, 1, 5, 6, 4}

231564 -> 6 mismatch 
two cycles -> 123 and 456 
swap 1,2 then 2,3, then 4,5 then 5,6 -> 4 swaps to sort 
 
Probably the easiest algorithm would be to use a bitarray. Initialize it to 0, then start at the first 0. Swap the number there to the right place and put a 1 there. Continue until the current place holds the right number. Then move on to the next 0 
 
Example: 
231564 
000000 
-> swap 2,3 
321564 
010000 
-> swap 3,1 
123564 
111000 
-> continue at next 0; swap 5,6 
123654 
111010 
-> swap 6,4 
123456 
111111 
-> bitarray is all 1's, so we're done. 

 

代码：

#include <iostream>
#include <algorithm>

using namespace std;

template <typename T>
int GetMinimumSwapsForSorted(T seq[], int n)
{
    bool* right_place_flag = new bool[n];
    T* sorted_seq = new T[n];
    int p ,q;
   
    copy(seq, seq + n, sorted_seq);
    sort(sorted_seq, sorted_seq + n);    可采用效率更高的排序算法
   
    for(int i = 0; i < n; i++)
    {
        if(seq[i] != sorted_seq[i])
            right_place_flag[i] = false;
        else
            right_place_flag[i] = true;
    }
   
    p = 0;
    int minimumswap = 0;
    while(1)
    {
        while(right_place_flag[p])
            p++;
        q = p + 1;
        此种找法只对无重复序列能得出minimum swaps
        while(q < n)
        {
            if(!right_place_flag[q] && sorted_seq[q] == seq[p])
                break;
            q++;
        }

        if(q >= n || p >= n)
            break;
        right_place_flag[q] = true;
        if(seq[q] == sorted_seq[p])
            right_place_flag[p] = true;
        swap(seq[p], seq[q]);
        minimumswap++;
    }

    delete[] sorted_seq;
    delete[] right_place_flag;

    return minimumswap;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int seq[] = {3, 2, 1, 5, 6, 8, 4, 7 };//{2,3,1,5,6,4};//{2,3,2,4,7,6,3,5};
    int n = sizeof(seq) / sizeof(int);
    cout<<"minimum swaps : "<<GetMinimumSwapsForSorted(seq, n)<<endl;

    system("pause");
 return 0;
}

也就是依次将元素放在其应该在的位置