Problem: 2063B - Subsequence Update
Language: java

Solution 1 (runtime: 281 ms):
import java.util.*;

import java.io.*;

public class MooCounting {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int t = Integer.parseInt(br.readLine());



        while(t-- > 0)

        {

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

            int n = Integer.parseInt(st.nextToken());

            int left = Integer.parseInt(st.nextToken());

            left--;

            int right = Integer.parseInt(st.nextToken());

            right--;

            long k = (long)right - (long)left + 1;



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

            int[] arr = new int[n];

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

            {

                arr[i] = Integer.parseInt(st.nextToken());

            }



            // Case 1: [l, n]

            int[] option1 = Arrays.copyOfRange(arr, left, n);

            Arrays.sort(option1);

            long sum1 = 0;

            for (int i = 0; i < k; i++) sum1 += option1[i];



            // Case 2: [1, r]

            int[] option2 = Arrays.copyOfRange(arr, 0, right + 1);

            Arrays.sort(option2);

            long sum2 = 0;

            for (int i = 0; i < k; i++) sum2 += option2[i];



            

            System.out.println(Math.min(sum1, sum2)); 

        }

    }

}

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

      */

}