題目大意：
有一個1維的長度為N，高度無限的水櫃，現在要用N-1個擋板將其分為N個長度為1的小格，然後向水櫃中注水，水可以低於擋板也可以以溢位去（這樣就要與旁邊格子的水位相同），現在有M次探測，探測i,y,k為查詢第i個格子高度y+0.5處是否有水，k=1表示有水，k=0表示沒有水，這M次探測不保證結果正確，現求結果正確個數的最大可能值。

思路：
這道題可以用類似樹形dp的方法求解，依照分隔擋板由低到高的順序將相鄰的水櫃合併，視為一個水櫃，在合併前分別對兩個水櫃加水到剛好溢位，而對超出此水位的探測暫不處理，求出區域性最優解（不溢位最優解f和溢位最優解g），並將各自未處理的探測合併為一個集合。不斷進行此過程最後求出整個水櫃的最優解。

主要操作為合併和注水，對每個水櫃維護下列值：
注水高度h，不溢位最優解f，溢位最優解g，未處理探測集合E

以樣例1為例說明處理方法

初狀態
水櫃1：h=0，f=0，g=0，E={<1,3,1>}
水櫃2：h=0，f=0，g=0，E={<2,1,0>,<2,2,0>}
水櫃3：h=0，f=0，g=0，E={<3,3,1>}

先將擋板由低到高排序
於是首先合併水櫃1和水櫃2，合併前先分別對兩個水櫃注水到擋板的高度3，
水櫃1：h=3，f=0，g=0，E={<1,3,1>}
水櫃2：h=3，f=2，g=0，E={}
合併後水櫃1~2：h=3，f=2，g=0，E={<1,3,1>}

然後合併水櫃1~2和水櫃3，合併前先分別對兩個水櫃注水到擋板的高度4，
水櫃1~2：h=4，f=2，g=1，E={}
水櫃3：h=4，f=1，g=1，E={}
合併後水櫃1~3：h=4，f=3，g=2，E={}

最後注水到最大值（比如1e9+5）
水櫃1~3：h=4，f=3，g=2，E={}

於是得到結果為3

可以用並查集維護合併過程，用左斜樹（或其它可合併優先佇列）合併未處理的探測集合E，這樣每次合併的複雜度為O(logN+logM)，N次合併的總複雜度為O(NlogN+NlogM)

程式碼：
Problem : 5575 ( Discover Water Tank ) Judge Status : Accepted
RunId : 15797292 Language : G++ Author : qsqx
3213MS 9832K

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <stack>
#include <vector>
#include <memory.h>
#include <set>
#include <string.h>
#include <list>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <queue>
#define ll long long
#define forn(i,n) for(int i=0;i<n;++i)
#define rep(i,n) for(int i=1;i<=n;++i)
#define repc(i,l,r) for(int i=l;i<=r;++i)
#define mp(a,b) make_pair(a,b)
#define llf long double
#define pii pair<int,int>
using namespace std; 
int l[200005];
int r[200005];
pii query[200005];//
int dist[200005];
int dsu[100005];
pii stk[200005];//
int merge(int a, int b) {
    if (!a)return b;
    else if (!b)return a;
    if (query[a].first > query[b].first)swap(a, b);
    r[a] = merge(r[a], b);
    if (dist[r[a]] > dist[l[a]])swap(l[a], r[a]);
    if (!r[a]) dist[a] = 0;
    else dist[a] = dist[r[a]] + 1;
    return a;
}
struct Node {
    int qu, h;
    int f, g;
    void get(int hgt) {
        int nw = 0;
        int mx = 0;
        int fmr = -1;
        int tol = 0;
        int nf;
        while (qu&&query[qu].first<hgt) {
            stk[tol++] = query[qu];
            if (query[qu].second == 0) ++nw;
            qu = merge(l[qu], r[qu]);
        }
        nf = nw;
        forn(i, tol) {
            if (stk[i].first != fmr) {
                mx = max(mx, nw);
                fmr = stk[i].first;
            }
            if (stk[i].second)++nw;
            else --nw;
        }
        mx = max(mx, nw);
        f = max(f+nf, g + mx);//not overflow
        g += nw;
        h = hgt;
    }
}nds[100005];

int getgp(int u) {
    return dsu[u] = (dsu[u] != u ? getgp(dsu[u]) : u);
}
void mrg(int u, int v, int h) {
    u = getgp(u);
    v = getgp(v);
    if (nds[u].h < h) {
        nds[u].get(h);
    }
    if (nds[v].h < h) {
        nds[v].get(h);
    }
    dsu[v] = u;
    nds[u].qu = merge(nds[u].qu, nds[v].qu);
    nds[u].f += nds[v].f;
    nds[u].g += nds[v].g;
}
int n, m;
pii board[100005];//
void solve() {
    memset(l, 0, sizeof(l));
    memset(r, 0, sizeof(r));
    memset(dist, 0, sizeof(dist));
    memset(nds, 0, sizeof(nds));
    memset(board, 0, sizeof(board));
    memset(query, 0, sizeof(query));
    cin >> n >> m;
    rep(i, n)dsu[i] = i;
    rep(i, n - 1) {
        scanf("%d", &board[i].first);
        board[i].second = i;
    }
    sort(board + 1, board + n);

    int S = 0;
    rep(i, m) {
        int x;
        scanf("%d%d%d", &x, &query[i].first, &query[i].second);
        if (query[i].second) ++S;
        nds[x].qu = merge(nds[x].qu, i);
    }
    rep(i, n - 1) {
        mrg(board[i].second, board[i].second + 1, board[i].first);
    }
    int rt = getgp(1);
    nds[rt].get(1e9 + 100);
    cout << nds[rt].f << endl;
}
int main(){
    //freopen("abc.txt", "r", stdin);
    int T;
    cin >> T;
    rep(t, T) {
        printf("Case #%d: ", t);
        solve();
    }
    return 0;
}