Valera and Swaps

题意：

定义 $f(p)$ 表示将 $p$ 序列变换为有序序列最少要交换多少次，给一 $1 sim n$ 的排列 $a$ ，给一整数 $m$，

求问将 $a$ 最少交换多少次能得到 $p$ ，使得 $f(p) = m$，并将以此交换视作一个两个数字，将交换按顺序排列开

求出字典序最小的交换序列。

解法：

记 $id$ 表示排列 $id(i) = i$

考虑 $f(p)$ 怎么求，可以发现，将原排列视作一个从$p$置换到$id$的置换，则将置换拆分成 $tot$ 个循环后，

最小交换次数就是$sum_{i=1}^{tot}{cnt_i - 1}$，也就是$n - tot$。

这样考虑交换两个置换的元素，两个置换群会合为一个置换群， $tot$ 变为 $tot-1$。

考虑交换一个置换群内的元素，当前置换群会拆分为两个置换群，$tot$ 变为 $tot+1$。

我们注意到要求交换次数最小，这样两种操作一定不会共存，

这样分类讨论：

1.$n-m < tot$时，我们需要将原先的置换群不断合并，要求字典序最小，

所以我们每次找出含最小元素的置换，将其与含1的置换合并。

2.$n-m = tot$时，不用交换，答案为0

3.$n-m > tot$时，每一次我们只要选择含最小元素的置换，将其中的最小值和次小值交换，并将置换拆开。

总复杂度$O(n^2)$

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

#define N 3010
#define LL long long

using namespace std;

int n,m,tot;
int a[N];
bool v[N];
vector<int> cir[N];

int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        scanf("%d",&m);
        m=n-m;
        for(int i=1;i<=n;i++) v[i]=0;
        tot=0;
        for(int i=1;i<=n;i++)
        {
            if(v[i]) continue;
            int tmp=i;
            cir[++tot].clear();
            while(!v[tmp])
            {
                v[tmp]=1;
                cir[tot].push_back(tmp);
                tmp=a[tmp];
            }
        }
        if(tot==m) cout<<0<<endl;
        else if(tot>m)
        {
            cout<<tot-m<<endl;
            for(int Te=1;Te<=tot-m;Te++)
            {
                int t=0;
                for(int i=2;i<=tot;i++)
                    if(!cir[i].empty() && (!t || cir[i][0]<cir[t][0]))
                        t=i;
                cout<<cir[1][0]<<' '<<cir[t][0]<<' ';
                for(int i=0;i<(int)cir[t].size();i++)
                    cir[1].push_back(cir[t][i]);
                cir[t].clear();
            }
        }
        else
        {
            int tott=tot;
            cout<<m-tot<<endl;
            for(int Te=1;Te<=m-tot;Te++)
            {
                int t=0;
                for(int i=1;i<=tott;i++)
                    if(cir[i].size()>1 && (!t || cir[i][0]<cir[t][0]))
                        t=i;
                int pos=1;
                for(int i=2;i<(int)cir[t].size();i++)
                    if(cir[t][i]<cir[t][pos])
                        pos=i;
                cout<<cir[t][0]<<' '<<cir[t][pos]<<' ';
                swap(cir[t][0],cir[t][pos]);
                cir[++tott].clear();
                int cnt=0;
                for(int i=pos;i<(int)cir[t].size();i++)
                    cir[tott].push_back(cir[t][i]),cnt++;
                while(cnt--) cir[t].pop_back();
            }
        }
    }
    return 0;
}