問題描述：

有一個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次。

答案：需要交換的最少次數為該序列的逆序數。

證明：可以先將最大數交換到最後，由於是相鄰兩個數交換，需要交換的次數為最大數後面的數的個數（可以看做是最大數的逆序數），然後，交換過後，去除最大數，再考慮當前最大數也需要其逆序數次交換。則每個數都需要交換其逆序數次操作，則總最少交換次數為序列總體的逆序數。

第二題：現在想通過交換任意兩個元素的操作把一個給定序列交換成有序，最少需要交換的次數是多少？

答案：我認為是數字的總個數減去迴圈節的個數。

對於第二題有另一種方法：

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;
}

也就是依次將元素放在其應該在的位置