poj3171（dp + 线段树）

（和 poj1769 几乎一样，利用线段树dp的基础题）

题目大概意思为选几个区间，使 M 到 E 全都被覆盖，求选取区间的最少数量
(我们把从 M 到 E 转化成从 1 到 E - M + 1 )
且对于输入我们需要先排序排序一下

dp[i][j] : 意思为到第 i 个区间为止，能 刚好 覆盖到 j 的最小区间数目
例：区间为【1，10】，【5，20】，则 dp[1][10] = 1; dp[2][20] = 2; dp[2][19] = INF;
此时影响当前阶段的只有前一阶段的状态，无后效性，所以 dp 可行

预处理，i = 0时，dp[0][0] = 0; dp[0][j] = INF; ( 初始情况什么都没有被覆盖 ）

那 dp[i+1][j] 怎么处理？
假设 i + 1 区间的左右界分别为 a 和 b，我们遍历 dp[i][a - 1] 到 dp[i][b-1],找到其中最小值 c（这代表可以接上第 i + 1 个区间）
假设d = dp[i][[b]（ 即到 i 区间为止，最少用 d 个区间可以覆盖到 b ）
如果 c < d - 1，便将 dp[i+1][b] 更新为 c + 1

我们可以将数组优化为一维数组，dp[j] 也能正确运行

我们不难发现，我们进行了大量的 修改 和 关于区间的查找最小值操作 ，此模型符合线段树的RMQ结构
我们可以把 dp 数组 转化为 线段树 dat 数组，可大幅缩短时间复杂度

然后套模板即可，代码如下：

#include <iostream>
#include <stdio.h>
#include <algorithm>
#define INF 1000000005
using namespace std;
int n;
int dat[(1<<20)+5];
struct ddd
{
    int a, b, c;
};
void init(int n_)
{
    n = 1;
    while(n < n_) n *= 2;
    for(int i = 0; i < 2 * n - 1; i++) dat[i] = INF;
}
void update(int k, int a)
{
    k += n - 1;
    dat[k] = a;
    while(k > 0)
    {
        k = (k - 1) / 2;
        dat[k] = min(dat[k*2+1], dat[k*2+2]);
    }
}
bool cmp(struct ddd a, struct ddd b)
{
    if(a.a == b.a)
    {
        return a.b < b.b;
    }
    return a.a < b.a;
}
int query(int a, int b, int k, int l, int r)
{
    if(r <= a || b <= l) return INF;
    if(a <= l && r <= b) return dat[k];
    else
    {
        int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
        int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
        return min(vl, vr);
    }
}
int main()
{
    int num, p, q;
    struct ddd data[10005];
    scanf("%d %d %d", &num, &p, &q);
    q = q - p + 1;
    init(q + 1);
    update(0, 0);
    for(int i = 0; i < num; i++)
    {
        scanf("%d %d %d", &data[i].a, &data[i].b, &data[i].c);
    }
    sort(data, data + num, cmp);
    for(int i = 0; i < num; i++)
    {
        int a, b, c = data[i].c;
        a = data[i].a - p + 1;
        b = data[i].b - p + 1;
        int d = query(a - 1, b, 0, 0, n + 1);
        int e = query(b, n + 1, 0, 0, n + 1);
        if(d <= e - c)
        {
            update(b, d + c);
        }
    }
    if(dat[q+n-1] == INF)
    {
        printf("-1\n");
    }
    else
    {
        printf("%d\n", dat[q+n-1]);
    }
}