Codeforces #380（Div.2）C.Road to Cinema【思维+二分查找】好题~

C. Road to Cinema

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Vasya is currently at a car rental service, and he wants to reach cinema. The film he has bought a ticket for starts in t minutes. There is a straight road of length s from the service to the cinema. Let's introduce a coordinate system so that the car rental service is at the point 0, and the cinema is at the point s.

There are k gas stations along the road, and at each of them you can fill a car with any amount of fuel for free! Consider that this operation doesn't take any time, i.e. is carried out instantly.

There are n cars in the rental service, i-th of them is characterized with two integers c_i and v_i — the price of this car rent and the capacity of its fuel tank in liters. It's not allowed to fuel a car with more fuel than its tank capacity v_i. All cars are completely fueled at the car rental service.

Each of the cars can be driven in one of two speed modes: normal or accelerated. In the normal mode a car covers 1 kilometer in 2 minutes, and consumes 1 liter of fuel. In the accelerated mode a car covers 1 kilometer in 1 minutes, but consumes 2 liters of fuel. The driving mode can be changed at any moment and any number of times.

Your task is to choose a car with minimum price such that Vasya can reach the cinema before the show starts, i.e. not later than in t minutes. Assume that all cars are completely fueled initially.

Input

The first line contains four positive integers n, k, s and t (1 ≤ n ≤ 2·10⁵, 1 ≤ k ≤ 2·10⁵, 2 ≤ s ≤ 10⁹, 1 ≤ t ≤ 2·10⁹) — the number of cars at the car rental service, the number of gas stations along the road, the length of the road and the time in which the film starts.

Each of the next n lines contains two positive integers c_i and v_i (1 ≤ c_i, v_i ≤ 10⁹) — the price of the i-th car and its fuel tank capacity.

The next line contains k distinct integers g₁, g₂, ..., g_k (1 ≤ g_i ≤ s - 1) — the positions of the gas stations on the road in arbitrary order.

Output

Print the minimum rent price of an appropriate car, i.e. such car that Vasya will be able to reach the cinema before the film starts (not later than in t minutes). If there is no appropriate car, print -1.

Examples

Input

3 1 8 10
10 8
5 7
11 9
3

Output

10

Input

2 2 10 18
10 4
20 6
5 3

Output

20

Note

In the first sample, Vasya can reach the cinema in time using the first or the third cars, but it would be cheaper to choose the first one. Its price is equal to 10, and the capacity of its fuel tank is 8. Then Vasya can drive to the first gas station in the accelerated mode in 3 minutes, spending 6 liters of fuel. After that he can full the tank and cover 2 kilometers in the normal mode in 4 minutes, spending 2 liters of fuel. Finally, he drives in the accelerated mode covering the remaining 3 kilometers in 3 minutes and spending 6 liters of fuel. 

题目大意：

一共有n种车，每种车有两个属性：ci，vi，表示其租车需要的花费，以及这辆车的油量上限。

起点在位子0，终点在位子S，其间有K个加油站，在加油站加油不需要任何花费，包括时间花费和价格花费，必须在时间T内到达终点。

车子有两种行进的方式：

①快速，行进1KM，花费2L油，花费1单位的时间。

②慢速，行进1KM，花费1L油，花费2单位的时间。

每次选择行进方式的之后，必须走完1KM才能改变行进方式。

问组车的最小花费。

思路：

1、首先我们明确这样一点，油量上限越大，只要我们分配的行进方案足够贪心，那么肯定是时限会越少的（当然到达一定限定之后，就不会在减少了），那么我们这里就有一个单调性，所以我们可以通过枚举一个最小油量，使得这个油量的车可以在T时间内到达目标，然后再根据这个最小油量，能够知道这N种车都哪些车可以到达目的地，那么此时我们再O（n）维护可以到达目的地的车的最小花费即可。

2、因为我们如果枚举最小油量，那么对应时间消耗是很大的，又考虑到单调性，我们二分油量上限：

①对应枚举出的当前油量上限值mid，如果可以在时间限制内到达目的地，那么我们记录可行解继续二分，直到不能二分时候，最后记录的可行解肯定就是最小油量。

②那么对应二分出的当前油量上限值mid：
我们对应以K个油站为分界，将路程分成K+1段，对应将每一段的路程进行贪心，如果我们能够以全快速的方式行进，那么我们就以全快速的方式行进当前一段路程。

如果我们只能以全慢速的方式行进当前一段路程，那么我们只能以全慢速的方式进行当前一段路程。

那么如果存在一段路程需要一部分慢速一部分快速的方式行进，那么我们就以这个方式行进即可（同样二分，因为慢速的行进路程越多，那么时间消耗就越多，那么通过这个单调性，我们还可以二分查找这一最优情况）。

③统计K+1段路程需要消耗的最少时间，对应当前解是否可行，来判断继续进行二分的方向，直到不能二分为止，那么最终记录的可行解就是最小油量上限，只要高于这个油量上限的车子，是都可以到达目的地的。

3、那么根据最终维护处的这个最小油量上限，维护最小租车花费即可。

Ac代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct node
{
    int val;int vv;
} a[351545];
int p[351545];
int n,k,s,t;
int Slove(int mid)
{
    int tt=0;
    for(int i=1;i<=k+1;i++)
    {
        if((p[i]-p[i-1])>mid)return 0;
        if((p[i]-p[i-1])*2<=mid)tt+=p[i]-p[i-1];
        else if((p[i]-p[i-1])==mid)tt+=(p[i]-p[i-1])*2;
        else
        {
            int l=0;
            int ans=0x3f3f3f3f;
            int r=p[i]-p[i-1];
            while(r-l>=0)
            {
                int midd=(l+r)/2;
                if(midd+2*(p[i]-p[i-1]-midd)<=mid)
                {
                    ans=2*midd+(p[i]-p[i-1]-midd);
                    r=midd-1;
                }
                else
                {
                    l=midd+1;
                }
            }
            tt+=ans;
        }
    }
    if(tt<=t)
    return 1;
    else return 0;
}
int main()
{
    while(~scanf("%d%d%d%d",&n,&k,&s,&t))
    {
        for(int i=0; i<n; i++)
        {
            scanf("%d%d",&a[i].val,&a[i].vv);
        }
        p[0]=0;
        for(int i=1;i<=k;i++)
        {
            scanf("%d",&p[i]);
        }
        sort(p+1,p+1+k);
        p[k+1]=s;
        int l=0;
        int ans=0x3f3f3f3f;
        int r=1000000050;
        while(r-l>=0)
        {
            int mid=(l+r)/2;
            if(Slove(mid)==1)
            {
                ans=mid;
                r=mid-1;
            }
            else l=mid+1;
        }
        int output=0x3f3f3f3f;
        for(int i=0;i<n;i++)
        {
            if(a[i].vv>=ans)
            {
                output=min(output,a[i].val);
            }
        }
        if(output==0x3f3f3f3f)printf("-1\n");
        else printf("%d\n",output);
    }
}
/*
①. 慢速：1km消耗1L汽油，花费2分钟。
②. 快速：1km消耗2L汽油，花费1分钟。 路上有k个加油站，加油不需要花费时间，且直接给油箱加满。
*/