#include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define _mp make_pair
#define vt vector
#define MAXN 200002
using namespace std;
typedef long long LL;
ll mod=1e9+7;
//     f[0]=f[1]=inv[0]=inv[1]=1;
// for(int i=2;i<MAXN;i++) f[i]=(LL)f[i-1]*i%mod,inv[i]=(LL)(mod-mod/i)*inv[mod%i]%mod;
// for(int i=1;i<MAXN;i++) inv[i]=(LL)inv[i-1]*inv[i]%mod;
ll f[MAXN],inv[MAXN];

ll C(const int n,const int m){return n<m?0:(LL)f[n]*inv[m]%mod*inv[n-m]%mod;}

ll power(ll num, ll p)
{
    if (p == 0)
        return 1;
    if (p == 1)
        return num;
    ll n = power(num, p / 2);
    if (p % 2 == 0)
        return (n * n)%(998244353) ;
    return (num*((n*n)%(998244353)))%(998244353);
}
ll fact(ll val)
{
    if (val <= 1)
        return 1;
    return (val * fact(val - 1));
}
ll ncr(ll n, ll r)
{
    if (n < r)
        return 0;
    ll p = 1, k = 1;
    if ((n - r) < r)
        r = n - r;

    if (r != 0)
    {
        while (r)
        {
            p = (p * n)%mod;
            k = (k * r)%mod;
            ll m = __gcd(p, k);
            p /= m;
            k /= m;
            n--;
            r--;
        }
    }
    else
        p = 1;
    return p;
}
// bool cmp(pair<int,int> v1, pair<int,int> v2)
// {
//     if(v1.first==v2.first)return v1.second>v2.second;
//     return v1.first<v2.first;
// }
bool isFact(ll n)
{
  for (ll i = 1;; i++) {
    if (n % i == 0) {
      n /= i;
    }
    else {
      break;
    }
  }

  if (n == 1LL) {
    return true;
  }
  else {
    return false;
  }
}
int lcs(string s, string t, int m, int n)
{
    if (m==0||n==0)return 0;
    if (s[m-1]==t[n-1])return 1 + lcs(s, t, m - 1, n - 1);
    else return max(lcs(s, t, m, n - 1),lcs(s, t, m - 1, n));
}
pair<ll,ll> maxSubArraySum(vector<ll>&a, int size)
{
    ll max_so_far = 0, max_ending_here = 0;
     int num=0,mx_len=0;
    for (int i = 0; i < size; i++) {
        max_ending_here = (max_ending_here + a[i]);
        num++;
        if (max_so_far < max_ending_here)
            {max_so_far = max_ending_here;mx_len=num;}
        else{
            max_ending_here=0;num=0;
        }
    }
    if(mx_len==size)max_so_far=0;
    return {max_so_far,mx_len};
}
bool isPrime(ll N){
    int flag = 1;

    double sqroot = sqrt(N);

    // Iterate from 2 to sqrt(n)
    for (int i = 2; i <= sqroot; i++) {

        // If n is divisible by any number between 2 and
        // sqrt(n), it is not prime
        if (N % i == 0) {
            flag = 0;
            break;
        }
    }
    return flag;
}
void rev(int start,int ind,int end,vt<int>&vec){
int val=ind+1;
while(val>0){
    for(int i=start;i<end;i++)swap(vec[i],vec[i+1]);
    val--;
}
}
int gcdExtended(ll a, ll b, ll* x, ll* y)
{

    // Base Case
    if (a == 0) {
        *x = 0, *y = 1;
        return b;
    }

    // To store results of recursive call
    ll x1, y1;
    int gcd = gcdExtended(b % a, a, &x1, &y1);

    // Update x and y using results of recursive
    // call
    *x = y1 - (b / a) * x1;
    *y = x1;

    return gcd;
}
ll modInverse(ll A, ll M)
{
    ll x, y;
    ll g = gcdExtended(A, M, &x, &y);
    if (g != 1)
        return -1;
    else {

        // m is added to handle negative x
        ll res = (x % M + M) % M;
        return res;
    }
}

// bool fun(int a,int b,int X,int Y){
//     double dis1=
// }

bool cmp(pair<int,int>a,pair<int,int>b){
    if(a.second<b.second)return true;
    else return a.first<b.first;
}
int countAndMerge(vector<int>& arr, int l, int m, int r) {

    // Counts in two subarrays
    int n1 = m - l + 1, n2 = r - m;

    // Set up two vectors for left and right halves
    vector<int> left(n1), right(n2);
    for (int i = 0; i < n1; i++)
        left[i] = arr[i + l];
    for (int j = 0; j < n2; j++)
        right[j] = arr[m + 1 + j];

    // Initialize inversion count (or result) and merge two halves
    int res = 0;
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {

        // No increment in inversion count if left[] has a
        // smaller or equal element
        if (left[i] <= right[j])
            arr[k++] = left[i++];

        // If right is smaller, then it is smaller than n1-i
          // elements because left[] is sorted
        else {
            arr[k++] = right[j++];
            res += (n1 - i);
        }
    }

    // Merge remaining elements
    while (i < n1)
        arr[k++] = left[i++];
    while (j < n2)
        arr[k++] = right[j++];

    return res;
}

// Function to count inversions in the array
ll countInv(vector<int>& arr, int l, int r){
    ll res = 0;
    if (l < r) {
        int m = (r + l) / 2;

        // Recursively count inversions in the left and
        // right halves
        res += countInv(arr, l, m);
        res += countInv(arr, m + 1, r);

        // Count inversions such that greater element is in
          // the left half and smaller in the right half
        res += countAndMerge(arr, l, m, r);
    }
    return res;
}

ll inversionCount(vector<int>& arr) {
      int n = arr.size();
      return countInv(arr, 0, n-1);
}
ll p(ll x,ll y){
    if(y==0)return 1;
    if(y==1)return x;
    ll z=p(x,y/2);
    ll r=(z*z)%(998244353);
    if(y%2)r=(r*x)%(998244353);
    return r;
}
void _solve1()
{
    int t;cin>>t;
    while(t--){
    int n,l,r;
    cin>>n>>l>>r;
    vt<int>v(n);
    for(int i=0;i<n;i++)cin>>v[i];
    sort(v.begin(),v.end());
    ll sum=0;
    for(int i=0;i<(r-l+1);i++)sum+=v[i];
    cout<<sum<<'\n';
    }
}
void _solve2(){
int a=134,b=132,c=137;
cout<<((a^b)+(b^c)+(c^a))<<'\n';
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    _solve1();
    // _solve2();
}

#include <bits/stdc++.h>

#define ll long long int

#define pb push_back

#define _mp make_pair

#define vt vector

#define MAXN 200002

using namespace std;

typedef long long LL;

ll mod=1e9+7;

//     f[0]=f[1]=inv[0]=inv[1]=1;

// for(int i=2;i<MAXN;i++) f[i]=(LL)f[i-1]*i%mod,inv[i]=(LL)(mod-mod/i)*inv[mod%i]%mod;

// for(int i=1;i<MAXN;i++) inv[i]=(LL)inv[i-1]*inv[i]%mod;

ll f[MAXN],inv[MAXN];

ll C(const int n,const int m){return n<m?0:(LL)f[n]*inv[m]%mod*inv[n-m]%mod;}

ll power(ll num, ll p)

{

    if (p == 0)

        return 1;

    if (p == 1)

        return num;

    ll n = power(num, p / 2);

    if (p % 2 == 0)

        return (n * n)%(998244353) ;

    return (num*((n*n)%(998244353)))%(998244353);

}

ll fact(ll val)

{

    if (val <= 1)

        return 1;

    return (val * fact(val - 1));

}

ll ncr(ll n, ll r)

{

    if (n < r)

        return 0;

    ll p = 1, k = 1;

    if ((n - r) < r)

        r = n - r;

    if (r != 0)

    {

        while (r)

        {

            p = (p * n)%mod;

            k = (k * r)%mod;

            ll m = __gcd(p, k);

            p /= m;

            k /= m;

            n--;

            r--;

        }

    }

    else

        p = 1;

    return p;

}

// bool cmp(pair<int,int> v1, pair<int,int> v2)

// {

//     if(v1.first==v2.first)return v1.second>v2.second;

//     return v1.first<v2.first;

// }

bool isFact(ll n)

{

  for (ll i = 1;; i++) {

    if (n % i == 0) {

      n /= i;

    }

    else {

      break;

    }

  }

  if (n == 1LL) {

    return true;

  }

  else {

    return false;

  }

}

int lcs(string s, string t, int m, int n)

{

    if (m==0||n==0)return 0;

    if (s[m-1]==t[n-1])return 1 + lcs(s, t, m - 1, n - 1);

    else return max(lcs(s, t, m, n - 1),lcs(s, t, m - 1, n));

}

pair<ll,ll> maxSubArraySum(vector<ll>&a, int size)

