Problem:
Score : 500 points

Problem Statement

There is an infinitely long street that runs west to east, which we consider as a number line.

There are N roadworks scheduled on this street.
The i-th roadwork blocks the point at coordinate X_i from time S_i - 0.5 to time T_i - 0.5.

Q people are standing at coordinate 0. The i-th person will start the coordinate 0 at time D_i, continue to walk with speed 1 in the positive direction and stop walking when reaching a blocked point.

Find the distance each of the Q people will walk.

Constraints

All values in input are integers.

1 \leq N, Q \leq 2 \times 10^5

0 \leq S_i < T_i \leq 10^9

1 \leq X_i \leq 10^9

0 \leq D_1 < D_2 < ... < D_Q \leq 10^9

If i \neq j and X_i = X_j, the intervals [S_i, T_i) and [S_j, T_j) do not overlap.

Input

Input is given from Standard Input in the following format:

N Q
S_1 T_1 X_1
:
S_N T_N X_N
D_1
:
D_Q

Output

Print Q lines. The i-th line should contain the distance the i-th person will walk or -1 if that person walks forever.

Sample Input 1

4 6
1 3 2
7 13 10
18 20 13
3 4 2
0
1
2
3
5
8

Sample Output 1

2
2
10
-1
13
-1

The first person starts coordinate 0 at time 0 and stops walking at coordinate 2 when reaching a point blocked by the first roadwork at time 2.

The second person starts coordinate 0 at time 1 and reaches coordinate 2 at time 3. The first roadwork has ended, but the fourth roadwork has begun, so this person also stops walking at coordinate 2.

The fourth and sixth persons encounter no roadworks while walking, so they walk forever. The output for these cases is -1.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import static java.util.Comparator.*;				

public class Main {
	
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        MyInput in = new MyInput(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        
        Solver solver = new Solver();
        solver.solve(1, in, out);
        
        out.close();
    }
    
    // ======================================================================

    static class PPP {
    	public int key, val;
    	public PPP(int key, int val) {
    		this.key = key;
    		this.val = val;
    	}
		public int getKey() {
			return key;
		}
		public void setKey(int key) {
			this.key = key;
		}
		public int getVal() {
			return val;
		}
		public void setVal(int val) {
			this.val = val;
		}
    }
	static class Solver {
		// セグメント木
        class Seg1 {
            final int n;
            final int[] seg;
 
            public Seg1(final int n) {
            	// intの最も左側の1のビット以外を0にする
                this.n = Integer.highestOneBit(n) << 1;
                seg = new int[this.n << 1];
                Arrays.fill(seg, Integer.MAX_VALUE);
            }
 
            void update(int l, int r, int v) {
                update(l, r, v, 0, 0, n);
            }
 
            void update(int l, int r, int v, int k, int curL, int curR) {
                if (curR <= l || curL >= r) {
                    return;
                }
                if (l <= curL && curR <= r) {
                    seg[k] = Math.min(seg[k], v);
                    return;
                }
                final int curM = (curL + curR) / 2;
                update(l, r, v, 2 * k + 1, curL, curM);
                update(l, r, v, 2 * k + 2, curM, curR);
            }
 
            int get(int i) {
                i += n - 1;
                int ret = seg[i];
                while (i != 0) {
                    i = (i - 1) / 2;
                    ret = Math.min(ret, seg[i]);
                }
                return ret;
            }
        }
        
