Zonal Computing Olympiad 2012, 26 Nov 2011

The year is 2102 and today is the day of ZCO. This year there are N contests and the starting and ending times of each contest is known to you. You have to participate in exactly one of these contests. Different contests may overlap. The duration of different contests might be different. 

There is only one examination centre. There is a wormhole V that transports you from your house to the examination centre and another wormhole W that transports you from the examination centre back to your house. Obviously, transportation through a wormhole does not take any time; it is instantaneous. But the wormholes can be used at only certain fixed times, and these are known to you.

So, you use a V wormhole to reach the exam centre, possibly wait for some time before the next contest begins, take part in the contest, possibly wait for some more time and then use a W wormhole to return back home. If you leave through a V wormhole at time t1 and come back through a W wormhole at time t2, then the total time you have spent is (t2 - t1 + 1). Your aim is to spend as little time as possible overall while ensuring
that you take part in one of the contests.

You can reach the centre exactly at the starting time of the contest, if possible. And you can leave the examination centre the very second the contest ends, if possible. You can assume that you will always be able to attend at least one contest–that is, there will always be a contest such that there is a V wormhole before it and a W wormhole after it.

For instance, suppose there are 3 contests with (start,end) times (15,21), (5,10), and (7,25), respectively.  Suppose the V wormhole is available at times 4, 14, 25, 2 and the W wormhole is available at times 13 and 21.  In this case, you can leave by the V wormhole at time 14, take part in the contest from time 15 to 21, and then use the W wormhole at time 21 to get back home.  Therefore the time you have spent is (21 - 14 + 1) = 8. You can check that you cannot do better than this.

-----Input format-----
The first line contains 3 space separated integers N, X, and Y, where N is the number of contests, X is the number of time instances when wormhole V can be used and Y is the number of time instances when wormhole W can be used.  The next N lines describe each contest.  Each of these N lines contains two space separated integers S and E, where S is the starting time of the particular contest and E is the ending time of that contest, with S < E.  The next line contains X space separated integers which are the time instances when the wormhole V can be used.  The next line contains Y space separated integers which are the time instances when the wormhole W can be used.

-----Output format-----
Print a single line that contains a single integer, the minimum time needed to be spent to take part in a contest.

-----Testdata-----
All the starting and ending times of contests are distinct and no contest starts at the same time as another contest ends. The time instances when wormholes are available are all distinct, but may coincide with starting and ending times of contests. All the time instances (the contest timings and the wormhole timings) will be integers between 1 and 1000000 (inclusive).

- Subtask 1 (30 marks)
- Subtask 2 (70 marks)

You may assume that 
1 ≤ N ≤ 105,
1 ≤ X ≤ 105, and
1 ≤ Y ≤ 105.

In 30% of the cases, 
1 ≤ N ≤ 103,
1 ≤ X ≤ 103, and
1 ≤ Y ≤ 103.

-----Sample Input-----
3 4 2
15 21
5 10
7 25
4 14 25 2
13 21

-----Sample Output-----
8

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
import sys
(n, x, y) = input().split(' ')
n = int(n)
x = int(x)
y = int(y)
contests = {}
for i in range(n):
	(s, e) = input().split(' ')
	s = int(s)
	e = int(e)
	contests[s, e] = abs(s - e)
v_time = input().split(' ')
w_time = input().split(' ')
(v_time, w_time) = (list(map(int, v_time)), list(map(int, w_time)))
v_time.sort()
w_time.sort()
score = sys.maxsize
contests = dict(sorted(contests.items(), key=lambda item: item[1]))
for (k, v) in contests.items():
	start = -1
	end = sys.maxsize
	for i in range(x):
		if v_time[i] > k[0]:
			break
		start = v_time[i]
	for j in range(y):
		if w_time[j] >= k[1]:
			end = w_time[j]
			break
	if start == -1:
		continue
	score = min(score, end - start + 1)
	if score - 1 <= v:
		break
print(score)


import sys
import bisect
input = sys.stdin.readline
l = input().split()
n = int(l[0])
x = int(l[1])
y = int(l[2])
ok = []
for i in range(n):
	l = input().split()
	li = [int(i) for i in l]
	ok.append(li)
l = input().split()
xi = [int(i) for i in l]
l = input().split()
yi = [int(i) for i in l]
xi.sort()
yi.sort()
mina = 10 ** 18
for i in range(n):
	num1 = bisect.bisect_right(xi, ok[i][0])
	num2 = bisect.bisect_left(yi, ok[i][1])
	if num1 >= 1 and num2 < y:
		mina = min(yi[num2] - xi[num1 - 1], mina)
print(mina + 1)


import bisect