{

    ll max_so_far = 0, max_ending_here = 0;

     int num=0,mx_len=0;

    for (int i = 0; i < size; i++) {

        max_ending_here = (max_ending_here + a[i]);

        num++;

        if (max_so_far < max_ending_here)

            {max_so_far = max_ending_here;mx_len=num;}

        else{

            max_ending_here=0;num=0;

        }

    }

    if(mx_len==size)max_so_far=0;

    return {max_so_far,mx_len};

}

bool isPrime(ll N){

    int flag = 1;

    double sqroot = sqrt(N);

    // Iterate from 2 to sqrt(n)

    for (int i = 2; i <= sqroot; i++) {

        // If n is divisible by any number between 2 and

        // sqrt(n), it is not prime

        if (N % i == 0) {

            flag = 0;

            break;

        }

    }

    return flag;

}

void rev(int start,int ind,int end,vt<int>&vec){

int val=ind+1;

while(val>0){

    for(int i=start;i<end;i++)swap(vec[i],vec[i+1]);

    val--;

}

}

int gcdExtended(ll a, ll b, ll* x, ll* y)

{

    // Base Case

    if (a == 0) {

        *x = 0, *y = 1;

        return b;

    }

    // To store results of recursive call

    ll x1, y1;

    int gcd = gcdExtended(b % a, a, &x1, &y1);

    // Update x and y using results of recursive

    // call

    *x = y1 - (b / a) * x1;

    *y = x1;

    return gcd;

}

ll modInverse(ll A, ll M)

{

    ll x, y;

    ll g = gcdExtended(A, M, &x, &y);

    if (g != 1)

        return -1;

    else {

        // m is added to handle negative x

        ll res = (x % M + M) % M;

        return res;

    }

}

// bool fun(int a,int b,int X,int Y){

//     double dis1=

// }

bool cmp(pair<int,int>a,pair<int,int>b){

    if(a.second<b.second)return true;

    else return a.first<b.first;

}

int countAndMerge(vector<int>& arr, int l, int m, int r) {

    // Counts in two subarrays

    int n1 = m - l + 1, n2 = r - m;

    // Set up two vectors for left and right halves

    vector<int> left(n1), right(n2);

    for (int i = 0; i < n1; i++)

        left[i] = arr[i + l];

    for (int j = 0; j < n2; j++)

        right[j] = arr[m + 1 + j];

    // Initialize inversion count (or result) and merge two halves

    int res = 0;

    int i = 0, j = 0, k = l;

    while (i < n1 && j < n2) {

        // No increment in inversion count if left[] has a

        // smaller or equal element

        if (left[i] <= right[j])

            arr[k++] = left[i++];

        // If right is smaller, then it is smaller than n1-i

          // elements because left[] is sorted

        else {

            arr[k++] = right[j++];

            res += (n1 - i);

        }

    }

    // Merge remaining elements

    while (i < n1)

        arr[k++] = left[i++];

    while (j < n2)

        arr[k++] = right[j++];

    return res;

}

// Function to count inversions in the array

ll countInv(vector<int>& arr, int l, int r){

    ll res = 0;

    if (l < r) {

        int m = (r + l) / 2;

        // Recursively count inversions in the left and

        // right halves

        res += countInv(arr, l, m);

        res += countInv(arr, m + 1, r);

        // Count inversions such that greater element is in

          // the left half and smaller in the right half

        res += countAndMerge(arr, l, m, r);

    }

    return res;

}

ll inversionCount(vector<int>& arr) {

      int n = arr.size();

      return countInv(arr, 0, n-1);

}

ll p(ll x,ll y){

    if(y==0)return 1;

    if(y==1)return x;

    ll z=p(x,y/2);

    ll r=(z*z)%(998244353);

    if(y%2)r=(r*x)%(998244353);

    return r;

}

void _solve1()

{

    int t;cin>>t;

    while(t--){

    int n,l,r;

    cin>>n>>l>>r;

    vt<int>v(n);

    for(int i=0;i<n;i++)cin>>v[i];

    vt<int>s1,s2,s3;

    for(int i=0;i<l-1;i++)s1.pb(v[i]);

    for(int i=l-1;i<r;i++)s2.pb(v[i]);

    for(int i=r;i<n;i++)s3.pb(v[i]);

    sort(s1.begin(),s1.end());

    sort(s2.begin(),s2.end());

    sort(s3.begin(),s3.end());

    vt<ll>prea(s1.size()+1,0);

    vt<ll>preb(s2.size()+1,0);

    vt<ll>prec(s3.size()+1,0);

    for(int i=1;i<prea.size();i++){

     prea[i]=prea[i-1]+s1[i-1];

    }

    for(int i=1;i<preb.size();i++){

     preb[i]=preb[i-1]+s2[i-1];

    }

    for(int i=1;i<prec.size();i++){

     prec[i]=prec[i-1]+s3[i-1];

    }

    ll sum=1e15;

    for(int i=0;i<=min((int)s1.size(),(r-l+1));i++){

       sum=min(sum,prea[i]+preb[s2.size()-i]);

    }

    for(int i=0;i<=min((int)s3.size(),(r-l+1));i++){

        sum=min(sum,prec[i]+preb[s2.size()-i]);

    }

    cout<<sum<<'\n';

    }

}

void _solve2(){

int a=134,b=132,c=137;

cout<<((a^b)+(b^c)+(c^a))<<'\n';

}

int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    _solve1();

    // _solve2();

}

Answer: 2


#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());
    int 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;
}

#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;
}

Answer: 2


import java.util.Scanner;

public class Subsequence_Update{

    public static void merge(int[] arr, int l, int m, int r){

        int n1 = m - l + 1;

        int n2 = r - m;

        int[] L = new int[n1];

        int[] R = new int[n2];

        for(int i = 0; i<n1; i++){

            L[i] = arr[l + i];

        }

        for(int i = 0; i<n2; i++){

            R[i] = arr[m + 1 + i];

        }

        int i = 0;

        int j = 0;

        int k = l;

        while(i<n1 && j<n2){

            if(L[i] <= R[j]){

                arr[k] = L[i];

                i++;

            }else{

                arr[k] = R[j];

                j++;

            }

            k++;

        }

        while(i<n1){

            arr[k] = L[i];

            i++;

            k++;

        }

        while(j<n2){

            arr[k] = R[j];

            j++;

            k++;

        }

    }

    public static void mergeSort(int[] arr, int l, int r){

        if(l<r){

            int m = (l+r)/2;

            mergeSort(arr, l, m);

            mergeSort(arr, m+1, r);

            merge(arr, l, m, r);

        }

    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();

        for(int i = 0; i<t; i++){

            int n = sc.nextInt();

            long l = sc.nextLong();

            long r = sc.nextLong();

            int[] arr = new int[n];

            for(int j = 0; j<n; j++){

                arr[j] = sc.nextInt();

            }

            int[] arr1 = new int[(int) r];

            for(long j = 0; j<r; j++){

                arr1[(int)j] = arr[(int)j];

            }

            int[] arr2 = new int[(int)(n-l + 1)];

            for(int j = 0; j<n-l+1; j++){

                arr2[(int)j] = arr[(int)(j+l-1)];

            }

            mergeSort(arr1, 0, (int)(r-1));

            mergeSort(arr2, 0, (int)(n-l));

            int sum1 = 0;

            int sum2 = 0;

            for(int j = 0; j<(r - l + 1); j++){

                sum1 += arr1[j];

                sum2 += arr2[j];

            }

            if(sum1<=sum2){

                System.out.println(sum1);

            }else{

                System.out.println(sum2);

            }

        }

    }

}

