Problem: 2063B - Subsequence Update
Language: c++17 

Solution 1 (runtime: 62 ms):
#include <bits/stdc++.h>

using namespace std;

#define endl '\n'
#define int long long

void solve() {
    int n, l, r;
    cin >> n >> l >> r;
    l--;
    r--;
    int a[n];
    for (int &i : a)
        cin >> i;
    sort(a, a + l);
    sort(a + l, a + r + 1);
    sort(a + r + 1, a + n);
    int ans = 0;
    for (int i = l; i <= r; i++) {
        ans += a[i];
    }
    int left = ans;
    for (int i = 0; l <= r - i && i < l && a[i] < a[r - i]; i++) {
        left += a[i] - a[r - i];
    }
    int right = ans;
    for (int i = 0; l <= r - i && i + r + 1 < n && a[i + r + 1] < a[r - i];
         i++) {
        right += a[i + r + 1] - a[r - i];
    }
    cout << min(left, right) << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int t = 1;
    cin >> t;
    while (t--)
        solve();
}


Solution 2 (runtime: 155 ms):
#include<iostream>

#include<cstring>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<iomanip>

#include<unordered_set>

#include<set>

#include<queue>

#include <map>

#include <unordered_map>

#include <iterator>

#include <list>

#include <stack>



#define M_PI 314159265358979323846264338327

#define lli long long int

#define li long int

#define ld long double

#define f0r(i,x) for(int i=0;i<x;i++)

#define all(x) x.begin(), x.end()

#define vvi vector<vector<int>>

#define vpi vector<pair<int,int>>

#define vi vector<int>

#define vb vector<bool>

#define pb push_back

#define F first

#define S second



using namespace std;





int mod=1e9+7;

const lli inf = 1e9, MAX = 1e6 + 5;

vector<int>adj[MAX];

vector<pair<lli,lli>>adjP[MAX];

//vector<bool>visit(MAX);

vector<vector<bool>>vis(1005,vector<bool>(1005));





int dx[] = { 1, 0, -1, 0, -1, -1, 1, 1 };

int dy[] = { 0, -1, 0, 1, -1, 1, -1, 1 };

int di[]={'D','L','U','R'};



lli gcd(lli a, lli b) {

    if (b == 0) {

        return a;

    } else {

        return gcd(b, a % b);

    }

}





vector<pair<int,lli>>adjj[MAX];

//lli dist[200][200];

//vector<pair<int,lli>>parent(MAX,{-1,0});

vector<lli>paths(MAX);

vector<lli>mn(MAX);

vector<lli>mx(MAX*12);

vector<int>parent(MAX,-1);

vector<vector<char>> board(200,vector<char>(200));





//vector<int>divs;

//int ans=0;

//void primeDivisor(int n){

//    while(!(n%2)){

////        divs.push_back(2);

//        n/=2;

//        ans++;

//    }

//

//    for(int i=3;i<=sqrt(n);i+=2){

//        if(!(n%i)){

////            divs.push_back(i);

//            n/=i;

//            ans++;

//        }

//

//

//    }

//    if(n>2){

////        divs.push_back(n);

//        ans++;

//    }

//}







//----- num of divisors --------

lli D[MAX+1000];

void divss(){

    memset(D,0,sizeof D);

    for(int i=1;i<MAX;i++){

        for(int j=i;j<MAX;j+=i){

            D[j]++;

        }

    }

}







vector<bool>visit(MAX);

vector<int>score(MAX,0);

int cyclePoint=0;

int cycles=0;

void dfs(lli x){

    score[x]++;

    cycles++;

    if(visit[x]){ cyclePoint=x; return;}

    visit[x]=true;

    for(auto u:adj[x]){

        if(!visit[u]) {

            dfs(u);

        }

    }

}



vector<int>root(MAX);



struct DSU{

    vector<int>par,sz;

    int components;

    DSU(int n){

        par.resize(n+1);

        sz.resize(n+1);

        components=n;

        f0r(i,n){

            par[i+1]=i+1;

            sz[i+1]=1;

        }

    }



    int find(int x){

        if(par[x]!=x)

        {

            par[x]=find(par[x]);

        }

        return par[x];

    }



    bool unite(int a, int b){

        a=find(a);

        b=find(b);

        if(a==b){ return false;}

        if(sz[a]<sz[b]){swap(a,b);}

        par[b]=a;

        sz[a] += sz[b];

        components--;

        return true;

    }

};



struct edge{

    int a,b;

    lli w;



    bool operator<(edge& e)const

    {

        return w<e.w;

    }

};



void Kruskal(int n, vector<edge>& edges){

    sort(all(edges));

    DSU dsu(n);

    lli mx=0;

    for(auto e:edges){

        if(dsu.unite(e.a,e.b)){

            mx=max(mx,e.w);

        }

        if(dsu.components==1){break;}

    }



    cout<<mx<<"\n";



}

vector<int>spf(1e6),primeNumbers;

vector<bool>isPrime(1e6,false);







void Sieve(){

//    for(int i=1;i<=1e6;i++){

//        spf[i]=i;

//    }

    isPrime[1]=true;

    isPrime[0]=true;

    for(int i=2;i*i<=1e6;i++){

        if(isPrime[i]){continue;}

        for(int j=2*i;j<=1e6;j+=i){

            isPrime[j]=true;

//            spf[j]=min(spf[j],i);

        }

    }

    f0r(i,1e6){

        if(!isPrime[i]){

            primeNumbers.push_back(i);

        }

    }

}



map<int,int> factorize(int x){

    map<int,int>fact;

    while(x>1){

        fact[x]++;

        x/=spf[x];

        fact[spf[x]]++;

    }

    return fact;

}



lli fastPower(lli a,lli b,lli mod){



    if(b==0) return 1;

    lli pi=fastPower(a,b/2,mod);

    if(b&1)

    {

        return ((pi*1ll*pi)%mod*1ll*a)%mod;

    }

    else

    {

        return (pi*1ll*pi)%mod;

    }

}



bool checkPrime(lli x){

    for(int i=2;i<min(x,MAX);i++){

        if(x%i==0){return false;}

    }

    return true;

}



void solve() {

    int n,l,r;

    cin>>n>>l>>r;

    vector<int>v1,v2,v3;

    bool flag=false;

    f0r(i,n){

        if(i>=l-1 && i<=r-1){

            int x;

            cin>>x;

            v1.push_back(x);

            flag=true;

        }

        else if(!flag){

            int x;

            cin>>x;

            v2.push_back(x);

        }

        else{

            int x;

            cin>>x;

            v3.push_back(x);

        }

    }

    sort(all(v1),greater<>());

    sort(all(v2));

    sort(all(v3));

    lli curr1=0;

    int i=0,j=0;

    for(;i<v1.size();){

        if(j<v2.size()) {

            if (v2[j] < v1[i]) {

                curr1 += v2[j];

                i++;

                j++;

            }

            else{curr1+=v1[i]; i++;}

        }

        else{curr1+=v1[i]; i++;}

    }



    lli curr2=0;

    i=0,j=0;

    for(;i<v1.size();){

        if(j<v3.size()) {

            if (v3[j] < v1[i]) {

                curr2 += v3[j];

                i++;

                j++;

            }

            else{curr2+=v1[i]; i++;}

        }

        else{curr2+=v1[i]; i++;}

    }

    lli ans=min(curr1,curr2);

    cout<<ans<<"\n";

}

int main() {



    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    cout.tie(NULL);



//    freopen("input.in","r",stdin);

//    freopen("output.out","w",stdout);

//    Sieve();

    int t = 1;

    cin >> t;

    while (t--) {

        solve();



    }





}