def wormholes(tlist, vlist, wlist):
	sumlist = []
	for i in range(len(tlist)):
		if tlist[i][0] not in vlist:
			x = bisect.bisect_left(vlist, tlist[i][0])
			x = x - 1
			if x < 0:
				continue
		else:
			x = vlist.index(tlist[i][0])
		if tlist[i][1] not in wlist:
			y = bisect.bisect_right(wlist, tlist[i][1])
			if y >= len(wlist):
				continue
		else:
			y = wlist.index(tlist[i][1])
		sumlist.append(wlist[y] - vlist[x] + 1)
	return min(sumlist)
(n, x, y) = input().split()
(n, x, y) = (int(n), int(x), int(y))
timelist = []
for i in range(n):
	(s, e) = input().split()
	(s, e) = (int(s), int(e))
	timelist.append([s, e])
v = list(map(int, input().strip().split()))
w = list(map(int, input().strip().split()))
v.sort()
w.sort()
miv = min(v)
maw = max(w)
for i in range(n):
	if timelist[i][0] < miv or timelist[i][1] > maw:
		timelist[i] = [0, 0]
while [0, 0] in timelist:
	timelist.remove([0, 0])
print(wormholes(timelist, v, w))


import bisect

def wormholes(tlist, vlist, wlist):
	sumlist = []
	for i in range(len(tlist)):
		if tlist[i][0] not in vlist:
			x = bisect.bisect_left(vlist, tlist[i][0])
			x = x - 1
		else:
			x = vlist.index(tlist[i][0])
		if tlist[i][1] not in wlist:
			y = bisect.bisect_right(wlist, tlist[i][1])
		else:
			y = wlist.index(tlist[i][1])
		if y < len(wlist) and x >= 0:
			sumlist.append(wlist[y] - vlist[x] + 1)
	return min(sumlist)
(n, x, y) = input().split()
(n, x, y) = (int(n), int(x), int(y))
timelist = []
for i in range(n):
	(s, e) = input().split()
	(s, e) = (int(s), int(e))
	timelist.append([s, e])
v = list(map(int, input().strip().split()))
w = list(map(int, input().strip().split()))
v.sort()
w.sort()
print(wormholes(timelist, v, w))


def bs1(arr, x):
	low = 0
	high = len(arr) - 1
	p = 0
	while low <= high:
		mid = (low + high) // 2
		if arr[mid] == x:
			return arr[mid]
		elif arr[mid] < x:
			p = mid
			low = mid + 1
		else:
			high = mid - 1
	if arr[p] <= x:
		return arr[p]
	else:
		return 0

def bs2(arr, x):
	low = 0
	high = len(arr) - 1
	p = 0
	while low <= high:
		mid = (low + high) // 2
		if arr[mid] == x:
			return arr[mid]
		elif arr[mid] < x:
			low = mid + 1
		else:
			p = mid
			high = mid - 1
	if arr[p] >= x:
		return arr[p]
	else:
		return 1000000
(n, a, b) = list(map(int, input().strip().split()))
s = []
e = []
for i in range(n):
	(c, d) = list(map(int, input().strip().split()))
	s.append(c)
	e.append(d)
ws = list(map(int, input().strip().split()))
vs = list(map(int, input().strip().split()))
ws.sort()
vs.sort()
r = 1000000
for i in range(n):
	s1 = bs1(ws, s[i])
	e1 = bs2(vs, e[i])
	r1 = e1 - s1 + 1
	if r1 < r:
		r = r1
print(r)


(n, a, b) = list(map(int, input().strip().split()))
s = []
e = []
for i in range(n):
	(c, d) = list(map(int, input().strip().split()))
	s.append(c)
	e.append(d)
ws = list(map(int, input().strip().split()))
vs = list(map(int, input().strip().split()))
ws.sort(reverse=True)
vs.sort()
r = 1000000
for i in range(n):
	s1 = 0
	e1 = 1000000
	for j in range(a):
		if ws[j] <= s[i]:
			s1 = ws[j]
			break
	for j in range(b):
		if vs[j] >= e[i]:
			e1 = vs[j]
			break
	r1 = e1 - s1 + 1
	if r1 < r:
		r = r1
print(r)


(n, v, w) = list(map(int, input().strip().split()))
s = []
e = []
for i in range(n):
	(o, u) = list(map(int, input().strip().split()))
	s.append(o)
	e.append(u)
vs = list(map(int, input().strip().split()))
ws = list(map(int, input().strip().split()))
vs.sort()
ws.sort()
r = 1000000
for i in range(n):
	s1 = 0
	e1 = 1000000
	for j in vs:
		if s[i] >= j:
			s1 = j
		else:
			break
	for j in range(len(ws) - 1, -1, -1):
		if e[i] <= ws[j]:
			e1 = ws[j]
		else:
			break
	r1 = e1 - s1 + 1
	if r1 < r:
		r = r1
print(r)


import itertools
(N, X, Y) = list(map(int, input().split()))
contests = []
for _ in range(N):
	contests.append(list(map(int, input().split())))
