一、逆序对系列问题
题目:http://poj.org/problem?id=1804
题意:给定一个序列a[],每次只允许交换相邻两个数,最少要交换多少次才能把它变成非递降序列.
求逆序对的裸题。
如果我们交换相邻两个数，我们逆序对的个数只能是+1或-1
我们现在需要得到一个非递减数列，即消去所有逆序对，
而我们需要最少交换次数，即统计原数组中逆序对个数。
对于一个序列中，有Ai>Aj，i<j的两个元素，我们把这个二元组称为逆序对
有常见的三种方法求逆序对
1.n^2的冒泡
2.树状数组
可以把数一个个插入到树状数组中,每插入一个数,统计比他小的数的个数，对应的逆序为 i- getsum(data[i])，其中 i 为当前已经插入的数的个数， getsum(data[i])为比 data[i] 小的数的个数,i-getsum(data[i])即比 data[i] 大的个数,即逆序的个数。最后需要把所有逆序数求和,就是在插入的过程中边插入边求和。
const maxn=200001;
var val,hash,tree:array [0..maxn] of longint;
n:longint;
function lowbit(x:longint):longint;
begin
exit(x and (-x));
end;
function getsum(pos:longint):longint;
var ans:longint;
begin
ans:=0;
while pos>0 do
begin
inc(ans,tree[pos]);
dec(pos,lowbit(pos));
end;
exit(ans);
end;
procedure modify(pos:longint);
begin
while pos<=n do
begin
inc(tree[pos]);
inc(pos,lowbit(pos));
end;
end;
procedure qsort(l,r:longint);
var i,j,t,p:longint;
begin
if l>=r then exit;
i:=random(r-l+1)+l;
t:=val[i]; p:=hash[i];
val[i]:=val[l]; hash[i]:=hash[l];
i:=l; j:=r;
while i<j do
begin
while (i<j) and (t<val[j]) do dec(j);
if i=j then break;
val[i]:=val[j]; hash[i]:=hash[j];
inc(i);
while (i<j) and (val[i]<t) do inc(i);
if i=j then break;
val[j]:=val[i]; hash[j]:=hash[i];
dec(j);
end;
val[i]:=t; hash[i]:=p;
qsort(l,i-1);
qsort(i+1,r);
end;
procedure main;
var i,ans,m:longint;
begin
ans:=0; m:=0;
randomize;
read(n);
for i:=1 to n do
begin
read(val[i]);
hash[i]:=i;
end;
qsort(1,n);
tree:=val;
for i:=1 to n do
if tree[i]<>tree[i-1] then
begin
inc(m);
val[hash[i]]:=m;
end
else val[hash[i]]:=m;
fillchar(tree,sizeof(tree),0);
for i:=1 to n do
begin
inc(ans,getsum(m)-getsum(val[i]));
modify(val[i]);
end;
writeln(ans);
end;
begin
main;
end.
3.归并排序
实际上归并排序的交换次数就是这个数组的逆序对个数，为什么呢？
我们可以这样考虑：
归并排序是将数列a[l,h]分成两半a[l,mid]和a[mid+1,h]分别进行归并排序，然后再将这两半合并起来。
在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在
前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并排序中的合并过程中计算逆序数.
在合并的时候设左数组为1~x,右数组为x+1~y，则当a[i]<a[j]，(1<=i<=x,x+1<=j<=y)必定有a[i]>a[x+1]~a[j-1]，于是它们都是逆序对。
const maxn=100001;
var val,hash:array [0..maxn] of longint;
ans:longint;
procedure merge(l,mid,r:longint);
var i,j,k:longint;
begin
i:=l; j:=m+1; k:=l;
while (i<=m) and (j<=r) do
begin
if val[i]>val[j] then
begin
hash[k]:=val[j];
inc(k);
inc(j);
inc(ans,m-i+1);
end
else
begin
hash[k]:=val[i];
inc(k);
inc(i);
end;
end;
end;
procedure merge_sort(l,r:longint);
var mid:longint;
begin
if l<r then
begin
mid:=(l+r)>>1;
merge_sort(l,mid);
merge_sort(mid+1,r);
merge(l,mid,r);
end;
end;
procedure main;
var i,n:longint;
begin
read(n);
for i:=1 to n do
read(a[i]);
merge_sort(1,n);
writeln(ans);
end;
begin
main;
end.
二、置换群系列问题
题目:http://poj.org/problem?id=3270
题意:给定一个序列a[],每次只允许交换任意两个数,最少要交换多少次才能把它变成非递降序列.
看上去跟逆序对很像，但是我们发现，我们每交换一次，可能减少很多逆序对
所以显然不是统计逆序对的题目。
怎么搞呢？
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之中小的那个数字。
置换群是啥？
一个置换可以写成若干循环的乘积，那么如果置换求幂的话，一个循环不会跑到另一个循环里面去。
我们可以简单理解为这几个位置的数来回换。
const maxn=100001;
type node=record
val,cnt:longint;
end;
var n,minvalue:longint;
sum,tot:int64;
m,t:array [0..maxn] of longint;
flag:array [0..maxn] of boolean;
a:array [0..maxn] of node;
function min(x,y:longint):longint; inline;
begin
if x<y then exit(x)
else exit(y);
end;
procedure find(x:longint); inline;
var i:longint;
begin
for i:=0 to n-1 do
begin
if (t[i]=x) and (not flag[i]) then
begin
flag[i]:=true;
inc(a[tot].cnt);
a[tot].val:=min(a[tot].val,t[i]);
find(m[i]);
end;
end;
end;
procedure qsort(l,r:longint); inline;
var i,j,x,y:longint;
begin
i:=l; j:=r; x:=m[(l+r)>>1];
repeat
while m[i]<x do inc(i);
while m[j]>x do dec(j);
if i<=j then
begin
y:=m[i];
m[i]:=m[j];
m[j]:=y;
inc(i);
dec(j);
end;
until i>j;
if i<r then qsort(i,r);
if l<j then qsort(l,j);
end;
procedure main;
var i:longint;
begin
read(n);
minvalue:=maxlongint;
for i:=0 to n-1 do
begin
read(m[i]);
inc(sum,m[i]);
t[i]:=m[i];
minvalue:=min(minvalue,m[i]);
end;
qsort(0,n-1);
tot:=0;
for i:=0 to n-1 do
begin
if flag[i] then continue;
a[tot].val:=t[i];
a[tot].cnt:=1;
flag[i]:=true;
find(m[i]);
inc(tot);
end;
for i:=0 to tot-1 do
inc(sum,min(a[i].val*(a[i].cnt-2),minvalue*(a[i].cnt+1)+a[i].val));
writeln(sum);
end;
begin
main;
end.
题目:http://poj.org/problem?id=2369
题意:给出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次后就可以到达目的状态，所以我们只需要确定各个循环节长度的最小公倍数。
const maxn=1001;
var val,v:array [0..maxn] of longint;
n:longint;
function gcd(x,y:int64):longint;
begin
if x mod y=0 then exit(y)
else exit(gcd(y,x mod y));
end;
procedure main;
var i,j,k,sum:longint;
ans:int64;
begin
read(n);
ans:=1;
for i:=1 to n do
read(val[i]);
for i:=1 to n do
if (v[i]=0) and (val[i]<>i) then
begin
v[val[i]]:=1;
j:=val[i];
k:=2;
while val[j]<>i do
begin
inc(k);
v[val[j]]:=1;
j:=val[j];
end;
v[i]:=1;
sum:=gcd(ans,k);
ans:=ans*(k div sum);
end;
writeln(ans);
end;
begin
main;
end.
题目:http://poj.org/problem?id=1026
题意:首先给出一个置换，然后给出一个字符串，问置换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].
我们预处理出2^k，然后乱搞一下即可
const maxn=201;
maxm=31;
type arr=array [0..maxn] of longint;
var n,i,j,k,l:longint;
cache,ans:arr;
change:array [0..maxm] of arr;
s:string;
temp:char;
procedure prepare;
var i,j:longint;
begin
for j:=1 to maxm do
for i:=1 to n do
change[j,i]:=change[j-1,change[j-1,i]];
end;
procedure main;
begin
repeat
read(n);
if n=0 then break;
for i:=1 to n do
read(change[0,i]);
readln;
prepare;
repeat
read(k);
if k=0 then break;
read(temp);
readln(s);
l:=length(s);
while l<n do
begin
s:=s+‘ ‘;
inc(l);
end;
for i:=1 to n do
ans[i]:=i;
while k<>0 do
begin
j:=trunc(ln(k)/ln(2));
for i:=1 to n do
cache[change[j,i]]:=ans[i];
ans:=cache;
k:=k-(1<<j);
end;
for i:=1 to n do
write(s[ans[i]]);
writeln;
until false;
writeln;
until false;
end;
begin
main;
end.
再说下循环的概念。
记（a1 a2 ^ an）= 为一个循环。循环亦称做轮换。可以认为是a1到an组成了一个环。而一个置换可以写成多个循环的乘积。比如
=（a1a3a6）(a2a4)(a5)。而循环节的长度就是轮换的个数。这里循环节长度为3。
对于循环有一些操作。比如乘上一个[对换]。
定义(a1,b1)为将a循环中的a1元素和b循环中的b1元素交换。则这是一个两元素在不同轮换中的对换。给循环乘上这个对换。即相当于将原来的两个“环”分别在a1和b1处拆开，再连接成一个新的“环”。也就是说，就是这种对换将两个轮换合并成了一个。
反之，如果对换发生在某轮换内部，那么相当于在(a1,ai)处将此环拆开，然后分别合并为了两个新“环”。也就是说，这种对换将轮换分拆为了两个新的轮换。
如果我们记置换群中元素个数为n，循环节长度为a，可以发生的内部对换数为b。则有下列式子成立：
b = n-a。
想到了神马？对了，最小路径覆盖。
实际上，二分图就是一个置换群。上面一排元素为X集，下面一排元素为Y集。在利用二分图求解最小路径覆盖问题的时候，每次增加一个匹配，路径数就会减少一条。也就是说，匹配数+路径条数=顶点个数。如果想要尽量减小路径条数，大家都看得出来要求最大匹配。
类比一下，匹配数即为轮换内对换数，路径条数即为循环节长度，而顶点个数也就是置换群内的元素个数。所以说，此题其实是求置换群中循环节的长度。
还有一个记忆犹新的例子。那就是某个神奇的DP题。
题目大意大概就是一些钥匙分别对应一些门，但是这些钥匙分别放在不同的门里，并且锁起来了（多么悲催~~）。现在你有两条途径得到这些钥匙。要么破坏门，拿出里面的钥匙。要么用之前得到的钥匙去开现在面对的门。求最少破坏的门的数目。
看出来了，对不对？门看做大括号上面一排元素，钥匙看做下面一排。如果出现“钥匙转圈”的现象，那么即形成一个轮换。此题即变为求循环节的长度。
而用dp求解的时候，我们写方程如下：
f[i,j]:=min{f[i-1,j-1],(i-1)*f[i-1,j]}。这样，第一个式子是设前面i-1个元素组成一个循环，而后一个式子则是通过给前i-1个元素组成的循环乘上一个两元素分属于不同轮换的对换将它和第i个元素的轮换合并为了一个。
这样，不论是DP还是图论，我们都可以统一地用离散数学的群论来总结和解释。
其实，之前在学习群论的过程中，就隐约体会到了其对于其他领域问题的一些本质解释。比如拓扑排序，比如线性代数。