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 C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
class ChokudaiSpeedRun002 {
    static int __cnt = 0;
#if LOCAL_ENVIRONMENT
    static string __mark = "@@@";
#endif
    static void Main(string[] args) {
#if LOCAL_ENVIRONMENT
        StreamReader __sr = new StreamReader("stdin.txt");
        string __str = __sr.ReadToEnd();
        __sr.Close();
        int __index = __str.IndexOf(__mark, 0);
        while (__index != -1) {
            __index = __str.IndexOf(__mark, __index + __mark.Length);
            __cnt++;
        }
        if (__cnt > 0) {
            Console.Write("Eenter test data no(1-{0})? ", __cnt);
            Console.Out.Flush();
            if (!int.TryParse(Console.ReadLine(), out __cnt)) __cnt = 1;
            Console.WriteLine("Select/Default test data: {0}", __cnt);
        }
        var stdin = new System.IO.StreamReader("stdin.txt");
        Console.SetIn(stdin);
#endif
        SimpleScanner sc = new SimpleScanner(__cnt);
        long N = sc.NextLong(), Q = sc.NextLong();
        var A = new List<Item>();
        for (var n = 0; n < N; n++) {
            long s = sc.NextLong(), t = sc.NextLong(), x = sc.NextLong();
            A.Add(new Item(x, s, t));
        }
        var S = new DItem[Q];
        for (var q = 0; q < Q; q++) {
            long d = sc.NextLong();
            S[q] = new DItem(d, q);
        }
        A.Sort();
#if LOCAL_ENVIRONMENT
        Console.Error.WriteLine($"N:{N}, Q:{Q}");
        Console.Error.WriteLine($"A:{A.ToArray().ToStringA()}");
        Console.Error.WriteLine($"S:{S.ToStringA()}");
#endif
        long[] ans = new long[Q];
        for (var n = 0; n < Q; n++) ans[n] = -1;
        for (var n = 0; n < N; n++) {
            long x = A[n].no, l = A[n].start - x, r = A[n].end - x;
#if LOCAL_ENVIRONMENT
                Console.Error.WriteLine($"x:{x}, l:{l}, r:{r}");
#endif
            int it = Array.BinarySearch(S, new DItem(l, -1));
#if LOCAL_ENVIRONMENT
                Console.Error.WriteLine($"it:{it}, value:{new DItem(l, -1)}");
#endif
            if (it <= 0) it = 0;
            while (S[it] == null) it++;
            while (it < S.Length && S[it].time < r) {
#if LOCAL_ENVIRONMENT
                Console.Error.WriteLine($"it:{it}, S[it]:{S[it]}");
#endif
                ans[S[it].index] = x;
                Array.Clear(S, it, 1);
                while (S[it] == null) it++;
#if LOCAL_ENVIRONMENT
                Console.Error.WriteLine($"S:{S.ToStringA()}");
                Console.Error.WriteLine($"ans:{ans.ToStringA()}");
#endif
            }
        }
        foreach (var x in ans) Console.WriteLine(x);
    } //Main

    public static int LowerBound(List<DItem> array, int start, int end, long value, IComparer<long> comparer) {
        int low = start, high = end, mid;
        while (low < high) {
            mid = ((high - low) >> 1) + low;
            if (comparer.Compare(array[mid].time, value) < 0)
                low = mid + 1;
            else
                high = mid;
        }
#if LOCAL_ENVIRONMENT
        Console.Error.WriteLine($"LowerBound(array:{array.ToArray().ToStringA()}");
        Console.Error.WriteLine($"LowerBound(start:{start}, end:{end}, value:{value.ToString()}) return:{low}");
#endif
        return low;
    }
    public static int LowerBound(List<DItem> array, long value) {
        return LowerBound(array, 0, array.Count, value, Comparer<long>.Default);
    }

