ICPC20昆明J——图论建模，构造题

题意

给你一个排列a和无限多个CPU。一个CPU在一次操作里可以交换你指定的两个下标的数。设你这一次操作用了k个CPU，你指定的下标为(x[1],y[1])，……，(x[k],y[k])。唯一的要求是x[1]，y[1]，……，x[k]，y[k]两两不同。求最少需要几次操作可以把a变为升序，并打印每次操作要用的CPU个数c，和要交换的c个下标pair。

思路

一个可行的切入点是考虑1号点被x[1]占领，x[1]被x[2]占领……这样必然构成一个环。事实上这就是一个循环（置换群的概念）。a就由若干不相交循环构成。下面只要考虑一个循环怎么还原即可。

这时需要建模，我们没有发现比“有向图”更合适的模型，因此用有向图来建模。在原数组a的一个交换操作，实际上就是交换某2个点的唯一出边的指向。现在定义一个环的编号是l[0]~l[m-1]。比如，交换l[0]和l[m-1]的出边指向（后文的“交换”都指交换两个点的出边指向）则得到l[0]指向自己和一个大小m-1的环。

我们发现一个看似有点优秀的方案：设l[i]和l[(i+1)%m]交换，则可以让l[(i+1)%m]自己成环。于是一次操作可以用大约m/2个CPU：(l[0],l[1])，(l[2],l[3])……把所有下标为奇数的拿出来独自成环，于是大环的大小变为一半。这样操作次数是log(m)。

遗憾的是，它并不是最优秀的方案。我们可以找到（但有点难找QAQ）更优秀的方案，即第1步把大环拆成m/2个大小<=2的环，第2步把所有的大小为2的环一起拆开。

1. 首先交换l[1]和l[m-1]，则l[0]和l[1]构成一个大小为2的环。这一步是特殊的，后面若干步是一般性的。
2. 之后点l[m-1]已经用过，故选择交换l[2]和l[m-2]，则l[m-1]和l[2]构成一个大小为2的环。
3. 之后点l[m-2]已经用过，故选择交换l[3]和l[m-3]，则l[m-2]和l[3]构成一个大小为2的环。
4. 依此类推，l[m+1-i]和l[i]构成一个大小为2的环……

大小为2的环p1，p2，只需要交换p1和p2即可。

总结一下，第一次操作的下标对为：(l[1],l[m-1])，(l[2],l[m-2])，(l[3],l[m-3])……第二次操作的下标对为：(l[0],l[1])，(l[m-1],l[2])，(l[m-2],l[3])……

这个方案很构造，想不到就算了QAQ随便画个图理解一下就行……

第一次操作和第二次操作的下标对都可能为空，特判一下即可。

有一种用reverse操作来表达以上结论的实现（也就是说，这个链接里的reverse操作（用swap实现的reverse）只是更简洁地表达以上结论的一个技巧），更为优雅：参考

我的直观实现代码如下

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

const int N = 1e5 + 5;

int n,a[N];bool vis[N];

struct Node{
    int x,y;
};

void dbg(){puts("");}
template<typename T, typename... R>void dbg(const T &f, const R &... r) {
    cout << f << " ";
    dbg(r...);
}
template<typename Type>inline void read(Type &xx){
    Type f = 1;char ch;xx = 0;
    for(ch = getchar();ch < '0' || ch > '9';ch = getchar()) if(ch == '-') f = -1;
    for(;ch >= '0' && ch <= '9';ch = getchar()) xx = xx * 10 + ch - '0';
    xx *= f;
}

int main(int argc, char** argv) {
    read(n);rep(i,1,n) read(a[i]);
    vector<Node> ans1,ans2;
    rep(i,1,n){
        if(vis[i]) continue;
        int x = i;
        vector<int> want;
        do{
            want.push_back(x);vis[x] = true;
            x = a[x];
        }
        while(x != i);
        if(want.size() <= 1) continue;
        if(want.size() == 2){
            ans1.push_back({want[0],want[1]});
        }
        else{
            int m = want.size();
            rep(i,1,(m-1)/2){
                if(i == m-i) break;
                ans1.push_back({want[i],want[m-i]});
            }
            ans2.push_back({want[0],want[1]});
            rep(i,2,m){
                if(i >= m+1-i) break;
                ans2.push_back({want[i],want[m+1-i]});
            }
        }
    }
    int ans = (ans1.size() > 0) + (ans2.size() > 0);
    printf("%d\n",ans);
    if(ans1.size()){
        printf("%d",ans1.size());
        for(auto x: ans1) printf(" %d %d",x.x,x.y);
        puts("");
    }
    if(ans2.size()){
        printf("%d",ans2.size());
        for(auto x: ans2) printf(" %d %d",x.x,x.y);
        puts("");
    }
    return 0;
}