Problem: 2063B - Subsequence Update
Language: java

Solution 1 (runtime: 343 ms):
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.nio.channels.Pipe.SourceChannel;
import java.rmi.StubNotFoundException;
import java.util.*;

public class cf {
    static int mod = (int) 1e9 + 7;
    static int N = (int) 2e5 + 5;
    static FastReader sc = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);
    static int count = 0;

    public static void main(String[] args) {

        // boolean[] isPrime=prime(1000000009);

        int tCase = sc.nextInt();

        l1: 
        while (tCase-- > 0) {
 
            int n=sc.nextInt();
            int l=sc.nextInt();
            int r=sc.nextInt();
 
            List<Integer> lft=new ArrayList<>();
            List<Integer> rght=new ArrayList<>();
            List<Integer> arr=new ArrayList<>();
            long sum=0,ans=0;
            for(int i=0 ;i<n ;i++){
                int temp=sc.nextInt();
                if(i>=l-1 && i<=r-1){
                    
                    arr.add(temp);
                    sum+=(long)temp;
                }else if(i<l){
                    lft.add(temp);
                }else{
                    rght.add(temp);
                }
            }
            long tempSum=sum;
            Collections.sort(arr);
            Collections.sort(lft);
            Collections.sort(rght);

            ans=sum;
            for(int i=0, j=arr.size()-1; i<lft.size() && j>=0; i++,j--){
                if(arr.get(j)>lft.get(i)){
                    sum-=(long)arr.get(j);
                    sum+=(long)lft.get(i);
                }else break;
            }
            ans=Math.min(ans,sum);
            sum=tempSum;
            for(int i=0, j=arr.size()-1; i<rght.size() && j>=0; i++,j--){
                if(arr.get(j)>rght.get(i)){
                    sum-=(long)arr.get(j);
                    sum+=(long)rght.get(i);
                }else break;
            }
            ans=Math.min(ans,sum);
 
            
            
            System.out.println(ans);
            
            

        }
        out.flush();

    }

    public static long findSum(List<Long> l,boolean flag){
        long sum=0;
        for(Long i:l){
            if(flag){
                sum-=i;
            }else{
                sum+=i;
            }

        }
        return Math.abs(sum);
    }

    public static long longSqrt(long n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        return BigInteger.valueOf(n).sqrt().longValue();
    }

    public static long fact(int num) {
        if (num == 1 || num == 0)
            return 1;
        return (num  * fact(num - 1));
    }

    public static long powerMod(long base, long exp, long mod) {
        long res = 1;
        base = base % mod;
        if (base == 0)
            return 0;

        while (exp > 0) {
            if ((exp & 1) == 1) {
                res = (res * base) % mod;
            }
            exp = exp >> 1;
            base = (base * base) % mod;
        }
        return res;
    }

    // public static HashMap<String,Pair> sortMap(HashMap<String,Pair> m){
    // List<Map.Entry<String, Pair>> list = new ArrayList<>(m.entrySet());

    // list.sort((e1,e2) -> {
    // Pair p1=e1.getValue();
    // Pair p2=e2.getValue();

    // if (p1.i != p2.i) {
    // return Integer.compare(p1.i, p2.i);
    // } else {
    // return Integer.compare(p1.j, p2.j);
    // }
    // });

    // LinkedHashMap<String, Pair> sortedMap = new LinkedHashMap<>();
    // for (Map.Entry<String, Pair> entry : list) {
    // sortedMap.put(entry.getKey(), entry.getValue());
    // }
    // return sortedMap;
    // }

    public static <K> HashMap<K, Pair> sortMap(Map<K, Pair> map) {
        List<Map.Entry<K, Pair>> list = new ArrayList<>(map.entrySet());

        list.sort((e1, e2) -> {
            Pair p1 = e1.getValue();
            Pair p2 = e2.getValue();

            if (p1.i != p2.i) {
                return Integer.compare(p1.i, p2.i);
            } else {
                return Integer.compare(p1.j, p2.j);
            }
        });

        HashMap<K, Pair> sortedMap = new LinkedHashMap<>();
        for (Map.Entry<K, Pair> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        return sortedMap;
    }

    public static long sumOf2(int x, int y) {
        return (long) ((long) Math.pow(2, y + 1) - Math.pow(2, x));
    }

    static class Pair {
        int i;
        int j;

        public Pair(int i, int j) {
            this.i = i;
            this.j = j;
        }
    }

    public static BigDecimal sqrt(BigDecimal value, MathContext mc) {
        BigDecimal x = new BigDecimal(Math.sqrt(value.doubleValue()), mc);
        return x.add(new BigDecimal(value.subtract(x.multiply(x)).doubleValue() / (x.doubleValue() * 2.0), mc));
    }

    

    public static BigDecimal distance(BigDecimal x1, BigDecimal y1, BigDecimal x2, BigDecimal y2) {
        BigDecimal deltaX = x2.subtract(x1);
        BigDecimal deltaY = y2.subtract(y1);

        BigDecimal sumOfSquares = deltaX.multiply(deltaX).add(deltaY.multiply(deltaY));
        return sqrt(sumOfSquares, MathContext.DECIMAL128);
    }

    public static int closestMultiple(int a, int b, int k) {
        int quotient = b / a;
        int multipleBelow = a * quotient;
        int multipleAbove = a * (quotient + 1);

        int distanceBelow = Math.abs(multipleBelow - b);
        int distanceAbove = Math.abs(multipleAbove - b);
        if (distanceBelow <= k && distanceAbove <= k) {
            return distanceBelow < distanceAbove ? multipleBelow : multipleAbove;
        } else if (distanceBelow <= k) {
            return multipleBelow;
        } else if (distanceAbove <= k) {
            return multipleAbove;
        } else {
            return -1;
        }
    }

    public static boolean[] prime(int limit) {
        boolean[] isPrime = new boolean[limit + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = false;
        isPrime[1] = false;

        for (int i = 2; i * i <= limit; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= limit; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        return isPrime;

    }

    public static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        if (num <= 3) {
            return true;
        }
        if (num % 2 == 0 || num % 3 == 0) {
            return false;
        }
        for (int i = 5; i * i <= num; i += 6) {
            if (num % i == 0 || num % (i + 2) == 0) {
                return false;
            }
        }
        return true;
    }

    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    // public static long combination(int n, int k) {
    // if(n < k) return 0;
    // return (fact[n] * p((fact[n - k] * fact[k]) % mod, mod - 2)) % mod;
    // }
    public static long p(long a, long b) {
        long r = 1;
        while (b > 0) {
            long res = b & 1;
            if (res == 1)
                r = (r * a) % mod;
            b /= 2;
            a = (a * a) % mod;
        }
        return r;
    }

    public static long combination(int n, int k) {
        if (k > n) {
            return 0;
        }
        if (k == 0 || k == n) {
            return 1;
        }
        k = Math.min(k, n - k);
        long c = 1;
        for (int i = 0; i < k; i++) {
            c = c * (n - i) / (i + 1);
        }
        return c;
    }

    public static int findGCD(int[] arr) {
        int result = arr[0];
        for (int i = 1; i < arr.length; i++) {
            result = gcd(result, arr[i]);
            if (result == 1) {
                return 1;
            }
        }
        return result;
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(
                    new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                if (st.hasMoreTokens()) {
                    str = st.nextToken("\n");
                } else {
                    str = br.readLine();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}


Solution 2 (runtime: 296 ms):
import java.io.*;

import java.util.*;

import static java.lang.Math.*;

public class  MyCPTemplate{

    static final int MOD = (int) (1e9 + 7);static final int INF = (int) (1e9) + 10;

    // safe use long

    static void solve() throws IOException{

        int n = fr.nextInt();

        int l = fr.nextInt();

        int r = fr.nextInt();

        l--;

        r--;

        int[] a = new int[n];



        for(int i =0;i<n;i++) a[i] =fr.nextInt();



        int[] b = new int[n];

        int[] c = new int[n];



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

        for(int i =0;i<n;i++) c[i] = a[i];



        Arrays.sort(b,l,n);

        Arrays.sort(c,0,r+1);



        long c1 = 0;

        long c2 = 0;

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

            c1+=b[i];

        }

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

            c2+=c[i];

        }





        out.println(min(c1,c2));



    }





    public static void main(String[] args) throws Exception {

        int t = 1;

        t = fr.nextInt();

        while (t-->0){

            solve();

        }



        out.close();

    }





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

    static void debug(Object... argObjects) throws IOException {out.println(Arrays.deepToString(argObjects));}

    static FastReader fr = new FastReader();

    static FastWriter out = new FastWriter();

    static class Pair<F extends Comparable<F>,S extends Comparable<S>> implements Comparable<Pair<F,S>>{

        public F first;

        public S second;

        public Pair(){}

        public Pair(F k,S v){

            first = k;

            second = v;

        }

        public String toString(){

            return "(" + first + ", " + second + ")";

        }



        @Override

        public int compareTo(Pair<F, S> that) {

            int cmp = this.first.compareTo(that.first);

            if (cmp == 0) {

                return this.second.compareTo(that.second);

            }

            return cmp;

        }

    }

    static class FastReader {



        BufferedReader br;

        StringTokenizer st;



        public FastReader() {

            br = new BufferedReader(new InputStreamReader(System.in),1<<18);

        }



        String next() {

            while (st == null || !st.hasMoreElements()) {

                try {

                    st = new StringTokenizer(br.readLine());

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            return st.nextToken();

        }



        int nextInt() {

            return Integer.parseInt(next());

        }



        long nextLong() {

            return Long.parseLong(next());

        }



        double nextDouble() {

            return Double.parseDouble(next());

        }



        String nextLine() {

            String str = "";

            try {

                str = br.readLine();

            } catch (IOException e) {

                e.printStackTrace();

            }

            return str;

        }

    }

    static class FastWriter {

        private final BufferedWriter bw;



        public FastWriter() {

            bw = new BufferedWriter(new OutputStreamWriter(System.out), 1 << 18);

        }



        // Print a single value

        public void print(String s) throws IOException {

            bw.write(s);

        }



        public void print(int x) throws IOException {

            bw.write(Integer.toString(x));

        }



        public void print(long x) throws IOException {

            bw.write(Long.toString(x));

        }



        public void print(double x) throws IOException {

            bw.write(Double.toString(x));

        }

        public void print(Object obj) throws IOException{

            bw.write(obj.toString());

        }



        // Print a value with a newline

        public void println(String s) throws IOException {

            bw.write(s);

            bw.newLine();

        }

        public void println() throws IOException {

            bw.newLine();

        }



        public void println(int x) throws IOException {

            bw.write(Integer.toString(x));

            bw.newLine();

        }



        public void println(long x) throws IOException {

            bw.write(Long.toString(x));

            bw.newLine();

        }



        public void println(double x) throws IOException {

            bw.write(Double.toString(x));

            bw.newLine();

        }

        public void println(Object obj) throws IOException {

            bw.write(obj.toString());

            bw.newLine();

        }







        // Print arrays

        public void printArray(int[] arr) throws IOException {

            for (int x : arr) {

                print(x + " ");

            }

            println("");

        }



        public void printArray(int[][] arr) throws IOException{

            for(int[] a: arr){

                for(int i:a){

                    print(i+" ");

                }

                println();

            }

        }





        public void printArray(long[] arr) throws IOException {

            for (long x : arr) {

                print(x + " ");

            }

            println("");

        }



        // Print collections

        public <T> void printCollection(Collection<T> col) throws IOException {

            for (T x : col) {

                print(x.toString() + " ");

            }

            println("");

        }



        // Flush the buffer

        public void flush() throws IOException {

            bw.flush();

        }



        // Close the writer

        public void close() throws IOException {

            bw.close();

        }

    }







    /*

         Random stuff to try when stuck:

            -if it's 2C then it's dp

            -for combo/probability problems, expand the given form we're interested in

            -make everything the same then build an answer (constructive, make everything 0 then do something)

            -something appears in parts of 2 --> model as graph

            -assume a greedy then try to show why it works

            -find way to simplify into one variable if multiple exist

            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)

            -find lower and upper bounds on answer

            -figure out what ur trying to find and isolate it

            -see what observations you have and come up with more continuations

            -work backwards (in constructive, go from the goal to the start)

            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)

            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)

            -draw something

            -simulate a process

            -dont implement something unless if ur fairly confident its correct

            -after 3 bad submissions move on to next problem if applicable

            -do something instead of nothing and stay organized

            -write stuff down

            -check for some values which might be incorrect --> ((long)sqrt(n) does not always give the max number t*t<=n, adjust t).

         Random stuff to check when wa:

            -if code is way too long/cancer then reassess

            -switched N/M

            -int overflow

            -switched variables

            -wrong MOD

            -hardcoded edge case incorrectly

         Random stuff to check when tle:

            -continue instead of break

            -condition in for/while loop bad

         Random stuff to check when rte:

            -switched N/M

            -long to int/int overflow

            -division by 0

            -edge case for empty list/data structure/N=1

      */

}