import java.util.Scanner;
public class Subsequence_Update{
    public static void merge(int[] arr, int l, int m, int r){
        int n1 = m - l + 1;
        int n2 = r - m;

        int[] L = new int[n1];
        int[] R = new int[n2];

        for(int i = 0; i<n1; i++){
            L[i] = arr[l + i];
        }

        for(int i = 0; i<n2; i++){
            R[i] = arr[m + 1 + i];
        }

        int i = 0;
        int j = 0;
        int k = l;

        while(i<n1 && j<n2){
            if(L[i] <= R[j]){
                arr[k] = L[i];
                i++;
            }else{
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while(i<n1){
            arr[k] = L[i];
            i++;
            k++;
        }

        while(j<n2){
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    public static void mergeSort(int[] arr, int l, int r){
        if(l<r){
            int m = (l+r)/2;
            mergeSort(arr, l, m);
            mergeSort(arr, m+1, r);
            merge(arr, l, m, r);
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Long t = sc.nextLong();
        for(int i = 0; i<t; i++){
            int n = sc.nextInt();
            long l = sc.nextLong();
            long r = sc.nextLong();
            int[] arr = new int[n];
            for(int j = 0; j<n; j++){
                arr[j] = sc.nextInt();
            }

            int[] arr1 = new int[(int) r];
            for(long j = 0; j<r; j++){
                arr1[(int)j] = arr[(int)j];
            }

            int[] arr2 = new int[(int)(n-l + 1)];
            for(int j = 0; j<n-l+1; j++){
                arr2[(int)j] = arr[(int)(j+l-1)];
            }

            mergeSort(arr1, 0, (int)(r-1));
            mergeSort(arr2, 0, (int)(n-l));

            Long sum1 = 0l;
            Long sum2 = 0l;

            for(int j = 0; j<(r - l + 1); j++){
                sum1 += arr1[j];
                sum2 += arr2[j];
            }

            if(sum1<=sum2){
                System.out.println(sum1);
            }else{
                System.out.println(sum2);
            }
        }
    }
}

Answer: 2


#include<bits/stdc++.h>

using namespace std;

typedef vector<int> vi;
typedef vector<long long int> vll;
typedef long long int lli;
typedef pair<int, int> pii;
typedef map<string, int> msi;
typedef map<int, vector<int>> miv;

// Funciones vector
#define PB(a) push_back(a);

bool sort_func(lli a, lli b) {
  if (a < b) {
    return true;
  } else {
    return false;
  }
}
#define ord(vect) sort(vect.begin(), vect.end(), sort_func);

#define borra_el(vect, el) vect.erase(vect.find(el));
#define borra_range(vect, a, b) vect.erase(a, b);
#define borra(vect, n) vect.erase(vect.begin() + n);
#define B begin();
#define E end();
#define copia(v1, v2)                                                          \
  ;                                                                            \
  copy(v1.begin(), v1.end(), back_inserter(v2));

// Funciones map
#define F first;
#define S second;

// Logaritmo de 2
double log_2 = log(2);
double log2(int a) { return (log(a) / log_2); }

void Imprime(vi vect) {
  for (int i = 0; i < vect.size(); i++) {
    cout << vect[i] << " ";
  }
  cout << "\n";
}

void Imprime2d(vector<vi> vect) {
  for (int j = 0; j<vect.size(); j++){
    for (int i = 0; i < vect[j].size(); i++) {
        cout << vect[j][i] << " ";
    }
    cout << "\n";
  }
}

void Imprime_set(set<int> s) {
  copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));
  cout << endl;
}

int maximo_comun_divisor(int a, int b) {
  int temporal; // Para no perder b
  while (b != 0) {
    temporal = b;
    b = a % b;
    a = temporal;
  }
  return a;
}

int minimo_comun_multiplo(int a, int b) {
  return (a * b) / maximo_comun_divisor(a, b);
}

bool isNumeric(string const &str) {
  auto it = str.begin();
  while (it != str.end() && isdigit(*it)) {
    it++;
  }
  return !str.empty() && it == str.end();
}

vll lee(lli n) {
  lli el;
  vll vect;
  for (int i = 0; i < n; i++) {
    cin >> el;
    vect.PB(el);
  }
  return (vect);
}

int solve() {
  // Code aquí
  lli n, l, r;
  cin >> n >> l >> r;

  vll a;
  a = lee(n);

  vll al, ar;
  for (int i = 0; i<n; i++){
    if (i<=r-1){
        al.PB(a[i]);
    }
    if (i>=l-1){
        ar.PB(a[i]);
    }
  }
  ord(al);
  ord(ar);
  lli sum_1 = 0, sum_2 = 0;
  for (int i = 0; i<r-l+1; i++){
    if (i<al.size()){
        sum_1+=al[i];
    }
    if (i<ar.size()){
        sum_2+=ar[i];
    }
  }
  cout << min(sum_1, sum_2) << endl;

  return 0;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  int T;
  cin >> T; // Número de casos
  while (T--) {
    solve();
  }
  return 0;
}

//Eliminar comentario si el proyecto está terminado (Dinámica empezó el 21/06/2024)

#include<bits/stdc++.h>

using namespace std;

typedef vector<int> vi;
typedef vector<long long int> vll;
typedef long long int lli;
typedef pair<int, int> pii;
typedef map<string, int> msi;
typedef map<int, vector<int>> miv;

// Funciones vector
#define PB(a) push_back(a);

bool sort_func(int a, int b) {
  if (a < b) {
    return true;
  } else {
    return false;
  }
}
#define ord(vect) sort(vect.begin(), vect.end(), sort_func);

#define borra_el(vect, el) vect.erase(vect.find(el));
#define borra_range(vect, a, b) vect.erase(a, b);
#define borra(vect, n) vect.erase(vect.begin() + n);
#define B begin();
#define E end();
#define copia(v1, v2)                                                          \
  ;                                                                            \
  copy(v1.begin(), v1.end(), back_inserter(v2));

// Funciones map
#define F first;
#define S second;

// Logaritmo de 2
double log_2 = log(2);
double log2(int a) { return (log(a) / log_2); }

void Imprime(vi vect) {
  for (int i = 0; i < vect.size(); i++) {
    cout << vect[i] << " ";
  }
  cout << "\n";
}

void Imprime2d(vector<vi> vect) {
  for (int j = 0; j<vect.size(); j++){
    for (int i = 0; i < vect[j].size(); i++) {
        cout << vect[j][i] << " ";
    }
    cout << "\n";
  }
}

void Imprime_set(set<int> s) {
  copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));
  cout << endl;
}

int maximo_comun_divisor(int a, int b) {
  int temporal; // Para no perder b
  while (b != 0) {
    temporal = b;
    b = a % b;
    a = temporal;
  }
  return a;
}

int minimo_comun_multiplo(int a, int b) {
  return (a * b) / maximo_comun_divisor(a, b);
}

bool isNumeric(string const &str) {
  auto it = str.begin();
  while (it != str.end() && isdigit(*it)) {
    it++;
  }
  return !str.empty() && it == str.end();
}

vi lee(int n) {
  int el;
  vi vect;
  for (int i = 0; i < n; i++) {
    cin >> el;
    vect.PB(el);
  }
  return (vect);
}

int solve() {
  // Code aquí
  int n, l, r;
  cin >> n >> l >> r;

  vi a;
  a = lee(n);

  vi al, ar;
  for (int i = 0; i<n; i++){
    if (i<=r-1){
        al.PB(a[i]);
    }
    if (i>=l-1){
        ar.PB(a[i]);
    }
  }
  ord(al);
  ord(ar);
  int sum_1 = 0, sum_2 = 0;
  for (int i = 0; i<r-l+1; i++){
    if (i<al.size()){
        sum_1+=al[i];
    }
    if (i<ar.size()){
        sum_2+=ar[i];
    }
  }
  cout << min(sum_1, sum_2) << endl;

  return 0;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  int T;
  cin >> T; // Número de casos
  while (T--) {
    solve();
  }
  return 0;
}

//Eliminar comentario si el proyecto está terminado (Dinámica empezó el 21/06/2024)

Answer: 1


#include<iostream>

#include<cmath>

#include<cstring>

#include<algorithm>

using namespace std;

const int N=1e5+5;

int a[N];

typedef long long ll;

int main(){

	ios::sync_with_stdio(false);

	cin.tie(0);

	cout.tie(0);

	int  t;cin>>t;

	while(t--){

		int n,l,r;cin>>n>>l>>r;

		for(int i=1;i<=n;i++)cin>>a[i];

		sort(a+1,a+1+n);

		ll sum=0;

		for(int i=1;i<=r-l+1;i++)sum+=a[i];

		cout<<sum<<"\n";

	}

}

#include<iostream>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

const int N=1e5+5;
int a[N],b[N];

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int  t;cin>>t;
	while(t--){
		int n,l,r;
		cin>>n>>l>>r;
		for(int i=1;i<=n;i++){
			cin>>a[i];
			b[i]=a[i];
		}
		sort(a+1,a+1+r);
		sort(b+l,b+n+1);
		ll sum1=0,sum2=0;
		for(int i=1;i<=r-l+1;i++)sum1+=a[i];
		for(int i=l;i<=r;i++)sum2+=b[i];
		cout<<min(sum1,sum2)<<"\n";
	}
}

Answer: 2


for _ in range(int(input())):
    n,l,r=map(int,input().split())
    l-=1
    r-=1
    a=list(map(int,input().split()))
    if l==0 and r==n-1:
        print(sum(a[l:r+1]))
        continue
    if l==r:
        print(min(a))
        continue
    sub,subleft,subright,t,res=sorted(a[l:r+1],reverse=True),sorted(a[:l]),sorted(a[r+1:]),sum(a[l:r+1]),float('inf')
    if l>0:
        change=0
        for i in range(r-l+1):
            if i<len(subleft):
                if subleft[i]<sub[i]:
                    change+=subleft[i]-sub[i]
            else:
                break
        res=min(res,t+change)
    if r<n:
        change=0
        for i in range(r-l+1):
            if i<len(subright):
                if subright[i]<sub[i]:
                    change+=subright[i]-sub[i]
            else:
                break
        res=min(res,t+change)
    print(res)

