POJ3171 线段树优化dp

题意：给范围为l到r的区间，给n个奶牛，每个奶牛可以覆盖一段区间同时有一个代价，求把所有区间覆盖的最小代价

思路：给n个奶牛按照r从小到大排序，按照这个顺序我们依次来判断每个奶牛，设f[x]表示[l,x]这个区间被覆盖的最小代价，初始化[l,r]=inf,[l-1.l-1]=0,对于每个奶牛它可以从[l-1,r]这个区间的最小代价转移到到它所能覆盖的最右端点r，

每次判断区间最小值和端点修改用线段树，树状数组也可以。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int maxm=9e4;
const int maxn=1e4+10;
const int INF=0x3f3f3f3f;
int f[maxm];
struct node
{
    int l,r,cost;
} row[maxn];
int cmp(node a,node b)
{
    return a.r<b.r;
}
struct note
{
    int left,right,minn;
} tree[maxm*4];
void pushup(int id)
{
    tree[id].minn=min(tree[id<<1].minn,tree[id<<1|1].minn);
}
void build(int id,int l,int r)
{
    tree[id].left=l;
    tree[id].right=r;
    if(l==r)
        tree[id].minn=f[l];
    else
    {
        int mid=(l+r)/2;
        build(id<<1,l,mid);
        build(id<<1|1,mid+1,r);
        pushup(id);
    }
}
int query(int id,int l,int r)
{
    if(l<=tree[id].left&&tree[id].right<=r)
        return tree[id].minn;
    int mid=(tree[id].left+tree[id].right)/2;
    int ans=INF;
    if(l<=mid) ans=min(ans,query(id<<1,l,r));
    if(r>mid) ans=min(ans,query(id<<1|1,l,r));
    return ans;
}
void update(int id,int l,int r,int val)
{
    if(l<=tree[id].left&&tree[id].right<=r)
    {
        tree[id].minn=val;
        return;
    }
    int mid=(tree[id].left+tree[id].right)/2;
    if(l<=mid) update(id<<1,l,r,val);
    if(r>mid) update(id<<1|1,l,r,val);
    pushup(id);
}

int main()
{
    int n,l,r;
    scanf("%d%d%d",&n,&l,&r);
    memset(f,0x3f,sizeof(f));
    f[l]=0;
    build(1,l,r);
    for(int i=1; i<=n; i++)
        scanf("%d%d%d",&row[i].l,&row[i].r,&row[i].cost);
    sort(row+1,row+1+n,cmp);
    int ans=0x3f3f3f3f;
    for(int i=1; i<=n; i++)
    {
        f[row[i].r]=min(f[row[i].r],query(1,row[i].l-1,row[i].r)+row[i].cost);
        update(1,row[i].r,row[i].r,f[row[i].r]);
        if(row[i].r>=r)
            ans=min(ans,f[row[i].r]);
    }
    if(ans>=INF) printf("-1");
    else printf("%d",ans);
    return 0;
}