keda#P1125. 回家路线

题目描述

猫国的铁路系统中有 nn 个站点，从 1 - n1−n 编号。小猫准备从 11 号站点出发，乘坐列车回到猫窝所在的 nn 号站点。它查询了能够乘坐的列车，这些列车共 mm 班，从1 - m1−m编号。小猫将在 00 时刻到达 11 号站点。对于 ii 号列车，它将在时刻 p_ipi 从站点 x_ixi 出发，在时刻 q_iqi 直达站点 y_iyi，小猫只能在时刻 p_ipi 上 ii 号列车，也只能在时刻 q_iqi 下 ii 号列车。小猫可以通过多次换乘到达 nn 号站点。一次换乘是指对于两班列车，假设分别为 uu号与 vv 号列车，若 y_u = x_vyu=xv 并且 q_u \leq p_vqu≤pv，那么小猫可以乘坐完 uu 号列车后在 y_uyu 号站点等待 p_v - q_upv−qu 个时刻，并在时刻 p_vpv 乘坐 vv 号列车。

小猫只想回到猫窝并且减少途中的麻烦，对此它用烦躁值来衡量。

• 小猫在站点等待时将增加烦躁值，对于一次 t (t \geq 0)t(t≥0) 个时刻的等待，烦躁值将增加 At^2 + Bt + CAt2+Bt+C，其中 A, B,CA,B,C 是给定的常数。注意：小猫登上第一班列车前，即从 00 时刻起停留在 11 号站点的那些时刻也算作一次等待。

• 若小猫最终在时刻 zz 到达 nn 号站点，则烦躁值将再增加 zz。

形式化地说，若小猫共乘坐了 kk 班列车，依次乘坐的列车编号可用序列 s_1, s_2, \cdots , s_ks1,s2,⋯,sk表示。该方案被称作一条可行的回家路线，当且仅当它满足下列两个条件：

1. x_{s1} = 1xs1=1 , y_{sk} = nysk=n

2. 对于所有 j (1 \leq j < k)j(1≤j<k)，满足 y_{sj} = x_{s_{j+1}}ysj=xsj+1 且 q_{sj}\leq p_{s_{j+1}}qsj≤psj+1

对于该回家路线，小猫得到的烦躁值将为：

q_{s_k}+(A\times p_{s_1}^2+B\times p_{s_1}+C)+\sum_{j=1}^{k-1}(A(p_{s_{j+1}}-q_{s_j})^2+B(p_{s_{j+1}}-q_{s_j})+C)qsk+(A×ps12+B×ps1+C)+j=1∑k−1(A(psj+1−qsj)2+B(psj+1−qsj)+C)

小猫想让自己的烦躁值尽量小，请你帮它求出所有可行的回家路线中，能得到的最 小的烦躁值。题目保证至少存在一条可行的回家路线。

输入格式

第一行五个整数 n, m, A, B,Cn,m,A,B,C，变量意义见题目描述。

接下来 mm 行，第 ii 行四个整数 x_i, y_i, p_i, q_ixi,yi,pi,qi，分别表示 ii 号列车的出发站、到达站、出发时刻与到达时刻。

输出格式

输出仅一行一个整数，表示所求的答案。

样例

输入数据 1

3 4 1 5 10
1 2 3 4
1 2 5 7
1 2 6 8
2 3 9 10

Copy

输出数据 1

94

Copy

输入数据 2

4 3 1 2 3
1 2 2 3
2 3 5 7
3 4 7 9

Copy

输出数据 2

34

Copy

提示

样例 1 解释

共有三条可行的回家路线：

• 依次乘坐 1，4 号列车，得到的烦躁值为：10 + (1 \times 3^2 + 5 \times 3 + 10) + (1 \times (9 - 4)^2 + 5 \times (9 - 4) + 10)= 10410+(1×32+5×3+10)+(1×(9−4)2+5×(9−4)+10)=104

• 依次乘坐 2，4 号列车，得到的烦躁值为：10 + (1 \times 5^2 + 5 \times 5 + 10) + (1 \times (9 - 7)^2 + 5 \times (9 - 7) + 10)= 9410+(1×52+5×5+10)+(1×(9−7)2+5×(9−7)+10)=94

