UESTC 1558 Charitable Exchange

UESTC_1558

    如果这个题目不考虑t而是改成问最少的转换次数，那么我们只要每次让它转换得越大越好，因此就可以将所有的exchange按r进行排序，每一次在一定的范围内选出v最大的exchange即可（这一点可以用堆来实现）。

    而现在是需要考虑t的，显然就不能直接贪心了，于是我们不妨往dp的角度上想一下。如果dp的话，那么就涉及到一个顺序的问题，按我们上面的思路将r排序后进行dp是否可行呢？是可以的，不妨假设y.r>=x.r且 y能够更新x，而由于y.r>=x.r，那么更新y的那个点就一定也可以更新x，而这样是比用y去更新x更优的。因此，如果我们将exchange按r排序后，后面的点是不会作为更新前面的点的决策的。

    接下来还有一个问题，就是我们如何去选择决策点呢，也就是说对于当前这个点i，我们选择前面的哪个点j来更新i？显然f[j]（用到第j个exchange时花费的最小时间）越小越好，但前面拥有最小的f[j]的这个点j是否一定符合要求呢？不一定，因为有可能j.v<i.r。这样我们再联想到选择最小的f[j]是用堆（这里我是用线段树实现的堆）来实现的，那么如果j.v<i.r我们就将其从堆中删除，直到遇到j.v>=i.r的j，这样是否可以呢？其实究竟可不可以是取决于我们当前删除的j还是否可能做为更新后续一些比i大的点的决策，这显然是不会的，因为我们是按r将点排序的，如果j.v<i.r，那么j.v一定小于后续所有点的r。

    这样用线段树+dp的这个算法的可行性就讨论完了，最后再顺便说一下，我一开始写的时候结构体排序使用的是qsort，结果发现一直RE（只剩下了读入数据和排序的部分，其余部分全注释掉了），于是就想到不妨换一下sort试试，从队友那学完sort之后一交竟然真的AC了……难道这个题目对qsort有歧视……

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#define MAXD 100010
#define INF 0x3f3f3f3f3f3f3f3fll
using namespace std;
int N, M, minf[4 * MAXD];
long long f[MAXD];
struct Ex
{
    int v, r, t;
    bool operator < (const Ex &x) const
    {
        return r < x.r;
    }
}ex[MAXD];
void update(int cur)
{
    int ls = cur << 1, rs = cur << 1 | 1;
    minf[cur] = f[minf[ls]] < f[minf[rs]] ? minf[ls] : minf[rs];
}
void build(int cur, int x, int y)
{
    int mid = (x + y) >> 1, ls = cur << 1, rs = cur << 1 | 1;
    minf[cur] = 0;
    if(x == y)
    {
        f[x] = INF;
        return ;
    }
    build(ls, x, mid);
    build(rs, mid + 1, y);
}
void refresh(int cur, int x, int y, int k, int op)
{
    int mid = (x + y) >> 1, ls = cur << 1, rs = cur << 1 | 1;
    if(x == y)
    {
        minf[cur] = (op ? k : 0);
        return ;
    }
    if(k <= mid)
        refresh(ls, x, mid, k, op);
    else
        refresh(rs, mid + 1, y, k, op);
    update(cur);
}
void init()
{
    int i;
    scanf("%d%d", &N, &M);
    ++ N;
    ex[1].v = 1, ex[1].r = ex[1].t = 0;
    for(i = 2; i <= N; i ++)
        scanf("%d%d%d", &ex[i].v, &ex[i].r, &ex[i].t);
    sort(ex + 1, ex + 1 + N);
    build(1, 1, N);
    f[0] = INF, f[1] = 0;
    refresh(1, 1, N, 1, 1);
}
void solve()
{
    int i, j, k;
    long long ans = INF;
    for(i = 2; i <= N; i ++)
    {
        while((k = minf[1]) && ex[k].v < ex[i].r)
            refresh(1, 1, N, k, 0);
        if(k == 0)
            break;
        f[i] = f[k] + ex[i].t;
        refresh(1, 1, N, i, 1);
    }
    for(i = 1; i <= N; i ++)
        if(ex[i].v >= M && f[i] < ans)
            ans = f[i];
    printf("%lld\n", ans == INF ? -1ll : ans);
}
int main()
{
    int t, tt;
    scanf("%d", &t);
    for(tt = 0; tt < t; tt ++)
    {
        init();
        printf("Case #%d: ", tt + 1);
        solve();
    }
    return 0;
}