看了几天置换群，一直没搞清楚定义是怎么回事，一个置换可以写成若干循环的乘积，那么如果置换求幂的话，一个循环不会跑到另一个循环里面去。
我们可以简单理解为这几个位置的数来回换。
poj3270
给出一列数，求将这列数排成升序的最小花费，这里花费定义为交换两个数的和。
例如给出一排数8 4 5 3 2 7，那么我们最终的状态为2 3 4 5 7 8，这里的轮换有（8 2 7）（4 5 3），这里8应该在第六个位置，
而第6个位置是7,7应该在5这个位置，而第5个位置为2,2应该在1这个位置，这样就到了8所在的位置，我们称这是一个轮换。
首先需要明确的一点是对于每个群，假设有k个数，那么我们需要交换k-1次得到升序。
对于每一个群，我们有两种换发：
1.群里换，拿群里最小的数t与其他每个数交换，共k-1次,花费为：sum+(k-2)*t.
2.将这个数列最小的数m，拉入这个群，与该群最小的数t交换，然后用这个最小的数与其他数交换k-1次，然后再将m与t换回来，这样
花费为：sum+t+(k+1)m
那么最小花费我们取两者中最小的，即sum+min{(k-2)*t,t+(k+1)*m}.
对于这个题关键就是怎么确定每个群，我们利用计数排序，得到每个数应该在的位置，然后循环判断这个位置是否已经被访问了。时间
复杂度为O(n)
代码：
#include <iostream>
#include <stdio.h>
using namespace std;
const int N=100001;
const int INF=100000000;
int m[N],cnt[N+1];
bool used[N+1];
int main()
{
int n,i,j,tmp1,tmp2,len,t,maxValue,minValue,sum=0,curSum;
memset(cnt,0,sizeof(cnt));
memset(used,false,sizeof(used));
minValue=INF;
maxValue=0;
scanf("%d",&n);
for(i=1;i<=n;++i)
{
cin>>m[i];
cnt[m[i]]++;
if(m[i]<minValue)
minValue=m[i];
if(m[i]>maxValue)
maxValue=m[i];
}
//计数，得到每个数的位置，我们按照上面的那排数，得到的结果应该为6 3 4 2 1 5
for(i=1;i<=maxValue;++i)
cnt[i]=cnt[i]+cnt[i-1];
/* for(i=1;i<=n;++i)
cout<<cnt[m[i]]<<" ";
cout<<endl;
*/
for(i=1;i<=n;++i)
{
if(!used[i])
{
j=i;
t=m[i];
len=0;
curSum=0;
//首先1这个位置未访问，得到8这个数，找到8应该在的位置，是6,6这个位置未访问，得到数7，。。。依次类推
while(!used[j])
{
++len;
if(m[j]<t)
t=m[j];
curSum+=m[j];
used[j]=true;
j=cnt[m[j]];
}
if(1 < len)
sum+=curSum;
if(2<len)
{
tmp1=(len-2)*t;
tmp2=(len+1)*minValue+t;
if(tmp1 > tmp2)
tmp1=tmp2;
sum=sum+tmp1;
}
}
}
cout<<sum<<endl;
return 0;
}
poj2369
给出1-n的一个排列，a1,a2,...,an,表示P(1)=a1,P(2)=a2,...,P(n)=an,P(P(1))=P(a1),P(P(2))=P(a2),
...,P(P(n))=P(an).问经过多少次后使得P(1)=1,...,P(n)=n.
这个是置换群的概念题，找到每个循环节，确定其长度len1,len2,...,lenk,求他们的最小公倍数。
对于题目中给定的一个例子进行分析：
1 2 3 4 5
4 1 5 2 3
上面定义了函数P，那么我们可以看出这个置换可以写成(1 4 2)(3 5),这样循环1中的数绝对不会跑到第二个循环中，每个循环i需要经过leni次后就可以到达目的状态，所以我们只需要确定各个循环节长度的最小公倍数。
poj1026
首先给出一个置换，然后给出一个字符串，问置换k次之后得到的字符串是什么？
我们求出来子循环，然后对每个子循环计算k次之后置换群变成什么排列，用b[0],b[1],...,b[t-1]表示一个子群，那么长度为t,经过一次置换后变成b[0]=b[1],b[1]=b[2],..,b[t-1]=b[0],所以经过k次后变成
b[(0+k)%t],b[(1+k)%t],..,b[(t-1+k)%t],即b[i]->b[(i+k)%t].
代码:
#include <iostream>
#include <stdio.h>
using namespace std;
const int N=201;
int a[N],b[N],c[N];
bool visit[N];
char message[N],rs[N];
int main()
{
int n,k,i,j,t;
while(1)
{
cin>>n;
if(!n)
break;
for(i=0;i<n;++i)
{
cin>>a[i];
--a[i];
}
while(cin>>k)
{
if(!k)
break;
memset(message,'\0',sizeof(message));
memset(rs,'\0',sizeof(rs));
memset(visit,0,sizeof(visit));
getchar();
cin.getline(message,N,'\n');
int len=strlen(message);
if(len<N)
{
for(i=len;i<n;++i)
message[i]=' ';
}
for(i=0;i<n;++i)
{
j=i;
t=0;
if(!visit[j])
{
while(!visit[j])
{
visit[j]=true;
b[t]=j;
t++;
j=a[j];
}
// for(j=0;j<t;++j)
// cout<<b[j]<<" ";
// cout<<endl;
for(j=0;j<t;++j)
{
// cout<<b[j]<<" "<<b[(j+k)%t]<<endl;
rs[b[(j+k)%t]]=message[b[j]];
}
}
}
cout<<rs<<endl;
}
cout<<endl;
}
return 0;
}
poj1721
洗牌机
给出洗牌规则，如果位置I上的牌是J，而且位置J上的牌是K，那么通过洗牌机后位置I上的牌将是K。
首先给出初始顺序a1,a2,...,an,在位置ai处放置ai+1,得到初始序列为x1,x2,...,xn，经过s次洗牌之后，得到新的序列p1,p2,...,pn,现在给出最终序列即s，让我们求xi。这个完全可以用模拟来做，但是时间复杂度可能会高，我们可以求出循环节t，那么s=s%t之后，我们在进行洗n-s次就可以了。
#include <iostream>
using namespace std;
const int N=1001;
int a[N],b[N],m[N];
int main()
{
int i,n,s,j,t;
cin>>n>>s;
for(i=1;i<=n;++i)
{
scanf("%d",&a[i]);
m[i]=a[i];
}
// memset(used,0,sizeof(used));
//找到循环节
t=0;
bool flag;
while(1)
{
for(i=1;i<=n;++i)
b[i]=a[a[i]];
++t;
flag=true;
for(i=1;i<=n;++i)
{
if(b[i]!=m[i])
{
flag=false;
break;
}
}
if(flag)
break;
for(i=1;i<=n;++i)
a[i]=b[i];
}
s=s%t;
t=t-s;
for(i=1;i<=n;++i)
a[i]=b[i];
while(t--)
{
for(i=1;i<=n;++i)
b[i]=a[a[i]];
for(i=1;i<=n;++i)
a[i]=b[i];
}
for(j=1;j<=n;++j)
printf("%d\n",b[j]);
return 0;
}