CodeForces-1061D TV Shows

题目链接

https://vjudge.net/problem/CodeForces-1061D

题面

Description

There are nn TV shows you want to watch. Suppose the whole time is split into equal parts called "minutes". The i-th of the shows is going from li-th to ri-th minute, both ends inclusive.

You need a TV to watch a TV show and you can't watch two TV shows which air at the same time on the same TV, so it is possible you will need multiple TVs in some minutes. For example, if segments [li,ri] and [lj,rj] intersect, then shows i and j can't be watched simultaneously on one TV.

Once you start watching a show on some TV it is not possible to "move" it to another TV (since it would be too distracting), or to watch another show on the same TV until this show ends.

There is a TV Rental shop near you. It rents a TV for xx rupees, and charges y (y<x) rupees for every extra minute you keep the TV. So in order to rent a TV for minutes [a;b] you will need to pay x+y⋅(b−a)

You can assume, that taking and returning of the TV doesn't take any time and doesn't distract from watching other TV shows. Find the minimum possible cost to view all shows. Since this value could be too large, print it modulo \(10^9+7\).

Input

The first line contains integers n, x and y (\(1≤n≤10^5 , 1≤y<x≤10^9\)) — the number of TV shows, the cost to rent a TV for the first minute and the cost to rent a TV for every subsequent minute.

Each of the next n lines contains two integers li and ri (\(1≤li≤ri≤10^9\)) denoting the start and the end minute of the i-th TV show.

Output

Print exactly one integer — the minimum cost to view all the shows taken modulo 109+7109+7.

Examples

Input

5 4 3
1 2
4 10
2 4
10 11
5 9

Output

60

Input

6 3 2
8 20
6 22
4 15
20 28
17 25
20 27

Output

142

Input

2 1000000000 2
1 2
2 3

Output

999999997

Note

In the first example, the optimal strategy would be to rent 33 TVs to watch:

• Show [1,2] on the first TV,
• Show [4,10] on the second TV,
• Shows [2,4],[5,9],[10,11] on the third TV.

This way the cost for the first TV is 4+3⋅(2−1)=7, for the second is 4+3⋅(10−4)=22 and for the third is 4+3⋅(11−2)=31, which gives 6060 int total.

In the second example, it is optimal watch each show on a new TV.

In third example, it is optimal to watch both shows on a new TV. Note that the answer is to be printed modulo \(10^9+7\)

题意

给定 n 个电视节目和两个参数 x,y。你想要看全部的电视节目，但是同一个电视机同一个时刻只能播放一个电视节目，所以你只能多租赁电视机。在时间 [l,r] 租赁一台电视机的花费是 x + y (r−l)。一台电视机不可以在节目没有播放完时中断播放，播放时间包括r，也就是说如果一个节目在r时结束，另一个节目在r时开始时，这台电视机不能给刚开始的节目用。求最小花费。答案对 1e9+7 取模。

题解

首先我们把电视节目排序，排序按左端点小的在前，左端点相同时按右端点小的在前，因为靠前的节目肯定要先看，然后我们用一个multiset维护当前已经有的电视机的使用结束时间，首先对于第一个节目，此时还没有电视机，肯定要先买一台电视机，加上相应的花费，然后这台电视机在\(r_1\)时使用结束，set中有一台电视机的信息

然后从2到n开始循环，每次循环找到一台电视机的使用结束时间比这个节目的开始时间早，离这个节目开始最近的电视，没有的话就要再租一台电视机，如果有的话，就要判断一下，看是使用已有的电视机比较便宜还是再租一台比较便宜，如果使用已有电视机比较便宜的话，那么就要把这台电视机的结束时间更新到这次节目的结束时间，如果再租一台比较便宜，就要新加入一台使用结束时间在这次节目结束时间的电视机，同时计算花费，这样一直贪心选取计算答案即可。

为什么要这么贪心呢，因为如果在一个节目开始时间之前有多台电视机可以继续使用的话，结束时间更早的电视机肯定不如结束时间较晚的电视机优，因为它要花费更多的单位时间的租金。

至于找到结束时间最近的电视机，就直接使用\(lower\_bound\)即可，找到第一个大于等于的，再-1就是比它小的。

代码有点丑

AC代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <set>
#define N 100050
using namespace std;
typedef long long ll;
const int p = (int)1e9 + 7;
struct node {
	ll l, r;
	bool operator < (const node &b) const {
		if (l == b.l) return r < b.r;
		else return l < b.l;
	}
} a[N];
int main() {
	multiset<ll> s;
	ll n, x, y;
	scanf("%lld%lld%lld", &n, &x, &y);
	for (int i = 1; i <= n; i++) {
		scanf("%lld%lld", &a[i].l, &a[i].r);
	}
	sort (a + 1, a + n + 1);
	s.insert(a[1].r);
	multiset<ll>::iterator it;
	ll ans = (x + y * (a[1].r - a[1].l) % p) % p;
	for (int i = 2; i <= n; i++) {
		it = s.lower_bound(a[i].l);
		if (it == s.begin()) {
			ans = (ans + x + y * (a[i].r - a[i].l) % p) % p;
			s.insert(a[i].r);
		}
		else {
			it--;
			while (a[i].l == *it && it != s.begin()) {
				it--;
			}
			if (*it == a[i].l) {
				ans = (ans + x + y * (a[i].r - a[i].l) % p) % p;
			}
			else {
				if ((a[i].l - *it) * y < x) {
					ans = (ans + (a[i].r - *it) * y % p) % p;
					s.erase(it);
				}
				else {
					ans = (ans + x + (a[i].r - a[i].l) * y % p) % p;
				}
			}
			s.insert(a[i].r);
		}
	}
	cout << ans % p << endl;
	return 0;
}