Problem:
ワカサギ釣り大会 2

桧原湖でワカサギ釣り大会が行われました。今回はキャッチ＆リリースが推奨されているようです。

参加者番号と釣った匹数またはリリースした匹数を１つのイベントとして順番に読み込み、各イベントの直後に最も多くのワカサギを手元に獲得している参加者番号と匹数を出力するプログラムを作成してください。最も多く獲得している参加者が複数いる場合（あるいは全ての参加者が 0 匹の場合）は、その中で参加者番号が最も小さい一人を出力してください。

入力

入力は以下の形式で与えられる。

n q
a1 v1
a2 v2
:
aq vq

n (1 ≤ n ≤ 1000000) は参加者の数、q (1 ≤ q ≤ 100000)はイベントの数を表す。ai (1 ≤ ai ≤ n)   vi ( -100 ≤ vi ≤ 100) は、i 番目のイベントで参加者 ai が vi 匹獲得あるいはリリースしたことを示す。vi は正の値が獲得、負の値がリリースを示し、0 が与えられることはない。

出力

各イベントごとに、最も多くのワカサギを手元に獲得している参加者の参加者番号と匹数を１つの空白区切りで１行に出力する。

入力例1

3 5
1 4
2 5
1 3
3 6
2 7

出力例1

1 4
2 5
1 7
1 7
2 12

入力例2

3 5
1 4
2 5
2 -3
3 4
1 -1

出力例2

1 4
2 5
1 4
1 4
3 4

Solution in JAVA (judge verdict: Wrong Answer)

public class
Main
{
  public void
  run (
    final java.util.Scanner sc,
    final java.io.PrintStream out
    )
  {
    Pair[ ] heap;
    int[ ]  paeh;
    int n, q;
    int i;
    
    n = sc.nextInt ( );
    q = sc.nextInt ( );

    heap = new Pair[ n ];
    paeh = new int[ n + 1 ];
    for ( i = 1; i <= n; ++i )
    {
      paeh[ i ] = i - 1;
      heap[ paeh[ i ] ] = new Pair ( i, 0 );
    }

    for ( ; q > 0; --q )
    {
      int a, v;

      a = sc.nextInt ( );
      v = sc.nextInt ( );

      heap[ paeh[ a ] ].value += v;
      for ( ; ; )
      {
        if ( v > 0 )
        {
          if ( paeh[ a ] > 0
            && heap[ paeh[ a ] ].compareTo ( heap[ ( paeh[ a ] - 1 ) / 2 ] ) < 0 )
          {
            swap ( heap, paeh[ a ], ( paeh[ a ] - 1 ) / 2 );
            swap ( paeh, a, heap[ paeh[ a ] ].index );
          }
          else break ;
        }
        else if ( v < 0 )
        {
          if ( paeh[ a ] * 2 + 2 < heap.length - 1
            && heap[ paeh[ a ] * 2 + 2 ].compareTo ( heap[ paeh[ a ] * 2 + 1 ] ) < 0
            && heap[ paeh[ a ] * 2 + 2 ].compareTo ( heap[ paeh[ a ] ] ) < 0 )
          {
            swap ( heap, paeh[ a ], paeh[ a ] * 2 + 2 );
            swap ( paeh, a, heap[ paeh[ a ] ].index );
          }
          else if ( paeh[ a ] * 2 + 1 < heap.length - 1
                 && heap[ paeh[ a ] * 2 + 1 ].compareTo ( heap[ paeh[ a ] ] ) < 0 )
          {
            swap ( heap, paeh[ a ], paeh[ a ] * 2 + 1 );
            swap ( paeh, a, heap[ paeh[ a ] ].index );
          }
          else break ;
        }
        else break ;
      }
      System.out.println ( heap[ 0 ].index + " " + heap[ 0 ].value );
    }
  }

  private static void
  swap (
    int[ ] a,
    int i,
    int j
    )
  {
    final int t = a[ i ];
    a[ i ] = a[ j ];
    a[ j ] = t;
  }

  private static <T> void
  swap (
    T[ ] a,
    int i,
    int j
    )
  {
    final T t = a[ i ];
    a[ i ] = a[ j ];
    a[ j ] = t;
  }

  public static void
  main (
    final String[ ] args
    )
  {
    ( new Main ( ) ).run ( new java.util.Scanner ( System.in ), System.out );
  }

  private class
  Pair
  implements Comparable<Pair>
  {
    public final int index;
    public       int value;

    public
    Pair (
      final int index,
      final int value
      )
    {
      this.index = index;
      this.value = value;
    }

    public int
    compareTo (
      final Pair obj
      )
    {
      if ( this.value == obj.value )
        return ( this.index - obj.index );
      return ( obj.value - this.value );
    }
  }
}