题意：
    按照顺序接收重量为 4, 3, 2, 1, 4的block时，可按照重量为4 –> 3 –>2 –> 1 的顺序推成塔，然后最后为了装饰塔顶，可以使用重量为4的block。
    用例：
    1
    5
    2 4
    1 2
    3 3
    2 6
    1 4
    —> # 13

    1. package indexTree;
    3. import java.io.BufferedReader;
    4. import java.io.FileInputStream;
    5. import java.io.InputStreamReader;
    6. import java.util.Arrays;
    7. import java.util.Comparator;
    8. import java.util.StringTokenizer;
    10. public class 积木游戏3{
    11.     static int T,N;
    12.     static long[] indexTree;
    13.     static block[] blockArr;
    14.     static class block{
    15.         int index;
    16.         int w;
    17.         int val;
    18.         int max;
    19.         public block(int index, int w, int val, int max) {
    20.             this.index = index;
    21.             this.w = w;
    22.             this.val = val;
    23.             this.max = max;
    24.         }
    25.     }
    26.     static class compM implements Comparator<block>{
    27.         @Override
    28.         public int compare(block o1, block o2) {
    29.             if (o1.w != o2.w) {
    30.                 return o2.w-o1.w;
    31.             }else {
    32.                 //此处的排序   当重量相同时  index 按照 降序排列 
    33.                 // 因为题目中要求相同重量的不能叠放。
    34.                 return o2.index-o1.index;
    35.             }
    36.         }
    37.     }
    38.     public static void main(String[] args) throws Exception {
    39.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    40.         StringTokenizer st = new StringTokenizer(br.readLine());
    41.         T = Integer.parseInt(st.nextToken());
    42.         for (int i0 = 1; i0 <= T; i0++) {
    43.             st = new StringTokenizer(br.readLine());
    44.             N = Integer.parseInt(st.nextToken());
    45.             blockArr = new block[N];
    46.             for (int i = 0; i < N; i++) {
    47.                 st = new StringTokenizer(br.readLine());
    48.                 int weightTemp = Integer.parseInt(st.nextToken());
    49.                 int valTemp = Integer.parseInt(st.nextToken());
    50.                 blockArr[i] = new block(i,weightTemp, valTemp,0);
    51.             }
    52.             //获取当前点之后的最大值
    53.             for (int i = N-2; i >=0; i--) {
    54.                 blockArr[i].max = Math.max(blockArr[i+1].max, blockArr[i+1].val);
    55.             }
    56.             Arrays.sort(blockArr,0,N,new compM());
    57.             int lastNodeNum = 1;
    58.             while(lastNodeNum < N) {
    59.                 lastNodeNum <<=1;
    60.             }
    61.             indexTree = new long[2*lastNodeNum];
    62.             long ans = 0;
    63.             for (int i = 0; i < N; i++) {
    64.                 long sum = query(lastNodeNum, lastNodeNum+blockArr[i].index)+blockArr[i].val;
    65.                 update(lastNodeNum+blockArr[i].index, sum);
    66.                 ans = Long.max(ans, sum+blockArr[i].max);
    67.             }
    68.             System.out.println("#"+i0+" "+ans);
    69.         }
    70.     }
    72.     private static void update(int index, long val) {
    73.         while (index > 0) {
    74.             indexTree[index] = Math.max(val,indexTree[index]);
    75.             index >>= 1;
    76.         }
    77.     }
    79.     private static long query(int s, int e) {
    80.         long max = 0;
    81.         while (s <= e) {
    82.             if (s % 2 == 1) max = Long.max(max, indexTree[s]);
    83.             if (e % 2 == 0) max = Long.max(max, indexTree[e]);
    84.             s = (s + 1) >> 1;
    85.             e = (e - 1) >> 1;
    86.         }
    87.         return max;
    88.     }
    90. }