• 依次乘坐 3，4 号列车，得到的烦躁值为：10 + (1 \times 6^2 + 5 \times 6 + 10) + (1 \times (9 - 8)^2 + 5 \times (9 - 8) + 10)= 10210+(1×62+5×6+10)+(1×(9−8)2+5×(9−8)+10)=102

第二条路线得到的烦躁值最小为 9494。

数据范围

对于所有测试点：2\le n\le 10^5,1\le m\le 2\times 10^5,0 \le A \le 10 , 0 \le B, C \le 10^6,1 \le x_i, y_i \le n , x_i \neq y_i , 0 \le p_i < q_i \le 10^32≤n≤105,1≤m≤2×105,0≤A≤10,0≤B,C≤106,1≤xi,yi≤n,xi=yi,0≤pi<qi≤103。

每个测试点的具体限制见下表：

测试点编号	n	m	A,B,C 的特殊限制	其他特殊条件
1\sim 21∼2	\le 100≤100	=n-1=n−1	无	y_i=x_i+1yi=xi+1
3\sim 43∼4		\le 100≤100	A=B=C=0A=B=C=0
5\sim 85∼8	\le 2\times 10^3≤2×103	\le 4\times 10^3≤4×103		x_i < y_ixi<yi
99			A=B=0A=B=0	x_i \le y_ixi≤yi
1010			A=0A=0
11\sim 1411∼14			无	无
15\sim 1615∼16	\le 10^5≤105	\le 2\times 10^5≤2×105	A=0A=0

#include <bits/stdc++.h>
#define N 200005
#define ll long long
#define db double
#define getchar nc
using namespace std;
inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline int read()
{
    register int x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*f;
}
inline void write(register ll x)
{
    if(!x)putchar('0');if(x<0)x=-x,putchar('-');
    static int sta[20];register int tot=0;
    while(x)sta[tot++]=x%10,x/=10;
    while(tot)putchar(sta[--tot]+48);
}
inline int Max(register int a,register int b)
{
    return a>b?a:b;
}
inline ll Min(register ll a,register ll b)
{
    return a<b?a:b;
}
struct node{
    ll x,y;
    int id;
};
int n,m,A,B,C,maxT=0;
int x[N],y[N],p[N],q[N],head[N];
ll ans=1926081700000000ll,dp[N];
vector<int> d[1005];
vector<node>que[N];
queue<int> res[1005];
inline db gslope(register node a,register node b)
{
    return 1.0*(a.y-b.y)/(1.0*(a.x-b.x));
}
inline void ins(register int id)
{
    int pos=y[id];
    node now=(node){q[id],dp[id]+A*q[id]*q[id]-B*q[id],id};
    while(que[pos].size()-head[pos]>=2)
    {
        int len=que[pos].size();
        if(gslope(que[pos][len-1],que[pos][len-2])<gslope(que[pos][len-2],now))
            break;
        que[pos].pop_back();
    }
    que[pos].push_back(now);
}
inline void del(register db slpe,register int pos)
{
    while(que[pos].size()-head[pos]>=2)
    {
        if(gslope(que[pos][head[pos]],que[pos][head[pos]+1])>slpe)
            return;
        ++head[pos];
    }
}
int main()
{
    n=read(),m=read(),A=read(),B=read(),C=read();
    for(register int i=1;i<=m;++i)
        x[i]=read(),y[i]=read(),p[i]=read(),q[i]=read(),maxT=Max(maxT,q[i]);
    for(register int i=1;i<=m;++i)
        d[p[i]].push_back(i);
    que[1].push_back((node){0,0,0});
    for(register int t=0;t<=maxT;++t)
    {
        while(!res[t].empty())
            ins(res[t].front()),res[t].pop();
        int len=d[t].size();
        for(register int k=0;k<len;++k)
        {
            int id=d[t][k];
            int pos=x[id];
            if(que[pos].size()==head[pos])
                continue;
            db slpe=2.0*A*p[id];
            del(slpe,pos);
            int j=que[pos][head[pos]].id;
            dp[id]=dp[j]+1ll*A*(p[id]-q[j])*(p[id]-q[j])+1ll*B*(p[id]-q[j])+C;
            res[q[id]].push(id);
            if(y[id]==n)
                ans=Min(ans,dp[id]+q[id]);
        }
    }
    write(ans);
    return 0;
}

已测，同过！！