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

Solution 1 (runtime: 77 ms):
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll log_2(ll n) {
    if(n==0) {
        return -1; 
    }
    ll pos=0;
    ll bitPos=-1;
    while(n>0) {
        if(n&1) {
            bitPos=pos;
        }
        n=n>>1;
        pos++;
    }
    return bitPos;
}
ll MEX(vector<ll> &a) {
    std::unordered_set<ll> s(a.begin(), a.end());
    ll mex=0;
    while(s.find(mex)!=s.end()) {
        mex++;
    }
    return mex;
}
int binarySearch(vector<ll> &arr, int l, int r, int x) {
    while(l<=r) {
        int m=l+((r-l)/2);
        if(arr[m]==x) {
            return m;
        }
        if(arr[m]<x) {
            l=m+1;
        } else {
            r=m-1;
        }
    }
    return -1;
}
int countSubstring(string &s1, string &s2) {
	if(s2.length()==0) {
        return 0;
    }
	int ct=0;
	for(size_t offset=s1.find(s2); offset!=std::string::npos; offset=s1.find(s2, offset+s2.length())) {
		++ct;
	}
	return ct;
}
bool isSubSequence(string s1, string s2) {
    int n = s1.length(), m = s2.length();
    int i = 0, j = 0;
    while (i < n && j < m) {
        if (s1[i] == s2[j])
            i++;
        j++;
    }
    return i == n;
}
bool ok(vector<int> &a) {
    int n=a.size();
    int ct=0;
    for(int i=0; i<n; i++) {
        if(a[i]>a[(i+1)%n]) {
            ct++;
        }
    }
    return ct<=1;
}
ll GCD(vector<ll> &a) {
    int n=a.size();
    ll gcd=0; 
    for(int i=0; i<n; i++) { 
        gcd=__gcd(gcd, a[i]); 
    } 
    return gcd; 
}
ll LCM(vector<ll> a) {
    ll lcm=a[0];
    for(int i=1; i<a.size(); i++) {
        ll num1=lcm;
        ll num2=a[i];
        ll gcd=__gcd(num1, num2);
        lcm=(lcm*a[i])/gcd;
    }
    return lcm;
}
ll lcm(ll a, ll b) {
    return (a/__gcd(a, b))*b;
}
bool isSorted(vector<ll> a, int size) {
    for(int i=1; i<size; i++) {
        if(a[i-1]>a[i]) {
            return false;
        }
    }
    return true;
}
ll factorial(int n) {
    vector<ll> f(n+1);
    f[0]=1;
    f[1]=1;
    for(int i=2; i<=n; i++) {
        f[i]=f[i-1]*i;
    }
    return f[n];
}
// int dfs(vector<vector<int>> &a, vector<vector<int>> &vis, int i, int j) {
//     int n=a.size(), m=a[0].size();
//     vis[i][j]=1;
//     int ans=a[i][j];
//     if(i && a[i-1][j] && !vis[i-1][j]) {
//         ans+=dfs(a, vis, i-1, j);
//     }
//     if(i!=n-1 && a[i+1][j] && !vis[i+1][j]) {
//         ans+=dfs(a, vis, i+1, j);
//     }
//     if(j && a[i][j-1] && !vis[i][j-1]) {
//         ans+=dfs(a, vis, i, j-1);
//     }
//     if(j!=m-1 && a[i][j+1] && !vis[i][j+1]) {
//         ans+=dfs(a, vis, i, j+1);
//     }
//     return ans;
// }
// const int NMAX=2e5+5;
// int dp[NMAX], id[NMAX];
// vector<pair<int, int>> edg[NMAX];
// void dfs(int u) {
//     for(auto it : edg[u]) {
//         if(dp[it.first]==0) {
//             dp[it.first]=dp[u]+(it.second<=id[u]);
//             id[it.first]=it.second;
//             dfs(it.first);
//         }
//     }
// }
ll sumOfDigits(ll n) {
    ll sum=0;
    while(n) {
        sum+=(n%10);
        n/=10;
    }
    return sum;
}
ll flips(vector<ll> &a) {
    ll n=a.size();
    ll ct=0, ans=0;
    for(int i=n-1; i>=0; i--) {
        if(!a[i]) {
            ct++;
        } else {
            ans+=ct;
        }
    }
    return ans;
}
const ll mod=1e9+7;
bool is_square(ll n) {
    ll l=1, r=3037000500, mid;
    while(r-l>1) {
        mid=(l+r)/2;
        ll x=mid*mid;
        if(x<=n) {
            l=mid;
        } else {
            r=mid;
        }
    }
    return (l*l==n);
}
ll power(ll a, ll b) {
    ll ans=1;
    while(b) {
        if(b%2) {
            ans*=a;
        }
        a*=a;
        b/=2;
    }
    return ans;
}
ll powmod(ll a, ll b, ll mod) {
    ll ans=1;
    a%=mod;
    while(b) {
        if(b%2) {
            ans=(a*ans)%mod;
        }
        a=(a*a)%mod;
        b/=2;
    }
    return ans;
}
ll factmod(ll n, ll mod) {
    ll ans=1;
    while(n) {
        ans=(ans*(n--))%mod;
    }
    return ans;
}
ll ncrmod(ll n, ll r, ll mod) {
    return (((factmod(n, mod)*powmod(factmod(r, mod), mod-2, mod))%mod)*powmod(factmod(n-r, mod), mod-2, mod))%mod;
}
// ll score(vector<int> &p, vector<int> &a, int s, int k) {
// 	int n=p.size();
// 	ll mx=0, cur=0;
// 	vector<int> vis(n, 0);
// 	while(!vis[s] && k>0) {
// 		vis[s]=1;
// 		mx=max(mx, cur+(1ll*k*a[s]));
// 		cur+=a[s];
// 		k--;
// 		s=p[s];
// 	}
// 	return mx;
// }
// void add_divs(int x, map<int, int> &mp) {
//     int i=2;
//     while(i*i<=x) {
//         while(x%i==0) {
//             mp[i]++;
//             x/=i;
//         }
//         i++;
//     }
//     if(x>1) {
//         mp[x]++;
//     }
// }
// int getPos(vector<int> &dp, int n, int pos) {
//     if(pos>n) {
//         return n+1;
//     }
//     if(pos==n) {
//         return 0;
//     }
//     return dp[pos];
// }
// const int N=200003;
// const int M=30;
// int pf[N][M];
// int a[N];
// void Buildprefix(int n) {
//     for(int i=0; i<n; i++) {
//         for(int j=0; j<30; j++) {
//             if(a[i]&(1<<j)) {
//                 pf[i+1][j]=pf[i][j]+1;
//             } else{
//                 pf[i+1][j]=pf[i][j];
//             }
//         }
//     }
// }
// void dfs(int v, int p, vector<vector<int>> g, vector<ll> ct) {
//     if(g[v].size()==1 && g[v][0]==p) {
//         ct[v]=1;
//     } else {
//         for(auto u : g[v]) {
//             if(u!=p) {
//                 dfs(u, v, g, ct);
//                 ct[v]+=ct[u];
//             }
//         }
//     }
// }
bool helper(const string &s, const string &t) {
    int i=0, j=0;
    while(i<s.length() && j<t.length()) {
        if(s[i]==t[j]) {
            ++j;
        }
        ++i;
    }
    return j==t.length();
}
ll findMedian(vector<ll> &a, int ind) {
    vector<ll> c;
    for(int i=0; i<a.size(); i++) {
        if(i!=ind) {
            c.push_back(a[i]);
        }
    }
    sort(c.begin(), c.end());
    if(c.size()%2) {
        return c[(c.size()-1)/2];
    } else {
        return c[(c.size()/2)-1];
    }
}
ll dist(ll x1, ll y1, ll x2, ll y2) {
    return (1LL*(x2-x1)*(x2-x1))+(1LL*(y2-y1)*(y2-y1));
}
ll modInv(ll a, ll m) {
    ll m0=m, y=0, x=1;
    if(m==1) {
        return 0;
    }
    while(a>1) {
        ll q=a/m;
        ll t=m;
        m=a%m;
        a=t;
        t=y;
        y=x-q*y;
        x=t;
    }
    if(x<0) {
        x+=m0;
    }
    return x;
}
int calcFib(int a1, int a2, int a3, int a4, int a5) {
    int ct=0;
    if(a4==a3+a2) {
        ct++;
    }
    if(a3==a2+a1) {
        ct++;
    }
    if(a5==a4+a3) {
        ct++;
    }
    return ct;
}
void solve() {
    // int a, b;
    // cin>>a>>b;
    // if(abs(a)==abs(b)) {
    //     cout<<2*(abs(a))<<endl;
    // } else {
    //     cout<<2*(max(abs(a), abs(b)))-1<<endl;
    // }
    // int n;
    // cin>>n;
    // vector<int> b(n);
    // int l=0, u=0;
    // for(int i=0; i<n; i++) {
    //     cin>>b[i];
    //     if(b[i]>0) {
    //         l++;
    //     } else {
    //         u++;
    //     }
    // }
    // for(int i=1; i<=n; i++) {
    //     if(i<=l) {
    //         cout<<i<<" ";
    //     } else {
    //         cout<<(2*l)-i<<" ";
    //     }
    // }
    // cout<<endl;
    // for(int i=1; i<=n; i++) {
    //     if(i<=2*u) {
    //         cout<<i%2<<" ";
    //     } else {
    //         cout<<i-(2*u)<<" ";
    //     }
    // }
    // cout<<endl;
    // int n;
    // cin>>n;
    // string s;
    // cin>>s;
    // for(int i=0; i<n; i++) {
    //     if(s[i]>'A' && s[i]<'Z') {
    //         s[i]='a'+s[i]-'A';
    //     }
    // }
    // s.erase(unique(s.begin(), s.end()), s.end());
    // cout<<(s=="meow" ? "yes" : "no")<<endl;
    // int n;
    // cin>>n;
    // vector<int> a(n), b(n);
    // // int maxA=INT_MIN, maxB=INT_MIN;
    // for(int i=0; i<n; i++) {
    //     cin>>a[i];
    //     // maxA=max(maxA, a[i]);
    // }
    // for(int i=0; i<n; i++) {
    //     cin>>b[i];
    //     // maxB=max(maxB, b[i]);
    // }
    // for(int i=0; i<n-1; i++) {
    //     if(a[i]>a[n-1] || b[i]>b[n-1]) {
    //         int temp=a[i];
    //         a[i]=b[i];
    //         b[i]=temp;
    //     }
    // }
    // int ans=1;
    // for(int i=0; i<n-1; i++) {
    //     if(a[i]>a[n-1] || b[i]>b[n-1]) {
    //         ans=0;
    //         break;
    //     }
    // }
    // if(ans) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // int k;
    // cin>>k;
    // string s;
    // cin>>s;
    // string ref="";
    // for(int i=1; i<=100; i++) {
    //     if(i%3==0) {
    //         ref+='F';
    //     }
    //     if(i%5==0) {
    //         ref+='B';
    //     }
    // }
    // int x=ref.find(s);
    // if(x!=string::npos) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // int n, m;
    // cin>>n>>m;
    // string s, t;
    // cin>>s>>t;
    // reverse(t.begin(), t.end());
    // s+=t;
    // int ct=0;
    // for(int i=1; i<n+m; i++) {
    //     ct+=(s[i-1]==s[i]);
    // }
    // cout<<(ct<=1 ? "yes" : "no")<<endl;
    // int n;
    // cin>>n;
    // vector<string> a(2*(n-1));
    // vector<string> ans;
    // for(int i=0; i<(2*(n-1)); i++) {
    //     cin>>a[i];
    //     if(a[i].length()==n-1) {
    //         ans.push_back(a[i]);
    //     }
    // }
    // reverse(ans[0].begin(), ans[0].end()); 
    // if(ans[0]==ans[1]) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // ll a, b;
    // cin>>a>>b;
    // ll n, m;
    // cin>>n>>m;
    // ll q=n/(m+1), r=n-(q*(m+1));
    // cout<<(q*min(a*m, b*(m+1)))+(r*min(a, b))<<endl;
    // int n;
    // cin>>n;
    // vector<int> h(n);
    // int ct=0;
    // for(int i=0; i<n; i++) {
    //     cin>>h[i];
    //     if(h[i]==1) {
    //         ct++;
    //     }
    // }
    // cout<<(ct/2)+(n-ct)+(ct%2)<<endl;
    // int n, a, b;
    // cin>>n>>a>>b;
    // string s;
    // cin>>s;
    // int ans=0;
    // int x=0, y=0;
    // for(int i=0; i<100; i++) {
    //     for(char c : s) {
    //         if(c=='N') {
    //             y++;
    //         } else if(c=='S') {
    //             y--;
    //         } else if(c=='E') {
    //             x++;
    //         } else {
    //             x--;
    //         }
    //         if(x==a && y==b) {
    //             ans=1;
    //             break;
    //         }
    //     }
    // }
    // if(ans) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // ll n, b, c;
    // cin>>n>>b>>c;
    // if(!b) {
    //     if(c>=n) {
    //         cout<<n<<endl;
    //     } else if(c>=n-2) {
    //         cout<<n-1<<endl;
    //     } else {
    //         cout<<-1<<endl;
    //     }
    // } else {
    //     if(c>=n) {
    //         cout<<n<<endl;
    //     } else {
    //         cout<<n-max(0LL, 1+((n-c-1)/b))<<endl;
    //     }
    // }
    // int n;
    // cin>>n;
    // cout<<n-1<<endl;
    // string s;
    // cin>>s;
    // for(int i=0; i<s.length(); i++) {
    //     if(s[i]=='p') {
    //         s[i]='q';
    //     } else if(s[i]=='q') {
    //         s[i]='p';
    //     }
    // }
    // reverse(s.begin(), s.end());
    // cout<<s<<endl;
    // int n, a, b;
    // cin>>n>>a>>b;
    // if(a%2==b%2) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // int n;
    // cin>>n;
    // vector<int> a(n), b(n);
    // for(int i=0; i<n; i++) {
    //     cin>>a[i];
    // }
    // int ok=-1, mini=1e9, req=0;
    // bool ans=false;
    // for(int i=0; i<n; i++) {
    //     cin>>b[i];
    //     if(a[i]<b[i]) {
    //         if(ok!=-1) {
    //             ans=true;
    //         }
    //         ok=i;
    //         req=b[i]-a[i];
    //     } else {
    //         mini=min(mini, a[i]-b[i]);
    //     }
    // }
    // if(ans) {
    //     cout<<"no"<<endl;
    // } else {
    //     cout<<((mini>=req) ? "yes" : "no")<<endl; 
    // }
    // int n, m;
    // cin>>n>>m;
    // vector<vector<int>> cards(n, vector<int> (m));
    // for(int i=0; i<n; i++) {
    //     for(int j=0; j<m; j++) {
    //         cin>>cards[i][j];
    //     }
    //     sort(cards[i].begin(), cards[i].end());
    // }
    // vector<int> ind(n);
    // for(int i=0; i<n; i++) {
    //     ind[i]=i;
    // }
    // sort(ind.begin(), ind.end(), [&](int x, int y) {
    //     return cards[x][0]<cards[y][0];
    // });
    // int topCard=-1;
    // bool ok=true;
    // for(int r=0; r<m && ok; r++) {
    //     for(int i=0; i<n; i++) {
    //         int cow=ind[i];
    //         auto it=upper_bound(cards[cow].begin(), cards[cow].end(), topCard);
    //         if(it==cards[cow].end()) {
    //             ok=false;
    //             break;
    //         }
    //         topCard=*it;
    //         cards[cow].erase(it);
    //     }
    // }
    // if(ok) {
    //     for(int i=0; i<n; i++) {
    //         cout<<ind[i]+1<<" ";
    //     }
    //     cout<<endl;
    // } else {
    //     cout<<-1<<endl;
    // }
    // int n, k;
    // cin>>n>>k;
    // vector<int> x(n);
    // unordered_map<int, int> mp;    
    // for(int i=0; i<n; i++) {
    //     cin>>x[i];
    //     mp[x[i]]++;
    // }
    // int score=0;
    // for(auto it=mp.begin(); it!=mp.end(); it++) {
    //     int num=it->first;
    //     int comp=k-num;
    //     if(mp[num]>0) {
    //         if(num==comp) {
    //             score+=mp[num]/2;
    //             mp[num]%=2;
    //         } else if(mp.count(comp)) {
    //             int pairs=min(mp[num], mp[comp]);
    //             score+=pairs;
    //             mp[num]-=pairs;
    //             mp[comp]-=pairs;
    //         }
    //     }
    // }
    // cout<<score<<endl;
    // int n;
    // cin>>n;
    // vector<int> a(n);
    // for(int i=0; i<n; i++) {
    //     cin>>a[i];
    // }
    // bool ans=true;
    // for(int i=1; i<n; i++) {
    //     if(a[i]<a[i-1]) {
    //         ans=false;
    //     }
    //     int diff=min(a[i], a[i-1]);
    //     a[i]-=diff;
    //     a[i-1]-=diff;
    // }
    // for(int i=1; i<n; i++) {
    //     if(a[i]<a[i-1]) {
    //         ans=false;
    //     }
    // }
    // if(ans) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // string s;
    // cin>>s;
    // int ans=0;
    // for(int i=0; i<s.length(); i++) {
    //     if(s[i]=='1') {
    //         ans++;
    //     }
    // }
    // cout<<ans<<endl;
    // int n;
    // cin>>n;
    // vector<ll> a(n);
    // bool ans=true;
    // for(int i=0; i<n; i++) {
    //     cin>>a[i];
    // }
    // for(int i=0; i<n; i++) {
    //     if(a[i]<=2*(max(i, n-1-i))) {
    //         ans=false;
    //         break;
    //     }
    // }
    // if(ans) {
    //     cout<<"yes"<<endl;
    // } else {
    //     cout<<"no"<<endl;
    // }
    // ll l, r;
    // cin>>l>>r;
    // if(l==r && l==1) {
    //     cout<<1<<endl;
    // } else {
    //     cout<<r-l<<endl;
    // }
    int n, l, r;
    cin>>n>>l>>r;
    l--;
    r--;
    vector<ll> a(n);
    for(int i=0; i<n; i++) {
        cin>>a[i];
    }
    int x=r-l+1;
    vector<ll> v1, v2;
    for(int i=0; i<=r; i++) {
        v1.push_back(a[i]);
    }
    for(int i=l; i<n; i++) {
        v2.push_back(a[i]);
    }
    sort(v1.begin(), v1.end());
    sort(v2.begin(), v2.end());
    ll ans1=0, ans2=0;
    for(int i=0; i<x; i++) {
        ans1+=v1[i];
        ans2+=v2[i];
    }
    cout<<min(ans1, ans2)<<endl;
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int t;
    cin>>t;
    while(t--) {
        solve();
    }
    return 0;
}

Solution 2 (runtime: 93 ms):
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define f0(i, n) for (int i = 0; i < n; i++)
#define pb push_back

void fillnums(vector<int> &nums, int &n)
{
    f0(i, n)
    {
        int x;
        cin >> x;
        nums.pb(x);
    }
}

void solve()
{
    int n, l, r;
    cin >> n >> l >> r;
    vector<int> nums;
    fillnums(nums, n);

    int val = r - l + 1; 

    
    vector<int> left(nums.begin(), nums.begin() + r);
    vector<int> right(nums.begin() + l - 1, nums.end());

    
    sort(left.begin(), left.end());
    sort(right.begin(), right.end());

   
    int leftSum = (left.size() >= val) ? accumulate(left.begin(), left.begin() + val, 0LL) : LLONG_MAX;
    int rightSum = (right.size() >= val) ? accumulate(right.begin(), right.begin() + val, 0LL) : LLONG_MAX;


    cout << min(leftSum, rightSum) << "\n";
}

signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}