for _ in range(int(input())):

    n,l,r=map(int,input().split())

    l-=1

    r-=1

    a=list(map(int,input().split()))

    if l==0 and r==n-1:

        print(sum(a[l:r+1]))

        continue

    if l==r:

        print(min(a))

        continue

    sub,subleft,subright,t,res=sorted(a[l:r+1],reverse=True),sorted(a[:l]),sorted(a[r+1:]),sum(a[l:r+1]),9999999

    combined=[]

    for i in subleft:

        combined.append(i)

    for i in subright:

        combined.append(i)

    combined.sort()

    change=0

    for i in range(r-l+1):

        if i<len(combined):

            if combined[i]<sub[i]:

                change+=combined[i]-sub[i]

        else:

            break

    res=min(res,t+change)

    print(res)

Answer: 1


#include<bits/stdc++.h>

using namespace std;

#define int long long

#define PB push_back

typedef vector<int> vi;

typedef vector<string> vs;

const int mod = 1e9 + 7;

const int inf = INT_MAX;

template<typename t>

vector<t> I(int n) {

    vector<t> vector;

    for (int i = 0; i < n; i++) {

        t input;

        cin >> input;

        vector.push_back(input);

    }

    return vector;

}

template<typename t>

void D(vector<t> vector) {

    for (auto i: vector) {

        cout << i << " ";

    }

    cout << "\n";

}

void solve() {

    int n, l , r;

    cin >> n >> l >> r;

    vi x = I<int>(n);

    vi first(x.begin(), x.begin() + r);

    vi second(x.begin() + l - 1, x.end());

    sort(first.begin(), first.end());

    sort(second.begin(), second.end());

    long long sum1 = accumulate(first.begin(), first.begin() + (r - l + 1), 0LL);

    long long sum2 = accumulate(second.begin(), second.begin() + (r - l + 1), 0LL);

    cout << min(sum1, sum2) << "\n";

}

int32_t main() {

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    cout.tie(NULL);

    int t;

    cin >> t;

    while (t--) {

        solve();

    }

}

#include<bits/stdc++.h>

using namespace std;

#define int long long

#define PB push_back

typedef vector<int> vi;

typedef vector<string> vs;

const int mod = 1e9 + 7;

const int inf = INT_MAX;

template<typename t>

vector<t> I(int n) {

    vector<t> vector;

    for (int i = 0; i < n; i++) {

        t input;

        cin >> input;

        vector.push_back(input);

    }

    return vector;

}

template<typename t>

void D(vector<t> vector) {

    for (auto i: vector) {

        cout << i << " ";

    }

    cout << "\n";

}

void solve() {

    int n, l , r;

    cin >> n >> l >> r;

    vi x = I<int>(n);

    vi first(x.begin(), x.begin() + r);

    vi second(x.begin() + l - 1, x.end());

    sort(first.begin(), first.end());

    sort(second.begin(), second.end());

    int sum1 = accumulate(first.begin(), first.begin() + r - l + 1, 0);

    int sum2 = accumulate(second.begin(), second.begin() + r - l + 1, 0);

    cout << min(sum1, sum2) << "\n";

}

int32_t main() {

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    cout.tie(NULL);

    int t;

    cin >> t;

    while (t--) {

        solve();

    }

}

Answer: 1


#include<bits/stdc++.h>

using namespace std;

const int N=100010;

typedef long long ll;

int a[N],b[N];

ll sum1[N],sum2[N];

int main()

{

    int T;

    cin>>T;

    while(T--)

    {

        memset(a,0,sizeof a);

        memset(b,0,sizeof b);

        memset(sum1,0,sizeof sum1);

        memset(sum2,0,sizeof sum2);

        int n,l,r;

        cin>>n>>l>>r;

        for(int i=1;i<=n;i++)

        {

            scanf("%d",&a[i]);

        }

        for(int i=l;i<=n;i++)

        {

            b[i-l+1]=a[i];

        }

        sort(a+1,a+r+1);

        sort(b+1,b+n-l+2);

        for(int i=1;i<=r;i++)

        {

            sum1[i]=sum1[i-1]+a[i];

            sum2[i]=sum2[i-1]+b[i];

        }

        printf("%lld\n",min(sum1[r-l+1],sum2[r-l+1]));

    }

    return 0;

}

#include<bits/stdc++.h>

using namespace std;

const int N=100010;

typedef long long ll;

int a[N];

ll sum[N];

int main()

{

    int T;

    cin>>T;

    while(T--)

    {

        memset(a,0,sizeof a);

        memset(sum,0,sizeof sum);

        int n,l,r;

        cin>>n>>l>>r;

        for(int i=1;i<=n;i++)

        {

            scanf("%d",&a[i]);

        }

        sort(a+1,a+n+1);

        for(int i=1;i<=n;i++)

        {

            sum[i]=sum[i-1]+a[i];

        }

        printf("%lld\n",sum[r-l+1]-sum[0]);

    }

    return 0;

}

Answer: 1


#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define all(x) x.begin(),x.end()
#define vii vector<int>
#define vll vector<ll>
#define rep(i,x,n) for(int i = x;i<n;i++)
#include <algorithm>
using namespace std;
#include <numeric>
#define mod 1000000007
#ifndef ONLINE_JUDGE
#define debug(x) cerr<<#x<<"->"<<x<<endl;
#else
#define debug(x)
#endif
// using namespace __gnu_pbds;

// typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
//              tree_order_statistics_node_update>
//     ordered_set;

/* -----------TRIE-----------
class TrieNode{
    public:
        TrieNode* children[26];
        bool isEnd;
        TrieNode(){
            isEnd = false;
            for(auto &e:children)
                e = nullptr;
        }
};
class Trie{
    public:
        TrieNode* root = new TrieNode();
        void insert(string s){
            TrieNode* crawl = root;
            for(auto e:s){
                int i = e-'a';
                if(crawl->children[i] == nullptr){
                    crawl->children[i] = new TrieNode();
                }
                crawl = crawl->children[i];
            }
            crawl->isEnd = true;
        }
        bool search(string s){
            TrieNode* crawl = root;
            for(auto e:s){
                int i = e-'a';
                if(!crawl->children[i])
                    return false;
                crawl = crawl->children[i];
            }
            if(crawl && crawl->isEnd)
                return true;
            return false;
        }

};

*/
/* ---------DFS--------------
int dx[] = {0,0,1,-1};
int dy[] = {-1,1,0,0};
bool isSafe(int x, int y, int n, int m){
    return (x>=0&&x<n&&y>=0&&y<m);
}
void dfs(vector<vector<int>> &mat,int i,int j,vector<vector<bool>> &visited,int &count){
    visited[i][j] = true;
    count+=mat[i][j];
    for(int z = 0;z<4;z++){
        int x = dx[z]+i;
        int y = dy[z]+j;
        if(isSafe(x,y,mat.size(),mat[0].size()) && !visited[x][y]&&mat[x][y]>0){
            visited[x][y] = true;
            dfs(mat,x,y,visited,count);
        }
    }
}
*/
// void dfs(int v, int p,vector<vector<long long>> &mp,vector<long long> &arr) {
//     if (mp[v].size() == 1 && mp[v][0] == p) {
//         arr[v] = 1;
//     } else {
//         for (auto u : mp[v]) {
//             if (u != p) {
//                 dfs(u, v,mp,arr);
//                 arr[v] += arr[u];
//             }
//         }
//     }
// }

/*-----------------------DSU--------------------------------- */
// vector<pair<int,int>> parent(200009);
// void initialize(){
//     for(int i = 1;i<=parent.size();i++)
//         parent[i] = {i,1};
// }
// pair<int, int> find(int x){
//     if(parent[x].first == x)
//         return parent[x];
//     parent[x] = find(parent[x].first);
//     return parent[x];
// }
// void Union(int x, int y){
//     auto x1 = find(x);
//     auto y1 = find(y);
//     if(x1.first != y1.first){
//         // cout<<x<<"-"<<y<<" ";
//         // if(parent[x].second)
//         parent[x1.first].first = y;
//         parent[y1.first].second += parent[x1.first].second;
//     }
// }

// void dfs(unordered_map<int,vector<int>> mp,vector<int> &a,vector<bool> &visited,int i,int &mini){
//     visited[i] = true;
//     for(auto e:mp[i]){
//         if(!visited[e]){
//             visited[e] = true;
//             mini = min(mini,a[e]);
//             dfs(mp,a,visited,e,mini);
//         }
//     }
// }

