E task

#pragma optimization_level 3
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#include <iostream>
#include <algorithm>
#include <fstream>
#include <vector>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <math.h>
#include <cmath>
#include <string>
#include <random>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <string.h>
#include <stack>
#include <assert.h>
#include <list>
#include <time.h>
#include <memory>
#include <chrono>
using namespace std;
//
#define fast cin.tie(0);cout.tie(0);cin.sync_with_stdio(0);cout.sync_with_stdio(0);
//#define cin in
//#define cout out
#define ll long long
#define db double
#define ld long double
#define uset unordered_set
#define umap unordered_map
#define F first
#define S second
#define ms multiset
#define pb push_back
#define pq priority_queue
#define umap unordered_map
#define uset unordered_set
#define ull unsigned long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<ld, ld>
#define pnn pair<Node*, Node*>
#define uid uniform_int_distribution
#define PI acos(-1.0)
//#define sort(a, b) sort(a.begin(), a.end(), b())
//mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
ifstream in("input.txt");
ofstream out("output.txt");

//#pragma comment(linker, "/STACK:256000000")

const int MAX_N = 3e5;
int n, m, type;
vector<int> nums;

int fen[2*MAX_N], ans[MAX_N];

void incr(int p, int val) {
    for (; p < 2*MAX_N; p |= (p + 1))
        fen[p]+= val;
}

int get_sum(int p) {
    int sum = 0;
    for (; p >= 0; p = (p & (p + 1)) - 1)
        sum += fen[p];
    return sum;
}

int get_sum(int l, int r) {
    if (l > r) return 0;
    return get_sum(r) - (l == 0 ? 0 : get_sum(l - 1));
}

void q1() {
    vector<pii> poss(n);
    for (int i = 0; i < n; i++) poss[i] = { nums[i], i };
    sort(poss.begin(), poss.end(), greater<pii>());

    for (int i = 0; i < n;) {
        int a = poss[i].first;

        int j = i;
        while (j < n && poss[j].first == a) j++;
        j--;

        ans[poss[j].second] = get_sum(poss[j].second) + a;

        while (i <= j)
            incr(poss[i++].second, 1);
    }
}

void q2() {
    memset(fen, 0, sizeof(fen));
    vector<int> L(MAX_N, -1);
    //memset(L, 255, sizeof(L));

    for (int i = 0; i < n; i++) {
        int a = nums[i];
        int lp = L[a];
        if (lp != -1) {
            ans[i] = get_sum(lp + 1, i - 1) + 1;
            incr(lp, -1);
        }
        L[a] = i;
        incr(i, 1);
    }
}

void solve1() {
    q1();
    q2();
}

int s_array[2 * MAX_N];

int get_kth(int k) {
    int l = -1, r = 2 * MAX_N-1;
    while (r - l > 1) {
        int m = (l + r) / 2;
        if (get_sum(m) >= k) r = m;
        else l = m;
    }
    return r;
}

void solve2() {
    for (int i = 0; i < m; i++) {
        s_array[n + i] = i+1;
        incr(n + i, 1);
    }

    int p = n - 1;

    for (int i = 0; i < n; i++) {
        int pos = get_kth(nums[i]);
        incr(pos, -1);
        incr(p, 1);
        s_array[p] = ans[i] = s_array[pos];
        p--;
    }
}

void input() {
    cin >> n >> m >> type;
    nums.resize(n);
    for (int& x : nums) cin >> x;
}

int main() {
    fast;
    input();

    if (type == 1) solve1();
    else solve2();
    for (int i = 0; i < n; i++) cout << ans[i] << ' ';
}