[NOIP2011 提高组] 观光公交

题目描述

风景迷人的小城 Y 市，拥有 nn 个美丽的景点。由于慕名而来的游客越来越多，Y 市特意安排了一辆观光公交车，为游客提供更便捷的交通服务。观光公交车在第 00 分钟出现在 11 号景点，随后依次前往 2,3,4,\cdots,n2,3,4,⋯,n 号景点。从第 ii 号景点开到第 i+1i+1 号景点需要 D_iDi​ 分钟。任意时刻，公交车只能往前开，或在景点处等待。

设共有 mm 个游客，每位游客需要乘车 11 次从一个景点到达另一个景点，第 ii 位游客在 T_iTi​ 分钟来到景点 A_iAi​，希望乘车前往景点 B_iBi​（A_i<B_iAi​<Bi​）。为了使所有乘客都能顺利到达目的地，公交车在每站都必须等待需要从该景点出发的所有乘客都上车后才能出发开往下一景点。

假设乘客上下车不需要时间。一个乘客的旅行时间，等于他到达目的地的时刻减去他来到出发地的时刻。因为只有一辆观光车，有时候还要停下来等其他乘客，乘客们纷纷抱怨旅行时间太长了。于是聪明的司机 ZZ 给公交车安装了 kk 个氮气加速器，每使用一个加速器，可以使其中一个 D_i-1Di​−1。对于同一个 D_iDi​ 可以重复使用加速器，但是必须保证使用后 D_i\ge0Di​≥0。

那么 ZZ 该如何安排使用加速器，才能使所有乘客的旅行时间总和最小？

输入格式

第 11 行是 33 个整数 n,m,kn,m,k，每两个整数之间用一个空格隔开。分别表示景点数、乘客数和氮气加速器个数。

第 22 行是 n-1n−1 个整数，每两个整数之间用一个空格隔开，第 ii 个数表示从第 ii 个景点开往第 i+1i+1 个景点所需要的时间，即 D_iDi​。

第 33 行至 m+2m+2 行每行 33 个整数 T_i,A_i,B_iTi​,Ai​,Bi​，每两个整数之间用一个空格隔开。第 i+2i+2 行表示第 ii 位乘客来到出发景点的时刻，出发的景点编号和到达的景点编号。

输出格式

一个整数，表示最小的总旅行时间。

输入输出样例

输入 #1复制

3 3 2
1 4
0 1 3
1 1 2
5 2 3

输出 #1复制

10

说明/提示

【输入输出样例说明】

对 D_2D2​ 使用 22 个加速器，从 22 号景点到 33 号景点时间变为 22 分钟。

公交车在第 11 分钟从 11 号景点出发，第 22 分钟到达 22 号景点，第 55 分钟从 22 号景点出发，第 77 分钟到达 33 号景点。

第 11 个旅客旅行时间 7-0=77−0=7 分钟。

第 22 个旅客旅行时间 2-1=12−1=1 分钟。

第 33 个旅客旅行时间 7-5=27−5=2 分钟。

总时间 7+1+2=107+1+2=10 分钟。

【数据范围】

对于 10\%10% 的数据，k=0k=0。

对于 20\%20% 的数据，k=1k=1。

对于 40\%40% 的数据，2 \le n \le 502≤n≤50，1 \le m \le 10^31≤m≤103，0 \le k \le 200≤k≤20，0 \le D_i \le 100≤Di​≤10，0 \le T_i \le 5000≤Ti​≤500。

对于 60\%60% 的数据，1 \le n \le 1001≤n≤100，1 \le m \le 10^31≤m≤103，0 \le k \le 1000≤k≤100，0 \le D_i \le 1000≤Di​≤100，0 \le T_i \le 10^40≤Ti​≤104。

对于 100\%100% 的数据，1 \le n \le 10^31≤n≤103，1 \le m \le 10^41≤m≤104，0 \le k \le 10^50≤k≤105，0 \le D_i \le 1000≤Di​≤100，0 \le T_i \le 10^50≤Ti​≤105。

对方并不想和你说话并向你扔了一个费用流233

变量名：tim_itimi​到一个点的时间 Mx_iMxi​一个点乘客最晚到达时间 down_idowni​一个点下车人数

首先构建模型