// long long fact(long long n)
// {
//       if(n==0)
//       return 1;
//     long long res = 1;
//     for (long long i = 2; i <= n; i++)
//         res = res * i;
//     return res;
// }
// long long nCr(long long n, long long r)
// {
//     ll nume = fact(n);
//     ll deno = fact(r);
//     nume/=deno;
//     deno = fact(n-r);
//     nume/=deno;
//     return nume;
// }
// bool isSafe(int x, int y, int n, int m){
//     return (x>=0&&x<n&&y>=0&&y<m);
// }
// int lcs(string a, string b){
//     int m = a.size(),n = b.size();
//     int dp[m + 1][n + 1];
//     for (int i = 0; i <= m; i++) {
//         for (int j = 0; j <= n; j++) {
//             if (i == 0 || j == 0)
//                 dp[i][j] = 0;
//             else if (a[i - 1] == b[j - 1])
//                 dp[i][j] = dp[i - 1][j - 1] + 1;
//             else
//                 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
//         }
//     }
//     return dp[m][n];
// }

// void rev(string &s,int l,int r){
//     // cout<<l<<"&"<<r<<" ";
//     l--;
//     r--;
//     while(l<=r){
//         swap(s[l],s[r]);
//         l++;
//         r--;
//     }
// }
// ll gcd(ll a, ll b){  ll c = a % b;  while(c != 0)  {    a = b;    b = c;    c = a % b;  }  return b;}
// ll get_factorial(ll x){
//     ll ans = 1;
//     while(x>0){
//         ans*=x;
//         x--;
//     }
//     return ans;
// }
//only perfect squares have odd number of divisors...........
void findAns(){
    int n,l,r;
    cin>>n>>l>>r;
    l--;
    r--;
    vii arr(n);
    rep(i,0,n)
        cin>>arr[i];

    vii brr = arr;
    sort(brr.begin(),brr.begin()+r+1);
    sort(arr.begin()+l,arr.end());
    // for(auto e:brr)
    //     cout<<e<<" ";
    // cout<<endl;
    ll ans = INT_MAX;
    ll curr = 0;
    ll stack = 0;
    for(int i = 0;i<r-l+1;i++){
        curr+=brr[i];
        stack++;
        if(stack == r-l+1){
            break;
        }
    }
    if(stack == r-l+1)
        ans = curr;
    curr = 0;
    stack = 0;
    for(int i = l;i<n;i++){
        curr+=arr[i];
        stack++;
        if(stack == r-l+1){
            break;
        }
    }
    if(stack == r-l+1)
        ans = min(ans,curr);
    ans = min(ans,curr);
    cout<<ans<<endl;

}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    #ifndef ONLINE_JUDGE
    freopen("error.txt","w",stderr);
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    #endif

    int n ;
    cin>>n;
    // int x = n ;
    while(n--){
        findAns();
    }
}

#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define all(x) x.begin(),x.end()
#define vii vector<int>
#define vll vector<ll>
#define rep(i,x,n) for(int i = x;i<n;i++)
#include <algorithm>
using namespace std;
#include <numeric>
#define mod 1000000007
#ifndef ONLINE_JUDGE
#define debug(x) cerr<<#x<<"->"<<x<<endl;
#else
#define debug(x)
#endif
// using namespace __gnu_pbds;

// typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
//              tree_order_statistics_node_update>
//     ordered_set;

/* -----------TRIE-----------
class TrieNode{
    public:
        TrieNode* children[26];
        bool isEnd;
        TrieNode(){
            isEnd = false;
            for(auto &e:children)
                e = nullptr;
        }
};
class Trie{
    public:
        TrieNode* root = new TrieNode();
        void insert(string s){
            TrieNode* crawl = root;
            for(auto e:s){
                int i = e-'a';
                if(crawl->children[i] == nullptr){
                    crawl->children[i] = new TrieNode();
                }
                crawl = crawl->children[i];
            }
            crawl->isEnd = true;
        }
        bool search(string s){
            TrieNode* crawl = root;
            for(auto e:s){
                int i = e-'a';
                if(!crawl->children[i])
                    return false;
                crawl = crawl->children[i];
            }
            if(crawl && crawl->isEnd)
                return true;
            return false;
        }

};

*/
/* ---------DFS--------------
int dx[] = {0,0,1,-1};
int dy[] = {-1,1,0,0};
bool isSafe(int x, int y, int n, int m){
    return (x>=0&&x<n&&y>=0&&y<m);
}
void dfs(vector<vector<int>> &mat,int i,int j,vector<vector<bool>> &visited,int &count){
    visited[i][j] = true;
    count+=mat[i][j];
    for(int z = 0;z<4;z++){
        int x = dx[z]+i;
        int y = dy[z]+j;
        if(isSafe(x,y,mat.size(),mat[0].size()) && !visited[x][y]&&mat[x][y]>0){
            visited[x][y] = true;
            dfs(mat,x,y,visited,count);
        }
    }
}
*/
// void dfs(int v, int p,vector<vector<long long>> &mp,vector<long long> &arr) {
//     if (mp[v].size() == 1 && mp[v][0] == p) {
//         arr[v] = 1;
//     } else {
//         for (auto u : mp[v]) {
//             if (u != p) {
//                 dfs(u, v,mp,arr);
//                 arr[v] += arr[u];
//             }
//         }
//     }
// }

/*-----------------------DSU--------------------------------- */
// vector<pair<int,int>> parent(200009);
// void initialize(){
//     for(int i = 1;i<=parent.size();i++)
//         parent[i] = {i,1};
// }
// pair<int, int> find(int x){
//     if(parent[x].first == x)
//         return parent[x];
//     parent[x] = find(parent[x].first);
//     return parent[x];
// }
// void Union(int x, int y){
//     auto x1 = find(x);
//     auto y1 = find(y);
//     if(x1.first != y1.first){
//         // cout<<x<<"-"<<y<<" ";
//         // if(parent[x].second)
//         parent[x1.first].first = y;
//         parent[y1.first].second += parent[x1.first].second;
//     }
// }

// void dfs(unordered_map<int,vector<int>> mp,vector<int> &a,vector<bool> &visited,int i,int &mini){
//     visited[i] = true;
//     for(auto e:mp[i]){
//         if(!visited[e]){
//             visited[e] = true;
//             mini = min(mini,a[e]);
//             dfs(mp,a,visited,e,mini);
//         }
//     }
// }

// long long fact(long long n)
// {
//       if(n==0)
//       return 1;
//     long long res = 1;
//     for (long long i = 2; i <= n; i++)
//         res = res * i;
//     return res;
// }
// long long nCr(long long n, long long r)
// {
//     ll nume = fact(n);
//     ll deno = fact(r);
//     nume/=deno;
//     deno = fact(n-r);
//     nume/=deno;
//     return nume;
// }
// bool isSafe(int x, int y, int n, int m){
//     return (x>=0&&x<n&&y>=0&&y<m);
// }
// int lcs(string a, string b){
//     int m = a.size(),n = b.size();
//     int dp[m + 1][n + 1];
//     for (int i = 0; i <= m; i++) {
//         for (int j = 0; j <= n; j++) {
//             if (i == 0 || j == 0)
//                 dp[i][j] = 0;
//             else if (a[i - 1] == b[j - 1])
//                 dp[i][j] = dp[i - 1][j - 1] + 1;
//             else
//                 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
//         }
//     }
//     return dp[m][n];
// }

// void rev(string &s,int l,int r){
//     // cout<<l<<"&"<<r<<" ";
//     l--;
//     r--;
//     while(l<=r){
//         swap(s[l],s[r]);
//         l++;
//         r--;
//     }
// }
// ll gcd(ll a, ll b){  ll c = a % b;  while(c != 0)  {    a = b;    b = c;    c = a % b;  }  return b;}
// ll get_factorial(ll x){
//     ll ans = 1;
//     while(x>0){
//         ans*=x;
//         x--;
//     }
//     return ans;
// }
//only perfect squares have odd number of divisors...........
void findAns(){
    int n,l,r;
    cin>>n>>l>>r;
    l--;
    r--;
    vii arr(n);
    rep(i,0,n)
        cin>>arr[i];

    vii brr = arr;
    sort(brr.begin(),brr.begin()+r);
    sort(arr.begin()+l,arr.end());

    ll ans = INT_MAX;
    ll curr = 0;
    ll stack = 0;
    for(int i = 0;i<r-l+1;i++){
        curr+=brr[i];
        stack++;
        if(stack == r-l+1){
            break;
        }
    }
    if(stack == r-l+1)
        ans = curr;
    curr = 0;
    for(int i = 0;i<r-l+1;i++){
        curr+=arr[i];
        stack++;
        if(stack == r-l+1){
            break;
        }
    }
    if(stack == r-l+1)
        ans = min(ans,curr);
    ans = min(ans,curr);
    cout<<ans<<endl;

}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    #ifndef ONLINE_JUDGE
    freopen("error.txt","w",stderr);
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);

    #endif

    int n ;
    cin>>n;
    // int x = n ;
    while(n--){
        findAns();
    }
}

Answer: 1


#include<iostream>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

using namespace std;

const int N=200010;

long long a[N],b[N],c[N];

