题目描述
猫国的铁路系统中有 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表示。该方案被称作一条可行的回家路线，当且仅当它满足下列两个条件：
- x_{s1} = 1xs1=1 , y_{sk} = nysk=n
- 对于所有 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
样例输入 #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
样例输入 #2
4 3 1 2 3
1 2 2 3
2 3 5 7
3 4 7 9
Copy
样例输出 #2
34
Copy
提示
更多样例
您可以通过附加文件获得更多样例。
样例 3
见附加文件的 route/route3.in 与 route/route3.ans。
该样例的数据类型与最终测试点 5 \sim 85∼8 一致。
样例 4
见附加文件的 route/route4.in 与 route/route4.ans。
该样例的数据类型与最终测试点 11 \sim 1411∼14 一致。
样例 5
见附加文件的 route/route5.in 与 route/route5.ans。
该样例的数据类型与最终测试点 18 \sim 2018∼20 一致。
样例 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。
每个测试点的具体限制见下表：
| 测试点编号 | nn | mm | A,B,CA,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 |
代码:
#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;
}
