2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest Problem J 【二分+DP+单调队列】

题目链接

题意

有n个地铁站，全部成线性排列，有n-1种地铁票，第i种地铁票的价格为p_i，并且能坐i站（也就是在第k个站能够到达[k-i,k+i]中的站）。现在想从起点站坐到终点站，地铁在相邻两个站之间运行花费1s（这里原文是“get from a stop to the next one in just one minute.”有歧义，坑了好久），给出在每个站出来又进去花费的时间，并且从一个站出来又进去后同一张票又可以重新使用，现给定最大的时间花费，求能够到达终点站的票中最便宜的价格。

分析

先考虑这样一个问题，假设固定一次最多能坐到的距离，求到终点的最短时间。很容易想到这样的转移方程：
（令dp[i]为到第i个站花费的最少时间，d[i]是在该站上下所花时间，r是当前票能够坐的距离）
dp[i]=dp[x]+d[i]+(i−x)
其中 dp[x]=min{dp[i−r]→dp[i−1]}

同时考虑到，我们始终是要从起始站坐到终点站的，又因为往回坐始终不是最优的选择，因此地铁运行所带来的时间花费始终是n-1，因此我们在状态转移的时候不考虑它，而在最后时间加上n-1即可

dp[i]=min{dp[i−r]→dp[i−1]}+d[i]
最终时间为 dp[n−1]+n−1

对于min{dp[i−r]→dp[i−1]}，可以用单调队列优化或者直接用线段树，但单调队列在时间上会更优一些。

那么再考虑买哪一种票，首先能够走得更远但价格便宜的票肯定更优，于是先处理一下，去掉价格贵但走不远的票。这样处理后，所有票都会是按照价格递增，距离递增的顺序出现，二分枚举答案即可。

时间复杂度： O(nlog(n))（单调队列） O(nlog2(n)) （线段树）

AC代码

//2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest Problem J. Journey to the “The World’s Start”
//AC 2016-9-11 15:02:46
//DP, Binary Search, Monotonic Queue
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <set>
#include <string>
#include <map>
#include <queue>
#include <deque>
#include <list>
#include <sstream>
#include <stack>
using namespace std;

#define cls(x) memset(x,0,sizeof x)
#define inf(x) memset(x,0x3f,sizeof x)
#define neg(x) memset(x,-1,sizeof x)
#define ninf(x) memset(x,0xc0,sizeof x)
#define st0(x) memset(x,false,sizeof x)
#define st1(x) memset(x,true,sizeof x)
#define INF 0x3f3f3f3f
#define lowbit(x) x&(-x)
#define input(x) scanf("%d",&(x))
#define inputt(x,y) scanf("%d %d",&(x),&(y))
#define bug cout<<"here"<<endl;
//#pragma comment(linker, "/STACK:1024000000,1024000000")//stack overflow
#define debug

const int maxn=1000100;
struct autoque
{
    long long que[maxn];
    int index[maxn];
    int l;
    int r;
    int k;
    int cur;
    autoque():l(0),r(0),k(0),cur(0){}
    autoque(int kk):l(0),r(0),k(kk),cur(0)
    {
        memset(que,0,sizeof que);
        return;
    }
    void reset(int kk)
    {
        l=0;r=0;k=kk;cur=0;
        memset(que,0,sizeof que);
    }
    long long front()
    {
        while(index[l]<cur-k)
            ++l;
        return que[l];
    }
    void insert(long long x)
    {
        if(l==r)
        {
            que[r]=x;
            index[r++]=cur++;
            return;
        }
        int ll=l,rr=r;
        int mid;
        while(rr>=ll)
        {
            mid=(ll+rr)/2;
            if(rr==ll)
                break;
            if(x==que[mid])
                break;
            if(x<que[mid])
                ll=mid+1;
            if(x>que[mid])
                rr=mid;
        }
        que[mid]=x;
        index[mid]=cur++;
        r=mid+1;
        return;
    }
}que;

int n;
long long t;
vector<pair<int,int> > p;
int d[50500];
long long dp[50500];

bool valid(int x)
{
    if(x==-1) return 0;
    dp[0]=0;
    que.reset(p[x].first);
    for(int i=1;i<n;++i)
    {
        que.insert(-dp[i-1]);
        dp[i]=-que.front()+d[i];
    }
    return dp[n-1]<=t;
}

int main()
{
    //ios::sync_with_stdio(false);
    //cin.tie(0);
    #ifdef debug
        freopen("journey.in","r",stdin);
        freopen("journey.out","w",stdout);
    #endif
    //IO
    cin>>n>>t;
    t-=(n-1);
    pair<int,int> pri;
    for(int i=0;i<n-1;++i)
    {
        input(pri.second);
        pri.first=i+1;
        while(p.size()&&p.back().second>=pri.second)
            p.pop_back();
        p.push_back(pri);
    }
    for(int i=1;i<n-1;++i)
        input(d[i]);
    d[n-1]=0;
    int ans=INF;
    int l=-1,r=p.size()-1,mid=(l+r)>>1;
    while(l<r-1)
    {
        mid=(l+r)>>1;
        if(valid(mid))
            r=mid;
        else
            l=mid;
    }
    cout<<p[r].second<<endl;
    return 0;
}