poj3270 Cow Sorting

给定有序数组a[1...n]的一个置换a[σ(1)...σ(n)], 通过交换数组元素把置换后的数组恢复为有序，

定义进行一次交换的代价为两元素之和，试问此过程的最小总代价。

实际上一种置换即定义S = {1,...,n}到其自身的一个双射函数f。

可以证明必然存在整数k使得f^k = f0 = I。即存在周期性。

实际上此函数的幂存在局部周期性，即存在若干个互不相交循环单位，S中每个元素恰属于其中一个循环节。

例如考虑：f：u（1,2,3,4,5,6,7） -> v（3,6,7,5,1,2,4）

将循环单位极小化：（3,7,5,1,4）（6,2）。

循环节内的元素按其在v中的位置排列。

我们的目标是将其调整为（1,3,4,5,7）（2,6）。

循环节内的每一个元素都在不合适的位置上，因此长度为l循环节内部至少需要进行（l - 1）次互换可使其有序。

考虑长度为l的循环节：

由于所有元素均需要调整，因此循环节内部调整代价的一个下界是循环节内所有元素之和加上最小元素与交换次数的乘积。

可以达到该下界：

例考虑调整（3,7,5,1,4），由于1占据了5应该所处的位置，（5,1）交换得到（3,7,1,5,4）。

如此不断迭代将其整理为有序所需代价为min_value * (l - 2) + sum_value（*）。

由于循环节内部调整相互独立，即可以分步进行，考虑利用非循环节内部元素进一步降低代价。

交换循环节外部一元素a（取最小的元素显然更优）和循环节内部一元素b，如此总代价为：

2 * (a + b) + a * (l - 2) + sum_value - b + a = b + a * (l + 1) + sum_value（#），

由于a取外部最小值，b取内部最小值，（#）可能会优于（*）。

（#）-（*) = a * (l + 1) - (l - 3) * b = (l + 1) * (a - b) + 4 * b,

由于已经引入全局最小值，若再次交换则必有a > b，只会增加代价。

因此最多交换一次。

这样本题就可以给出答案了。

http://poj.org/problem?id=3270

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 const int maxn = 1e4 + ;
 const int inf = 0x3f3f3f3f;
 int f[maxn];
 int a[maxn], n, mini;
 bool vis[maxn];

 void solve(){
     memset(vis, , sizeof vis);
     int ans = ;
     for(int i = ; i < n; i++){
         if(vis[i]) continue;
         vis[i] = ;
         int len = , minii = a[i], sum = a[i];
         int j = f[i];
         while(j != i){
             vis[j] = ;
             sum += a[j];
             ++len;
             minii = min(minii, a[j]);
             j = f[j];
         }
         ans += (len - ) * minii + sum + min(, (len + ) * (mini - minii) +  * minii);
     }
     printf("%d\n", ans);
 }

 bool cmp1(int u, int v) { return a[u] < a[v]; }

 int main(){
     freopen("in.txt", "r", stdin);
     while(~scanf("%d", &n)){
         mini = inf;
         for(int i = ; i < n; i++){
             scanf("%d", &a[i]);
             mini = min(a[i], mini);
         }
         for(int i = ; i < n; i++) f[i] = i;
         sort(f, f + n, cmp1);
         solve();
     }
     return ;
 }