void solve(){

	int n,l,r;

	cin>>n>>l>>r;

	for(int i=0;i<n;i++){

		cin>>a[i];

	}

	for(int i=0;i<r;i++) b[i]=a[i];

	int k=0;

	for(int i=l-1;i<n;i++) c[k++]=a[i];

	sort(b,b+r);

	sort(c,c+k);

	int t=r-l+1;

	long long minv=0;

	long long cnt=1e17;

	for(int i=0;i<t;i++) minv+=b[i];

	cnt=min(cnt,minv);

	minv=0;

	for(int i=0;i<t;i++) minv+=c[i];

	cnt=min(cnt,minv);

	cout << cnt << endl;

}

int main(){

	int t;

	cin>>t;

	while(t--){

		solve();

	}

	return 0;

}

#include<iostream>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

using namespace std;

const int N=200010;

long long a[N],b[N],c[N];

void solve(){

	int n,l,r;

	cin>>n>>l>>r;

	for(int i=0;i<n;i++){

		cin>>a[i];

	}

	for(int i=0;i<r;i++) b[i]=a[i];

	int k=0;

	for(int i=l-1;i<n;i++) c[k++]=a[i];

	sort(b,b+r);

	sort(c,c+k);

	int t=r-l+1;

	long long minv=0;

	long long cnt=1e13;

	for(int i=0;i<t;i++) minv+=b[i];

	cnt=min(cnt,minv);

	minv=0;

	for(int i=0;i<t;i++) minv+=c[i];

	cnt=min(cnt,minv);

	cout << cnt << endl;

}

int main(){

	int t;

	cin>>t;

	while(t--){

		solve();

	}

	return 0;

}

Answer: 1


#include <bits/stdc++.h>
using namespace std;

#define int long long

#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;

void fastio(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
}

const int maxN=2e3;
const int INF=1e9;
const int MOD=1e9+7;

int t, n, l, r, ans1, ans2;
vi arrM, arr;

bool invComp(int a, int b){
    return a>=b;
}

signed main(){
    fastio();
    cin >> t;
    while(t--){
        cin >> n >> l >> r;
        arr.resize(n+50, 0);
        for(int i=0; i<n; i++){
            cin >> arr[i];
        }
        l--; r--;
        ans1=ans2=0;
        arrM=arr;
        sort(arrM.begin(), arrM.begin()+r+1, invComp);
        for(int i=l; i<=r; i++){
            ans1+=arrM[i];
        }
        arrM=arr;
        sort(arrM.begin()+l, arrM.begin()+n);
        for(int i=l; i<=r; i++){
            ans2+=arrM[i];
        }
        cout << min(ans1, ans2) << endl;
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

#define int long long

#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;

void fastio(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
}

const int maxN=2e3;
const int INF=1e9;
const int MOD=1e9+7;

int t, n, l, r, ans1, ans2, a;
vi arr1, arr2;

signed main(){
    fastio();
    cin >> t;
    while(t--){
        cin >> n >> l >> r;
        arr1.clear();
        arr2.clear();
        l--; r--;
        for(int i=0; i<n; i++){
            cin >> a;
            if(i<=r) arr1.pb(a);
            if(i>=l) arr2.pb(a);
        }
        ans1=ans2=0;
        sort(all(arr1));
        sort(all(arr2));
        for(int i=0; i<=r-l; i++){
            ans1+=arr1[i];
            ans2+=arr2[i];
        }
        cout << min(ans1, ans2) << endl;
    }
    return 0;
}

Answer: 2


#include<iostream>

#include<vector>

#include<algorithm>

#include<unordered_map>

#include<unordered_set>

#include<sstream>

#include<string>

#include<set>

#include<map>

#include<queue>

#define ll long long

#define MAX 200'001

using namespace std;

void solve() {

    int n, l, r;

    cin >> n >> l >> r;

    vector<int> array(n);

    for(int &a : array) {

        cin >> a;

    }

    vector<int> left_half;

    for(int i = 0; i < l; i++) {

        left_half.push_back(array[i]);

    }

    vector<int> right_half;

    for(int i = r; i < n; i++) {

        right_half.push_back(array[i]);

    }

    sort(left_half.begin(), left_half.end());

    sort(right_half.begin(), right_half.end());

    ll left_sum = 0;

    int left_pointer = 0;

    int segment_pointer = l - 1;

    while(left_pointer < left_half.size() && segment_pointer < r) {

        int min_value = min(array[segment_pointer], left_half[left_pointer]);

        if(min_value == array[segment_pointer]) {

            left_sum += min_value;

            segment_pointer++;

        }

        else {

            left_sum += min_value;

            left_pointer++;

            segment_pointer++;

        }

    }

    while(segment_pointer < r) {

        left_sum += array[segment_pointer];

        segment_pointer++;

    }

    ll right_sum = 0;

    int right_pointer = 0;

    segment_pointer = l - 1;

    while(right_pointer < right_half.size() && segment_pointer < r) {

        int min_value = min(array[segment_pointer], right_half[right_pointer]);

        if(min_value == array[segment_pointer]) {

            right_sum += min_value;

            segment_pointer++;

        }

        else {

            right_sum += min_value;

            right_pointer++;

            segment_pointer++;

        }

    }

    while(segment_pointer < r) {

        right_sum += array[segment_pointer];

        segment_pointer++;

    }

    cout << min(left_sum, right_sum) << '\n';

}

int main() {

    int t;

    cin >> t;

    while(t--) {

        solve();

    }

    return 0;

}

#include<iostream>

#include<vector>

#include<algorithm>

#include<unordered_map>

#include<unordered_set>

#include<sstream>

#include<string>

#include<set>

#include<map>

#include<queue>

#define ll long long

#define MAX 200'001

using namespace std;

void solve() {

    int n, l, r;

    cin >> n >> l >> r;

    vector<int> array(n);

    for(int &a : array) {

        cin >> a;

    }

    vector<int> left_half;

    for(int i = 0; i < l - 1; i++) {

        left_half.push_back(array[i]);

    }

    vector<int> right_half;

    for(int i = r; i < n; i++) {

        right_half.push_back(array[i]);

    }

    sort(left_half.begin(), left_half.end());

    sort(right_half.begin(), right_half.end());

    sort(array.begin() + l - 1, array.begin() + r, greater<int>());

    ll left_sum = 0;

    int left_pointer = 0;

    int segment_pointer = l - 1;

    while(left_pointer < left_half.size() && segment_pointer < r) {

        int min_value = min(array[segment_pointer], left_half[left_pointer]);

        if(min_value == array[segment_pointer]) {

            left_sum += min_value;

            segment_pointer++;

        }

        else {

            left_sum += min_value;

            left_pointer++;

            segment_pointer++;

        }

    }

    while(segment_pointer < r) {

        left_sum += array[segment_pointer];

        segment_pointer++;

    }

    ll right_sum = 0;

    int right_pointer = 0;

    segment_pointer = l - 1;

    while(right_pointer < right_half.size() && segment_pointer < r) {

        int min_value = min(array[segment_pointer], right_half[right_pointer]);

        if(min_value == array[segment_pointer]) {

            right_sum += min_value;

            segment_pointer++;

        }

        else {

            right_sum += min_value;

            right_pointer++;

            segment_pointer++;

        }

    }

    while(segment_pointer < r) {

        right_sum += array[segment_pointer];

        segment_pointer++;

    }

    cout << min(left_sum, right_sum) << '\n';

}

int main() {

    int t;

    cin >> t;

    while(t--) {

        solve();

    }

    return 0;

}

Answer: 2


#include <bits/stdc++.h>

using namespace std;

typedef long long i64;

typedef __int128_t i128;

const int M = 1e9 + 7;

#define N 200005

void solve()

{

    int n, l, r;

    cin >> n >> l >> r;

    l--;

    vector<int> L, R;

    for (int i = 0; i < n; i++)

    {

        int x;

        cin >> x;

        if (i < r)

        {

            L.push_back(x);

        }

        if (i >= l)

        {

            R.push_back(x);

        }

    }

    sort(L.begin(), L.end());

    sort(R.begin(), R.end());

    i64 ans1 = accumulate(L.begin(), L.begin() + r - l, 0LL);

    i64 ans2 = accumulate(R.begin(), R.begin() + r - l, 0LL);

    cout << min(ans1, ans2) << endl;

}

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    int t;

    cin >> t;

    while (t--)

    {

        solve();

    }

    return 0;

}

#include <bits/stdc++.h>
using namespace std;
typedef long long i64;
const int M = 1e9 + 7;
#define N 200005

void solve()
{
    int n;
    cin >> n;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    if (n == 1)
    {
        cout << 1 << " " << 1 << endl;
        return;
    }

    map<int, int> cnt;
    for (int i = 1; i <= n; i++)
    {
        cnt[a[i]]++;
    }

    int cntmx = 0;
    int k = -1;
    for (const auto &[i, cnt_] : cnt)
    {
        if (cnt_ > cntmx)
        {
            cntmx = cnt_;
            k = i;
        }
    }

    vector<int> idxs;
    for (int i = 1; i <= n; i++)
    {
        if (a[i] == k)
        {
            idxs.push_back(i);
        }
    }

    int dis = 0;
    int l = -1;
    int r = -1;
    for (int i = 1; i < idxs.size(); i++)
    {
    int temp = idxs[i] - idxs[i - 1] - 1;
        if (temp > dis)
        {
            dis = temp;
            l = idxs[i - 1];
            r = idxs[i];
        }
    }

    // 输出结果
    if (l != -1 && r != -1)
    {
        cout << l + 1 << " " << r - 1 << endl;
    }
    else
    {
        cout << 0 << endl;
    }
}

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

Answer: 1


#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

void solve() {

    int n,l,r ; cin>>n>>l>>r;

    vector<int>v(n+1),ans1,ans2;

    for (int i = 1 ; i <= n ; ++i)

        cin>>v[i];

        int siz = r-l+1 , ans = 0;

        for (int i = l ; i <= r ; ++i)

            ans1.push_back(v[i]),ans2.push_back(v[i]);

        for (int i = 1 ; i < l ; ++i)

            ans1.push_back(v[i]);

        for (int i = r+1 ; i <= n ; ++i)

            ans2.push_back(v[i]);

        sort(ans1.begin(),ans1.end());

        sort(ans2.begin(),ans2.end());

        ll sum1 = 0 , sum2 = 0;

        for (int i = 0 ; i <siz ; ++i)

            sum1 += ans1[i];

        for (int i = 0 ; i < siz ; ++i)

            sum2 += ans2[i];

        cout<<min(sum1,sum2)<<endl;

}

int main() {

    int t ; cin>>t;

    while(t--)

        solve();

    return 0;

}

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

void solve() {

    int n,l,r ; cin>>n>>l>>r;
    vector<int>v(n+1);
    for (int i = 1 ; i <= n ; ++i)
        cin>>v[i];
        sort(v.begin(),v.end());
        int siz = r-l+1 , ans = 0;
        for (int i = 1 ; i <= siz ; ++i)
            ans += v[i];
        cout<<ans<<endl;
}
int main() {

    int t ; cin>>t;
    while(t--)
        solve();
    return 0;
}

Answer: 1


#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;

#define inf 1e9
#define mod 1000000007
#define MAX 1000000000
#define vpii vector<pair<int,int>>
#define int long long
#define pb push_back
#define read(arr) for (int i = 0; i < arr.size(); i++) cin >> arr[i]
#define print(arr) for (int i = 0; i < arr.size(); i++) cout << arr[i] << " "; cout << "\n"
#define vi vector<int>
#define vvi vector<vi>
#define all(v) v.begin(), v.end()

void solve(int t) {
   int n; cin >> n;
   int ans = 1;
   vector<set<int>> adj(n+1);
   vector<pair<int,int>> v(n+1, {0,0} );
   for(int i = 0 ; i  <  n +1; ++i) {
        v[i].second = i;
   }
   vi last(n+1,0);
   for(int i = 0; i < n-1; ++i) {
    int a, b; cin >> a >> b;
        adj[a].insert(b);
        adj[b].insert(a);
        v[a].first++;
        v[b].first++;
        last[a]++;
        last[b]++;
   }
    sort(v.begin(),v.end());

    int maxi = INT_MIN;
    for(int i= 1; i < n+1; ++i) {
        int p1 = i;
        int two = 0;
        for(int j  = n; j>=0 ;j--) {
            if(i!= v[j].second) {
            two = max(v[j].first, two);
            set<int>&s = adj[i];
            while(j>= 0 && v[j].second != i && s.find(v[j].second)!=s.end()) {
                --j;
            }

            if(j >= 0 && v[j].second != i) {
                int one = v[j].first;
                maxi = max(maxi , one + last[i] - 1);
            }
            maxi = max(two +last[i] -2 ,maxi);
            break;
            }
        }
    }
    cout << maxi << "\n";

}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int test = 1;
    cin >> test;

    for (int i = 1; i <= test; ++i) {
        solve(i);
    }
}

