Light OJ 1402 (Dp + 树状数组)

题目：

[LINK](http://www.lightoj.com/volume_showproblem.php?problem=1402)
给你一些点（SRT， R）;
按照SRT排序， 然后再坐标系中画出这些点， 连成一条线。
线会有峰点（peak），一个点是峰点， 相邻两个点的 R 值都比它小 或 大。
然后WARush 要丧病的忽略一些点，（忽略第X点后，第 X 后面的点会前移！ ） 
会形成新的线。 然后题目要求输出所有线条中刚好有 K 个峰点的**不同线条**的数量。

分析：

题目中 单个点 和 没有点 都算一种情况。
先把所有点排序， 然后依次画图， 统计线条数。
对于 第 i 个点画图时 ：
    枚举 K 值
    当K == 0时， 我们可以得出：
        上升线条 Up = [比 Ri 低的点的数目] + [总结点数] + [上升线条尾端点值比 Ri 低的数]
        下降线条 Down 同理。
        故Dp[k] = Up + Down + 节点node 数。
    当 K > 0 时。 :
        上升线条 Up(k) = [上升线条 Up(k) 中尾端点比 Ri 小的线条数] + \
                       [ 下降线条 Down(k-1) 中尾端点比 Ri 小的线条数].
        下降线条 Down(k) 同理。
怎么求这些值？ 用树状数组维护就好了。

Code：

#include <bits/stdc++.h>

using namespace std;

typedef unsigned int U32;
const int maxn = 10000 + 131;
inline int lowbit(int x) {
    return x & (-x);
}
///树状数组
struct BIT {
    U32 Num[maxn];
    int N;

    void INIT(int n) {
        N = n;
        memset(Num, 0, sizeof(Num));
    }

    void Add(int x, U32 val) {
        while(x <= N) {
            Num[x] += val;
            x   += lowbit(x);
        }
    }

    U32 Sum(int x) {
        U32 ret = 0;
        while(x > 0) {
            ret += Num[x];
            x   -= lowbit(x);
        }
        return ret;
    }

    U32 Sec(int L, int R) {
        return Sum(R) - Sum(L-1);
    }
};
/// DP 状态
struct State {
    BIT Up, Down, Node;
    void INIT(int n) {
        Up.INIT(n);
        Down.INIT(n);
        Node.INIT(n);
    }
};

struct Data {
    int s, r;
    bool operator < (const Data& a) const {
        return this->s < a.s;
    }
};

Data node[maxn];
State Dp[60];
int R_n[maxn];

int main() {
    int T;
    scanf("%d",&T);
    for(int kase = 1; kase <= T; ++kase) {
        int n, K;
        scanf("%d%d",&n, &K);
        for(int i = 0; i < n; ++i) {
            scanf("%d%d",&node[i].s, &node[i].r);
            R_n[i] = node[i].r;
        }
        sort(R_n, R_n+n);
        int C   = unique(R_n, R_n+n) - R_n;
        int Max = -1;
        for(int i = 0; i < n; ++i) {
            node[i].r = lower_bound(R_n, R_n+C, node[i].r)-R_n+1;
            Max       = max(Max, node[i].r);
        }
        sort(node, node+n);
        ///离散化结束
        for(int i = 0; i <= K; ++i) Dp[i].INIT(Max);
        for(int i = 0; i < n; ++i) {
            int h = node[i].r;
            for(int k = 0; k <= K; ++k) {
                //相同点会造成相同的线条， 所以要减去。
                U32 Sum_Up   = -Dp[k].Up.Sec(h,h);
                U32 Sum_down = -Dp[k].Down.Sec(h,h);
                U32 Sum_node = -Dp[k].Node.Sec(h,h);
                Sum_Up       += Dp[k].Up.Sum(h-1) + Dp[k].Node.Sum(h-1);
                Sum_down     += Dp[k].Down.Sec(h+1, Max) + Dp[k].Node.Sec(h+1,Max);
                if(k == 0) Sum_node++;
                else {
                    Sum_Up   += Dp[k-1].Down.Sum(h-1);
                    Sum_down += Dp[k-1].Up.Sec(h+1, Max);
                }
                if(Sum_Up) Dp[k].Up.Add(h, Sum_Up);
                if(Sum_down) Dp[k].Down.Add(h, Sum_down);
                if(Sum_node) Dp[k].Node.Add(h, Sum_node);
            }
        }
        U32 Ans = 0;
        Ans = Dp[K].Down.Sum(Max) + Dp[K].Up.Sum(Max) + Dp[K].Node.Sum(Max);
        if(K == 0) Ans ++;
        printf("Case %d: %u\n",kase, Ans);
    }
    return 0;
}