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 Ruby (2.3.3) (judge verdict: Wrong Answer)

class Heap
  def initialize(n)
    @nodes = Array.new(n)
    @index = Hash.new
    @size = 0
  end

  def push(x)
    i = @size
    @size += 1
    while i > 0 do
      #親ノードのindex
      t = (i-1)>>1
      # 親より自分が大きいなら、入れ替え不要
      break if @nodes[t] <= x
      # 親より自分が小さい時、入れ替え操作を行う
      @index[@nodes[t]] = i
      @nodes[i] = @nodes[t]
      i = t
    end
    @index[x] = i
    @nodes[i] = x
  end

  def delete(x)
    # 削除したい値のあるindexへ、最新nodeの値を入れる
    current_node_value = @nodes[@size - 1]
    return unless current_node_index = @index.delete(x)
    @size -= 1
    @nodes[current_node_index] = current_node_value
    @index[current_node_value] = current_node_index

    # 大小関係が正されるように、要素を入れ替える
    if x > current_node_value
      # 末端のほうが削除する値よりも小さかった場合は、親ノードへ入れ替えを確認していく
      parent_node_index = (current_node_index - 1) >> 1
      while @nodes[parent_node_index]&.< @nodes[current_node_index] do
        change(parent_node_index, current_node_index)
        current_node_index = parent_node_index
        current_node_value = @nodes[current_node_index]
        parent_node_index = (current_node_index - 1) >> 1
      end
    else
      # 末端のほうが大きかった場合は、子ノードへ入れ替えを確認していく
      # 末端のほうが削除する値よりも小さかった場合は、親ノードへ入れ替えを確認していく
      child_node_index_l = (current_node_index + 1) << 1
      child_node_index_r = child_node_index_l - 1
      child_node_value_l = @nodes[child_node_index_l]
      child_node_value_r = @nodes[child_node_index_r]
      if child_node_value_l&.>(child_node_value_r)
        min_child_info = [child_node_value_r , child_node_index_r]
      else
        min_child_info = [child_node_value_l , child_node_index_l]
      end
      while (min_child_info[0]&.<(current_node_value)) do
        change(current_node_index, min_child_info[1])
        current_node_index = min_child_info[1]
        current_node_value = min_child_info[0]
        child_node_index_l = (current_node_index + 1) << 1
        child_node_index_r = child_node_index_l - 1
        break if child_node_index_r >= @size
        child_node_value_l = @nodes[child_node_index_l]
        child_node_value_r = @nodes[child_node_index_r]
        min_child_info = (child_node_value_l&.>(child_node_value_r)) ? [child_node_value_r , child_node_index_r] : [child_node_value_l , child_node_index_l]
      end
    end
  end

  def top
    @size == 0 ? -1 : @nodes[0]
  end

  private

  def change(index_i, index_j)
    @nodes[index_i], @nodes[index_j] = @nodes[index_j], @nodes[index_i]
    @index[@nodes[index_i]] = index_i
    @index[@nodes[index_j]] = index_j
  end
end

nn, qq = gets.split.map(&:to_i)
events = []
temp = []

t = 0
nn.times do
  temp = gets.split.map(&:to_i)
  next if (t = temp[1] - temp[2]) <= 0

  events.push(
    ((temp[0] - temp[2]) << 32) +
    (2 << 30) +
    temp[2]
  )
  events.push(
    (t << 32) +
    temp[2]
  )
end

1.step(qq, 1) do |i|
  events.push(
    (gets.to_i << 32) +
    (3 << 30) +
    i
  )
end

# '30bit-2bit-30bit'
#  ソートするための区間 - タイプ - indexなどの情報
mask_3 = ((1 << 30) - 1)
mask_4 = ((1 << 18) - 1)

events.sort!

ss = Heap.new(qq)
ans = []

events.each do |event|
  if event[30] == 0
    if event[31] == 1
      ss.push(event & mask_3)
    else
      ss.delete(event & mask_3)
    end
  else
    ans[(event & mask_4)] = ss.top
  end
end

puts ans[1..-1]