#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;

#define inf 1e9
#define mod 1000000007
#define MAX 1000000000
#define vpii vector<pair<int,int>>
#define int long long
#define pb push_back
#define read(arr) for (int i = 0; i < arr.size(); i++) cin >> arr[i]
#define print(arr) for (int i = 0; i < arr.size(); i++) cout << arr[i] << " "; cout << "\n"
#define vi vector<int>
#define vvi vector<vi>
#define all(v) v.begin(), v.end()

void solve(int t) {
   int n; cin >> n;
   int ans = 1;
   vector<vector<int>> adj(n+1);
   vector<int> v(n+1, 0 );
   for(int i = 0; i < n-1; ++i) {
    int a, b; cin >> a >> b;
        adj[a].push_back(b);
        adj[b].push_back(a);
        v[a]++;
        v[b]++;
   }
    int maxi = INT_MIN;
    int ind;
   for(int i = 1 ; i  < n+1; ++i) {
        if(maxi < v[i]) {
            maxi = v[i];
            ind = i;

        }
   }
    ans += maxi - 1;
    vector<vector<int>> mat(n);
    vector<int> u(n,0);
    for(int i = 1 ; i  < adj.size(); ++i) {
        if(i!=ind) {
        for(int j = 0 ; j < adj[i].size(); ++j) {
            if(adj[i][j] != ind) {
                int nind = i - (i>ind);
                int nind2 = adj[i][j] - (adj[i][j] > ind);
                mat[nind].push_back(nind2);
                u[nind]++;
            }
         }
        }
    }

    // for(int i = 1; i < mat.size(); ++i) {
    //     cout << i << "-> ";
    //     for(auto j :mat[i] ) {
    //         cout << j << " ";
    //     }
    //     cout << "\n";
    // }

    // for(int i = 1; i  < u.size(); ++i) {
    //     cout << u[i] << " ";
    // }
    // cout << "\n";
    maxi =INT_MIN;
    for(int i = 1; i  < u.size(); ++i ) {
        maxi = max(maxi, u[i]);
    }

    ans += maxi - 1;

    cout << ans << "\n";

}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int test = 1;
    cin >> test;

    for (int i = 1; i <= test; ++i) {
        solve(i);
    }
}

Answer: 1


#include <bits/stdc++.h>
#define pb push_back
#define se second
#define fi first
#define all(x) (x).begin(), (x).end()
#define el "\n"
#define bit(mask,i) ((mask>>i)&1)
#define taskname "test"
using namespace std;

typedef long long ll;
typedef pair<ll,ll> pi;

const int MAXN = 2e5+5;
const ll MOD = 998244353;
const ll INF = 1e18;
const double EPSILON = 0.000001;

// Initial function
ll add_mod (ll &a, ll b) {
    if ((a += b) >= MOD) a -= b;
    return a;
}

ll sub_mod (ll &a, ll b) {
    return (a - b + MOD) % MOD;
}

ll mul_mod (ll &a, ll b) {
    return (a = (1LL * a * b % MOD));
}

void maximize (ll &x, ll val)
{
    x = max (x, val);
}

void minimize (ll &x, ll val)
{
    x = min (x, val);
}

void debug (ll x, ll type = 0)
{
    cout << x;
    cout << (type == 0 ? el : " " );
}
// -----------------------

// Variable
ll n, res;
multiset <ll> m;
vector <ll> adj[MAXN];

// -----------------------

// Setup Function
void del (ll x) {
    auto itr = m.find (x);
    m.erase (x);
}

// -----------------------

// subtask

// -----------------------

int main ()
{
    if (fopen (taskname".inp", "r"))
    {
        freopen (taskname".inp", "r", stdin);
        freopen (taskname".out", "w", stdout);
    }

    ios_base :: sync_with_stdio (false);
    cin.tie (NULL);
    cout.tie (NULL);

    ll t; cin >> t;
    while (t--) {
        for (int i = 1; i <= n; i ++) adj[i].clear ();
        m.clear ();
        res = 0;

        cin >> n;
        for (int i = 1; i <= n - 1; i ++){
            ll x, y; cin >> x >> y;
            adj[x].pb (y), adj[y].pb (x);
        }

        for (int i = 1; i <= n; i ++)
            m.insert (adj[i].size());

        for (int i = 1; i <= n; i ++) {
            ll ans = adj[i].size();
            del (ans);

            for (auto u : adj[i]) {
                del (adj[u].size());
                m.insert (adj[u].size() - 1);
            }

            ll maxx = *m.rbegin();
            // cout << maxx << el;
            ans += maxx - 1;
            maximize (res, ans);

            m.insert (adj[i].size());
            for (auto u : adj[i]) {
                m.insert (adj[u].size());
                del (adj[u].size() - 1);
            }
        }

        cout << res << el;
    }
    return 0;
}

/*
{\_/}
(>.<)
/>AC
*/

