Problem: 2063B - Subsequence Update
Language: java

Solution 1 (runtime: 217 ms):
  
/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

public class Main {

    //------------------------------------------main--------------------------------------------------//
    public static void main(String[] args) throws java.lang.Exception {
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        FastReader sc = new FastReader();
        Task s = new Task(sc, out);
        s.solve();
        out.close();
        // your code goes here"
    }
}

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 {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }

    public int[] readIntArray(int n) throws IOException {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextInt();
        }
        return arr;
    }

    public long[] readLongArray(int n) throws IOException {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextLong();
        }
        return arr;
    }
}

class Task {

    PrintWriter out;
    FastReader sc;

    Task(FastReader sc, PrintWriter out) {
        this.sc = sc;
        this.out = out;
    }
    //----------------------------------------------inputfunction------------------------------------------//

    String st() {
        return sc.nextLine();
    }

    int i() {
        return sc.nextInt();
    }

    long l() {
        return sc.nextLong();
    }

    double d() {
        return sc.nextDouble();
    }

    //---------------------------------------------absolute----------------------------------------------//
    public long abs(long a) {
        return a < 0 ? -a : a;
    }

    public int abs(int a) {
        return a < 0 ? -a : a;
    }

    //-------------------------------------------max--------------------------------------------------//
    public int max(int a, int b) {
        return a >= b ? a : b;
    }

    public long max(long a, long b) {
        return a >= b ? a : b;
    }

    public int max(int a, int b, int c) {
        return Math.max(a, Math.max(b, c));
    }

    public long max(long a, long b, long c) {
        return Math.max(a, Math.max(b, c));
    }

    //------------------------------------------min---------------------------------------------------//
    public int min(int a, int b) {
        return a <= b ? a : b;
    }

    public long min(long a, long b) {
        return a <= b ? a : b;
    }

    public int min(int a, int b, int c) {
        return Math.min(a, Math.min(b, c));
    }

    public long min(long a, long b, long c) {
        return Math.min(a, Math.min(b, c));
    }

    //----------------------------------------sortingfunction---------------------------------------------//
    private void sort(int[] arr) {
        int n = arr.length;
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list);
        for (int i = 0; i < n; i++) {
            arr[i] = list.get(i);
        }
    }

    private void sort(char[] arr) {
        int n = arr.length;
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list);
        for (int i = 0; i < n; i++) {
            arr[i] = list.get(i);
        }
    }

    private void rsort(char[] arr) {
        int n = arr.length;
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list, Collections.reverseOrder());
        for (int i = 0; i < n; i++) {
            arr[i] = list.get(i);
        }
    }

    private void rsort(int[] arr) {
        int n = arr.length;
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list, Collections.reverseOrder());
        for (int i = 0; i < n; i++) {
            arr[i] = list.get(i);
        }
    }

    private void sort(long[] arr) {
        int n = arr.length;
        List<Long> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list);
        for (int i = 0; i < n; i++) {
            arr[i] = list.get(i);
        }
    }

    private void rsort(long[] arr) {
        int n = arr.length;
        List<Long> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list, Collections.reverseOrder());
        for (int i = 0; i < n; i++) {
            arr[i] = list.get(i);
        }
    }
    //---------------------------------------power----------------------------------------------------//

    public long pow(long a, int b) {
        long ans = 1L;
        while (b > 0) {
            if ((b & 1) > 0) {
                ans *= a;
            }
            a *= a;
            b >>= 1;
        }
        return b;
    }
    //----------------------------------------binary_exponentiation-----------------------------------//

    public long exp(long a, long b, long mod) {
        long ans = 1L;
        while (b > 0) {
            if ((b & 1) > 0) {
                ans = (ans * a) % mod;
            }
            a = (a * a) % mod;
            b >>= 1;
        }
        return ans;
    }

    //---------------------------------------helpingmethods-------------------------------------------//
    //---------------------------------------main-----------------------------------------------------//
    int t, n;

    public void solve() throws IOException {
        int T = sc.nextInt();
        for(int  t= 1;t<=T;t++) {
            int n = i(), l  = i(),  r= i();
            List<Integer> x = new ArrayList<>(), y = new ArrayList<>(), z = new ArrayList<>();
            for(int i= 1;i<l;i++) x.add(i());
            for(int i  = l ;i<=r;i++) y.add(i());
            for(int i = r+1;i<=n;i++) z.add(i());
            long ans = 0, sum= 0;
            Collections.sort(x);
            Collections.sort(y);
            Collections.sort(z);
            Collections.reverse(y);
            for(int e: y) sum += e;
            long temp = ans = sum;
            for(int i = 0;i<min(y.size(), x.size());i++){
                if(x.get(i)>=y.get(i)) break;
                temp += x.get(i) - y.get(i);
            }
            ans = min(ans, temp);
            temp= sum;
            for(int i = 0;i<min(y.size(), z.size());i++){
                if(z.get(i)>=y.get(i)) break;
                temp += z.get(i) - y.get(i);
            }
            ans = min(temp , ans );
            out.print(ans);
            out.print("\n");
        }
    }
}


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

      */

}