Vijos 1901 学姐的钱包（线段树优化dp）

最新推荐文章于 2019-10-03 15:59:09 发布

原创最新推荐文章于 2019-10-03 15:59:09 发布 · 327 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#线段树 #dp

dp 同时被 3 个专栏收录

218 篇文章

订阅专栏

线段树

45 篇文章

订阅专栏

Tyvj/Vijos

21 篇文章

订阅专栏

本文介绍了一种使用线段树结合动态规划解决带权值的线段覆盖问题的方法。通过将问题转化为寻找达到特定数值的最小代价，采用自定义的数据结构辅助更新与查询区间最小值来优化解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接

分析：
学长讲的线段树例题

我们可以将钱数看做是一个数轴
将一次交换看成数轴上的一个线段： $(R[i]-V[i])$
那么题目就可以视为带权值的线段覆盖问题

如果不带权值，就是贪心的经典问题
而此问题我们需要用dp解决：

设计状态： $f[i]$ 表示换成钱数 $i$ 的最小花费
我们把所有的线段按照右端点排序，顺序转移
因为每个线段一定是全部选择，所以我们转移右端点

对于线段 $[l,r]$
$f[r]=min(f[k]+v)$ ，其中 $l<=k<=r$
我们每次进行转移的时候，需要查询一个区间最小值，这个可以用线段树维护

tip

思路很简单，但是在代码实现的时候还是遇到了一些麻烦

首先我们在离散化的时候，只离散右端点即可
转移的时候枚举每个线段
最后统计答案的时候： $ask(m,max(m,Y))$

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long

using namespace std;

const ll INF=1e18;
const int N=100005;
int n,m,cnt,nn;
struct po{
    int l,r,v;
};
po a[N];
int X[N<<1];
struct node{
    ll mn;
};
node t[N<<2];

int cmp(const po &A,const po &B) {return A.r<B.r;}

void build(int bh,int l,int r)
{
    if (l!=1) t[bh].mn=INF;
    else t[bh].mn=0;
    if (l==r) return;
    int mid=(l+r)>>1;
    build(bh<<1,l,mid);
    build(bh<<1|1,mid+1,r);
}

void insert(int bh,int l,int r,int x,ll z)
{
    if (l==r)
    {
        t[bh].mn=min(t[bh].mn,z);
        return;
    }
    int mid=(l+r)>>1;
    if (x<=mid) insert(bh<<1,l,mid,x,z);
    else insert(bh<<1|1,mid+1,r,x,z);
    t[bh].mn=min(t[bh<<1].mn,t[bh<<1|1].mn);
}

ll ask(int bh,int l,int r,int L,int R)
{
    if (l>=L&&r<=R) return t[bh].mn;
    ll ans=INF;
    int mid=(l+r)>>1;
    if (L<=mid) ans=min(ans,ask(bh<<1,l,mid,L,R));
    if (R>mid) ans=min(ans,ask(bh<<1|1,mid+1,r,L,R));
    return ans;
}

int main()
{
    int T;
    scanf("%d",&T);
    for (int cas=1;cas<=T;cas++)
    {
        scanf("%d%d",&n,&m);
        cnt=0; nn=0;
        for (int i=1;i<=n;i++) 
        {
            cnt++;
            scanf("%d%d%d",&a[i].r,&a[i].l,&a[i].v);
            if (a[i].l>a[i].r) cnt--;
            else X[++nn]=a[i].r;
        }

        X[++nn]=1;                            //dp初始值 
        sort(X+1,X+1+nn);
        nn=unique(X+1,X+1+nn)-X-1;
        build(1,1,nn);

        sort(a+1,a+1+cnt,cmp);
        for (int i=1;i<=cnt;i++)
        {
            int x=lower_bound(X+1,X+1+nn,a[i].l)-X;
            int y=lower_bound(X+1,X+1+nn,a[i].r)-X;
            ll minn=ask(1,1,nn,x,y);
            if (minn!=INF)
                insert(1,1,nn,y,minn+(ll)a[i].v);
        }

        printf("Case #%d: ",cas);
        ll ans=ask(1,1,nn,lower_bound(X+1,X+1+nn,m)-X,nn);
        if (ans!=INF) printf("%d\n",ans);
        else printf("-1\n");
    } 
    return 0;
}