POJ 3270 Cow Sorting（置换群）

题目链接

题意 ： N头牛，每个牛的坏脾气都有一个值，每个值都不相同，把这个值按照从小到大排序，如果两个值交换，那么会花掉这两个值之和的时间，让你花最少的时间将每个值从小到大排好序，求最小的总时间。

思路 ： 这个在黑书上有写，就是置换群，248页有写。写的挺详细的。每个状态都可以分为若干个循环的乘积。对于任意循环 i ，设其长度为ki，则至少需要交换ki-1次，即每次让一个元素到达目标位置，而当第ki-1个元素到达目标以后显然第ki个也已经到达目标。第一个方法是让循环中最小的元素t参加所有的交换，其他元素值参加一次，总花费为sum+（k-2）t。sum为循环中所有元素的和。

但是这个并不是最优的。

例如初始状态是2 3 1，目标状态是1 2 3，形成的下标数组是3 1 2。

1 2 3

3 1 2

这个置换对应的循环是(1 3 2)，只有一个循环节，交换的代价是1+3=4 1+2=3总代价是7

很明显我们是用(1 3 2)这个循环里的最小的数去和其他的数交换，这样能使最后的代价最小，并且一个循环的交换次数是k-1次，k 是这个循环包含的数的个数。

但是这种考虑的方法不一定是最优的，样例中只有一个循环节，若有多个循环节，我们可以用别的循环里的比这个循环里的所有的数小的数来和这个循环里的数来交换，付出的代价不一定比先前那种思路大，所以第二方面我们要考虑把所有数中最小的数与各个循环里最小的数交换，然后与前面那种思路付出的代价比较，取较小的那个。

公式就是ans=sum+∑(从1到n)min{(cnt-2)*t,t+(cnt+1)*m}

 //
 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <algorithm>

 using namespace std ;

 struct node
 {
     int position ;
     int level ;
 }a[];
 bool cmp(node c,node d)
 {
     return c.level < d.level;
 }
 int N,minn =  ;
 int ans ;
 bool vis[] ;

 void solve()
 {
     memset(vis,false ,sizeof(vis)) ;
     ans =  ;
     int cnt , t , sum ,pos ;
     for(int i =  ; i < N ; i++)
     {
         if(!vis[i])
         {
             vis[i] = true ;
             cnt =  ;
             t = sum = a[i].level ;
             pos = a[i].position ;
             while(pos != i)
             {
                 sum += a[pos].level ;
                 vis[pos] = true ;
                 t = min(t,a[pos].level) ;
                 pos = a[pos].position ;
                 cnt ++ ;
             }
             ans += sum + min((cnt-)*t,t+(cnt+)*minn) ;
         }
     }
     printf("%d\n",ans) ;
 }
 int main()
 {
     scanf("%d",&N) ;
     for(int i =  ; i < N ; i++)
     {
         a[i].position = i ;
         scanf("%d",&a[i].level) ;
         minn = min(minn,a[i].level) ;
     }
     sort(a,a+N,cmp) ;
     solve() ;
     return  ;
 }