Anton and Making Potions
time limit per test
4 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
Anton is playing a very interesting computer game, but now he is stuck at one of the levels. To pass to the next level he has to prepare n potions.
Anton has a special kettle, that can prepare one potions in x seconds. Also, he knows spells of two types that can faster the process of preparing potions.
- Spells of this type speed up the preparation time of one potion. There are m spells of this type, the i-th of them costs bi manapoints and changes the preparation time of each potion to ai instead of x.
- Spells of this type immediately prepare some number of potions. There are k such spells, the i-th of them costs di manapoints and instantly create ci potions.
Anton can use no more than one spell of the first type and no more than one spell of the second type, and the total number of manapoints spent should not exceed s. Consider that all spells are used instantly and right before Anton starts to prepare potions.
Anton wants to get to the next level as fast as possible, so he is interested in the minimum number of time he needs to spent in order to prepare at least n potions.
Input
The first line of the input contains three integers n, m, k (1 ≤ n ≤ 2·109, 1 ≤ m, k ≤ 2·105) — the number of potions, Anton has to make, the number of spells of the first type and the number of spells of the second type.
The second line of the input contains two integers x and s (2 ≤ x ≤ 2·109, 1 ≤ s ≤ 2·109) — the initial number of seconds required to prepare one potion and the number of manapoints Anton can use.
The third line contains m integers ai (1 ≤ ai < x) — the number of seconds it will take to prepare one potion if the i-th spell of the first type is used.
The fourth line contains m integers bi (1 ≤ bi ≤ 2·109) — the number of manapoints to use the i-th spell of the first type.
There are k integers ci (1 ≤ ci ≤ n) in the fifth line — the number of potions that will be immediately created if the i-th spell of the second type is used. It‘s guaranteed that ci are not decreasing, i.e. ci ≤ cj if i < j.
The sixth line contains k integers di (1 ≤ di ≤ 2·109) — the number of manapoints required to use the i-th spell of the second type. It‘s guaranteed that di are not decreasing, i.e. di ≤ dj if i < j.
Output
Print one integer — the minimum time one has to spent in order to prepare n potions.
Examples
input
Copy
20 3 210 992 4 320 10 404 1510 80
output
Copy
20
input
Copy
20 3 210 992 4 3200 100 4004 15100 800
output
Copy
200
Note
In the first sample, the optimum answer is to use the second spell of the first type that costs 10 manapoints. Thus, the preparation time of each potion changes to 4 seconds. Also, Anton should use the second spell of the second type to instantly prepare 15 potions spending 80 manapoints. The total number of manapoints used is 10 + 80 = 90, and the preparation time is 4·5 = 20 seconds (15 potions were prepared instantly, and the remaining 5 will take 4 seconds each).
In the second sample, Anton can‘t use any of the spells, so he just prepares 20 potions, spending 10 seconds on each of them and the answer is 20·10 = 200.
题意:
有n瓶药，一开始做这n瓶药每瓶需要x的时间，现在有s块钱，并有两种魔法，每种魔法最多只能用一次（也就是说可用不用，这是坑点，要注意no more,at least之类的）
第一种魔法是把所有药的准备时间变为ai，花费是bi，第二种魔法是用0秒时间立刻做出ci个药，花费是di，注意input那指出第二种魔法的ci和di是非严格递增的
思路:
看到递增就想到了二分，所以就枚举第一种魔法，同时二分第二种魔法，复杂度O(mlogk)，注意要单独算出两种魔法都不用，只用第一种魔法和只用第二种魔法的情况，这是本题的坑点
1 #include<bits/stdc++.h>
2 using namespace std;
3 typedef long long ll;
4 const int amn=2e5+5;
5 ll a[amn],b[amn],c[amn],d[amn],ans,l,r,mid,rm,rn;
6 int main(){
7 ///注意：可用只用第一种魔法，或只用第二种魔法，或两种魔法各用一个
8 ll n,m,k,x,s;
9 ios::sync_with_stdio(0);
10 cin>>n>>m>>k>>x>>s; ///n毒药数量，m第一个，k第二个，x初始时间，s初始钱
11 for(int i=1;i<=m;i++)cin>>a[i]; ///改变时间
12 for(int i=1;i<=m;i++)cin>>b[i]; ///timecost
13 for(int i=1;i<=k;i++)cin>>c[i]; ///立刻做多少
14 for(int i=1;i<=k;i++)cin>>d[i]; ///docost
15 ans=n*x;
16 for(int i=1;i<=k;i++){
17 if(s-d[i]<0)continue;
18 ans=min(ans,(n-c[i])*x);
19 }
20 for(int i=1;i<=m;i++){
21 rm=s-b[i];
22 if(rm<0)continue;
23 ans=min(ans,n*a[i]);
24 l=1,r=k;
25 mid=(l+r)>>1;
26 while(l<=r){
27 if(d[mid]>rm)r=mid-1;
28 else l=mid+1;
29 mid=(l+r)>>1;
30 }
31 rn=max(n-c[mid],0ll);
32 ans=min(ans,rn*a[i]);
33 // cout<<rm<<‘ ‘<<rn<<‘ ‘<<b[i]<<‘ ‘<<l<<‘ ‘<<r<<‘ ‘<<c[l]<<‘ ‘<<c[r]<<endl;
34 }
35 printf("%lld\n",ans);
36 }
37 /***
38 有n瓶药，一开始做这n瓶药每瓶需要x的时间，现在有s块钱，并有两种魔法，每种魔法最多只能用一次（也就是说可用不用，这是坑点，要注意no more,at least之类的）
39 第一种魔法是把所有药的准备时间变为ai，花费是bi，第二种魔法是用0秒时间立刻做出ci个药，花费是di，注意input那指出第二种魔法的ci和di是非严格递增的
40 看到递增就想到了二分，所以就枚举第一种魔法，同时二分第二种魔法，复杂度O(mlogk)，注意要单独算出两种魔法都不用，只用第一种魔法和只用第二种魔法的情况，这是本题的坑点
41 ***/
原文地址：https://www.cnblogs.com/Railgun000/p/11376313.html