#include <bits/stdc++.h>
#define pb push_back
#define se second
#define fi first
#define all(x) (x).begin(), (x).end()
#define el "\n"
#define bit(mask,i) ((mask>>i)&1)
#define taskname "test"
using namespace std;

typedef long long ll;
typedef pair<ll,ll> pi;

const int MAXN = 2e5+5;
const ll MOD = 998244353;
const ll INF = 1e18;
const double EPSILON = 0.000001;

// Initial function
ll add_mod (ll &a, ll b) {
    if ((a += b) >= MOD) a -= b;
    return a;
}

ll sub_mod (ll &a, ll b) {
    return (a - b + MOD) % MOD;
}

ll mul_mod (ll &a, ll b) {
    return (a = (1LL * a * b % MOD));
}

void maximize (ll &x, ll val)
{
    x = max (x, val);
}

void minimize (ll &x, ll val)
{
    x = min (x, val);
}

void debug (ll x, ll type = 0)
{
    cout << x;
    cout << (type == 0 ? el : " " );
}
// -----------------------

// Variable
ll n, res;
multiset <ll> m;
vector <ll> adj[MAXN];

// -----------------------

// Setup Function
void del (ll x) {
    auto itr = m.find (x);
    m.erase (itr);
}

// -----------------------

// subtask

// -----------------------

int main ()
{
    if (fopen (taskname".inp", "r"))
    {
        freopen (taskname".inp", "r", stdin);
        freopen (taskname".out", "w", stdout);
    }

    ios_base :: sync_with_stdio (false);
    cin.tie (NULL);
    cout.tie (NULL);

    ll t; cin >> t;
    while (t--) {
        for (int i = 1; i <= n; i ++) adj[i].clear ();
        m.clear ();
        res = 0;

        cin >> n;
        for (int i = 1; i <= n - 1; i ++){
            ll x, y; cin >> x >> y;
            adj[x].pb (y), adj[y].pb (x);
        }

        for (int i = 1; i <= n; i ++)
            m.insert (adj[i].size());

        for (int i = 1; i <= n; i ++) {
            ll ans = adj[i].size();
            del (ans);

            for (auto u : adj[i]) {
                del (adj[u].size());
                m.insert (adj[u].size() - 1);
            }

            ll maxx = *m.rbegin();
            // cout << maxx << el;
            ans += maxx - 1;
            maximize (res, ans);

            m.insert (adj[i].size());
            for (auto u : adj[i]) {
                m.insert (adj[u].size());
                del (adj[u].size() - 1);
            }
        }

        cout << res << el;
    }
    return 0;
}

/*
{\_/}
(>.<)
/>AC
*/

Answer: 2


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define mod 1000000007

vector<bool> is_prime;

void sieve(ll n) {
    is_prime.assign(n + 1, true);
    is_prime[0] = is_prime[1] = false;
    for (ll i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            for (ll j = i * i; j <= n; j += i)
                is_prime[j] = false;
        }
    }
}

ll lcm(ll a, ll b) {
    return (a / __gcd(a, b)) * b;
}

/*
1. Read question carefully
2. generalize the logic
3. convert it to mathematical equation
4. !!!!! don't think  (CHECK) again until you get wrong answer
5. write the code
*/

void solve() {
     ll n;
    cin>>n; // number of nodes;
    vector<pair<ll,ll>>edges(n-1);
    map<pair<ll,ll>,ll>mp;
    for(ll i=0;i<n-1;i++){
        cin>>edges[i].first>>edges[i].second;
        if(edges[i].first>edges[i].second){
            swap(edges[i].first,edges[i].second);
        }
        mp[{edges[i].first,edges[i].second}]=1;
    }

    // prepraing adjacency list
    vector<ll>degree(n,0);
    vector<vector<ll>>list(n,vector<ll>());
    for(ll i=0;i<n-1;i++){
        ll a=edges[i].first;
        ll b=edges[i].second;
        a--;
        b--;

        list[a].push_back(b);
        list[b].push_back(a);
        degree[a]++;
        degree[b]++;

    }

    vector<pair<ll,ll>>ans;

    // degree,node

    for(ll i=0;i<n;i++){
        ans.push_back({degree[i],i});
    }
    sort(ans.rbegin(),ans.rend());

    ll s1=ans[0].first; // max degree
     ll s2=ans[1].first;// low

    ll max1=ans[0].second;

    vector<ll>help;

    for(ll i=1;i<ans.size();i++){
        if(ans[i].first==s2){
            help.push_back(ans[i].second);
        }
    }
    // for(ll i=0;i<ans.size();i++){

    //        cout<<ans[i].first<<" "<<ans[i].second<<endl;

    // }

    // cout<<endl;
    // cout<<endl;

    vector<ll>unconet;
    vector<ll>con;

    for(ll i=0;i<help.size();i++){
        if(mp.find({max1+1,help[i]+1})!=mp.end() || mp.find({help[i]+1,max1+1})!=mp.end() ){
            con.push_back(help[i]);
        }
        else{
            unconet.push_back(help[i]);

        }
    }

    // for(auto it:unconet){
    //     cout<<it<<" ";
    // }
    // cout<<"||||";

    // cout<<'u'<<endl;

    // for(auto it:con){
    //     cout<<it<<" ";
    // }
    // cout<<endl;
    // cout<<1<<endl;;
    ll maxi=0;
    if(unconet.size()==0){

        ll a=con[0];
        ll dega=list[a].size();

         for(auto &it:con){
            maxi=max(maxi,degree[it]+s1-2);
        }
        cout<<maxi<<endl;

    }
    else{

        for(auto &it:unconet){
            maxi=max(maxi,degree[it]+s1-1);
        }
        // cout<<a<<" ";
        // ll dega=list[a].size();
        // cout<<s1+dega-1<<endl;
    cout<<maxi<<endl;
    }

}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    ll test = 1;
    cin >> test;
    while (test--) {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define mod 1000000007

vector<bool> is_prime;

void sieve(ll n) {
    is_prime.assign(n + 1, true);
    is_prime[0] = is_prime[1] = false;
    for (ll i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            for (ll j = i * i; j <= n; j += i)
                is_prime[j] = false;
        }
    }
}

ll lcm(ll a, ll b) {
    return (a / __gcd(a, b)) * b;
}

/*
1. Read question carefully
2. generalize the logic
3. convert it to mathematical equation
4. !!!!! don't think  (CHECK) again until you get wrong answer
5. write the code
*/

void solve() {
     ll n;
    cin>>n; // number of nodes;
    vector<pair<ll,ll>>edges(n-1);
    map<pair<ll,ll>,ll>mp;
    for(ll i=0;i<n-1;i++){
        cin>>edges[i].first>>edges[i].second;
        if(edges[i].first>edges[i].second){
            swap(edges[i].first,edges[i].second);
        }
        mp[{edges[i].first,edges[i].second}]=1;
    }

    // prepraing adjacency list
    vector<ll>degree(n,0);
    vector<vector<ll>>list(n,vector<ll>());
    for(ll i=0;i<n-1;i++){
        ll a=edges[i].first;
        ll b=edges[i].second;
        a--;
        b--;

        list[a].push_back(b);
        list[b].push_back(a);
        degree[a]++;
        degree[b]++;

    }

    vector<pair<ll,ll>>ans;

    // degree,node

    for(ll i=0;i<n;i++){
        ans.push_back({degree[i],i});
    }
    sort(ans.rbegin(),ans.rend());

    ll s1=ans[0].first; // max degree
     ll s2=ans[1].first;// low

    if(s1==s2){
    vector<ll>help;

    for(ll i=0;i<ans.size();i++){
        if(ans[i].first==s2){
            help.push_back(ans[i].second);
        }
    }
    ll maxi=-1e9;
    if(help.size()>=3){
        maxi=max(maxi,2*degree[help[0]]-1);
    }
    else{
        if(mp.find({help[0]+1,help[1]+1})!=mp.end() || mp.find({help[1]+1,help[0]+1})!=mp.end()){
            maxi=max(maxi,2*degree[help[0]]-2);
        }
        else{
            maxi=max(maxi,2*degree[help[0]]-1);

        }
    }
    cout<<maxi<<endl;

    }
    else{
    vector<ll>help;
    ll max1=ans[0].second;

    for(ll i=1;i<ans.size();i++){
        if(ans[i].first==s2){
            help.push_back(ans[i].second);
        }
    }

    ll maxi=-1;

    for(ll i=0;i<help.size();i++){
        if(mp.find({max1+1,help[i]+1})!=mp.end() || mp.find({help[i]+1,max1+1})!=mp.end() ){
           maxi=max(maxi,degree[max1]+degree[help[i]]-2);
        }
        else{
           maxi=max(maxi,degree[max1]+degree[help[i]]-1);

        }
    }
    cout<<maxi<<endl;

    }

}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    ll test = 1;
    cin >> test;
    while (test--) {
        solve();
    }
    return 0;
}

Answer: 2