		public void solve(int testNumber, MyInput in, PrintWriter out) {
			int N = in.nextInt();
			int Q = in.nextInt();
            TreeSet<Integer> set = new TreeSet<>();
            int[][] stop = new int[N][];						// 工事場所
			int s, t, x;
			for(int i=0; i < N; i++) {
    			s = in.nextInt();
    			t = in.nextInt();
    			x = in.nextInt();
    											
                stop[i] = new int[]{s - x, t - x, x};			// ２次元配列への代入
                set.add(stop[i][0]);							// 時間をセット
                set.add(stop[i][1]);							// 時間をセット
    		}
			int[] D = new int[Q];
			for(int i=0; i < Q; i++) {
				D[i] = in.nextInt();
				set.add(D[i]);									// 時間をセット			
			}
            int[] cmp = new int[set.size()];					// 時間を圧縮する
            for (int i = 0; i < cmp.length; i++) {
                cmp[i] = set.pollFirst();
            }
            Seg1 seg = new Seg1(cmp.length);					// セグメント木を作る
            for (int i = 0; i < stop.length; i++) {				// 工事場所分、繰り返す
                int l = Arrays.binarySearch(cmp, stop[i][0]);	//   開始時間を検索（必ずある）
                int r = Arrays.binarySearch(cmp, stop[i][1]);	//   終了時間を検索（必ずある）
                seg.update(l, r, stop[i][2]);					//   停止位置を設定する
            }
            int idx, ans;
            for (int q : D) {
                idx = Arrays.binarySearch(cmp, q);				// 時間を圧縮しているので、位置を検索する
                ans = seg.get(idx);								// セグメント木から停止位置を取得する
                if (ans == Integer.MAX_VALUE) ans = -1;			// なければ -1
                out.println(ans);
            }
        }
    }

    // ======================================================================
    static class Pair<K, V> extends AbstractMap.SimpleEntry<K, V> {
        /** serialVersionUID. */
        private static final long serialVersionUID = 6411527075103472113L;

        public Pair(final K key, final V value) {
            super(key, value);
        }
     }    
    static class MyInput {
        private final BufferedReader in;
        private static int pos;
        private static int readLen;
        private static final char[] buffer = new char[1024 * 8];
        private static char[] str = new char[500 * 8 * 2];
        private static boolean[] isDigit = new boolean[256];
        private static boolean[] isSpace = new boolean[256];
        private static boolean[] isLineSep = new boolean[256];
 
        static {
            for (int i = 0; i < 10; i++) {
                isDigit['0' + i] = true;
            }
            isDigit['-'] = true;
            isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
            isLineSep['\r'] = isLineSep['\n'] = true;
        }
 
        public MyInput(InputStream is) {
            in = new BufferedReader(new InputStreamReader(is));
        }
 
        public int read() {
            if (pos >= readLen) {
                pos = 0;
                try {
                    readLen = in.read(buffer);
                } catch (IOException e) {
                    throw new RuntimeException();
                }
                if (readLen <= 0) {
                    throw new MyInput.EndOfFileRuntimeException();
                }
            }
            return buffer[pos++];
        }
 
        public int nextInt() {
            int len = 0;
            str[len++] = nextChar();
            len = reads(len, isSpace);
            int i = 0;
            int ret = 0;
            if (str[0] == '-') {
                i = 1;
            }
            for (; i < len; i++) ret = ret * 10 + str[i] - '0';
            if (str[0] == '-') {
                ret = -ret;
            }
            return ret;
        }
 
        public long nextLong() {
            int len = 0;
            str[len++] = nextChar();
            len = reads(len, isSpace);
            int i = 0;
            long ret = 0L;
            if (str[0] == '-') {
                i = 1;
            }
            for (; i < len; i++) ret = ret * 10 + str[i] - '0';
            if (str[0] == '-') {
                ret = -ret;
            }
            return ret;
        }
 
       public String nextString() {
        	String ret = new String(nextDChar()).trim();
            return ret;
        }
 
        public char[] nextDChar() {
            int len = 0;
            len = reads(len, isSpace);
            char[] ret = new char[len + 1];
            for (int i=0; i < len; i++)		ret[i] = str[i];
            ret[len] = 0x00;
            return ret;
        }
 
        public char nextChar() {
            while (true) {
                final int c = read();
                if (!isSpace[c]) {
                    return (char) c;
                }
            }
        }
 
        int reads(int len, boolean[] accept) {
            try {
                while (true) {
                    final int c = read();
                    if (accept[c]) {
                        break;
                    }
                    if (str.length == len) {
                        char[] rep = new char[str.length * 3 / 2];
                        System.arraycopy(str, 0, rep, 0, str.length);
                        str = rep;
                    }
                    str[len++] = (char) c;
                }
            } catch (MyInput.EndOfFileRuntimeException e) {
            }
            return len;
        }
 
        static class EndOfFileRuntimeException extends RuntimeException {
        }
    }
}