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 Kotlin (1.0.0) (judge verdict: Time Limit Exceeded)

private data class Work(val start: Int, val end: Int, val dist: Int)
private data class Position(val pos: Int, val index: Int)

fun main(args: Array<String>) {
    val (n, q) = readLine()!!.split(" ").map { it.toInt() }

    // イベントソート


    // segTree ライブラリがあればいけるとのこと
    // RMQ とは??


    // 工事を格納
    var workList = mutableListOf<Work>()

    for (i in 0 until n) {
        val (s, t, x) = readLine()!!.split(" ").map { it.toInt() }

        // 切り上げ，切り捨てをして閉区間で考える
        var start = Math.ceil(s - 0.5 - x).toInt()
        var end = Math.floor(t - 0.5 - x).toInt()

        workList.add(Work(start, end, x))
    }

    // 工事を距離が近い順にソート
    workList.sortBy { it.dist }

    // スタート地点を配列に保持してソート
    // スタート地点の中で，ある工事区間に含まれるものを取り出し，配列から削除,
    var posList = mutableListOf<Position>()
    for (i in 0 until q) {
        posList.add(Position(readLine()!!.toInt(), i))
    }

    // 開始地点を近い順にソート
    posList.sortBy { it.pos }

    // 答えにはデフォルトで -1 を設定 (選ばれなかったものは工事に合わない = -1 )
    val ans = IntArray(q) { -1 }


    /////////////////////////////////////////////////
    // 探索を開始
    /////////////////////////////////////////////////

    // n = 10^5 ループが回る
    // ループ内ではまず log N = log 10^5 探索
    // while ループが回る数は合計で q = 10^5
    // なので全体のオーダーとしては O(NlogN) くらいになるはず だがTLEなのはなぜか？？

    for (i in 0 until n) {

        val work = workList[i]

        // work.start よりも大きな開始地点を持つ posList 内の 最初のインデックスを取得
        // binarySearch を用いて実装する必要がある
        val j = getLowerBound(posList, work.start)


        while (true) {
            // WA: 配列が空になってしまう場合を考慮漏れ
            if (posList.isEmpty() || j >= posList.size || posList[j].pos > work.end) {
                break
            }

            // 工事の範囲に収まる開始点を持つ人を判別, 行ける最短の距離を割り当てる
            ans[posList[j].index] = work.dist

            // 該当の人を削除する & 次の要素に進む操作が必要 & かならずしも先頭からではない & 毎回削除していくことで探索コストを抑えることだできる
            // やはり繰り返しの中で動的に要素数を変更していきたい
            // 懸念点インデックス j でのイテレーションが面倒かもしれない -> 最後に removeAll でまとめて削除すれば j についてのループでは心配しなくて良いかも？？
            // 削除すれば それはつまり１つ進んだことと同じ

            posList.removeAt((j))

            if (posList.isEmpty()) {
                break
            }
        }
    }

    for( a in ans){
        println(a)
    }
}

private fun getLowerBound(data: MutableList<Position>, boundary: Int): Int {

    // 該当値のインデックス, もしくはその値を挿入するならどこになるかを示してくれている
    // 空の配列に対して操作した場合は？？
    val index = data.binarySearch { it.pos - boundary }

    if (index >= 0) {
        return index
    }
    return -1 * index - 1
}