1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdlib>
#include <vector>

struct Przedzial {
	long long pocz;
	long long kon;
};

std::ostream& operator<< (std::ostream& os, Przedzial const& p) {
	os << "(" << p.pocz << " " << p.kon << ")";
	return os;
}

long long odleglosc(long long i, Przedzial const& p) {
	if ((p.pocz <=i) && (i <= p.kon)) return 0;

	return std::min(std::abs(i - p.pocz), std::abs(i - p.kon));
}

bool przylega (Przedzial const& a, Przedzial const& b) {
	if (a.kon + 1 == b.pocz) return true;
	if (b.kon + 1 == a.pocz) return true;

	return false;
}

struct Sortownik {
	long long poz_szk;

	bool operator() (Przedzial const& a, Przedzial const& b) {
		long long odl_a = odleglosc(poz_szk, a);
		long long odl_b = odleglosc(poz_szk, b);

		// blizsze najpierw
		if (odl_a != odl_b) {
			return odl_a < odl_b;
		}

		// dluzsze najpierw
		return (a.kon - a.pocz) > (b.kon - b.pocz);
	}
};

bool powieksz(Przedzial& zab, Przedzial const& kolejny) {
	if (przylega(zab, kolejny)) {

		zab.pocz = std::min(zab.pocz, kolejny.pocz);
		zab.kon = std::max(zab.kon, kolejny.kon);

		return true;
	}
	else {
		return false;
	}
}

long long rozwiaz(long long poz_szk, Przedzial const& zab, long long ostatni) {
	long long prop1 = zab.pocz - 1;
	long long prop2 = zab.kon + 1;

	if (0 == prop1)      return prop2;
	if (ostatni < prop2) return prop1;

	if ((poz_szk - prop1) <= (prop2 - poz_szk)) {
		return prop1;
	}
	else {
		return prop2;
	}
}

int main() {
	std::istream& WEJ = std::cin;

	long long l_budynkow; WEJ >> l_budynkow;
	size_t    l_przedz;   WEJ >> l_przedz;
	long long poz_szk;    WEJ >> poz_szk;

	std::vector< Przedzial > budynki;
	budynki.resize(l_przedz);
	for (size_t i = 0; i < l_przedz; ++i) {
		WEJ >> budynki[i].pocz;
		WEJ >> budynki[i].kon;
	}

	std::sort(budynki.begin(), budynki.end(), Sortownik{poz_szk});

	Przedzial okolica_szkoly = budynki.front();

	for (auto it = std::next(budynki.begin()); it != budynki.end(); ++it) {
		if (! powieksz(okolica_szkoly, *it)) break;
	}

	std::cout << rozwiaz(poz_szk, okolica_szkoly, l_budynkow) << "\n";
}