ybtoj火车载客（精）

ybtoj火车载客问题（精）

这题很有意思，花了我5h，最终在一众大佬围攻下，终于出来了

题意

大概意思就是限客c人的列车经过n站，现在有k个站，每个站有一组人，他们起点相同终点相同，现在我们要在不超载客量的情况下让能到达的人数最大（可以不整组取），求人数是多少

起始の思路

对于每组人，起点和终点组成的线段可以拆分为起点和终点（废话），这样对于所有点不管起点还是终点，我们可以将其离线，并且按照时间进行排序，枚举到每站的时候列车会发生什么
那么列车上会发生什么呢
首先站分两种，一种是上车一种是下车
下车简单啊，直接统计这站下车的人就行了
问题是上车
上车呢，又分两种，一种车上有空，一种车上没空
车上有空简单啊，直接硬往里塞就完了，能塞多少塞多少
问题是车上没空，这时要考虑我们将要加进去的人是否更优
那么怎么算是更优呢
这里我们可以考虑到一个上古题目：线段覆盖
想想线段覆盖怎么做的，对于一条线段，我们贪心地让右端点尽量小，这样对于接下来的选择影响就会更小，最终结果就会更优
回到这道题上，我们可以发现，当一些人下车更早的时候，他们对后面的影响就会更小，后面的结果就会更优，而因为上这些人和下这些人人数相同，所以我们前面的结果并不会受到影响
所以始终选下车早的并用其替换掉下车晚的，结果就会更优，这里我们可以用堆来实现
但是这里有个问题，就是到地方之后要把到的人踢下火车！

起始の代码

#include<bits/stdc++.h>
#define N 300005
#define ll long long
#define pqg(x) priority_queue<x,vector<x>,greater<x> >
#define pql(x) priority_queue<x>
#define fn(i,st,ed) for(int i=st;i<=ed;i++)
#define fd(i,st,ed) for(int i=st;i>=ed;i--)
#define pa pair<int,pair<int,pair<int,int> > >
#define mkp(x,y) make_pair(x,y)
using namespace std;
inline ll read(){
    ll x=0,f=1;char c=getchar();
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c)){x=x*10+c-'0';c=getchar();}
    return x*f;
}
struct train{int st,ed,num,id;}a[N];
struct Time{int time,id,op;}b[N];
pqg(train)q;
bool operator>(const train& a,const train& b){return a.ed>b.ed;}
bool operator<(const train& a,const train& b){return a.ed<b.ed;}
bool cmp(Time a,Time b){return a.time!=b.time?a.time<b.time:a.op>b.op;}
int main(){
    int k=read(),n=read(),c=read(),time_tot=0,sum=0,ans=0;
    fn(i,1,k){int s=read(),t=read(),p=read();
        a[i]=(train){s,t,p,0};
        b[++time_tot]=(Time){s,i,0};
        b[++time_tot]=(Time){t,i,1};
    }
    sort(b,b+time_tot+1,cmp);
    fn(i,1,time_tot){int id=b[i].id;
        if(b[i].op==0){
            while(sum<c&&a[id].num){
                int add=min(a[id].num,c-sum);
                a[id].id+=add;a[id].num-=add;
                q.push((train){a[id].st,a[id].ed,add,id});
                sum+=add;
            }
            while(!q.empty()&&a[id].num&&a[id]<q.top()){
                while(!q.empty()&&q.top().ed<b[i].time)
                    a[q.top().id].id=0,q.pop();
                if(q.empty())break;
                train temp=q.top();q.pop();
                int add=min(a[id].num,temp.num);
                temp.num-=add,a[temp.id].id-=add;
                a[id].num-=add,a[id].id+=add;
                if(temp.num)q.push(temp);
                q.push((train){a[id].st,a[id].ed,add,id});
            }
        }else{
            ans+=a[id].id;
            sum-=a[id].id;
            a[id].id=0;
        }
    }
    printf("%d\n",ans);
    return 0;
}

噩梦般的debug

大概花了两小时把上面的代码写完了
接下来问题就开始不停地出现，首先是我优先队列重载运算符
以后一定要记住，优先队列重载是重载和优先队列不同方向的运算符，一点小技巧就是可以两种全都重载
随后重载整好了，但是发现我重载反了，应该使用小根堆才对
到这里就能拿60分了，而且时间并不是很长，大概半小时左右
真正的噩梦降临
我开始疯狂调试，首先检查过程中的量是否都计算正确，再重新理顺自己的思路，感觉好像没什么问题
大概整了一个点，和题解也大概对过了，实在是蚌埠住了，决定向大佬求助
在向大佬阐述思路的过程中我注意到了有一丝丝不对劲，在大佬一顿明示之下，我好像悟了，我执行上车下车的顺序有问题，在经过一个关键车站时，我们首先应该做的应该是检查在关键站之间有没有下车的，在这之后，首先是要填空隙，之后再进行调换

60分代码

