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: 296 ms):
//-------------------------------KING DONT LOOK DOWN---------------------------------------//

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.List;


import java.awt.*;

public class Main {

  static long sx = 0, sy = 0;
  static int[][] dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
  // static ArrayList<Integer>[] a;
  static ArrayList<Integer>[] g;
  static ArrayList<Integer>[] ra;
  static long[][] dp;
  static long[] fa;
  static int[] farr;
  public static PrintWriter out = new PrintWriter(System.out);
  // static ArrayList<pair> pa = new ArrayList<>();
  static StringBuilder sb = new StringBuilder();
  static boolean cycle = false;
  static long mod = 998244353;
  static long[] no, col;
  static String s;
  // static long k = 0, n = 0, ans = 0;
  static long cnt;
  // static long[] dp;
  // static long[] p;
  // static long[] ans;
  // static Double[][] a = new Double[2][2];
  static Double[] x;
  static Double[] y;
  static long[] d;
  static int[][] par;
  static long[] v;
  static HashMap<Integer, Integer> map;
  // static ArrayList<Integer> p;
  static int time = 0;
  static int[] id;
  static TreeSet<Long> hm;
  // static int[] ans;
  static boolean[] prime;

  static int[] depth;
  static int[] leafs;
  static int[] size;

  static int[] depth1Count;
  static HashSet<Integer> nonLeafPar1;

  static long ans, totalLeafs, depth1;


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

    // Scanner scn = new Scanner(new BufferedReader(new
    //     InputStreamReader(System.in)));
    Reader scn = new Reader();

    int t = scn.nextInt();
    StringBuilder sb = new StringBuilder();

    z:
    while (t-- > 0) {

      int n = scn.nextInt();

      int[] a = scn.nextIntArray(n);

      for (int i = 1; i < n; i++) {

        if (a[i] >= a[i - 1]) {
          a[i] -= a[i - 1];
        } else {
          sb.append("NO");
          sb.append("\n");
          continue z;
        }

      }

      sb.append("YES");

      sb.append("\n");
    }

    out.println(sb);
    out.flush();


  }

  public static void evaluate(int v, int par) {

    int n = g.length - 1;

    if (g[v].size() == 1) {
      ans += n - totalLeafs;
      return;
    }

    if (par != -1 && depth[par] == 1) {
      ans += (n - size[v] - depth1 - totalLeafs + leafs[v] + depth1Count[v]);
    }

    for (int nbr : g[v]) {
      if (nbr != par) {
        evaluate(nbr, v);

        if (depth[nbr] == 1) {
          ans += size[nbr] - leafs[nbr] - depth1Count[nbr];
        }
      }
    }
  }


  public static void dfs(int v, int par) {

    if (g[v].size() == 1) {
      depth[v] = 0;
      leafs[v] = 1;
      size[v] = 1;
      return;
    }

    int minDepth = Integer.MAX_VALUE;

    for (int nbr : g[v]) {

      if (nbr != par) {
        dfs(nbr, v);
        minDepth = Math.min(minDepth, depth[nbr]);
        leafs[v] += leafs[nbr];
        size[v] += size[nbr];
        depth1Count[v] += depth1Count[nbr];
      }
    }

    size[v]++;
    depth[v] = minDepth + 1;

    if (depth[v] == 1) {
      depth1++;
      depth1Count[v]++;
    }

  }

  // public static long lcm(long x, long y) {
  //
  // return (x * y) / gcd(x, y);
  // }
  //
  // private static long gcd(long x, long y) {
  // if (x == 0)
  // return y;
  //
  // return gcd(y % x, x);
  // }
  //
  // static class comp implements Comparator<pair> {
  //
  //   @Override
  //   public int compare(pair p1, pair p2) {
  //
  //     if (p1.val2 != p2.val2) {
  //       return (int) (p1.val2 - p2.val2);
  //     } else {
  //       return (int) (p1.val1 - p2.val2);
  //     }
  //
  //   }
  // }

  //
  // }
  //
  public static long pow(long a, long b) {

    if (b < 0) {
      return 0;
    }

    if (b == 0 || b == 1) {
      return (long) Math.pow(a, b);
    }

    if (b % 2 == 0) {

      long ret = pow(a, b / 2) % mod;
      return (ret * ret) % mod;

    } else {
      return ((pow(a, b - 1) % mod) * a % mod) % mod;
    }
  }

  private static class pair implements Comparable<pair> {

    int u, v;

    pair(int u, int v) {

      this.u = u;
      this.v = v;
      // this.w = w;

    }

    @Override
    public int compareTo(pair o) {
      return 0;
    }

    // @Override

    // public String toString() {
    //
    //   return val1 + " " + val2;
    // }

    // @Override
    //
    // public int hashCode() {
    // return (int) (a * 17+);
    // }
    //
    // @Override
    //
    // public boolean equals(Object o) {
    //
    // pair p = (pair) o;
    // return this.a == p.a;
    // }
    //
    // @Override
    //
    // public String toString() {
    // return this.a + " ";
    // }

  }

  private static String reverse(String s) {

    return new StringBuilder(s).reverse().toString();
  }

  public static class Reader {

    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
      din = new DataInputStream(System.in);
      buffer = new byte[BUFFER_SIZE];
      bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
      din = new DataInputStream(new FileInputStream(file_name));
      buffer = new byte[BUFFER_SIZE];
      bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
      byte[] buf = new byte[1000000 + 1]; // line length
      int cnt = 0, c;
      while ((c = read()) != -1) {
        if (c == '\n') {
          break;
        }
        buf[cnt++] = (byte) c;
      }
      return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
      int ret = 0;
      byte c = read();
      while (c <= ' ') {
        c = read();
      }
      boolean neg = (c == '-');
      if (neg) {
        c = read();
      }
      do {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');

      if (neg) {
        return -ret;
      }
      return ret;
    }

    public long nextLong() throws IOException {
      long ret = 0;
      byte c = read();
      while (c <= ' ') {
        c = read();
      }
      boolean neg = (c == '-');
      if (neg) {
        c = read();
      }
      do {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');
      if (neg) {
        return -ret;
      }
      return ret;
    }

    public double nextDouble() throws IOException {
      double ret = 0, div = 1;
      byte c = read();
      while (c <= ' ') {
        c = read();
      }
      boolean neg = (c == '-');
      if (neg) {
        c = read();
      }

      do {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');

      if (c == '.') {
        while ((c = read()) >= '0' && c <= '9') {
          ret += (c - '0') / (div *= 10);
        }
      }

      if (neg) {
        return -ret;
      }
      return ret;
    }

    private void fillBuffer() throws IOException {
      bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
      if (bytesRead == -1) {
        buffer[0] = -1;
      }
    }

    private byte read() throws IOException {
      if (bufferPointer == bytesRead) {
        fillBuffer();
      }
      return buffer[bufferPointer++];
    }

    public void close() throws IOException {
      if (din == null) {
        return;
      }
      din.close();
    }

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

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

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

    public long[][] nextInt2DArrayL(int m, int n) throws IOException {
      long[][] arr = new long[m][n];
      for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
          arr[i][j] = nextInt();
        }
      }
      return arr;
    }
    // kickstart - Solution
    // atcoder - Main
  }

}