    public class BIT {
        int n;
        int[] data;
        public BIT(int size){
            n = size + 1;
            data = new int[n];
        }
        public void add(int i, int x) {
            while (i < n) {
                data[i] += x;
                i += i & -i;
            }
        }
        public int sum(int i) {
            int ret = 0;
            while (i > 0) {
                ret += data[i];
                i -= i & -i;
            }
            return ret;
        }
    }
    public class DItem : IEquatable<DItem>, IComparable<DItem> {
        public long time { get; set; }
        public long index { get; set; }
        public DItem(long time, long index) {
            this.time = time;
            this.index = index;
        }
        public override string ToString() {
            return $"[time:{this.time}, index:{this.index}]";
        }
        public bool Equals(DItem other) {
            if (other == null) return false;
            return this.time == other.time && this.index == other.index;
        }
        public override bool Equals(Object obj) {
            if (obj == null) return false;
            DItem item = obj as DItem;
            if (item == null)  return false;
            else return Equals(item);
        }
        public override int GetHashCode() {
            return this.index.GetHashCode();
        }
        public int CompareTo(DItem other) {
            if (other == null) return -1;
            return this.time.CompareTo(other.time);
        }
        public int Compare(DItem x, DItem y) {//Compare
            if (x == null) return 1;
            else return x.CompareTo(y);
        }
    }
    public class Item : IEquatable<Item>, IComparable<Item> {
        public long no { get; set; }
        public long start { get; set; }
        public long end { get; set; }
        public Item(long no, long start, long end) {
            this.no = no;
            this.start = start;
            this.end = end;
        }
        public override string ToString() {
            return $"[no:{this.no}, start:{this.start}, end:{this.end}]";
        }
        public bool Equals(Item other) {
            if (other == null) return false;
            return this.no == other.no && this.start == other.start && this.end == other.end;
        }
        public override bool Equals(Object obj) {
            if (obj == null) return false;
            Item item = obj as Item;
            if (item == null)  return false;
            else return Equals(item);
        }
        public override int GetHashCode() {
            return this.no.GetHashCode();
        }
        public int CompareTo(Item other) {
            if (other == null) return -1;
            if (this.no == other.no)
                if (this.start == other.start)
                    return this.end.CompareTo(other.end);
                else
                    return this.start.CompareTo(other.start);
            else
                return this.no.CompareTo(other.no);
        }
        public int Compare(Item x, Item y) {
            if (x == null) return 1;
            else return x.CompareTo(y);

        }
    }

    public class SimpleScanner {
        private int cnt;
        private string[] items;
        public SimpleScanner(int cnt = 0) {
            this.cnt = 0;
            var sb = new StringBuilder();
            var s = Console.ReadLine();
            while (s != null) {
                sb.Append(s + " ");
                s = Console.ReadLine();
            }
            this.items = sb.ToString().Split(' ');
#if LOCAL_ENVIRONMENT
            if (cnt > 0) {
                int index = Array.IndexOf(this.items, __mark + cnt.ToString());
                this.cnt = index + 1;
            }
            Console.Error.WriteLine("SimpleScanner.cnt: {0}", this.cnt);
            Console.Error.WriteLine("SimpleScanner.items: {0}", this.items.ToStringA());
#endif
        }
        public void SetCnt(int n) { this.cnt = n; }
        public int NextInt() {
            return int.Parse(this.items[this.cnt++]);
        }
        public long NextLong() {
            return long.Parse(this.items[this.cnt++]);
        }
        public string NextString() {
            return this.items[this.cnt++];
        }
        public int[] NextIntArray(int n) {
            if (n < 1) throw new IndexOutOfRangeException("引数は1以上であること！");
            var result = new int[n];
            for (var i = 0; i < n; i++) result[i] = this.NextInt();
#if LOCAL_ENVIRONMENT
            Console.Error.WriteLine("{0}", result.ToStringA());
#endif
            return result;
        }
        public long[] NextLongArray(int n) {
            if (n < 1) throw new IndexOutOfRangeException("引数は1以上であること！");
            var result = new long[n];
            for (var i = 0; i < n; i++) result[i] = this.NextLong();
#if LOCAL_ENVIRONMENT
            Console.Error.WriteLine("{0}", result.ToStringA());
#endif
            return result;
        }
        public string[] NextStringArray(int n) {
            if (n < 1) throw new IndexOutOfRangeException("引数は1以上であること！");
            var result = new string[n];
            for (var i = 0; i < n; i++) result[i] = this.NextString();
#if LOCAL_ENVIRONMENT
            Console.Error.WriteLine("{0}", result.ToStringA());
#endif
            return result;
        }
        public int[][] NextInt2Col(int n) {
            const int M = 2;
            if (n < 1) throw new IndexOutOfRangeException("引数は1以上であること！");
            int[][] result = new int[M][] {
                new int[n],
                new int[n],
            };
            for (var i = 0; i < n; i++) {
                result[0][i] = this.NextInt();
                result[1][i] = this.NextInt();
            }
#if LOCAL_ENVIRONMENT
            Console.Error.WriteLine("NextInt2Col: [");
            for (var i = 0; i < M; i++)
                Console.Error.WriteLine("  {0},", result[i].ToStringA());
            Console.Error.WriteLine("]");
#endif
            return result;
        }
    }

}
static class Extensions {
    public static string ToStringA<T>(this T[] array, string separator = ", ", string braces = "[]") {
        string bL = braces.Length > 0 ? braces[0].ToString() : "";
        string bR = braces.Length > 1 ? braces[1].ToString() : "";
        return bL + String.Join(separator, array) + bR;
    }
}