Problem: 2063B - Subsequence Update
Language: java

Solution 1 (runtime: 452 ms):
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);
            }
        }
    }
}

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

      */

}