#include<bits/stdc++.h>
#define N 300005
#define ll long long
#define pqg(x) priority_queue<x,vector<x>,greater<x> >
#define pql(x) priority_queue<x>
#define fn(i,st,ed) for(int i=st;i<=ed;i++)
#define fd(i,st,ed) for(int i=st;i>=ed;i--)
using namespace std;
inline int read(){
    int x=0,f=1;char c=getchar();
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c)){x=x*10+c-'0';c=getchar();}
    return x*f;
}
struct train{int st,ed,num,id;}a[N];
struct Time{int time,id,op;}b[N];
pqg(train)q;
bool operator>(const train& a,const train& b){return a.ed<b.ed;}
bool operator<(const train& a,const train& b){return a.ed<b.ed;}
bool cmp(Time a,Time b){return a.time!=b.time?a.time<b.time:a.op>b.op;}
signed main(){
    int k=read(),n=read(),c=read(),time_tot=0,sum=0,ans=0;
    fn(i,1,k){int s=read(),t=read(),p=read();
        a[i]=(train){s,t,p,0};
        b[++time_tot]=(Time){s,i,0};
        b[++time_tot]=(Time){t,i,1};
    }
    sort(b+1,b+time_tot+1,cmp);
    fn(i,1,time_tot){int id=b[i].id;
        if(b[i].op==0){
            while(!q.empty()&&q.top().ed<b[i].time)
                a[q.top().id].id=0,q.pop();
            while(sum<c&&a[id].num){
                int add=min(a[id].num,c-sum);
                a[id].id+=add;a[id].num-=add;
                q.push((train){a[id].st,a[id].ed,add,id});
                sum+=add;
            }
            while(!q.empty()&&a[id].num&&a[id]<q.top()){
                if(q.empty())break;
                train temp=q.top();q.pop();
                int add=min(a[id].num,temp.num);
                temp.num-=add,a[temp.id].id-=add;
                a[id].num-=add,a[id].id+=add;
                if(temp.num)q.push(temp);
                q.push((train){a[id].st,a[id].ed,add,id});
            }
        }else{
            ans+=a[id].id;
            sum-=a[id].id;
            a[id].id=0;
        }
    }
    printf("%d\n",ans);
    return 0;
}

终末の完成

但是上面的代码你交了之后还是60分啊，问题究竟出在哪里呢
在一顿输出中间量之后，我终于找到了！！！
对于计算总价值，这个while毫无意义啊，它要是想重复入队的话是不能每次直接入队的，否则基本是无效操作，需要统计总共上车的人数，然后最后处理，这样就功德圆满了
这里还有个小彩蛋，数组应该开到6e5，因为我们分别记起点与终点，而起点与终点分别为3e5，所以数组得开6e5才能过
数组这块也应该注意注意，最近总是错这块，以后得先算一下才能往上写啊

终末の代码

#include<bits/stdc++.h>
#define N 600005
#define ll long long
#define pqg(x) priority_queue<x,vector<x>,greater<x> >
#define pql(x) priority_queue<x>
#define fn(i,st,ed) for(int i=st;i<=ed;i++)
#define fd(i,st,ed) for(int i=st;i>=ed;i--)
using namespace std;
inline int read(){
    int x=0,f=1;char c=getchar();
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c)){x=x*10+c-'0';c=getchar();}
    return x*f;
}
struct train{int st,ed,num,id;}a[N];
struct Time{int time,id,op;}b[N];
pql(train)q;
bool operator<(const train& a,const train& b){return a.ed<b.ed;}
bool cmp(Time a,Time b){return a.time!=b.time?a.time<b.time:a.op>b.op;}
signed main(){
    int k=read(),n=read(),c=read(),time_tot=0,sum=0,ans=0,add;
    fn(i,1,k){int s=read(),t=read(),p=read();
        a[i]=(train){s,t,p,0};
        b[++time_tot]=(Time){s,i,0};
        b[++time_tot]=(Time){t,i,1};
    }
    sort(b+1,b+time_tot+1,cmp);
    train temp;
    fn(i,1,time_tot){int id=b[i].id;
    	//printf("%d %d %d %d %d %d %d %d\n",b[i].id,b[i].op,b[i].time,a[id].st,a[id].ed,a[id].num,a[id].id,sum);
        if(b[i].op==0){
            while(!q.empty()&&q.top().ed<=b[i].time)
                a[q.top().id].id=0,q.pop();
            while(sum<c&&a[id].num){
                int add1=min(a[id].num,c-sum);
                a[id].id+=add1;a[id].num-=add1;
                q.push((train){a[id].st,a[id].ed,add1,id});
                sum+=add1;
            }
            while(!q.empty()&&a[id].num&&a[id]<q.top()){
                temp=q.top();q.pop();
                int add1=min(a[id].num,temp.num);
                add+=add1;
                temp.num-=add1,a[temp.id].id-=add1;
                a[id].num-=add1,a[id].id+=add1;
                if(temp.num)q.push(temp);
            }
            q.push((train){a[id].st,a[id].ed,add,id});add=0;
        }else{
            ans+=a[id].id;
            sum-=a[id].id;
            a[id].id=0;
        }
    }
    printf("%d\n",ans);
    return 0;
}

最后一点

千万不要轻信题解！