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: Accepted)

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;

partial class Solver
{
    public class Data
    {
        public int Id { get; set; }
        public int Value { get; set; }
    }

    public void Run()
    {
        var N = ni();
        var Q = ni();
        var S = new int[N];
        var T = new int[N];
        var X = new int[N];
        for (int i = 0; i < N; i++)
        {
            S[i] = ni();
            T[i] = ni();
            X[i] = ni();
        }
        var D = ni(Q);

        var c = new List<int>();
        for (int i = 0; i < N; i++)
        {
            c.Add(S[i] - X[i]);
            c.Add(T[i] - X[i]);
        }
        for (int i = 0; i < Q; i++)
        {
            c.Add(D[i]);
        }

        var dic = IndexDictionaryFactory.Create(c);

        var tree = new AnonymousRangeUpdateSegmentTree<int>(Math.Min);
        tree.Build(dic.Count, i => int.MaxValue, int.MaxValue);

        for (int i = 0; i < N; i++)
        {
            var begin = dic.GetIndex(S[i] - X[i]);
            var end = dic.GetIndex(T[i] - X[i]);

            tree.Update(begin, end, X[i]);
        }


        foreach (var d in D)
        {
            var p = dic.GetIndex(d);
            var ans = tree.Get(p);
            if (ans == int.MaxValue) ans = -1;
            cout.WriteLine(ans);
        }
    }
}


public class IndexDictionary<T>
{
    private readonly Dictionary<T, int> _toIndex;
    private readonly T[] _array;

    public IndexDictionary(IEnumerable<T> source) : this(source, Comparer<T>.Default) { }

    public IndexDictionary(IEnumerable<T> source, IComparer<T> comparer)
    {
        _array = source.ToArray();
        Array.Sort(_array, comparer);
        _toIndex = new Dictionary<T, int>(_array.Length);
        int index = -1;
        foreach (var x in _array) _toIndex[x] = ++index;
    }

    public int Count { get { return _array.Length; } }

    public T this[int index] { get { return _array[index]; } }

    public int GetIndex(T value) { return _toIndex[value]; }
}

public class IndexDictionaryFactory
{
    public static IndexDictionary<T> Create<T>(IEnumerable<T> source)
    {
        return new IndexDictionary<T>(source);
    }
}

public abstract class RangeUpdateSegmentTree<TNodeValue> where TNodeValue : struct
{
    protected int N { get; private set; }
    protected TNodeValue[] node;
    protected static int Left(int p) { return p * 2 + 1; }
    protected static int Right(int p) { return p * 2 + 2; }

    public RangeUpdateSegmentTree() { }

    virtual public void Build(int _n, Func<int, TNodeValue> create, TNodeValue unit)
    {
        N = 1;
        while (N < _n) N *= 2;
        node = new TNodeValue[2 * N];
        for (int i = 0; i < node.Length; i++) node[i] = unit;
        for (int i = 0; i < _n; i++) node[i + N - 1] = create(i);
        for (int i = N - 2; i >= 0; i--) node[i] = Merge(node[Left(i)], node[Right(i)]);
    }

    protected abstract TNodeValue Merge(TNodeValue left, TNodeValue right);

    public TNodeValue Get(int index)
    {
        int p = index + N - 1;
        var result = node[p];
        while (p > 0)
        {
            p = (p - 1) >> 1;
            result = Merge(result, node[p]);
        }
        return result;
    }

    int Begin, End;

    protected virtual void Update(int k, int l, int r, TNodeValue value)
    {
        if (r <= Begin || End <= l) return;
        if (Begin <= l && r <= End)
        {
            node[k] = Merge(node[k], value);
            return;
        }
        int mid = (l + r) >> 1;
        Update((k << 1) + 1, l, mid, value);
        Update((k << 1) + 2, mid, r, value);
    }

    public void Update(int begin, int end, TNodeValue value)
    {
        Begin = begin;
        End = end;
        Update(0, 0, N, value);
    }
};

public class AnonymousRangeUpdateSegmentTree<TNodeValue> : RangeUpdateSegmentTree<TNodeValue> where TNodeValue : struct
{
    readonly Func<TNodeValue, TNodeValue, TNodeValue> _mergeMethod;

    public AnonymousRangeUpdateSegmentTree(Func<TNodeValue, TNodeValue, TNodeValue> merge)
    {
        _mergeMethod = merge;
    }

    protected override TNodeValue Merge(TNodeValue left, TNodeValue right)
    {
        return _mergeMethod(left, right);
    }
}

// PREWRITEN CODE BEGINS FROM HERE
partial class Solver : Scanner
{
    public static void Main(string[] args)
    {
#if LOCAL
        new Solver(Console.In, Console.Out).Run();
#else
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        new Solver(Console.In, Console.Out).Run();
        Console.Out.Flush();
#endif
    }

    TextReader cin;
    TextWriter cout;

    public Solver(TextReader reader, TextWriter writer)
        : base(reader)
    {
        this.cin = reader;
        this.cout = writer;
    }
    public Solver(string input, TextWriter writer)
        : this(new StringReader(input), writer)
    {
    }

    public int ni() { return NextInt(); }
    public int[] ni(int n) { return NextIntArray(n); }
    public long nl() { return NextLong(); }
    public long[] nl(int n) { return NextLongArray(n); }
    public double nd() { return NextDouble(); }
    public string ns() { return Next(); }
}

public class Scanner
{
    private TextReader Reader;
    private Queue<String> TokenQueue = new Queue<string>();
    private readonly CultureInfo ci = CultureInfo.InvariantCulture;

    public Scanner()
        : this(Console.In)
    {
    }

    public Scanner(TextReader reader)
    {
        this.Reader = reader;
    }

    public int NextInt() { return Int32.Parse(Next(), ci); }
    public long NextLong() { return Int64.Parse(Next(), ci); }
    public double NextDouble() { return double.Parse(Next(), ci); }
    public string[] NextArray(int size)
    {
        var array = new string[size];
        for (int i = 0; i < size; i++) array[i] = Next();
        return array;
    }
    public int[] NextIntArray(int size)
    {
        var array = new int[size];
        for (int i = 0; i < size; i++) array[i] = NextInt();
        return array;
    }

    public long[] NextLongArray(int size)
    {
        var array = new long[size];
        for (int i = 0; i < size; i++) array[i] = NextLong();
        return array;
    }

    public String Next()
    {
        if (TokenQueue.Count == 0)
        {
            if (!StockTokens()) throw new InvalidOperationException();
        }
        return TokenQueue.Dequeue();
    }

    public bool HasNext()
    {
        if (TokenQueue.Count > 0)
            return true;
        return StockTokens();
    }

    private bool StockTokens()
    {
        while (true)
        {
            var line = Reader.ReadLine();
            if (line == null) return false;
            var tokens = line.Trim().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            if (tokens.Length == 0) continue;
            foreach (var token in tokens)
                TokenQueue.Enqueue(token);
            return true;
        }
    }
}