poj3270(置换群)

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

Cow Sorting

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 4811		Accepted: 1759

Description

Farmer John's N (1 ≤ N ≤ 10,000) cows are lined up to be milked in the evening. Each cow has a unique "grumpiness" level in the range 1...100,000. Since grumpy cows are more likely to damage FJ's milking equipment, FJ would like to reorder the cows in line so they are lined up in increasing order of grumpiness. During this process, the places of any two cows (not necessarily adjacent) can be interchanged. Since grumpy cows are harder to move, it takes FJ a total of X+Y units of time to exchange two cows whose grumpiness levels are X and Y.

Please help FJ calculate the minimal time required to reorder the cows.

Input

Line 1: A single integer: N.
Lines 2.. N+1: Each line contains a single integer: line i+1 describes the grumpiness of cow i.

Output

Line 1: A single line with the minimal time required to reorder the cows in increasing order of grumpiness.

Sample Input

3
2
3
1

Sample Output

7

Hint

2 3 1 : Initial order.
2 1 3 : After interchanging cows with grumpiness 3 and 1 (time=1+3=4).
1 2 3 : After interchanging cows with grumpiness 1 and 2 (time=2+1=3).

Source

USACO 2007 February Gold

来自网上：

http://www.cnblogs.com/DreamUp/archive/2010/08/17/1801700.html

置换，置换的运算

置换的概念还是比较好理解的，《组合数学》里面有讲。对于置换的幂运算大家可以参考一下潘震皓的那篇《置换群快速幂运算研究与探讨》，写的很好。

结论一：一个长度为l的循环T，l是k的倍数，则T^k是k个循环的乘积，每个循环分别是循环T中下标i mod k=0,1,2…的元素按顺序的连接。

结论二：一个长度为l的循环T，gcd(l,k)=1，则T^k是一个循环，与循环T不一定相同。

结论三：一个长度为l的循环T，T^k是m=gcd(l,k)个循环的乘积，每个循环分别是循环T中下标i mod gcd(l,k)=0,1,2…的元素的连接。

如果长度与指数不互质，单个循环就没有办法来开方。不过，我们可以选择相应m个长度相同的循环交错合并来完成开方的过程。可在这种情况下，如果找不到m个长度相同的循环，那就一定不能开方。其中：m是gcd(l,k)的倍数

*简单题：（应该理解概念就可以了）

# pku3270 Cow Sorting

题目描述：

给你一个数字序列（每个数字唯一），每次你可以交换任意两个数字，代价为这两个数字的和，问最少用多少代价能把这个序列按升序排列好。

题目的具体做法是参考刘汝佳的《算法艺术与信息学奥赛》大概思路是：以后再用别种方法解，
1.找出初始状态和目标状态。明显，目标状态就是排序后的状态。
2.画出置换群，在里面找循环。例如，数字是8 4 5 3 2 7
明显， 目标状态是2 3 4 5 7 8，能写为两个循环：(8 2 7)(4 3 5)。
3.观察其中一个循环，明显地，要使交换代价最小，应该用循环里面最小的数字2，去与另外的两个数字，7与8交换。这样交换的代价是：
sum - min + (len - 1) * min
化简后为：
sum + (len - 2) * min
其中，sum为这个循环所有数字的和，len为长度，min为这个环里面最小的数字。

4.考虑到另外一种情况，我们可以从别的循环里面调一个数字，进入这个循环之中，使交换代价更小。例如初始状态：1 8 9 7 6
可分解为两个循环：(1)(8 6 9 7)，明显，第二个循环为(8 6 9 7)，最小的数字为6。我们可以抽调整个数列最小的数字1进入这个循环。使第二个循环变为：(8 1 9 7)。让这个1完成任务后，再和6交换，让6重新回到循环之后。这样做的代价明显是：
sum + min + (len + 1) * smallest
其中，sum为这个循环所有数字的和，len为长度，min为这个环里面最小的数字，smallest是整个数列最小的数字。

5.因此，对一个循环的排序，其代价是sum - min + (len - 1) * min和sum + min + (len + 1) * smallest之中小的那个数字。但这里两个公式还不知道怎么推出来的。
6.我们在计算循环的时候，不需要记录这个循环的所有元素，只需要记录这个循环的最小的数及其和。

7.在储存数目的时候，我们可以使用一个hash结构，将元素及其位置对应起来，以达到知道元素，可以快速反查元素位置的目的。这样就不必要一个个去搜索。

#include
#include
#include
#include
using namespace std;
#define maxn 100010
int a[maxn],b[maxn],hash[maxn];
int vis[maxn];
__int64 ans,ans1,ans2,sum;
int main()
{
      int i,len,min,n;
      int start,id;
      while(scanf("%d",&n)!=EOF)
      {
              memset(vis,0,sizeof(vis));
              for(i=0;i
              {
                      scanf("%d",&a[i]);
                      b[i]=a[i];
              }
              sort(b,b+n);
              for(i=0;i
              {
                      hash[b[i]]=i;
              }
              ans=0;
              for(i=0;i
              {
                      len=0;
                      sum=0;
                      min=10000000;
                      start=a[i];
                      id=i;
                      if(!vis[i])
                      {
                              while(1)
                              {
                                      sum+=start;
                                    // printf("sum=%I64d\n",sum);
                                      vis[id]=1;
                                      if(min>start)
                                      {
                                              min=start;
                                      }
                                      id=hash[start];
                                      start=a[id];
                                      len++;
                                      if(start==a[i])
                                      {
                                              break;
                                      }
                              }
                              ans1=sum-min+(len-1)*min;
                              ans2=sum+min+(len+1)*b[0];
                              ans+=ans1
                      }
              }
              printf("%I64d\n",ans);
      }
      return 0;
}