题意:给范围为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;
}