哈工大acm热身赛 G 排序花费的最小代价

我们假设数组是1 400 200 300.
我们可以类似链状的去寻找排序，比如一上面的数组为例子。
400-300-200，即400去300的位置，300去两百的位置，两百去400，成了一个环。
这就是接这道题目的核心。
对于每一个环来说，一共有两种策略，一种是以当前环内最小的数字来作为媒介更新，还有一种是以整个的最小值最为媒介进行更新。我们每一次去最小值就好了。
对于第一种状况，我们可以知道，按照我们这样做出来的链状结构，最后一定是最小的
记sum位链状数字和，min为最小值。
那么花费就可以成为 cost=min*（k-1）+sum-min。（换k-1次最小数字）
对于第二种情况 多了一个先把allmin即数组最小值换入环内的操作，所以
cost=allmin*（k+1）+sum+min。
记录一下，这道题很靠思维啊，而且，代码感觉不好写。
记得先要离散化才能做。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<map>
//#include<regex>
#include<cstdio>
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
typedef pair<int, int> pir;
int n;
int a[1005];//离散化前的数组，即初始数组
int mp[10005];//记录，离散化后，每个价值对应的位置
int vis[10005];//访问
int pos[1005];//应该在的位置
int main()
{
    while (cin >> n)
    {
        memset(mp, 0, sizeof(mp));
        vector<int >v;
        int MIN = 1e9+2;
        up(i, 0, n)
        {
            cin >> a[i];
            v.push_back(a[i]);
            MIN = min(MIN, a[i]);
            pos[i] = i;
        }
        sort(v.begin(), v.end());
        up(i, 0, n)
        {
            //cout << "vi" << v[i] << endl;
            mp[v[i]] = i;//做离散化
            //cout << mp[v[i]] << endl;
        }
        ll sum = 0;
        memset(vis, 0, sizeof(vis));
        up(i, 0, n)
        {
            if (!vis[i])//如过没有访问过，就顺着去找链
            {
            //  cout << "pos" << pos[i] << mp[v[i]];
                if (pos[i] != mp[a[i]])
                {
                    //cout << "pos" << pos[i] << endl;
                    vector<int >vec;
                    int now = i;//当前节点
                    ll  nowsum = 0;
                    int tempmin = 1e9+2;
                    while (!vis[now])
                    {
                        vis[now] = 1;
                        vec.push_back(now);
                        nowsum += a[now];
                        tempmin = min(tempmin, a[now]);
                    //  cout << "now"<<now << endl;
                        now = pos[mp[a[now]]];//链指向下一个
                    }
                    //cout << vec.size()<<" " << tempmin << endl;
                    ll min1 = (vec.size() - 2)*tempmin + nowsum;
                    //cout << "min1" << min1 << endl;
                    ll min2 = tempmin + nowsum + (vec.size() +1)*MIN;
                    sum += min(min1, min2);//去两者最小的那个
                //  cout << sum << endl;
                }
                else vis[i] = 1;//如果一来就是对的，那么就结束
            }
        }
        cout << sum << endl;
    }
    return 0;
}