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

  def delete(x)
    # 削除したい値のあるindexへ、最新nodeの値を入れる
    current_node_index = @index.delete(x)
    @size -= 1
    return if current_node_index == @size || @size == 0
    current_node_value = @nodes[@size]
    @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
      # puts "#{self.inspect} delete:#{x} #{parent_node_index}" unless @nodes[parent_node_index]
      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_r = (current_node_index + 1) << 1
      child_node_index_l = child_node_index_r - 1
      return if child_node_index_r >= @size
      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_value = child_node_value_r
        min_child_index = child_node_index_r
      else
        min_child_value = child_node_value_l
        min_child_index = child_node_index_l
      end
      while (min_child_value < current_node_value) do
        change(current_node_index, min_child_index)
        current_node_index = min_child_index
        current_node_value = min_child_value
        child_node_index_r = (current_node_index + 1) << 1
        child_node_index_l = child_node_index_r - 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]
        if child_node_value_l > child_node_value_r
          min_child_value = child_node_value_r
          min_child_index = child_node_index_r
        else
          min_child_value = child_node_value_l
          min_child_index = child_node_index_l
        end
      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(nn)
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]