into = list(map(int, input().split()))
outo = list(map(int, input().split()))
worthwole = [(x, y) for (x, y) in itertools.product(into, outo) if x < y]
worthwole = sorted(worthwole, key=lambda x: x[1] - x[0])
result = 0
found = False
for w in worthwole:
	for c in contests:
		if w[0] <= c[0] and w[1] >= c[1]:
			result = w[1] - w[0] + 1
			found = True
			break
	if found:
		break
print(result)


import sys
from operator import itemgetter
(n, x, y) = map(int, input().strip().split())
tests = []
for _ in range(n):
	(start, end) = map(int, input().strip().split())
	tests.append([start, end, 1 + end - start])
start = []
start[:] = map(int, input().strip().split())
start.sort()
end = []
end[:] = map(int, input().strip().split())
end.sort()
tests.sort(key=itemgetter(0))
while tests[0][0] < start[0]:
	tests.pop(0)
	n -= 1
j = 0
for i in range(n):
	while j < x - 1 and start[j + 1] <= tests[i][0]:
		j += 1
	tests[i][2] += tests[i][0] - start[j]
tests.sort(key=itemgetter(1))
while tests[-1][1] > end[-1]:
	tests.pop()
	n -= 1
j = y - 1
for i in range(n - 1, -1, -1):
	while j > 0 and end[j - 1] >= tests[i][1]:
		j -= 1
	tests[i][2] += end[j] - tests[i][1]
minimo = tests[0][2]
for i in range(n):
	minimo = min(minimo, tests[i][2])
print(minimo)


nk = [int(i) for i in input().split()]
n = nk[0]
x = nk[1]
y = nk[2]
contests = []
time = []
while n > 0:
	contests.append([int(i) for i in input().split()])
	n = n - 1
n = nk[0]
vworm = [int(i) for i in input().split()]
wworm = [int(i) for i in input().split()]
vworm.sort(reverse=True)
wworm.sort()
t1 = 0
t2 = 0
mint = 10 ** 6
for contest in contests:
	if contest[1] - contest[0] > mint:
		continue
	t1 = 0
	for vbus in vworm:
		if vbus <= contest[0]:
			t1 = vbus
			break
	t2 = 0
	for wbus in wworm:
		if wbus >= contest[1]:
			t2 = wbus
			break
	if t1 > 0 and t2 > 0 and (t2 >= t1):
		t = t2 - t1 + 1
		if t <= mint:
			mint = t
print(mint)


def ub(arr, item):
	n = len(arr)
	low = 0
	high = n - 1
	while low <= high:
		mid = low + (high - low) // 2
		if arr[mid] == item:
			return mid
		elif arr[mid] < item:
			low = mid + 1
		else:
			high = mid - 1
	return low

def lb(arr, item):
	low = 0
	high = len(arr) - 1
	while low <= high:
		mid = low + (high - low) // 2
		if arr[mid] == item:
			return mid
		elif arr[mid] < item:
			low = mid + 1
		else:
			high = mid - 1
	return high

def main():
	(n, x, y) = map(int, input().split())
	timing = []
	for i in range(n):
		(p, q) = map(int, input().split())
		timing.append((p, q))
	v = list(map(int, input().split()))
	w = list(map(int, input().split()))
	timing.sort()
	v.sort()
	w.sort()
	mn = 1e+18
	for i in range(n):
		s = lb(v, timing[i][0])
		e = ub(w, timing[i][1])
		if s >= 0 and e < y:
			mn = min(mn, abs(v[s] - w[e]) + 1)
	print(mn)
main()


from sys import stdin, stdout
import math

def lower_bound(arr, ele):
	low = 0
	high = len(arr) - 1
	while low <= high:
		mid = (low + high) // 2
		if arr[mid] == ele:
			return arr[mid]
		elif ele < arr[mid]:
			high = mid - 1
		else:
			low = mid + 1
	if high > len(arr) - 1 or high < 0:
		return -1
	return arr[high]

def upper_bound(arr, ele):
	low = 0
	high = len(arr) - 1
	while low <= high:
		mid = (low + high) // 2
		if arr[mid] == ele:
			return arr[mid]
		elif ele < arr[mid]:
			high = mid - 1
		else:
			low = mid + 1
	if low > len(arr) - 1 or low < 0:
		return -1
	return arr[low]

def main():
	(n, n_x, n_y) = list(map(int, stdin.readline().split()))
	contests = [None] * n
	for i in range(n):
		(start, end) = list(map(int, stdin.readline().split()))
		contests[i] = (start, end)
	V = [int(x) for x in stdin.readline().split()]
	W = [int(x) for x in stdin.readline().split()]
	V.sort()
	W.sort()
	ans = math.inf
	for (start, end) in contests:
		opv = lower_bound(V, start)
		opw = upper_bound(W, end)
		if opv == -1 or opw == -1:
			continue
		ans = min(ans, opw - opv + 1)
	print(ans)

def __starting_point():
	main()
__starting_point()