洛谷P2127序列排序 思考与解答

将排序前的数和排序后的数列出，使用x->y表示将数x换到数y的位置

原数列         4 3 1 2

排序后         1 2 3 4

将排序后的数列记为b，排序前的数列记为a

则交换的情况为：将数b[i]换到数a[i]的位置

以上例为例 ： 1->4 2->3 3->1 4->2，发现其实可以构成一个环：

1-->4-->2-->3-->1 这个环表示：将数1换到4的位置，将4换到2的位置...将3换到1的位置

考虑如何使消耗最小：

首先，交换次数最少是k-1次（不介绍证明方法），具体方法是每次在环中选一个数，让他与环中的每个其他数都交换一次，例如1-->4-->2-->3-->1，选取1，先后交换：1和3,1和2,1和4，三次交换后即有序，要让每次交换的代价都尽量小，应该选取环中最小的数和其他数交换，这样，交换次数最少，每次交换的代价也最少，最后得到的消耗最小

也可以先将环内的最小的数替换成所有数中最小的数，然后进行上述交换，再把最小的数环到环中。在这两种情况中选择消耗较小的一种

数列中的数较大，为了节省内存开销（数组大小受限），可以离散化

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<climits>
using namespace std;

#define ll long long

const int maxn=100000+5;
int vis[maxn],b[maxn],a[maxn];
int n,min_in,min_global;

struct node{
    int v,id;
    bool operator < (const node &rhs ) const {
        return v<rhs.v;
    }
}dat[maxn];

int main()
{
    ios::sync_with_stdio(0);cin.tie(0);
    cin>>n;
    min_global=INT_MAX;
    for(int i=1;i<=n;i++){      //读入并找全局最小值
        cin>>a[i];
        min_global=min(min_global,a[i]);
        dat[i].v=a[i];      //为离散化做准备
        dat[i].id=i;
    }
    //离散化
    stable_sort(dat+1,dat+1+n);
    for(int i=1;i<=n;i++){
        b[dat[i].id]=i;
    }
    //计算答案
    ll ans=0;
    for(int i=1;i<=n;i++){
        if(vis[b[i]]==0){
            int start=b[i],cur=b[i],k=0;
            ll s=0;
            int min_in=INT_MAX;
            do{
                k++;
                vis[cur]=1;
                s+=dat[cur].v;
                min_in=min(min_in,dat[cur].v);
                cur=b[cur];
            }while(cur!=start);
            //计入答案
            ans+=min(s+1LL*(k-2)*min_in,s+1LL*(k+1)*min_global+min_in);
        }
    }
    cout<<ans<<"\n";
    return 0;
}