不难发现在一个点使用加速器造成的效果是阶段性的

即在一个阶段后区间会被劈开

考虑这个劈开的条件

当前面使用的加速器超过max(tim_i-Mx_i,0)max(timi​−Mxi​,0)时就不能对后面的产生影响了

把使用加速器个数作为流量

每个点都会被分配到至多D_iDi​的加速器

建立SS、S'S′、TT三个点

连边S\rightarrow S'S→S′ 容量为KK 费用为00 起到限制总个数的作用

把所有点ii分为i'i′和i''i′′

连边i'\rightarrow i''i′→i′′ 容量为max(tim_i-Mx_i,0)max(timi​−Mxi​,0) 费用为00 限制前面使用的加速器对后面的影响

连边S'\rightarrow i''S′→i′′ 容量为D_iDi​ 费用为00 分配加速器

连边i''\rightarrow (i+1)'i′′→(i+1)′ 容量为INFINF 费用为-down_{i+1}−downi+1​ 累计费用以及传递影响

连边i'\rightarrow Ti′→T 容量为INFINF 费用为00

显然1'1′和n''n′′是没有用的 可以在建图时舍去

然后就可以愉快的套模板了

最坏复杂度O(k*n*log(n))O(k∗n∗log(n))(Dijkstra)或O(k*n^2)O(k∗n2)(SPFA)

比贪心慢= =

#include<bits/stdc++.h>
using namespace std;
#define N 1010
#define M 10010
#define INF (0x3f3f3f3f)
struct peo{
    int t,l,r;
}a[M];
struct edge{
    int nxt,to,cap,cost;
}e[N<<3];
int head[N<<1],edge_cnt;
void add_edge(int x,int y,int z,int w){
    e[edge_cnt]=(edge){head[x],y,z,w};
    head[x]=edge_cnt++;
    e[edge_cnt]=(edge){head[y],x,0,-w};
    head[y]=edge_cnt++;
}
int D[N],Mx[N],down[N],tim[N],S,T;
struct MinCostMaxFlow{
    int d[N<<1],fa[N<<1],Mn[N<<1];
    bool vis[N<<1];
    queue<int>Q;
    int calc(){
        int i,res=0;
        while (1){
            memset(d,63,sizeof(d));
            d[S]=0;
            Q.push(S);
            Mn[S]=INF;
            while (!Q.empty()){
                int x=Q.front(); Q.pop();
                vis[x]=0;
                for (i=head[x];~i;i=e[i].nxt){
                    int To=e[i].to;
                    if (!e[i].cap || d[To]<=d[x]+e[i].cost) continue;
                    d[To]=d[x]+e[i].cost;
                    fa[To]=i;
                    Mn[To]=min(Mn[x],e[i].cap);
                    if (!vis[To]){
                        vis[To]=1;
                        Q.push(To);
                    }
                }
            }
            if (d[T]==INF) return res;
            res+=Mn[T]*d[T];
            int p=T;
            while (p!=S){
                e[fa[p]].cap-=Mn[T];
                e[fa[p]^1].cap+=Mn[T];
                p=e[fa[p]^1].to;
            }
        }
    }
}MCMF;
int main(){
    memset(head,-1,sizeof(head));
    int n,m,K,i,ans=0;
    scanf("%d%d%d",&n,&m,&K);
    for (i=1;i<n;i++) scanf("%d",&D[i]);
    for (i=1;i<=m;i++){
        scanf("%d%d%d",&a[i].t,&a[i].l,&a[i].r);
        down[a[i].r]++;
        Mx[a[i].l]=max(Mx[a[i].l],a[i].t);
    }
    for (i=1;i<n;i++) tim[i+1]=max(tim[i],Mx[i])+D[i];
    for (i=1;i<=m;i++) ans+=tim[a[i].r]-a[i].t;
    
    S=n*2+1; T=n*2+3;
    int S1=n*2+2;
    add_edge(S,S1,K,0);
    for (i=1;i<n;i++){
        add_edge(i,i+n,max(tim[i]-Mx[i],0),0);
        add_edge(i+n,i+1,INF,-down[i+1]);
        add_edge(S1,i+n,D[i],0);
        add_edge(i+1,T,INF,0);
    }
    printf("%d\n",ans+MCMF.calc());
    return 0;
}