这是我的代码（证明我不是来白嫖AC代码的）

#include<bits/stdc++.h>
using namespace std;
struct Info{
	int dx,xh;
}a[100001];
bool cmp(Info x,Info y){
	if(x.dx==y.dx){
		return x.xh<y.xh;
	}
	else{
		return x.dx<y.dx;
	}
}
int c[100001];
int main(){
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i].dx);	
		a[i].xh=i;
	}
	sort(a+1,a+n+1,cmp);
	for(int i=1;i<=n;i++){
		c[a[i].xh]=i;
	}
	for(int i=1;i<=n;i++){
		printf("%d ",a[i].dx);
	}
	printf("\n");
	for(int i=1;i<=n;i++){
		printf("%d ",c[i]);
	}
	return 0;
}

但是最优解大佬写了一堆我看不懂的东西，可以看一看吗，38ms，帮我解释一下，他写这么长代码是用的什么算法啊

#include <bits/stdc++.h>

typedef long long ll;
typedef unsigned long long ull;
#define itn int
#define nit int
#define nti int
#define tin int
#define tni int
#define pll pair<ll, ll>
#define pii pair<int, int>
#define ls first
#define rs second
#define Endl '\n'
#define FAST ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define pb push_back
#define eb emplace_back
// #define ll int

const int N = 1e6 + 3;
const ll mod = 1e9 + 7;
const double eps = 1e-8;
const double inf = 1e20;
const ll INF = 1e18;

using namespace std;

static struct FastInput {
    static constexpr int BUF_SIZE = 1 << 20;
    char buf[BUF_SIZE];
    size_t chars_read = 0;
    size_t buf_pos = 0;
    FILE* in = stdin;
    char cur = 0;

    inline char get_char()
    {
        if (buf_pos >= chars_read) {
            chars_read = fread(buf, 1, BUF_SIZE, in);
            buf_pos = 0;
            buf[0] = (chars_read == 0 ? -1 : buf[0]);
        }
        return cur = buf[buf_pos++];
    }

    inline void tie(int) { }

    inline explicit operator bool()
    {
        return cur != -1;
    }

    inline static bool is_blank(char c)
    {
        return c <= ' ';
    }

    inline bool skip_blanks()
    {
        while (is_blank(cur) && cur != -1) {
            get_char();
        }
        return cur != -1;
    }

    inline FastInput& operator>>(char& c)
    {
        skip_blanks();
        c = cur;
        get_char();
        return *this;
    }

    inline FastInput& operator>>(string& s)
    {
        if (skip_blanks()) {
            s.clear();
            do {
                s += cur;
            } while (!is_blank(get_char()));
        }
        return *this;
    }

    template <typename T>
    inline FastInput& read_integer(T& n)
    {
        // unsafe, doesn't check that characters are actually digits
        n = 0;
        if (skip_blanks()) {
            int sign = +1;
            if (cur == '-') {
                sign = -1;
                get_char();
            }
            do {
                n += n + (n << 3) + cur - '0';
            } while (!is_blank(get_char()));
            n *= sign;
        }
        return *this;
    }

    template <typename T>
    inline typename enable_if<is_integral<T>::value, FastInput&>::type operator>>(T& n)
    {
        return read_integer(n);
    }

#if !defined(_WIN32) || defined(_WIN64)
    inline FastInput& operator>>(__int128& n)
    {
        return read_integer(n);
    }
#endif

    template <typename T>
    inline typename enable_if<is_floating_point<T>::value, FastInput&>::type operator>>(T& n)
    {
        // not sure if really fast, for compatibility only
        n = 0;
        if (skip_blanks()) {
            string s;
            (*this) >> s;
            sscanf(s.c_str(), "%lf", &n);
        }
        return *this;
    }
} fast_input;

#define cin fast_input

static struct FastOutput {
    static constexpr int BUF_SIZE = 1 << 20;
    char buf[BUF_SIZE];
    size_t buf_pos = 0;
    static constexpr int TMP_SIZE = 1 << 20;
    char tmp[TMP_SIZE];
    FILE* out = stdout;

    inline void put_char(char c)
    {
        buf[buf_pos++] = c;
        if (buf_pos == BUF_SIZE) {
            fwrite(buf, 1, buf_pos, out);
            buf_pos = 0;
        }
    }
    inline void tie(int) { }
    ~FastOutput()
    {
        fwrite(buf, 1, buf_pos, out);
    }

    inline FastOutput& operator<<(char c)
    {
        put_char(c);
        return *this;
    }

    inline FastOutput& operator<<(const char* s)
    {
        while (*s) {
            put_char(*s++);
        }
        return *this;
    }

    inline FastOutput& operator<<(const string& s)
    {
        for (int i = 0; i < (int)s.size(); i++) {
            put_char(s[i]);
        }
        return *this;
    }

    template <typename T>
    inline char* integer_to_string(T n)
    {
        // beware of TMP_SIZE
        char* p = tmp + TMP_SIZE - 1;
        if (n == 0) {
            *--p = '0';
        } else {
            bool is_negative = false;
            if (n < 0) {
                is_negative = true;
                n = -n;
            }
            while (n > 0) {
                *--p = (char)('0' + n % 10);
                n /= 10;
            }
            if (is_negative) {
                *--p = '-';
            }
        }
        return p;
    }

    template <typename T>
    inline typename enable_if<is_integral<T>::value, char*>::type stringify(T n)
    {
        return integer_to_string(n);
    }

#if !defined(_WIN32) || defined(_WIN64)
    inline char* stringify(__int128 n)
    {
        return integer_to_string(n);
    }
#endif

    template <typename T>
    inline typename enable_if<is_floating_point<T>::value, char*>::type stringify(T n)
    {
        sprintf(tmp, "%.17f", n);
        return tmp;
    }

    template <typename T>
    inline FastOutput& operator<<(const T& n)
    {
        auto p = stringify(n);
        for (; *p != 0; p++) {
            put_char(*p);
        }
        return *this;
    }
} fast_output;

#define cout fast_output

ll ksm(ll a, ll b)
{
    ll res = 1;
    for (; b; b >>= 1, a = a * a % mod)
        if (b & 1)
            res = res * a % mod;
    return res;
}
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll floordiv(ll a, ll b) { return (a % b && a <= 0) ? a / b - 1 : a / b; }
ll ceildiv(ll a, ll b) { return (a % b && a > 0) ? a / b + 1 : a / b; }

ll n, m, opt, k;
pll a[N];
ll ans[N];
bool cmp(pll x, pll y)
{
    if (x.ls != y.ls) {
        return x.ls < y.ls;
    } else {
        return x.rs < y.rs;
    }
}
void solve()
{
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i].ls;
        a[i].rs = i;
    }
    sort(a + 1, a + 1 + n, cmp);
    for (int i = 1; i <= n; i++) {
        ans[a[i].rs] = i;
    }
    for (int i = 1; i <= n; i++) {
        cout << a[i].ls << " ";
    }
    cout << Endl;
    for (int i = 1; i <= n; i++) {
        cout << ans[i] << " ";
    }
    cout << Endl;
}
int main()
{
    FAST;
    ll t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}