Problem: 2060D - Subtract Min Sort
Language: java

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

import java.io.*;
	
			public class Main {
				

 
			public static void main(String[] args) throws FileNotFoundException,IOException, InterruptedException {
				Scanner s=new Scanner(System.in);
				PrintWriter pw=new PrintWriter(System.out);	
				
				
				int t=s.nextInt();
				while (t-->0)
				{
					int n=s.nextInt();
					int[]a=s.nextIntArr(n);
					boolean ans = true;
					for (int i=0; i<n-1;i++)
					{
						if (a[i] > a[i+1])
						{
							ans=false;
							break;
						}
						else {
							a[i+1]-=a[i];
							a[i]=0;
						}
					}
					for (int i=1; i<n;i++)
						ans&=a[i]>=a[i-1];
					pw.println(ans?"YES":"NO");
					
				}	
				pw.flush();
				
			}
			
			
			// used with hashmap or treemap
			// value should be integer, element type matches key
			static void putOrIncreaseCounter(int element, TreeMap<Integer, Integer> tm)
			{
				if (tm.containsKey(element))
					tm.put(element, tm.get(element)+1);
				else tm.put(element, 1);
			}
			
			
			// used with hashmap or treemap
			// value should be integer, element type matches key
			static void removeOrDecreaseCounter(int element, TreeMap<Integer, Integer> tm)
			{
				if (!tm.containsKey(element))
					return;
				if (tm.get(element)>1)
					tm.put(element, tm.get(element)-1);
				else tm.remove(element);
			}
			
	
			
			 static void shuffle(int []a)
			{	
				for (int i=0; i<a.length;i++)
				{
					int randIndex=(int)(Math.random()*a.length);
					int temp=a[i];
					a[i]=a[randIndex];
					a[randIndex]=temp;
				}
				
			}
			
			 static int gcd(int a, int b) // O(log(min(a,b))
		    {
			      if (b == 0)
			        return a;
			      return gcd(b, a % b); 
			    }
			
			static class Scanner 
			{
				StringTokenizer st;
				BufferedReader br;
		
				public Scanner() {
				br = new BufferedReader(new InputStreamReader(System.in));
				}		
				public Scanner(String s) throws FileNotFoundException
				{
					br =new BufferedReader(new FileReader(s));
				}
		
				public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		
		
				public String next() throws IOException 
				{
					while (st == null || !st.hasMoreTokens()) 
						st = new StringTokenizer(br.readLine());
					return st.nextToken();
				}
		
				public int nextInt() throws IOException {return Integer.parseInt(next());}
				
				public long nextLong() throws IOException {return Long.parseLong(next());}
		
				public String nextLine() throws IOException {return br.readLine();}
				
				public double nextDouble() throws IOException
				{
					String x = next();
					StringBuilder sb = new StringBuilder("0");
					double res = 0, f = 1;
					boolean dec = false, neg = false;
					int start = 0;
					if(x.charAt(0) == '-')
					{
						neg = true;
						start++;
					}
					for(int i = start; i < x.length(); i++)
						if(x.charAt(i) == '.')
						{
							res = Long.parseLong(sb.toString());
							sb = new StringBuilder("0");
							dec = true;
						}
						else
						{
							sb.append(x.charAt(i));
							if(dec)
								f *= 10;
						}
					res += Long.parseLong(sb.toString()) / f;
					return res * (neg?-1:1);
				}
				 public long[] nextLongArr(int n) throws IOException {
			            long[] arr = new long[n];
			            for (int i = 0; i < n; i++)
			                arr[i] = nextLong();
			            return arr;
			        }
		
			        public int[] nextIntArr(int n) throws IOException {
			            int[] arr = new int[n];
			            for (int i = 0; i < n; i++)
			                arr[i] = nextInt();
			            return arr;
			        }
				
				public boolean ready() throws IOException {return br.ready();}
				
				 
			} //end scanner
			
			
			
		
			
	}
		
	
		 class Pair implements Comparable{
			int x;
			int y;
			Pair(int x, int y)
			{
				this.x=x;
				this.y=y;
			}
			@Override
//			public int compareTo(Object o) {
//				Pair p=(Pair)o;
//				 return  this.x-p.x;
//			}
			public int compareTo(Object o)
			{
				Pair p=(Pair)o;
				return this.x==p.x?this.y-p.y:this.x-p.x;
			}
			public String toString()
			{
				return "("+x+","+y+")";
			}
			
		}
		
		 
		 class Edge implements Comparable<Edge> {
				int node, cost; //node to go to 
			
				Edge(int a, int b) {
					node = a;
					cost = b;
				}
			
				public int compareTo(Edge e) {
					return cost - e.cost;
				}
				public String toString()
				{
					return "{ "+this.node+","+this.cost+" }";
				}
		 
		 	 
		 } 
		 
		 
		

Solution 2 (runtime: 655 ms):
import java.util.*;
import java.lang.*;
import java.math.BigInteger;
import java.io.*;
public class cf{
    // public static long gcd(long a,long b){
    //     while(a!=0 && b!=0){
    //         if(a<b){
    //             b=b%a;
    //         }else{
    //             a=a%b;
    //         }
    //     }
    //     if(a!=0){
    //         return a;
    //     }else{
    //         return b;
    //     }
    // }  
    // public static long lcm(long a,long b){
    //     return (a/gcd(a,b))*b;
    // }

    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int tsts=sc.nextInt();
        for(int t=0;t<tsts;t++){
            int n=sc.nextInt();
            // int k=sc.nextInt();
            // int a4=sc.nextInt();
            // int a5=sc.nextInt();
            // int r2=sc.nextInt();
            // StringBuilder s=new StringBuilder(sc.next());
            // String a=sc.next();
            // String b=sc.next();
            // String c=sc.next();
            int[] a=new int[n];
            for(int i=0;i<n;i++){
                a[i]=sc.nextInt();
            }
            // int[] b=new int[n];
            // for(int i=0;i<n;i++){
            //     b[i]=sc.nextInt();
            // }
            // long n=sc.nextLong();
            // long k=sc.nextLong();
            // long r=sc.nextInt();
            // long c=sc.nextInt();
            for(int i=0;i<n-1;i++){
                int temp=Math.min(a[i],a[i+1]);
                a[i]-=temp;
                a[i+1]-=temp;
            }
            int[] b=new int[n];
            for(int i=0;i<n;i++){
                b[i]=a[i];
            }
            Arrays.sort(b);
            boolean flag=true;
            for(int i=0;i<n;i++){
                if(a[i]!=b[i]){
                    flag=false;
                    break;
                }
            }
            if(flag) System.out.println("Yes");
            else System.out.println("No");
        }    
    }
}