text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
struct Y {
int fir, sec;
};
bool cmp(Y i, Y j) {
if (i.fir != j.fir) return i.fir < j.fir;
return i.sec < j.sec;
}
int main() {
int n, a[100010];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n <= 2)
cout << -1 << endl;
else {
bool bb = 0;
int x = a[0], y = a[0], indx = 0, indy = 0, x1 = a[0], y1 = a[0], indx1 = 0,
indy1 = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] != a[i]) bb = 1;
if (a[i + 1] < x) {
indx = i + 1;
x = a[i + 1];
}
if (a[i + 1] > y) {
indy = i + 1;
y = a[i + 1];
}
if (a[i + 1] <= x1) {
indx1 = i + 1;
x1 = a[i + 1];
}
if (a[i + 1] >= y1) {
indy1 = i + 1;
y1 = a[i + 1];
}
}
if (!bb)
cout << -1 << endl;
else {
int k1 = 0, k2 = 0;
for (int i = 0; i < n; i++) {
if (a[i] != x) k1++;
if (a[i] != y) k2++;
}
if (k1 >= 2 || k2 >= 2) {
int ind1 = -1, ind2 = -1, k = 0;
for (int i = 0; i < n; i++) {
if (a[i] > x && k == 1 && i > indx) {
k++;
ind2 = i + 1;
}
if (a[i] > x && k == 0 && i > indx) {
k++;
ind1 = i + 1;
}
}
if (ind1 != -1 && ind2 != -1) {
cout << ind1 << " " << indx + 1 << endl;
return 0;
}
ind1 = -1, ind2 = -1, k = 0;
for (int i = 0; i < n; i++) {
if (a[i] > x1 && k == 1 && i < indx1) {
k++;
ind2 = i + 1;
}
if (a[i] > x1 && k == 0 && i < indx1) {
k++;
ind1 = i + 1;
}
}
if (ind1 != -1 && ind2 != -1) {
cout << ind2 << " " << indx1 + 1 << endl;
return 0;
}
ind1 = -1, ind2 = -1, k = 0;
for (int i = 0; i < n; i++) {
if (a[i] < y && k == 1 && i > indy) {
k++;
ind2 = i + 1;
}
if (a[i] < y && k == 0 && i > indy) {
k++;
ind1 = i + 1;
}
}
if (ind1 != -1 && ind2 != -1) {
cout << ind1 << " " << indy + 1 << endl;
return 0;
}
ind1 = -1, ind2 = -1, k = 0;
for (int i = 0; i < n; i++) {
if (a[i] < y1 && k == 1 && i < indy1) {
k++;
ind2 = i + 1;
}
if (a[i] < y1 && k == 0 && i < indy1) {
k++;
ind1 = i + 1;
}
}
if (ind1 != -1 && ind2 != -1) {
cout << ind2 << " " << indy1 + 1 << endl;
return 0;
}
cout << -1 << endl;
} else
cout << -1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
int n, i, x;
vector<int> a, b, c;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &x), a.push_back(x);
c = b = a;
sort(b.begin(), b.end());
sort(c.rbegin(), c.rend());
for (i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
swap(a[i], a[i - 1]);
if (a != b and c != a) return 0 * printf("%d %d", i, i + 1);
swap(a[i], a[i - 1]);
}
}
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int a[1000000];
int maxx, ind, i, j, n;
bool check1() {
for (int i = 1; i < n; i++)
if (a[i] > a[i + 1]) return false;
return true;
}
bool check2() {
for (int i = 1; i < n; i++)
if (a[i] < a[i + 1]) return false;
return true;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]]++;
}
if (m[a[1]] == n) {
cout << -1 << endl;
return 0;
}
if (n <= 100) {
for (i = 1; i <= n; i++)
for (j = i + 1; j <= n; j++)
if (a[i] != a[j]) {
swap(a[i], a[j]);
if (!(check1() || check2())) {
cout << i << " " << j << endl;
return 0;
}
swap(a[i], a[j]);
}
cout << -1 << endl;
return 0;
}
maxx = -1000000000;
for (i = 1; i <= n; i++)
if (maxx < a[i]) {
maxx = a[i];
ind = i;
}
if (ind > 1) {
swap(a[1], a[ind]);
if (!(check1() || check2())) {
cout << 1 << " " << ind << endl;
return 0;
}
swap(a[1], a[ind]);
}
for (i = 3; i <= n; i++)
if (a[i] != a[2]) {
swap(a[2], a[i]);
if (!(check1() || check2())) {
cout << 2 << " " << i << endl;
return 0;
}
swap(a[2], a[i]);
}
maxx = 1000000000;
for (i = 1; i <= n; i++)
if (maxx > a[i]) {
maxx = a[i];
ind = i;
}
if (ind < n) {
swap(a[n], a[ind]);
if (!(check1() || check2())) {
cout << n << " " << ind << endl;
return 0;
}
swap(a[n], a[ind]);
}
for (i = 1; i <= n - 2; i++)
if (a[i] != a[n - 1]) {
swap(a[n - 1], a[i]);
if (!(check1() || check2())) {
cout << n - 1 << " " << i << endl;
return 0;
}
swap(a[n - 1], a[i]);
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
int arr[100005], brr[100005];
int n;
bool asen() {
for (int i = 0; i < n - 1; i++)
if (brr[i] < brr[i + 1]) return false;
return true;
}
bool desen() {
for (int i = 0; i < n - 1; i++)
if (brr[i] > brr[i + 1]) return false;
return true;
}
int main() {
bool check = true;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
brr[i] = arr[i];
}
if (n != 2)
for (int i = 0; i < n - 1; i++)
if (arr[i] != arr[i + 1]) {
swap(brr[i], brr[i + 1]);
if (asen() || desen()) {
swap(brr[i], brr[i + 1]);
} else {
cout << i + 1 << " " << i + 2 << endl;
check = false;
break;
}
}
if (check) cout << "-1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b, c;
int main() {
int n, x, flag = 1;
scanf("%d", &n);
if (n == 1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
b.push_back(x);
c.push_back(x);
}
sort(b.rbegin(), b.rend());
sort(c.begin(), c.end());
bool flag1 = false;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
swap(a[i], a[i - 1]);
if (a == b || a == c) {
swap(a[i], a[i - 1]);
continue;
}
cout << i << " " << i + 1 << endl;
exit(0);
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
cin >> n;
vector<int> a(n);
set<int> s;
for (i = 0; i < n; i = i + 1) {
cin >> a[i];
s.insert(a[i]);
}
if (n == 1 || n == 2 || s.size() == 1) {
cout << "-1" << endl;
} else {
int r = 0, k, c, d;
for (i = 0; i < n - 1; i = i + 1) {
for (j = i + 1; j < n; j = j + 1) {
if (a[i] != a[j]) {
vector<int> b(n);
b = a;
swap(b[i], b[j]);
c = 0, d = 0;
for (k = 0; k < n - 1; k = k + 1) {
if (b[k] > b[k + 1])
c = c + 1;
else if (b[k] < b[k + 1])
d = d + 1;
if (c > 0 && d > 0) break;
}
if (c > 0 && d > 0) {
cout << i + 1 << " " << j + 1 << endl;
break;
}
}
}
if (c > 0 && d > 0) break;
}
if (c == 0 || d == 0) cout << "-1" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100001];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int flag;
if (n > 2) {
for (int i = 1; i < n; i++) {
if (a[i] != a[i + 1]) {
swap(a[i], a[i + 1]);
flag = 0;
for (int j = 2; j <= n; j++) {
if (a[j] > a[j - 1]) {
flag++;
break;
}
}
for (int j = 2; j <= n; j++) {
if (a[j] < a[j - 1]) {
flag++;
break;
}
}
swap(a[i], a[i + 1]);
if (flag < 2) continue;
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n == 1 || n == 2)
puts("-1");
else if (n == 3) {
map<int, int> mp;
for (int i = 1; i <= n; i++) mp[a[i]]++;
if (mp.size() == 1)
puts("-1");
else if (mp.size() == 2) {
if (mp[a[2]] == 1)
puts("-1");
else {
for (int i = 1; i <= n; i++) {
if (mp[a[i]] == 1) {
printf("%d %d\n", 2, i);
break;
}
}
}
} else {
int p = 1;
for (int i = 2; i <= n; i++) {
if (a[i] < a[p]) p = i;
}
if (p == 2)
puts("1 3");
else
printf("%d 2\n", p);
}
} else {
int maxx = a[1], minn = a[1];
for (int i = 2; i <= n; i++) {
maxx = max(maxx, a[i]);
minn = min(minn, a[i]);
}
if (maxx != minn) {
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (maxx == a[i])
cnt++;
else if (minn == a[i])
cnt++;
}
if (cnt == n) {
if (a[1] == a[2]) {
int p = n;
for (int i = n; i >= 1; i--) {
if (a[i] != a[2]) {
p = i;
break;
}
}
printf("%d %d\n", 2, p);
} else {
if (a[2] == a[3])
printf("%d %d\n", 1, 2);
else {
int p = -1;
for (int i = 4; i <= n; i++) {
if (a[i] == a[2]) {
p = i;
break;
}
}
if (p == -1)
printf("%d %d\n", 2, 3);
else
printf("%d %d\n", 3, p);
}
}
} else {
int x = 1, y = -1, z = -1;
for (int i = 2; i <= n; i++) {
if (y == -1 && a[i] != a[x]) {
y = i;
continue;
}
if (z == -1 && a[i] != a[x] && a[i] != a[y]) {
z = i;
break;
}
}
int minn = min(a[x], min(a[y], a[z]));
if (a[y] == minn)
printf("%d %d\n", x, z);
else
printf("%d %d\n", y, minn == a[x] ? x : z);
}
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool is_sort(int n, vector<int> vect);
int main() {
int n;
cin >> n;
vector<int> vect1(n);
for (int i = 0; i < n; i++) {
cin >> vect1[i];
}
if (count(vect1.begin(), vect1.end(), vect1[0]) == n or n == 2)
cout << "-1";
else {
if (is_sort(n, vect1)) {
for (int i = 0; i < n - 1; i++) {
if (vect1[i] != vect1[i + 1]) {
cout << i + 1 << " " << i + 2;
break;
}
}
} else {
for (int i = 0; i < n - 1; i++) {
if (vect1[i] != vect1[i + 1]) {
swap(vect1[i], vect1[i + 1]);
if (is_sort(n, vect1)) {
if (i == n - 2)
cout << "-1";
else {
swap(vect1[i], vect1[i + 1]);
continue;
}
} else {
swap(vect1[i], vect1[i + 1]);
cout << i + 1 << " " << i + 2;
break;
}
}
}
}
}
return 0;
}
bool is_sort(int n, vector<int> vect) {
vector<int> temp_1(n), temp_2(n);
for (int i = 0; i < n; i++) {
temp_1[i] = vect[i];
}
sort(temp_1.begin(), temp_1.end());
for (int i = 0; i < n; i++) {
temp_2[i] = temp_1[n - 1 - i];
}
for (int i = 0; i < n; i++) {
if (vect == temp_1 or vect == temp_2)
return true;
else
return false;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5e5 + 17;
const long long INF = 2e9 + 17;
const int MOD = 1e9 + 7;
int n, q, a[MaxN];
int g[MaxN], b[MaxN];
set<int> S;
inline bool check(int x, int y) {
swap(a[y], a[x]);
int z = 0, q = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] == b[i]) ++z;
if (a[i] == b[n - i + 1]) ++q;
}
swap(a[y], a[x]);
if (z == n || q == n) return 0;
return 1;
}
pair<int, int> c[MaxN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), S.insert(a[i]), b[i] = a[i], c[i] = make_pair(a[i], i);
if (S.size() == 1 || n == 2) puts("-1"), exit(0);
sort(b + 1, b + n + 1);
sort(c + 1, c + n + 1);
for (int j = 1; j <= 2; ++j) {
int x = c[j].second;
for (int i = n; i >= max(1, n - 2000); --i) {
int y = c[i].second;
if (check(x, y) && a[x] != a[y]) cout << x << ' ' << y, exit(0);
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5], p[5], length[5], q[5], pos[5];
int main() {
int n, top = 0;
scanf("%d%d", &n, a);
p[0] = 1;
for (int i = 2; i <= n; i++) {
int m;
scanf("%d", &m);
if (m != a[top]) {
a[++top] = m;
p[top] = i;
} else {
length[top]++;
}
if (top >= 3) i = n + 1;
}
int num = 0;
q[0] = a[0];
pos[0] = p[0];
for (int i = 1; i <= top; i++) {
bool st = 1;
for (int j = 0; j < i; j++)
if (a[j] == a[i]) st = 0;
if (st) {
q[++num] = a[i];
pos[num] = p[i];
}
}
if (num == 0) printf("-1\n");
if (num == 1) {
if (top <= 2) {
int i = 0;
while ((i <= top) && (length[i] == 0)) i++;
if (i == 0) {
printf("%d %d\n", p[1] - 1, p[1]);
} else {
if (i > top) {
printf("-1\n");
} else {
printf("%d %d\n", p[i] - 1, p[i]);
}
}
} else {
printf("%d %d\n", p[0], p[1]);
}
}
if (num >= 2) {
if (q[0] < q[1]) {
if (q[1] < q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
} else {
if (q[1] > q[2])
printf("%d %d\n", pos[0], pos[1]);
else
printf("%d %d\n", pos[0], pos[2]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1234567];
int main() {
int mx = 0;
ios_base::sync_with_stdio(0);
int n;
cin >> n;
set<int> s;
for (int i = 0; i < n; ++i) {
cin >> a[i];
s.insert(a[i]);
}
if (s.size() == 2) {
int c = *s.begin();
int d = *(++s.begin());
if (n == 2)
cout << -1;
else if (n == 3) {
if (a[0] != a[1] && a[1] != a[2])
cout << -1;
else {
if (a[0] == a[1])
cout << 2 << " " << 3;
else
cout << 1 << " " << 2;
}
} else {
int a0 = 0, a1 = 0;
if ((a[0] == c && a[n - 1] == c) || (a[0] == d && a[n - 1] == d)) {
int j = 0;
int k = 0;
for (int i = 1; i < n - 1; ++i) {
if (a[i] == c)
k = i;
else
j = i;
}
if (k == 0) {
if (a[0] == c) {
cout << 1 << " " << 2;
}
} else {
if (j == 0) {
if (a[0] == d) {
cout << 1 << " " << 2;
}
} else
cout << k + 1 << " " << j + 1;
}
} else {
if (a[0] != a[1]) {
cout << 1 << " " << 2;
} else {
cout << 2 << " " << n;
}
}
}
} else {
if (s.size() == 1) {
cout << -1;
} else {
int c = *s.begin();
int d = *(++s.begin());
int e = *(++(++s.begin()));
int ci, di, ei;
for (int i = 0; i < n; ++i) {
if (a[i] == c) ci = i;
if (a[i] == d) di = i;
if (a[i] == e) ei = i;
}
if ((ei > di && ei < ci) || (ei < di && ei > ci))
cout << di + 1 << " " << ci + 1;
else {
if ((ci > di && ci < ei) || (ci < di && ci > ei)) {
cout << di + 1 << " " << ei + 1;
} else {
cout << min(min(ci, di), ei) + 1 << " "
<< ci + di + ei - min(min(ci, ei), di) - max(max(ci, ei), di) +
1;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int main() {
int i, j;
bool up, down;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 2; i <= n; i++)
if (a[i - 1] != a[i]) break;
if (i == n + 1 || n <= 2) {
printf("-1\n");
continue;
}
for (i = 1; i < n; i++) {
if (a[i] == a[i + 1]) continue;
swap(a[i], a[i + 1]);
up = 0, down = 0;
for (j = 1; j < n; j++) {
if (a[j] > a[j + 1]) up = 1;
if (a[j] < a[j + 1]) down = 1;
if (up && down) break;
}
if (up && down) {
printf("%d %d\n", i, i + 1);
goto end;
}
swap(a[i], a[i + 1]);
}
printf("-1\n");
end:;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], c[100005];
bool cmp(int a, int b) { return a > b; }
int main() {
int n;
scanf("%d", &n);
if (n <= 2) {
cout << -1 << endl;
return 0;
}
int j, i;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = c[i] = a[i];
}
sort(b, b + n);
if (b[0] == b[n - 1]) {
cout << -1 << endl;
return 0;
}
sort(c, c + n, cmp);
for (i = 0; i < n; i++) {
if (a[i] == a[i + 1]) continue;
for (j = i + 1; j < n; j++) {
if (a[j] == a[j - 1]) continue;
if (a[i] == a[j]) continue;
if ((a[j] != b[i] || a[i] != b[j]) && (a[i] != c[j] || a[j] != c[i])) {
cout << i + 1 << " " << j + 1 << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 60;
bool check(long long a[], long long n) {
for (long long int i = 1; i < n; ++i)
if (a[i] < a[i - 1]) return false;
return true;
}
bool check1(long long a[], long long n) {
for (long long int i = 1; i < n; ++i)
if (a[i] > a[i - 1]) return false;
return true;
}
void solve() {
long long n;
cin >> n;
long long a[n];
set<long long, greater<long long> > s;
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
s.insert(a[i]);
}
if (s.size() < 2 || n < 3) {
cout << -1 << endl;
return;
}
for (long long int i = 0; i < n; ++i) {
for (long long int j = i + 1; j < n; ++j) {
if (a[j] != a[i]) {
swap(a[j], a[i]);
if (!check(a, n) && !check1(a, n)) {
cout << i + 1 << " " << j + 1 << endl;
return;
}
swap(a[j], a[i]);
}
}
}
cout << -1 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
const int MAX = 200000;
const int INF = 100000000;
const int MOD = 1000000007;
const double EPS = 1E-7;
const int IT = 10024;
map<int, vector<pair<int, int> > > r;
map<int, vector<pair<int, int> > > c;
map<int, int> R;
map<int, int> C;
int main() {
int n, m;
cin >> n >> m;
int k;
cin >> k;
for (long long(i) = (0); i < k; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
r[x1].push_back(make_pair(min(y1, y2), max(y1, y2)));
} else {
c[y1].push_back(make_pair(min(x1, x2), max(x1, x2)));
}
}
int dr = n - 1 - r.size();
int dc = m - 1 - c.size();
int res = 0;
if (dr & 1) res ^= m;
if (dc & 1) res ^= n;
for (map<int, vector<pair<int, int> > >::iterator it = r.begin();
it != r.end(); ++it) {
int cnt = 0;
sort(it->second.begin(), it->second.end());
cnt += it->second[0].first;
int rigth = it->second[0].second;
for (long long(i) = (1); i < it->second.size(); i++) {
cnt += max(0, it->second[i].first - rigth);
rigth = max(rigth, it->second[i].second);
}
cnt += m - rigth;
R[it->first] = cnt;
res ^= cnt;
}
for (map<int, vector<pair<int, int> > >::iterator it = c.begin();
it != c.end(); ++it) {
int cnt = 0;
sort(it->second.begin(), it->second.end());
cnt += it->second[0].first;
int rigth = it->second[0].second;
for (long long(i) = (1); i < it->second.size(); i++) {
cnt += max(0, it->second[i].first - rigth);
rigth = max(rigth, it->second[i].second);
}
cnt += n - rigth;
C[it->first] = cnt;
res ^= cnt;
}
if (res == 0) {
cout << "SECOND\n";
return 0;
} else {
cout << "FIRST\n";
}
if (dr && (res ^ m) <= m) {
int cut = m - (res ^ m);
int X;
for (long long(i) = (1); i < 100007; i++)
if (!R.count(i)) {
X = i;
break;
}
cout << X << ' ' << 0 << ' ' << X << ' ' << cut << endl;
return 0;
}
if (dc && (res ^ n) <= n) {
int cut = n - (res ^ n);
int X;
for (long long(i) = (1); i < 100007; i++)
if (!C.count(i)) {
X = i;
break;
}
cout << 0 << ' ' << X << ' ' << cut << ' ' << X << endl;
return 0;
}
for (map<int, int>::iterator it = R.begin(); it != R.end(); ++it) {
if ((res ^ it->second) <= it->second) {
int cut = it->second - (res ^ it->second);
int x = it->first;
vector<pair<int, int> > temp = r[x];
int cnt = 0;
cnt += temp[0].first;
if (cut <= temp[0].first) {
cout << x << ' ' << 0 << ' ' << x << ' ' << cut << endl;
return 0;
}
int rigth = temp[0].second;
for (long long(i) = (1); i < temp.size(); i++) {
int add = max(0, temp[i].first - rigth);
if (cnt + add >= cut) {
cout << x << ' ' << 0 << ' ' << x << ' ' << rigth + cut - cnt << endl;
return 0;
}
cnt += add;
rigth = max(rigth, temp[i].second);
}
cout << x << ' ' << 0 << ' ' << x << ' ' << rigth + cut - cnt << endl;
return 0;
}
}
for (map<int, int>::iterator it = C.begin(); it != C.end(); ++it) {
if ((res ^ it->second) <= it->second) {
int cut = it->second - (res ^ it->second);
int x = it->first;
vector<pair<int, int> > temp = c[x];
int cnt = 0;
if (cut <= temp[0].first) {
cout << 0 << ' ' << x << ' ' << cut << ' ' << x << endl;
return 0;
}
cnt += temp[0].first;
int rigth = temp[0].second;
for (long long(i) = (1); i < temp.size(); i++) {
int add = max(0, temp[i].first - rigth);
if (cnt + add >= cut) {
cout << 0 << ' ' << x << ' ' << rigth + cut - cnt << ' ' << x << endl;
return 0;
}
cnt += add;
rigth = max(rigth, temp[i].second);
}
cout << 0 << ' ' << x << ' ' << rigth + cut - cnt << ' ' << x << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int nn, mm;
typedef struct {
int x, s, e;
} ele;
int cmp(ele a, ele b) { return a.x < b.x || (a.x == b.x && a.s < b.s); }
vector<ele> a[2];
template <class T>
int dcdc(T s, T e, int x) {
ele l = *s;
s++;
for (; s != e; s++) {
if (l.e >= s->s) {
l.e = max(l.e, s->e);
} else {
x -= l.e - l.s;
l = *s;
}
}
return x - (l.e - l.s);
}
template <class T>
void dcdc2(T s, T e, int x, int m, int t) {
ele l = (ele){s->x, 0, 0};
int ts = 0;
for (; s != e; s++) {
if (l.e >= s->s) {
l.e = max(l.e, s->e);
} else {
ts += s->s - l.e;
if (ts >= x) {
if (t == 0)
printf("%d %d %d %d\n", l.x, 0, l.x, s->s - (ts - x));
else
printf("%d %d %d %d\n", 0, l.x, s->s - (ts - x), l.x);
return;
}
l = *s;
}
}
ts += m - l.e;
if (t == 0)
printf("%d %d %d %d\n", l.x, 0, l.x, m - (ts - x));
else
printf("%d %d %d %d\n", 0, l.x, m - (ts - x), l.x);
}
int test(int t, int tox, int m) {
int tn = (int)a[t].size();
for (int i = 0; i < tn;) {
int j = i;
for (; i < tn && a[t][i].x == a[t][j].x; i++)
;
int tt = dcdc(a[t].begin() + j, a[t].begin() + i, m);
if (tt > (tox ^ tt)) {
dcdc2(a[t].begin() + j, a[t].begin() + i, tt - (tox ^ tt), m, t);
return 1;
}
}
return 0;
}
void sol() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x, y, z, w;
scanf("%d %d %d %d", &x, &y, &z, &w);
if (x == z) {
if (y > w) swap(y, w);
a[0].push_back((ele){x, y, w});
} else {
if (x > z) swap(x, z);
a[1].push_back((ele){y, x, z});
}
}
nn = n - 1;
mm = m - 1;
int txo = ((nn & 1) * m) ^ ((mm & 1) * n);
for (int t = 0; t < 2; t++) {
sort(a[t].begin(), a[t].end(), cmp);
int tn = (int)a[t].size();
for (int i = 0; i < tn;) {
int j = i;
for (; i < tn && a[t][i].x == a[t][j].x; i++)
;
txo ^= m;
nn--;
txo ^= dcdc(a[t].begin() + j, a[t].begin() + i, m);
}
swap(n, m);
swap(nn, mm);
}
if (txo == 0) {
puts("SECOND");
} else {
puts("FIRST");
if (nn && m > (txo ^ m)) {
int tn = (int)a[0].size();
int ta = 1;
for (int i = 0; i < tn; i++) {
if (ta == a[0][i].x) ta++;
}
printf("%d %d %d %d\n", ta, 0, ta, m - (txo ^ m));
} else if (mm && n > (txo ^ n)) {
int tn = (int)a[1].size();
int ta = 1;
for (int i = 0; i < tn; i++) {
if (ta == a[1][i].x) ta++;
}
printf("%d %d %d %d\n", 0, ta, n - (txo ^ n), ta);
} else {
if (test(0, txo, m) == 0) test(1, txo, n);
}
}
a[0].clear();
a[1].clear();
}
int main() {
while (1) {
sol();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
const int INF = 1000 * 1000 * 1000;
const long long INF64 = sqr(static_cast<long long>(INF));
const double PI = acos(-1.0);
const int K = 200500;
long long n, m;
long long mex;
int k, a, b, c;
pair<long long, pair<long long, long long> > h[K], v[K];
pair<long long, long long> w[2 * K];
map<int, int> H, V;
int main() {
cin >> n >> m >> k;
if (m % 2 == 0) mex = mex ^ n;
if (n % 2 == 0) mex = mex ^ m;
for (int i = 0; i < k; ++i) {
int bx, by, ex, ey;
scanf("%d %d %d %d", &by, &bx, &ey, &ex);
if (bx > ex) swap(bx, ex);
if (by > ey) swap(by, ey);
if (bx == ex)
v[a++] = make_pair((long long)(bx),
make_pair((long long)(by), (long long)(ey)));
else
h[b++] = make_pair((long long)(by),
make_pair((long long)(bx), (long long)(ex)));
}
for (int i = 1; i < n && i < 100500; ++i)
h[b++] =
make_pair((long long)(i), make_pair((long long)(1), (long long)(1)));
for (int i = 1; i < m && i < 100500; ++i)
v[a++] =
make_pair((long long)(i), make_pair((long long)(1), (long long)(1)));
sort(v, v + a);
sort(h, h + b);
for (int i = 0; i < a;) {
int j = i + 1;
while (j < a && v[j].first == v[i].first) ++j;
int c = 0;
for (int p = i; p < j; ++p) {
w[c++] = make_pair(v[p].second.first, 1);
w[c++] = make_pair(v[p].second.second, 0);
}
w[c++] = make_pair(n, 0);
sort(w, w + c);
int cnt = 0;
for (int p = 0, prev = 0, balance = 0; p < c; ++p) {
if (balance <= 0) cnt += w[p].first - prev;
if (w[p].second)
++balance;
else
--balance;
prev = w[p].first;
}
V[v[i].first] = cnt;
i = j;
}
for (int i = 0; i < b;) {
int j = i + 1;
while (j < b && h[j].first == h[i].first) ++j;
int c = 0;
for (int p = i; p < j; ++p) {
w[c++] = make_pair(h[p].second.first, 1);
w[c++] = make_pair(h[p].second.second, 0);
}
w[c++] = make_pair(m, 0);
sort(w, w + c);
int cnt = 0;
for (int p = 0, prev = 0, balance = 0; p < c; ++p) {
if (balance <= 0) cnt += w[p].first - prev;
if (w[p].second)
++balance;
else
--balance;
prev = w[p].first;
}
H[h[i].first] = cnt;
i = j;
}
int VV = -1, HH = -1;
int q = 1;
for (map<int, int>::const_iterator it = V.begin(); it != V.end(); ++it) {
if (q != -1) {
if (it->first == q)
++q;
else {
VV = q;
q = -1;
}
}
mex = mex ^ n ^ it->second;
}
if (q != -1 && q < m) VV = q;
q = 1;
for (map<int, int>::const_iterator it = H.begin(); it != H.end(); ++it) {
if (q != -1) {
if (it->first == q)
++q;
else {
HH = q;
q = -1;
}
}
mex = mex ^ m ^ it->second;
}
if (q != -1 && q < n) HH = q;
if (VV != -1) V[VV] = n;
if (HH != -1) H[HH] = m;
if (mex == 0) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
for (map<int, int>::const_iterator it = V.begin(); it != V.end(); ++it) {
int CNT = it->second;
if ((mex ^ CNT) <= CNT) {
int x = CNT - (mex ^ CNT);
for (int i = 0; i < a; ++i) {
if (v[i].first < it->first) continue;
int j = i + 1;
while (j < a && v[j].first == v[i].first) ++j;
int c = 0;
for (int p = i; p < j; ++p) {
w[c++] = make_pair(v[p].second.first, 1);
w[c++] = make_pair(v[p].second.second, 0);
}
w[c++] = make_pair(n, 0);
sort(w, w + c);
int cnt = 0;
for (int p = 0, prev = 0, balance = 0; p < c; ++p) {
if (balance <= 0) {
cnt += w[p].first - prev;
if (cnt >= x) {
cout << "0 " << it->first << " " << w[p].first - (cnt - x) << " "
<< it->first << endl;
return 0;
}
}
if (w[p].second)
++balance;
else
--balance;
prev = w[p].first;
}
break;
}
}
}
for (map<int, int>::const_iterator it = H.begin(); it != H.end(); ++it) {
int CNT = it->second;
if ((mex ^ CNT) <= CNT) {
int x = CNT - (mex ^ CNT);
for (int i = 0; i < b; ++i) {
if (h[i].first < it->first) continue;
int j = i + 1;
while (j < b && h[j].first == h[i].first) ++j;
int c = 0;
for (int p = i; p < j; ++p) {
w[c++] = make_pair(h[p].second.first, 1);
w[c++] = make_pair(h[p].second.second, 0);
}
w[c++] = make_pair(m, 0);
sort(w, w + c);
int cnt = 0;
for (int p = 0, prev = 0, balance = 0; p < c; ++p) {
if (balance <= 0) {
cnt += w[p].first - prev;
if (cnt >= x) {
cout << it->first << " 0 " << it->first << " "
<< w[p].first - (cnt - x) << endl;
return 0;
}
}
if (w[p].second)
++balance;
else
--balance;
prev = w[p].first;
}
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, pair<int, int> > > X, Y;
vector<pair<int, int> > usedX, usedY;
int findX(int pos, int L) {
int last = 0, total = 0, xb, xe;
for (int i = 0; i < (int)X.size(); ++i) {
if (X[i].first != pos) continue;
xb = min(L, X[i].second.first);
xe = min(L, X[i].second.second);
total += max(0, xb - last);
last = max(last, xe);
}
total += L - last;
return total;
}
int findY(int pos, int L) {
int last = 0, total = 0, yb, ye;
for (int i = 0; i < (int)Y.size(); ++i) {
if (Y[i].first != pos) continue;
yb = min(L, Y[i].second.first);
ye = min(L, Y[i].second.second);
total += max(0, yb - last);
last = max(last, ye);
}
total += L - last;
return total;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; ++i) {
int xb, yb, xe, ye;
scanf("%d%d%d%d", &xb, &yb, &xe, &ye);
if (xb == xe) {
if (yb > ye) swap(yb, ye);
X.push_back(make_pair(xb, make_pair(yb, ye)));
} else {
if (xb > xe) swap(xb, xe);
Y.push_back(make_pair(yb, make_pair(xb, xe)));
}
}
sort((X).begin(), (X).end());
sort((Y).begin(), (Y).end());
if (X.size() != 0) {
int last = 0, now = X[0].first, total = 0;
for (int i = 0; i < (int)X.size(); ++i) {
if (X[i].first != now) {
total += m - last;
usedX.push_back(make_pair(now, total));
last = total = 0;
now = X[i].first;
}
total += max(0, X[i].second.first - last);
last = max(last, X[i].second.second);
}
total += m - last;
usedX.push_back(make_pair(now, total));
}
if (Y.size() != 0) {
int last = 0, now = Y[0].first, total = 0;
for (int i = 0; i < (int)Y.size(); ++i) {
if (Y[i].first != now) {
total += n - last;
usedY.push_back(make_pair(now, total));
last = total = 0;
now = Y[i].first;
}
total += max(0, Y[i].second.first - last);
last = max(last, Y[i].second.second);
}
total += n - last;
usedY.push_back(make_pair(now, total));
}
int Grundy = 0;
if ((n - 1 - (int)usedX.size()) % 2 != 0) Grundy = Grundy ^ m;
if ((m - 1 - (int)usedY.size()) % 2 != 0) Grundy = Grundy ^ n;
for (int i = 0; i < (int)usedX.size(); ++i) Grundy = Grundy ^ usedX[i].second;
for (int i = 0; i < (int)usedY.size(); ++i) Grundy = Grundy ^ usedY[i].second;
if (Grundy == 0) {
puts("SECOND");
return 0;
}
puts("FIRST");
if ((int)usedX.size() < n - 1) {
if (usedX.empty()) {
usedX.push_back(make_pair(1, m));
} else
for (int i = 1; i <= n - 1; ++i)
if (usedX[i - 1].first != i) {
usedX.push_back(make_pair(i, m));
break;
}
}
for (int i = 0; i < (int)usedX.size(); ++i)
if ((Grundy ^ usedX[i].second) <= usedX[i].second) {
int target = usedX[i].second - (Grundy ^ usedX[i].second);
int l = 0, r = m;
while (l < r) {
int mid = (l + r) / 2;
int d = findX(usedX[i].first, mid);
if (d == target) {
l = r = mid;
break;
}
if (d < target) {
l = mid + 1;
}
if (d > target) {
r = mid - 1;
}
}
printf("%d 0 %d %d\n", usedX[i].first, usedX[i].first, l);
return 0;
}
if ((int)usedY.size() < m - 1) {
if (usedY.empty()) {
usedY.push_back(make_pair(1, n));
} else
for (int i = 1; i <= m - 1; ++i)
if (usedY[i - 1].first != i) {
usedY.push_back(make_pair(i, n));
break;
}
}
for (int i = 0; i < (int)usedY.size(); ++i)
if ((Grundy ^ usedY[i].second) <= usedY[i].second) {
int target = usedY[i].second - (Grundy ^ usedY[i].second);
int l = 0, r = n;
while (l < r) {
int mid = (l + r) / 2;
int d = findY(usedY[i].first, mid);
if (d == target) {
l = r = mid;
break;
}
if (d < target) {
l = mid + 1;
}
if (d > target) {
r = mid - 1;
}
}
printf("0 %d %d %d\n", usedY[i].first, l, usedY[i].first);
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fun(const vector<pair<int, int> >& v, int m, vector<pair<int, int> >& u) {
int n = v.size();
map<int, int> mp;
for (int i = 0; i < n; ++i) {
++mp[v[i].first];
--mp[v[i].second];
}
int p0 = 0, q = 0;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it) {
if (it->second == 0) continue;
if (q == 0 and it->first != 0) u.push_back(pair<int, int>(p0, it->first));
q += it->second;
if (q == 0) p0 = it->first;
}
if (p0 != m) u.push_back(pair<int, int>(p0, m));
}
int cut(const vector<pair<int, int> >& v, int q) {
int t = 0;
for (int i = 0; i < int(v.size()); ++i) {
if (t + v[i].second - v[i].first >= q) return v[i].first + q - t;
t += v[i].second - v[i].first;
}
return -1;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
map<int, vector<pair<int, int> > > rows, cols;
for (int i = 0; i < k; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2)
rows[x1].push_back(pair<int, int>(min(y1, y2), max(y1, y2)));
else
cols[y1].push_back(pair<int, int>(min(x1, x2), max(x1, x2)));
}
int nim = 0;
if ((n - 1 - rows.size()) % 2 != 0) nim ^= m;
if ((m - 1 - cols.size()) % 2 != 0) nim ^= n;
for (map<int, vector<pair<int, int> > >::iterator it = rows.begin();
it != rows.end(); ++it) {
vector<pair<int, int> > v;
fun(it->second, m, v);
int s = 0;
for (int i = 0; i < int(v.size()); ++i) s += v[i].second - v[i].first;
nim ^= s;
}
for (map<int, vector<pair<int, int> > >::iterator it = cols.begin();
it != cols.end(); ++it) {
vector<pair<int, int> > v;
fun(it->second, n, v);
int s = 0;
for (int i = 0; i < int(v.size()); ++i) s += v[i].second - v[i].first;
nim ^= s;
}
if (nim == 0) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
if (n - 1 - rows.size() > 0) {
int t = m - (nim ^ m);
if (t > 0) {
int x = 1;
while (rows.count(x)) ++x;
cout << x << " 0 " << x << " " << t << endl;
return 0;
}
}
if (m - 1 - cols.size() > 0) {
int t = n - (nim ^ n);
if (t > 0) {
int y = 1;
while (cols.count(y)) ++y;
cout << "0 " << y << " " << t << " " << y << endl;
return 0;
}
}
for (map<int, vector<pair<int, int> > >::iterator it = rows.begin();
it != rows.end(); ++it) {
vector<pair<int, int> > v;
fun(it->second, m, v);
int s = 0;
for (int i = 0; i < int(v.size()); ++i) s += v[i].second - v[i].first;
int t = s - (nim ^ s);
if (t > 0) {
int y = cut(v, t);
if (y != -1) {
cout << it->first << " 0 " << it->first << " " << y << endl;
return 0;
}
}
}
for (map<int, vector<pair<int, int> > >::iterator it = cols.begin();
it != cols.end(); ++it) {
vector<pair<int, int> > v;
fun(it->second, n, v);
int s = 0;
for (int i = 0; i < int(v.size()); ++i) s += v[i].second - v[i].first;
int t = s - (nim ^ s);
if (t > 0) {
int x = cut(v, t);
if (x != -1) {
cout << "0 " << it->first << " " << x << " " << it->first << endl;
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5;
int n, m, k, ans;
pair<pair<int, int>, pair<int, int> > st;
vector<pair<pair<int, int>, pair<int, int> > > forn, form;
int len(pair<pair<int, int>, pair<int, int> > v) {
return (abs(v.first.first - v.second.first) +
abs(v.first.second - v.second.second));
}
void solve(int n, int m,
const vector<pair<pair<int, int>, pair<int, int> > >& f) {
int last = 0;
for (int l = 0, r = 0; l < (int)(f).size(); l = r) {
if ((f[l].first.first - last - 1) % 2) ans ^= m;
while (r < (int)(f).size() && f[r].first.first == f[l].first.first) r++;
int d = 0, bound = 0;
for (int i = l; i < r; i++) {
if (f[i].first.second >= bound)
d += len(f[i]);
else
d += max(0, f[i].second.second - bound);
bound = max(bound, f[i].second.second);
}
ans ^= (m - d);
last = f[l].first.first;
}
if ((n - 1 - last) % 2) {
ans ^= m;
}
}
int Try(int need, int have) {
need ^= have;
return have - need;
}
bool findAns(int n, int m,
const vector<pair<pair<int, int>, pair<int, int> > >& f, int val) {
int last = 0;
for (int l = 0, r = 0; l < (int)(f).size(); l = r) {
if (f[l].first.first - last - 1) {
int v = Try(val, m);
if (v >= 1 && v <= m) {
st = make_pair(make_pair(last + 1, 0), make_pair(last + 1, v));
return true;
}
}
while (r < (int)(f).size() && f[r].first.first == f[l].first.first) r++;
int d = 0, bound = 0;
for (int i = l; i < r; i++) {
if (f[i].first.second >= bound)
d += len(f[i]);
else
d += max(0, f[i].second.second - bound);
bound = max(bound, f[i].second.second);
}
int v = Try(val, m - d);
if (v >= 1 && v <= m - d) {
int free = 0, bound = 0;
for (int i = l; i < r; i++) {
if (f[i].first.second >= bound) {
if (free + f[i].first.second - bound >= v) {
st = make_pair(make_pair(f[i].first.first, 0),
make_pair(f[i].first.first, bound + v - free));
return true;
}
free += f[i].first.second - bound;
}
bound = max(bound, f[i].second.second);
}
st = make_pair(make_pair(f[l].first.first, 0),
make_pair(f[l].first.first, bound + v - free));
return true;
}
last = f[l].first.first;
}
if (n - 1 - last) {
int v = Try(val, m);
if (v >= 1 && v <= m) {
st = make_pair(make_pair(n - 1, 0), make_pair(n - 1, v));
return true;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2)
forn.push_back(
make_pair(make_pair(x1, min(y1, y2)), make_pair(x1, max(y1, y2))));
else
form.push_back(
make_pair(make_pair(y1, min(x1, x2)), make_pair(y1, max(x1, x2))));
}
sort(forn.begin(), forn.end());
sort(form.begin(), form.end());
solve(n, m, forn);
solve(m, n, form);
cerr << ans << endl;
if (ans) {
cout << "FIRST" << endl;
if (findAns(n, m, forn, ans))
cout << st.first.first << ' ' << st.first.second << ' ' << st.second.first
<< ' ' << st.second.second << endl,
cerr << "find with n" << endl;
else if (findAns(m, n, form, ans))
cout << st.first.second << ' ' << st.first.first << ' '
<< st.second.second << ' ' << st.second.first << endl,
cerr << "find with m" << endl;
else
assert(0);
} else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:100000000")
int xb[100500], xe[100500], yb[100500], ye[100500];
vector<int> indv, indh;
set<pair<int, int> > H, V;
vector<pair<int, int> > h, v, ev;
bool cmph(int i, int j) { return yb[i] < yb[j]; }
bool cmpv(int i, int j) { return xb[i] < xb[j]; }
int main() {
int i, j;
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int g = 0;
if (n % 2 == 0) g ^= m;
if (m % 2 == 0) g ^= n;
for (i = 0; i < k; ++i) {
scanf("%d%d%d%d\n", &xb[i], &yb[i], &xe[i], &ye[i]);
if (xb[i] > xe[i]) swap(xb[i], xe[i]);
if (yb[i] > ye[i]) swap(yb[i], ye[i]);
if (xb[i] == xe[i]) {
indv.push_back(i);
V.insert(make_pair(yb[i], i));
} else {
indh.push_back(i);
H.insert(make_pair(xb[i], i));
}
}
sort(indv.begin(), indv.end(), cmpv);
for (i = 0; i < indv.size();) {
ev.clear();
for (j = i; j < indv.size() && xb[indv[j]] == xb[indv[i]]; ++j) {
ev.push_back(make_pair(yb[indv[j]], 0));
ev.push_back(make_pair(ye[indv[j]], 1));
}
i = j;
sort(ev.begin(), ev.end());
int st;
int cnt = 0;
int stones = m;
for (j = 0; j < ev.size(); ++j) {
if (ev[j].second == 0) {
if (cnt == 0) st = ev[j].first;
cnt++;
} else {
cnt--;
if (cnt == 0) {
stones -= (ev[j].first - st);
}
}
}
v.push_back(make_pair(stones, xb[indv[i - 1]]));
g ^= (stones ^ m);
}
sort(indh.begin(), indh.end(), cmph);
for (i = 0; i < indh.size();) {
ev.clear();
for (j = i; j < indh.size() && yb[indh[j]] == yb[indh[i]]; ++j) {
ev.push_back(make_pair(xb[indh[j]], 0));
ev.push_back(make_pair(xe[indh[j]], 1));
}
i = j;
sort(ev.begin(), ev.end());
int st;
int cnt = 0;
int stones = n;
for (j = 0; j < ev.size(); ++j) {
if (ev[j].second == 0) {
if (cnt == 0) st = ev[j].first;
cnt++;
} else {
cnt--;
if (cnt == 0) {
stones -= (ev[j].first - st);
}
}
}
h.push_back(make_pair(stones, yb[indh[i - 1]]));
g ^= (stones ^ n);
}
if (g == 0) {
printf("SECOND\n");
return 0;
}
int g1 = g;
while (((g1 - 1) & g1) > 0) {
g1 = ((g1 - 1) & g1);
}
printf("FIRST\n");
for (i = 0; i < v.size(); ++i)
if ((g1 & v[i].first) != 0) {
int cnt = v[i].first - (g ^ v[i].first);
int x = 0;
while (!V.empty()) {
int seg = V.begin()->second;
V.erase(V.begin());
if (ye[seg] <= x || xb[seg] != v[i].second) continue;
if (yb[seg] > x) {
if (cnt - (yb[seg] - x) > 0) {
cnt -= (yb[seg] - x);
x = ye[seg];
} else {
break;
}
} else {
x = ye[seg];
}
}
x += cnt;
printf("%d %d %d %d\n", v[i].second, 0, v[i].second, x);
return 0;
}
for (i = 0; i < h.size(); ++i)
if ((g1 & h[i].first) != 0) {
int cnt = h[i].first - (g ^ h[i].first);
int x = 0;
while (!H.empty()) {
int seg = H.begin()->second;
H.erase(H.begin());
if (xe[seg] <= x || yb[seg] != h[i].second) continue;
if (xb[seg] > x) {
if (cnt - (xb[seg] - x) > 0) {
cnt -= (xb[seg] - x);
x = xe[seg];
} else {
break;
}
} else {
x = xe[seg];
}
}
x += cnt;
printf("%d %d %d %d\n", 0, h[i].second, x, h[i].second);
return 0;
}
int lst = 0;
v.push_back(make_pair(m, n));
for (i = 0; i < v.size(); ++i) {
if (v[i].second - lst > 1) {
if ((g1 & m) != 0) {
printf("%d %d %d %d\n", lst + 1, 0, lst + 1, m - (g ^ m));
return 0;
}
break;
}
lst = v[i].second;
}
lst = 0;
h.push_back(make_pair(m, m));
for (i = 0; i < h.size(); ++i) {
if (h[i].second - lst > 1) {
if ((g1 & n) != 0) {
printf("%d %d %d %d\n", 0, lst + 1, n - (g ^ n), lst + 1);
return 0;
}
break;
}
lst = h[i].second;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt1, cnt2, cnt, n, m, k, A, B, C, D, i, j, l, v[100005], sum1, sum2, Q, Q2,
nowx, nowy, ans, P, L, R, mid, CNT;
struct node {
int x, y, z;
} t1[100005], t2[100005], h[100005], s[100005], S[100005], H[100005];
int cmp(node i, node j) { return i.x < j.x; }
int OK(int x) {
int sum = 0;
for (int i = 1; i <= CNT; i++)
if (H[i].x <= x) {
if (H[i].y <= x)
sum += H[i].y - H[i].x + 1;
else
sum += x - H[i].x + 1;
}
return x - sum;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= k; i++) {
scanf("%d%d%d%d", &A, &B, &C, &D);
if (A == C) {
t1[++cnt1].x = A;
t1[cnt1].y = min(B, D);
t1[cnt1].z = max(B, D);
} else {
t2[++cnt2].x = B;
t2[cnt2].y = min(A, C);
t2[cnt2].z = max(A, C);
}
}
sort(t1 + 1, t1 + cnt1 + 1, cmp);
sort(t2 + 1, t2 + cnt2 + 1, cmp);
for (j = 1, i = 2; i <= cnt1 + 1; i++)
if (i == cnt1 + 1 || t1[i].x != t1[i - 1].x) {
cnt = 0;
sum1++;
for (k = j; k < i; k++) {
h[++cnt].x = t1[k].y;
h[cnt].y = t1[k].z;
}
sort(h + 1, h + cnt + 1, cmp);
s[++Q].x = m;
s[Q].y = t1[i - 1].x;
nowx = nowy = 0;
for (k = 1; k <= cnt; k++)
if (h[k].x <= nowy)
nowy = max(nowy, h[k].y);
else {
s[Q].x -= (nowy - nowx);
nowx = h[k].x;
nowy = h[k].y;
}
s[Q].x -= (nowy - nowx);
j = i;
}
for (j = 1, i = 2; i <= cnt2 + 1; i++)
if (i == cnt2 + 1 || t2[i].x != t2[i - 1].x) {
cnt = 0;
sum2++;
for (k = j; k < i; k++) {
h[++cnt].x = t2[k].y;
h[cnt].y = t2[k].z;
}
sort(h + 1, h + cnt + 1, cmp);
S[++Q2].x = n;
S[Q2].y = t2[i - 1].x;
nowx = nowy = 0;
for (k = 1; k <= cnt; k++)
if (h[k].x <= nowy)
nowy = max(nowy, h[k].y);
else {
S[Q2].x -= (nowy - nowx);
nowx = h[k].x;
nowy = h[k].y;
}
S[Q2].x -= (nowy - nowx);
j = i;
}
if ((n - sum1) % 2 == 0) {
s[++Q].x = m;
t1[cnt1 + 1].x = n;
for (i = 1; i <= cnt1 + 1; i++)
if (t1[i].x - t1[i - 1].x >= 2) {
s[Q].y = t1[i].x - 1;
break;
}
}
if ((m - sum2) % 2 == 0) {
S[++Q2].x = n;
t2[cnt2 + 1].x = m;
for (i = 1; i <= cnt2 + 1; i++)
if (t2[i].x - t2[i - 1].x >= 2) {
S[Q2].y = t2[i].x - 1;
break;
}
}
for (i = 1; i <= Q; i++) ans ^= s[i].x;
for (i = 1; i <= Q2; i++) ans ^= S[i].x;
if (!ans) {
cout << "SECOND";
return 0;
}
cout << "FIRST" << endl;
for (i = 1; i <= Q; i++)
if ((s[i].x ^ ans) < s[i].x) break;
if (i <= Q) {
cout << s[i].y << ' ' << 0 << ' ' << s[i].y << ' ';
j = i;
cnt = 0;
for (i = 1; i <= cnt1; i++)
if (t1[i].x == s[j].y) {
h[++cnt].x = t1[i].y;
h[cnt].y = t1[i].z;
}
sort(h + 1, h + cnt + 1, cmp);
nowx = nowy = 0;
for (k = 1; k <= cnt; k++)
if (h[k].x <= nowy)
nowy = max(nowy, h[k].y);
else {
H[++CNT].x = nowx + 1;
H[CNT].y = nowy;
nowx = h[k].x;
nowy = h[k].y;
}
H[++CNT].x = nowx + 1;
H[CNT].y = nowy;
L = 1;
R = m;
mid = (L + R) / 2;
s[j].x = s[j].x - (s[j].x ^ ans);
while (L <= R) {
if (OK(mid) >= s[j].x) {
R = mid - 1;
mid = (L + R) / 2;
} else {
L = mid + 1;
mid = (L + R) / 2;
}
}
cout << L << endl;
return 0;
}
for (i = 1; i <= Q2; i++)
if ((S[i].x ^ ans) < S[i].x) break;
cout << 0 << ' ' << S[i].y << ' ';
P = S[i].y;
j = i;
cnt = 0;
for (i = 1; i <= cnt2; i++)
if (t2[i].x == S[j].y) {
h[++cnt].x = t2[i].y;
h[cnt].y = t2[i].z;
}
sort(h + 1, h + cnt + 1, cmp);
nowx = nowy = 0;
for (k = 1; k <= cnt; k++)
if (h[k].x <= nowy)
nowy = max(nowy, h[k].y);
else {
H[++CNT].x = nowx + 1;
H[CNT].y = nowy;
nowx = h[k].x;
nowy = h[k].y;
}
H[++CNT].x = nowx + 1;
H[CNT].y = nowy;
S[j].x = S[j].x - (S[j].x ^ ans);
L = 1;
R = n;
mid = (L + R) / 2;
while (L <= R) {
if (OK(mid) >= S[j].x) {
R = mid - 1;
mid = (L + R) / 2;
} else {
L = mid + 1;
mid = (L + R) / 2;
}
}
cout << L << ' ' << P << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const double PI = acos(-1);
const double EPS = 1e-8;
void func(vector<pair<int, int> > &v) {
sort((v).begin(), (v).end());
int start = -1;
int end = -1;
vector<pair<int, int> > res;
for (int i = 0; i < (int)v.size(); ++i) {
if (i == 0) {
start = v[i].first;
end = v[i].second;
} else {
if (v[i].first <= end) {
(end < v[i].second ? (end = v[i].second, 1) : 0);
} else {
res.push_back(pair<int, int>(start, end));
start = v[i].first;
end = v[i].second;
}
}
}
if (start != -1) res.push_back(pair<int, int>(start, end));
v = res;
}
struct P {
int v;
int t, a;
P(int v, int t, int a) : v(v), t(t), a(a) {}
};
int maxbit(int a) {
int r = 0;
while (a) a >>= 1, r++;
return r - 1;
}
const int N = 200000;
bool tflag[N];
bool yflag[N];
int main() {
int w, h, k;
while (cin >> w >> h >> k) {
for (int i = 0; i < (int)N; ++i) tflag[i] = yflag[i] = 0;
map<int, vector<pair<int, int> > > tate, yoko;
for (int i = 0; i < (int)k; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
tate[x1].push_back(pair<int, int>(min(y1, y2), max(y1, y2)));
} else {
yoko[y1].push_back(pair<int, int>(min(x1, x2), max(x1, x2)));
}
}
assert(tate.size() <= w - 1 && yoko.size() <= h - 1);
vector<P> nim;
for (__typeof((tate).begin()) it = (tate).begin(); it != (tate).end();
++it) {
if (it->first < N) tflag[it->first] = 1;
vector<pair<int, int> > &v = it->second;
func(v);
int t = h;
for (__typeof((v).begin()) jt = (v).begin(); jt != (v).end(); ++jt) {
t -= jt->second - jt->first;
}
nim.push_back(P(t, 0, it->first));
}
for (__typeof((yoko).begin()) it = (yoko).begin(); it != (yoko).end();
++it) {
if (it->first < N) yflag[it->first] = 1;
vector<pair<int, int> > &v = it->second;
func(v);
int t = w;
for (__typeof((v).begin()) jt = (v).begin(); jt != (v).end(); ++jt) {
t -= jt->second - jt->first;
}
nim.push_back(P(t, 1, it->first));
}
if ((w - 1 - tate.size()) % 2 == 1) {
for (int i = 1; i < w; ++i)
if (!tflag[i]) {
nim.push_back(P(h, 0, i));
break;
}
}
if ((h - 1 - yoko.size()) % 2 == 1) {
for (int i = 1; i < h; ++i)
if (!yflag[i]) {
nim.push_back(P(w, 1, i));
break;
}
}
int val = 0;
for (__typeof((nim).begin()) it = (nim).begin(); it != (nim).end(); ++it) {
val ^= it->v;
}
if (val) {
puts("FIRST");
int mb = maxbit(val);
int x1, y1, x2, y2;
for (__typeof((nim).begin()) it = (nim).begin(); it != (nim).end();
++it) {
if ((it->v) >> mb & 1) {
int num = it->v - (it->v ^ val);
assert(num >= 1);
if (it->t == 0) {
x1 = x2 = it->a;
y1 = 0;
vector<pair<int, int> > &v = tate[it->a];
int low = 0, high = h;
while (low + 1 < high) {
int mid = (low + high) / 2;
int sum = mid;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end();
++it) {
if (it->second <= mid)
sum -= it->second - it->first;
else if (it->first <= mid)
sum -= mid - it->first;
}
if (sum >= num)
high = mid;
else
low = mid;
}
y2 = high;
} else {
y1 = y2 = it->a;
x1 = 0;
vector<pair<int, int> > &v = yoko[it->a];
int low = 0, high = w;
while (low + 1 < high) {
int mid = (low + high) / 2;
int sum = mid;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end();
++it) {
if (it->second <= mid)
sum -= it->second - it->first;
else if (it->first <= mid)
sum -= mid - it->first;
}
if (sum >= num)
high = mid;
else
low = mid;
}
x2 = high;
}
break;
}
}
printf("%d %d %d %d\n", x1, y1, x2, y2);
} else {
puts("SECOND");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace LYYY {
int read() {
int s = 0;
char c = getchar();
int f = 1;
while (c < 48 || c > 57) {
if (c == 45) f = -1;
c = getchar();
}
while (c >= 48 && c <= 57) s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
return s * f;
}
void write(int x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
void W(int x) {
if (x < 0) x = -x, putchar(45);
write(x);
}
} // namespace LYYY
using namespace LYYY;
const int maxn = 111111;
struct hhh {
int Id, ll, rr;
} Q[2][maxn];
pair<int, int> RST[2][maxn];
int N, M, K, cnt[2], tot[2];
bool cmp(const hhh &x, const hhh &y) {
return x.Id == y.Id ? x.ll < y.ll : x.Id < y.Id;
}
int Get(int x) {
for (int i = 30; ~i; --i)
if (x >= (1 << i)) return 1 << i;
return -1;
}
int fnd0() {
int lst = 0;
for (int i = 1; i <= cnt[0]; ++i)
if (Q[0][i].Id && Q[0][i].Id < N) {
if (Q[0][i].Id != lst) {
if (Q[0][i].Id != lst + 1) return lst + 1;
lst = Q[0][i].Id;
}
}
if (lst + 1 < N) return lst + 1;
return 0;
}
int fnd1() {
int lst = 0;
for (int i = 1; i <= cnt[1]; ++i)
if (Q[1][i].Id && Q[1][i].Id < M) {
if (Q[1][i].Id != lst) {
if (Q[1][i].Id != lst + 1) return lst + 1;
lst = Q[1][i].Id;
}
}
if (lst + 1 < M) return lst + 1;
return 0;
}
int main() {
N = read(), M = read(), K = read();
for (int i = 1; i <= K; ++i) {
int a = read(), b = read(), c = read(), d = read();
if (a == c)
Q[0][++cnt[0]] = (hhh){a, min(b, d), max(b, d)};
else
Q[1][++cnt[1]] = (hhh){b, min(a, c), max(a, c)};
}
Q[0][cnt[0] + 1].Id = Q[1][cnt[1] + 1].Id = -1;
sort(Q[0] + 1, Q[0] + 1 + cnt[0], cmp);
sort(Q[1] + 1, Q[1] + 1 + cnt[1], cmp);
int ans = 0;
if (M % 2 == 0) ans ^= N;
if (N % 2 == 0) ans ^= M;
for (int i = 1, Mx = -1, rst = M, Mn = -1; i <= cnt[0]; ++i)
if (Q[0][i].Id && Q[0][i].Id < N) {
int id = Q[0][i].Id, l = Q[0][i].ll, r = Q[0][i].rr;
if (l > Mx) {
rst -= Mx - Mn;
Mx = r, Mn = l;
} else
Mx = max(Mx, r);
if (id != Q[0][i + 1].Id) {
RST[0][++tot[0]] = make_pair(i, rst -= Mx - Mn);
ans ^= M ^ rst;
Mx = -1, Mn = -1, rst = M;
}
}
for (int i = 1, Mx = -1, rst = N, Mn = -1; i <= cnt[1]; ++i)
if (Q[1][i].Id && Q[1][i].Id < M) {
int id = Q[1][i].Id, l = Q[1][i].ll, r = Q[1][i].rr;
if (l > Mx) {
rst -= Mx - Mn;
Mx = r, Mn = l;
} else
Mx = max(Mx, r);
if (id != Q[1][i + 1].Id) {
RST[1][++tot[1]] = make_pair(i, rst -= Mx - Mn);
ans ^= N ^ rst;
Mx = -1, Mn = -1, rst = N;
}
}
if (!ans) {
puts("SECOND");
return 0;
}
puts("FIRST");
int op = Get(ans), op1 = fnd0(), op2 = fnd1();
if (op2 && (op & N)) {
op = N - (N ^ ans);
printf("0 %d %d %d", op2, op, op2);
return 0;
}
if (op1 && (op & M)) {
op = M - (M ^ ans);
printf("%d 0 %d %d", op1, op1, op);
return 0;
}
int flg = 0;
for (int i = 1; i <= tot[0]; ++i)
if (RST[0][i].second & op) {
op = i;
flg = 1;
break;
}
if (!flg) {
for (int i = 1; i <= tot[1]; ++i)
if (RST[1][i].second & op) {
op = i;
flg = 2;
break;
}
}
--flg;
ans = RST[flg][op].second - (RST[flg][op].second ^ ans);
op = RST[flg][op].first;
int opl = op;
for (int i = op - 1; i; --i)
if (Q[flg][i].Id == Q[flg][op].Id) opl = i;
int R = 0, r = 0;
for (int i = opl; i <= op; ++i) {
if (Q[flg][i].ll > r) {
int uuu = min(Q[flg][i].ll - r, ans);
ans -= uuu;
R = r + uuu;
if (!ans) break;
r = Q[flg][i].rr;
} else
r = max(r, Q[flg][i].rr);
}
if (ans) R = r + ans;
if (flg)
printf("0 %d %d %d", Q[flg][op].Id, R, Q[flg][op].Id);
else
printf("%d 0 %d %d", Q[flg][op].Id, Q[flg][op].Id, R);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
map<int, vector<pair<int, int> > > R, C;
int get_used(vector<pair<int, int> > from) {
vector<pair<int, int> > dat;
for (int i = 0; i < ((int)(from).size()); ++i) {
dat.push_back(make_pair(from[i].first, -1));
dat.push_back(make_pair(from[i].second, +1));
}
int le = 0, ri = 0, bal = 0, ret = 0;
sort(dat.begin(), dat.end());
for (int i = 0; i < ((int)(dat).size()); ++i) {
if (dat[i].second == -1) {
++bal;
if (bal == 1) {
le = dat[i].first;
}
ri = dat[i].first;
} else {
ri = dat[i].first;
--bal;
if (bal == 0) {
ret += ri - le + 1;
}
}
}
return ret;
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < K; ++i) {
int xf, yf, xt, yt;
scanf("%d%d%d%d", &xf, &yf, &xt, &yt);
if (xf > xt) swap(xf, xt);
if (yf > yt) swap(yf, yt);
if (xf == xt) {
R[xf].push_back(make_pair(yf, yt - 1));
} else {
C[yf].push_back(make_pair(xf, xt - 1));
}
}
vector<int> avb, avbt, avbp;
int LR = N - 1 - ((int)(R).size()), LC = M - 1 - ((int)(C).size());
if (LR & 1) {
for (int i = 1;; ++i) {
if (!R.count(i)) {
R[i] = vector<pair<int, int> >();
break;
}
}
}
if (LC & 1) {
for (int i = 1;; ++i) {
if (!C.count(i)) {
C[i] = vector<pair<int, int> >();
break;
}
}
}
for (map<int, vector<pair<int, int> > >::iterator it = R.begin();
it != R.end(); ++it) {
avb.push_back(M - get_used(it->second));
avbt.push_back('R');
avbp.push_back(it->first);
}
for (map<int, vector<pair<int, int> > >::iterator it = C.begin();
it != C.end(); ++it) {
avb.push_back(N - get_used(it->second));
avbt.push_back('C');
avbp.push_back(it->first);
}
int XOR = 0;
for (int i = 0; i < ((int)(avb).size()); ++i) {
XOR ^= avb[i];
}
if (XOR == 0)
puts("SECOND");
else {
puts("FIRST");
int BIG = 0;
for (BIG = 30;; --BIG)
if (XOR & (1 << BIG)) break;
int pos = 0;
for (int i = 0; i < ((int)(avb).size()); ++i)
if (avb[i] & (1 << BIG)) {
pos = i;
break;
}
XOR ^= avb[pos];
int TO = XOR;
if (avbt[pos] == 'R') {
int lo = 0, hi = M - 1, mid;
vector<pair<int, int> > U = R[avbp[pos]];
for (;;) {
if (lo + 1 >= hi) {
U.push_back(make_pair(0, lo));
if (TO == M - get_used(U))
mid = lo;
else
mid = hi;
break;
}
mid = (lo + hi) >> 1;
U.push_back(make_pair(0, mid));
if (TO >= M - get_used(U))
hi = mid;
else
lo = mid;
U.pop_back();
}
cout << avbp[pos] << ' ' << 0 << ' ' << avbp[pos] << ' ' << mid + 1
<< '\n';
} else {
int lo = 0, hi = N - 1, mid;
vector<pair<int, int> > U = C[avbp[pos]];
for (;;) {
if (lo + 1 >= hi) {
U.push_back(make_pair(0, lo));
if (TO == N - get_used(U))
mid = lo;
else
mid = hi;
break;
}
mid = (lo + hi) >> 1;
U.push_back(make_pair(0, mid));
if (TO >= N - get_used(U))
hi = mid;
else
lo = mid;
U.pop_back();
}
cout << 0 << ' ' << avbp[pos] << ' ' << mid + 1 << ' ' << avbp[pos]
<< '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct cut {
int pos, st, end;
};
int N, M, K;
vector<cut> horiz, vert;
bool cmp(cut left, cut right) {
if (left.pos == right.pos) {
if (left.st == right.st) return left.end < right.end;
return left.st < right.st;
}
return left.pos < right.pos;
}
int main() {
cin >> N >> M >> K;
for (int i = 0; i < K; i++) {
int xb, xe, yb, ye;
cin >> xb >> yb >> xe >> ye;
if (xb == xe && yb == ye)
continue;
else if (xb == xe) {
cut tmp;
tmp.pos = xb;
tmp.st = min(yb, ye);
tmp.end = max(yb, ye);
vert.push_back(tmp);
} else if (yb == ye) {
cut tmp;
tmp.pos = yb;
tmp.st = min(xb, xe);
tmp.end = max(xb, xe);
horiz.push_back(tmp);
}
}
sort(horiz.begin(), horiz.end(), cmp);
sort(vert.begin(), vert.end(), cmp);
int numuse = 0, sofar = 0, prev = 0, hun = -1, vun = -1;
for (int i = 0; i < horiz.size();) {
int head = i, tail = i;
while (tail < horiz.size() && horiz[tail].pos == horiz[head].pos) tail++;
int tot = N;
int currs = horiz[head].st, curre = horiz[head].end;
for (int j = head + 1; j < tail; j++) {
if (horiz[j].st <= curre)
curre = max(horiz[j].end, curre);
else {
tot -= curre - currs;
currs = horiz[j].st;
curre = horiz[j].end;
}
}
tot -= curre - currs;
numuse++;
sofar ^= tot;
if (horiz[head].pos > prev + 1 && hun == -1) hun = prev + 1;
prev = horiz[head].pos;
i = tail;
}
if (hun == -1) hun = prev + 1;
if ((M - 1 - numuse) % 2 == 1) sofar ^= N;
numuse = 0, prev = 0;
for (int i = 0; i < vert.size();) {
int head = i, tail = i;
while (tail < vert.size() && vert[tail].pos == vert[head].pos) tail++;
int tot = M;
int currs = vert[head].st, curre = vert[head].end;
for (int j = head + 1; j < tail; j++) {
if (vert[j].st <= curre)
curre = max(curre, vert[j].end);
else {
tot -= curre - currs;
currs = vert[j].st;
curre = vert[j].end;
}
}
tot -= curre - currs;
numuse++;
sofar ^= tot;
if (vert[head].pos > prev + 1 && vun == -1) vun = prev + 1;
prev = vert[head].pos;
i = tail;
}
if (vun == -1) vun = prev + 1;
if ((N - 1 - numuse) % 2 == 1) sofar ^= M;
if (sofar == 0) {
cout << "SECOND\n";
return 0;
}
cout << "FIRST\n";
if ((sofar ^ N) <= N && hun != M) {
int tmp = (sofar ^ N);
cout << "0 " << hun << " " << N - tmp << " " << hun << '\n';
return 0;
} else if ((sofar ^ M) <= M && vun != N) {
int tmp = (sofar ^ M);
cout << vun << " 0 " << vun << " " << M - tmp << '\n';
return 0;
}
for (int i = 0; i < horiz.size();) {
int head = i, tail = i;
while (tail < horiz.size() && horiz[tail].pos == horiz[head].pos) tail++;
int tot = N;
int currs = horiz[head].st, curre = horiz[head].end;
vector<int> seq;
for (int j = head + 1; j < tail; j++) {
if (horiz[j].st <= curre)
curre = max(horiz[j].end, curre);
else {
tot -= curre - currs;
seq.push_back(currs);
seq.push_back(curre);
currs = horiz[j].st;
curre = horiz[j].end;
}
}
tot -= curre - currs;
seq.push_back(currs);
seq.push_back(curre);
seq.push_back(N);
if ((sofar ^ tot) <= tot) {
int tmp = tot - (sofar ^ tot);
if (tmp <= seq[0]) {
cout << "0 " << horiz[head].pos << " " << tmp << ' ' << horiz[head].pos
<< '\n';
return 0;
}
tmp -= seq[0];
for (int i = 1; i < seq.size(); i += 2) {
if (tmp <= seq[i + 1] - seq[i]) {
cout << "0 " << horiz[head].pos << " " << tmp + seq[i] << ' '
<< horiz[head].pos << '\n';
return 0;
}
tmp -= seq[i + 1] - seq[i];
}
}
i = tail;
}
for (int i = 0; i < vert.size();) {
int head = i, tail = i;
while (tail < vert.size() && vert[tail].pos == vert[head].pos) tail++;
int tot = M;
int currs = vert[head].st, curre = vert[head].end;
vector<int> seq;
for (int j = head + 1; j < tail; j++) {
if (vert[j].st <= curre)
curre = max(vert[j].end, curre);
else {
tot -= curre - currs;
seq.push_back(currs);
seq.push_back(curre);
currs = vert[j].st;
curre = vert[j].end;
}
}
tot -= curre - currs;
seq.push_back(currs);
seq.push_back(curre);
seq.push_back(M);
if ((sofar ^ tot) <= tot) {
int tmp = tot - (sofar ^ tot);
if (tmp <= seq[0]) {
cout << vert[head].pos << " 0 " << ' ' << vert[head].pos << " " << tmp
<< '\n';
return 0;
}
tmp -= seq[0];
for (int i = 1; i < seq.size(); i += 2) {
if (tmp <= seq[i + 1] - seq[i]) {
cout << vert[head].pos << " 0 " << vert[head].pos << " "
<< tmp + seq[i] << '\n';
return 0;
}
tmp -= seq[i + 1] - seq[i];
}
}
i = tail;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int cutLen(vector<pair<int, int> > v) {
pair<int, int> p(0, 0);
int len = 0;
for (unsigned i = 0; i < v.size(); ++i) {
if (v[i].first <= p.second) {
p.second = max(v[i].second, p.second);
} else {
len += p.second - p.first;
p = v[i];
}
}
len += p.second - p.first;
return len;
}
int solve(vector<pair<int, int> > v, int len) {
int prev = 0;
for (unsigned i = 0; i < v.size(); ++i) {
if (v[i].first > prev) {
if (len <= v[i].first - prev) break;
len -= v[i].first - prev;
prev = v[i].second;
} else {
prev = max(prev, v[i].second);
}
}
return prev + len;
}
int main() {
int w, h, n;
cin >> w >> h >> n;
map<int, vector<pair<int, int> > > row, col;
while (--n >= 0) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (y1 == y2) {
if (x1 > x2) swap(x1, x2);
row[y1].push_back(make_pair(x1, x2));
} else {
if (y1 > y2) swap(y1, y2);
col[x1].push_back(make_pair(y1, y2));
}
}
int ret = 0;
if ((h - row.size()) % 2 == 0) ret ^= w;
if ((w - col.size()) % 2 == 0) ret ^= h;
for (map<int, vector<pair<int, int> > >::iterator it = row.begin();
it != row.end(); ++it) {
sort(it->second.begin(), it->second.end());
int len = w - cutLen(it->second);
ret ^= len;
}
for (map<int, vector<pair<int, int> > >::iterator it = col.begin();
it != col.end(); ++it) {
sort(it->second.begin(), it->second.end());
int len = h - cutLen(it->second);
ret ^= len;
}
if (!ret) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
for (int i = 1;; ++i) {
if (i < h) {
int y = i;
vector<pair<int, int> > v;
if (row.find(y) != row.end()) v = row[y];
int len = w - cutLen(v);
len = len - (len ^ ret);
if (len > 0) {
int x = solve(v, len);
cout << 0 << ' ' << y << ' ' << x << ' ' << y << endl;
return 0;
}
}
if (i < w) {
int x = i;
vector<pair<int, int> > v;
if (col.find(x) != col.end()) v = col[x];
int len = h - cutLen(v);
len = len - (len ^ ret);
if (len > 0) {
int y = solve(v, len);
cout << x << ' ' << 0 << ' ' << x << ' ' << y << endl;
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
struct data {
int len, x, y;
};
int n, m, SG, K, tot;
data seg[N];
map<int, vector<pair<int, int> > > col, row;
int maxx(int a, int b) { return a > b ? a : b; }
void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
void init() {
scanf("%d%d%d", &n, &m, &K);
int x1, y1, x2, y2;
for (int i = 1; i <= K; ++i) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2)
col[x1].push_back(make_pair(y1, y2));
else
row[y1].push_back(make_pair(x1, x2));
}
}
int length(vector<pair<int, int> > a, int L) {
sort(a.begin(), a.end());
vector<pair<int, int> >::iterator i;
int last = 0, s = 0, l, r;
for (i = a.begin(); i != a.end(); ++i) {
l = i->first;
r = i->second;
if (l > last) s += l - last;
last = maxx(last, r);
}
s += L - last;
return s;
}
int add(vector<pair<int, int> > a, int L) {
sort(a.begin(), a.end());
vector<pair<int, int> >::iterator i;
int last = 0, s = 0, l, r;
for (i = a.begin(); i != a.end(); ++i) {
l = i->first;
r = i->second;
if (l > last) L -= l - last;
if (L <= 0) {
L += l - last;
return last + L;
}
last = maxx(last, r);
}
s = last + L;
return s;
}
void work() {
int tn = n, tm = m;
map<int, vector<pair<int, int> > >::iterator i;
int len, tc = 0, tr = 0;
for (i = col.begin(); i != col.end(); ++i) {
--tn;
if (!tc && n - tn != (i->first)) tc = n - tn;
len = length(i->second, m);
SG ^= len;
++tot;
seg[tot].len = len;
seg[tot].x = (i->first);
seg[tot].y = 0;
}
if (!(tn % 2)) SG ^= m;
for (i = row.begin(); i != row.end(); ++i) {
--tm;
if (!tr && m - tm != (i->first)) tr = m - tm;
len = length(i->second, n);
SG ^= len;
++tot;
seg[tot].len = len;
seg[tot].x = 0;
seg[tot].y = (i->first);
}
if (!(tm % 2)) SG ^= n;
if (!SG)
cout << "SECOND\n";
else {
cout << "FIRST\n";
if (tn > 1) {
if (tc == 0) tc = n - tn + 1;
++tot;
seg[tot].len = m;
seg[tot].x = tc;
seg[tot].y = 0;
}
if (tm > 1) {
if (tr == 0) tr = m - tm + 1;
++tot;
seg[tot].len = n;
seg[tot].x = 0;
seg[tot].y = tr;
}
for (int i = 1; i <= tot; ++i)
if ((seg[i].len ^ SG) < seg[i].len) {
cout << seg[i].x << ' ' << seg[i].y << ' ';
len = seg[i].len - (seg[i].len ^ SG);
if (seg[i].y == 0) {
len = add(col[seg[i].x], len);
cout << seg[i].x << ' ' << len << endl;
} else {
len = add(row[seg[i].y], len);
cout << len << ' ' << seg[i].y << endl;
}
break;
}
}
}
int main() {
init();
work();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct Seg {
int x1, y1, x2, y2;
};
Seg c[N], r[N], tmp[N * 2];
int cl, rl, ans[N * 2], al;
bool cmpC(Seg a, Seg b) {
if (a.y1 == b.y1) return a.x1 < b.x1;
return a.y1 < b.y1;
}
bool cmpR(Seg a, Seg b) {
if (a.x1 == b.x1) return a.y1 < b.y1;
return a.x1 < b.x1;
}
void addAns(int len, int x1, int y1, int x2, int y2) {
ans[al] = len;
tmp[al].x1 = x1;
tmp[al].y1 = y1;
tmp[al].x2 = x2;
tmp[al].y2 = y2;
al++;
}
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
int i, j, f[4];
cl = rl = al = 0;
for (i = 0; i < k; i++) {
scanf("%d%d%d%d", &f[0], &f[1], &f[2], &f[3]);
if (f[0] == f[2]) {
if (f[1] > f[3]) {
int t = f[1];
f[1] = f[3];
f[3] = t;
}
r[rl].x1 = f[0];
r[rl].y1 = f[1];
r[rl].x2 = f[2];
r[rl++].y2 = f[3];
} else {
if (f[0] > f[2]) {
int t = f[0];
f[0] = f[2];
f[2] = t;
}
c[cl].x1 = f[0];
c[cl].y1 = f[1];
c[cl].x2 = f[2];
c[cl++].y2 = f[3];
}
}
sort(c, c + cl, cmpC);
sort(r, r + rl, cmpR);
int nn = n, mm = m;
for (i = 0; i < cl;) {
int tn = 0;
int tc = c[i].y1;
while (i < cl && c[i].y1 == tc) {
if (c[i].x2 <= tn) {
i++;
continue;
}
if (c[i].x1 > tn) addAns(c[i].x1 - tn, tn, tc, c[i].x1, tc);
tn = c[i++].x2;
}
if (tn != nn) addAns(nn - tn, tn, tc, nn, tc);
m--;
}
for (i = 0; i < rl;) {
int tn = r[i].x1;
int tc = 0;
while (i < rl && r[i].x1 == tn) {
if (r[i].y2 <= tc) {
i++;
continue;
}
if (r[i].y1 > tc) addAns(r[i].y1 - tc, tn, tc, tn, r[i].y1);
tc = r[i++].y2;
}
if (tc != mm) addAns(mm - tc, tn, tc, tn, mm);
n--;
}
if ((n - 1) & 1) {
ans[al] = mm;
int cnt = 1;
for (i = 0; i < rl; cnt++) {
if (r[i].x1 != cnt) break;
while (i < rl && r[i].x1 == cnt) i++;
}
if (i == rl) cnt = nn - 1;
tmp[al].x1 = tmp[al].x2 = cnt;
tmp[al].y1 = 0;
tmp[al].y2 = mm;
al++;
}
if ((m - 1) & 1) {
ans[al] = nn;
int cnt = 1;
for (i = 0; i < cl; cnt++) {
if (c[i].y1 != cnt) break;
while (i < cl && c[i].y1 == cnt) i++;
}
if (i == cl) cnt = mm - 1;
tmp[al].y1 = tmp[al].y2 = cnt;
tmp[al].x1 = 0;
tmp[al].x2 = nn;
al++;
}
int s = 0;
for (i = 0; i < al;) {
int ts = 0;
int tn = tmp[i].x1;
int tc = tmp[i].y1;
while (i < al && tn == tmp[i].x1 && tmp[i].x1 == tmp[i].x2)
ts += ans[i++];
while (i < al && tc == tmp[i].y1 && tmp[i].y1 == tmp[i].y2)
ts += ans[i++];
s ^= ts;
}
if (s == 0)
cout << "SECOND" << endl;
else {
cout << "FIRST" << endl;
for (i = 0; i < al; i += j) {
int ts = 0;
j = 0;
int tn = tmp[i].x1;
int tc = tmp[i].y1;
while (i + j < al && tn == tmp[i + j].x1 &&
tmp[i + j].x1 == tmp[i + j].x2)
ts += ans[i + j], j++;
while (i + j < al && tc == tmp[i + j].y1 &&
tmp[i + j].y1 == tmp[i + j].y2)
ts += ans[i + j], j++;
if (ts >= (s ^ ts)) {
ts -= (s ^ ts);
if (tmp[i].x1 == tmp[i].x2) {
int ty;
j = 0;
while (ts) {
if (ts > ans[i + j]) {
ts -= ans[i + j];
j++;
} else {
ty = tmp[i + j].y1 + ts;
break;
}
}
cout << tmp[i].x1 << " " << tmp[i].y1 << " " << tmp[i].x2 << " "
<< ty << endl;
} else {
int tx;
j = 0;
while (ts) {
if (ts > ans[i + j]) {
ts -= ans[i + j];
j++;
} else {
tx = tmp[i + j].x1 + ts;
break;
}
}
cout << tmp[i].x1 << " " << tmp[i].y1 << " " << tx << " "
<< tmp[i].y2 << endl;
}
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
struct Line {
int l, r;
Line(int l = 0, int r = 0) : l(l), r(r) {}
};
bool cmp(Line a, Line b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
const int N = 100004;
vector<Line> fs[N], sc[N];
int take[N];
int n, m, k, id;
map<int, int> row, cow;
void init() {
memset(fs, 0, sizeof(fs));
memset(sc, 0, sizeof(sc));
memset(take, 0, sizeof(take));
row.clear();
cow.clear();
id = 0;
for (int i = 0, x1, x2, y1, y2; i < k; ++i) {
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
if (cow.find(x1) == cow.end()) {
cow[x1] = id;
fs[id].push_back(Line(y1, y2));
++id;
} else {
fs[cow[x1]].push_back(Line(y1, y2));
}
} else {
if (x1 > x2) swap(x1, x2);
if (row.find(y1) == row.end()) {
row[y1] = id;
fs[id].push_back(Line(x1, x2));
++id;
} else {
fs[row[y1]].push_back(Line(x1, x2));
}
}
}
for (int i = 0; i < id; ++i) {
sort(fs[i].begin(), fs[i].end(), cmp);
int l = fs[i][0].l, r = fs[i][0].r;
for (int j = 1; j < fs[i].size(); ++j) {
if (fs[i][j].l > r) {
sc[i].push_back(Line(l, r));
take[i] += r - l;
l = fs[i][j].l;
r = fs[i][j].r;
} else {
r = max(r, fs[i][j].r);
}
}
take[i] += r - l;
sc[i].push_back(Line(l, r));
}
}
void solve() {
int s = 0, r = m - row.size() - 1, c = n - cow.size() - 1;
if (r & 1) s ^= n;
if (c & 1) s ^= m;
for (map<int, int>::iterator it = row.begin(); it != row.end(); ++it) {
int rest = n - take[it->second];
s ^= rest;
}
for (map<int, int>::iterator it = cow.begin(); it != cow.end(); ++it) {
int rest = m - take[it->second];
s ^= rest;
}
if (s == 0) {
puts("SECOND");
return;
}
puts("FIRST");
for (int i = 1; i < n; ++i) {
if (cow.find(i) == cow.end()) {
if (m >= (m ^ s)) {
int t = m - (m ^ s);
printf("%d %d %d %d\n", i, 0, i, t);
return;
} else
break;
}
}
for (int i = 1; i < m; ++i) {
if (row.find(i) == row.end()) {
if (n >= (n ^ s)) {
int t = n - (n ^ s);
printf("%d %d %d %d\n", 0, i, t, i);
return;
} else
break;
}
}
for (map<int, int>::iterator it = row.begin(); it != row.end(); ++it) {
int id = it->second, rest = n - take[id];
if (rest >= (rest ^ s)) {
int t = rest - (rest ^ s);
int sum = 0, p = 0;
sc[id].push_back(Line(n, n));
for (int i = 0; i < sc[id].size(); ++i) {
if (sum + sc[id][i].l - p >= t) {
printf("%d %d %d %d\n", 0, it->first, p + t - sum, it->first);
return;
}
sum += sc[id][i].l - p;
p = sc[id][i].r;
}
}
}
for (map<int, int>::iterator it = cow.begin(); it != cow.end(); ++it) {
int id = it->second, rest = m - take[id];
if (rest >= (rest ^ s)) {
int t = rest - (rest ^ s);
int sum = 0, p = 0;
sc[id].push_back(Line(m, m));
for (int i = 0; i < sc[id].size(); ++i) {
if (sum + sc[id][i].l - p >= t) {
printf("%d %d %d %d\n", it->first, 0, it->first, p + t - sum);
return;
}
sum += sc[id][i].l - p;
p = sc[id][i].r;
}
}
}
}
int main() {
while (cin >> n >> m >> k) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int stmp;
const int MAX = 100000;
const int INF = 1000000001;
map<int, vector<pair<int, int> > > hor, ver;
int n, m, k;
int nimber(const vector<pair<int, int> > &V, int z) {
int ret = 0, s = 0, last = 0;
for (__typeof((V).begin()) it = (V).begin(); it != (V).end(); ++it) {
if (s == 0) ret += (it->first - last);
s += it->second;
last = it->first;
}
ret += (z - last);
return ret;
}
int move(int t, const vector<pair<int, int> > &V, int z) {
int ret = 0, s = 0, last = 0;
for (__typeof((V).begin()) it = (V).begin(); it != (V).end(); ++it) {
if (s == 0) ret += (it->first - last);
if (ret >= t) return it->first - (ret - t);
s += it->second;
last = it->first;
}
return last + (t - ret);
}
void solve() {
int sum = 0;
for (__typeof((ver).begin()) it = (ver).begin(); it != (ver).end(); ++it) {
sort((it->second).begin(), (it->second).end());
sum ^= nimber(it->second, m);
}
for (__typeof((hor).begin()) it = (hor).begin(); it != (hor).end(); ++it) {
sort((it->second).begin(), (it->second).end());
sum ^= nimber(it->second, n);
}
if ((n - 1 - ((int)(ver).size())) & 1) sum ^= m;
if ((m - 1 - ((int)(hor).size())) & 1) sum ^= n;
if (sum) {
printf("FIRST\n");
for (__typeof((ver).begin()) it = (ver).begin(); it != (ver).end(); ++it) {
int nb = nimber(it->second, m);
if (nb > (sum ^ nb)) {
int t = nb - (sum ^ nb);
int r = move(t, it->second, m);
printf("%d %d %d %d\n", it->first, 0, it->first, r);
return;
}
}
for (__typeof((hor).begin()) it = (hor).begin(); it != (hor).end(); ++it) {
int nb = nimber(it->second, n);
if (nb > (sum ^ nb)) {
int t = nb - (sum ^ nb);
int r = move(t, it->second, n);
printf("%d %d %d %d\n", 0, it->first, r, it->first);
return;
}
}
int w = 1;
for (; w < n && ver.count(w); ++w)
;
if (w < n && m > (sum ^ m)) {
int t = m - (sum ^ m);
printf("%d %d %d %d\n", w, 0, w, t);
return;
}
w = 1;
for (; w < m && hor.count(w); ++w)
;
if (w < m && n > (sum ^ n)) {
int t = n - (sum ^ n);
printf("%d %d %d %d\n", 0, w, t, w);
return;
}
assert(false);
} else
printf("SECOND\n");
}
int main(int argc, char *argv[]) {
stmp = scanf("%d %d %d", &n, &m, &k);
while (k--) {
int x1, x2, y1, y2;
stmp = scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
ver[x1].push_back(make_pair(min(y1, y2), -1));
ver[x1].push_back(make_pair(max(y1, y2), 1));
} else {
hor[y1].push_back(make_pair(min(x1, x2), -1));
hor[y1].push_back(make_pair(max(x1, x2), 1));
}
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, yb, ye;
bool operator<(node b) const {
return ((x < b.x) || ((x == b.x) && (yb < b.yb)));
}
} Cut[2][100000];
int CutNum[2];
class Solution {
public:
int NimSum(node Cut[], int CutNum, int n, int m) {
int ans = 0;
int tot = 0, h = 0;
while (h < CutNum) {
int sum = m, b = Cut[h].yb, e = Cut[h].ye;
while ((h + 1 < CutNum) && (Cut[h + 1].x == Cut[h].x)) {
if (Cut[h + 1].yb <= e)
e = max(Cut[++h].ye, e);
else {
sum -= e - b;
b = Cut[++h].yb;
e = Cut[h].ye;
}
}
sum -= e - b;
ans ^= sum;
tot++;
h++;
}
if (((n - tot) & 1) == 0) ans ^= m;
return ans;
}
void Print(int x, int yb, int ye, int type) {
if (type == 0)
printf("%d %d %d %d", x, yb, x, ye);
else
printf("%d %d %d %d", yb, x, ye, x);
}
bool GetCut(node Cut[], int CutNum, int n, int m, int type, int Sum) {
int ans = 0;
int tot = 0, h = 0;
int j = 1;
if (CutNum > 0) {
if (Cut[0].x > 1) {
if ((Sum ^ m) <= m) {
Print(1, 0, m - (Sum ^ m), type);
return true;
}
}
if (Cut[CutNum - 1].x < n - 1) {
if ((Sum ^ m) <= m) {
Print(n - 1, 0, m - (Sum ^ m), type);
return true;
}
}
} else if (n > 1) {
if ((Sum ^ m) <= m) {
Print(1, 0, m - (Sum ^ m), type);
return true;
}
}
while (h < CutNum) {
int sum = Cut[h].yb, b = Cut[h].yb, e = Cut[h].ye, hh = h;
if ((h > 0) && (Cut[h - 1].x + 1 < Cut[h].x)) {
if ((Sum ^ m) <= m) {
Print(Cut[h - 1].x + 1, 0, m - (Sum ^ m), type);
return true;
}
}
while ((h + 1 < CutNum) && (Cut[h + 1].x == Cut[h].x)) {
if (Cut[h + 1].yb <= e)
e = max(Cut[++h].ye, e);
else {
sum += Cut[h + 1].yb - e;
b = Cut[++h].yb;
e = Cut[h].ye;
}
}
sum += m - e;
if ((Sum ^ sum) <= sum) {
h = hh;
Sum = (sum - (Sum ^ sum));
sum = Cut[h].yb, b = Cut[h].yb, e = Cut[h].ye;
if (sum >= Sum) {
Print(Cut[h].x, 0, Sum, type);
return true;
}
if ((h > 0) && (Cut[h - 1].x + 1 < Cut[h].x)) {
Print(Cut[h - 1].x, 0, Sum, type);
return true;
}
while ((h + 1 < CutNum) && (Cut[h + 1].x == Cut[h].x)) {
if (Cut[h + 1].yb <= e)
e = max(Cut[++h].ye, e);
else {
if (sum + Cut[h + 1].yb - e >= Sum) {
Print(Cut[h].x, 0, Sum - sum + e, type);
return true;
}
sum += Cut[h + 1].yb - e;
b = Cut[++h].yb;
e = Cut[h].ye;
}
}
if (sum + m - e >= Sum) {
Print(Cut[h].x, 0, Sum - sum + e, type);
return true;
}
}
h++;
}
return false;
}
};
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
CutNum[0] = CutNum[1] = 0;
for (int i = 0; i < k; i++) {
int xb, xe, yb, ye;
scanf("%d%d%d%d", &xb, &yb, &xe, &ye);
if (xb == xe) {
Cut[0][CutNum[0]].x = xb;
Cut[0][CutNum[0]].yb = min(yb, ye);
Cut[0][CutNum[0]++].ye = max(yb, ye);
} else {
Cut[1][CutNum[1]].x = yb;
Cut[1][CutNum[1]].yb = min(xb, xe);
Cut[1][CutNum[1]++].ye = max(xb, xe);
}
}
sort(Cut[0], Cut[0] + CutNum[0]);
sort(Cut[1], Cut[1] + CutNum[1]);
Solution ans;
int result =
ans.NimSum(Cut[0], CutNum[0], n, m) ^ ans.NimSum(Cut[1], CutNum[1], m, n);
if (result == 0)
printf("SECOND\n");
else {
printf("FIRST\n");
if (!ans.GetCut(Cut[0], CutNum[0], n, m, 0, result))
ans.GetCut(Cut[1], CutNum[1], m, n, 1, result);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int cx, cy;
int res = 0;
map<int, int> mpx, mpy;
int revx[100010], revy[100010];
vector<pair<int, int> > x[100010], y[100010];
vector<pair<int, int> > poss;
int main() {
cin >> n >> m >> k;
int a, b, c, d;
for (int i = 0; i < k; i++) {
cin >> a >> b >> c >> d;
if (a == c) {
if (mpx.find(a) == mpx.end()) {
revx[cx] = a;
mpx[a] = cx++;
}
x[mpx[a]].push_back(pair<int, int>(max(b, d), -1));
x[mpx[a]].push_back(pair<int, int>(min(b, d), 1));
} else {
if (mpy.find(b) == mpy.end()) {
revy[cy] = b;
mpy[b] = cy++;
}
y[mpy[b]].push_back(pair<int, int>(max(a, c), -1));
y[mpy[b]].push_back(pair<int, int>(min(a, c), 1));
}
}
if ((n - cx - 1) % 2) {
int t = 1;
while (mpx.find(t) != mpx.end()) t++;
revx[cx] = t;
mpx[t] = cx++;
}
int res = 0;
if ((m - cy - 1) % 2) {
int t = 1;
while (mpy.find(t) != mpy.end()) t++;
revy[cy] = t;
mpy[t] = cy++;
}
for (int i = 0; i < cx; i++) {
sort(x[i].begin(), x[i].end());
int rem = m, cnt = 0;
for (int j = 0; j < x[i].size(); j++) {
if (cnt > 0) rem -= x[i][j].first - x[i][j - 1].first;
cnt += x[i][j].second;
}
poss.push_back(pair<int, int>(rem, i));
res ^= rem;
}
for (int i = 0; i < cy; i++) {
sort(y[i].begin(), y[i].end());
int rem = n, cnt = 0;
for (int j = 0; j < y[i].size(); j++) {
if (cnt > 0) rem -= y[i][j].first - y[i][j - 1].first;
cnt += y[i][j].second;
}
poss.push_back(pair<int, int>(rem, -i - 1));
res ^= rem;
}
if (res) {
cout << "FIRST" << endl;
int gd;
for (int i = 0; i < poss.size(); i++)
if ((poss[i].first ^ res) < poss[i].first) gd = i;
int idx = poss[gd].second;
vector<pair<int, int> > v;
if (idx >= 0)
v = x[idx];
else
v = y[-idx - 1];
v.push_back(pair<int, int>(max(n, m), 2));
sort(v.begin(), v.end());
int sum = v[0].first, cnt = 1;
int p = 1, nd = poss[gd].first - (poss[gd].first ^ res);
for (; sum < nd && p < v.size(); p++) {
if (cnt == 0) sum += v[p].first - v[p - 1].first;
cnt += v[p].second;
}
if (idx >= 0)
cout << revx[idx] << " 0 " << revx[idx] << ' '
<< v[p - 1].first - (sum - nd) << endl;
else
cout << "0 " << revy[-idx - 1] << ' ' << v[p - 1].first - (sum - nd)
<< ' ' << revy[-idx - 1] << endl;
} else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100010;
const int mod = 1000000007;
const double eps = 1e-8;
const double Pi = 2 * acos(0.0);
int tailx = 0, taily = 0;
int n, m, k, a, b, c, d;
int lenx[M], leny[M];
bool visx[M], visy[M];
struct node {
int no, l, r;
} xx[M], yy[M];
bool cmp(node a, node b) {
if (a.no != b.no) return a.no < b.no;
if (a.l != b.l) return a.l < b.l;
return a.r > b.r;
}
void add(int x, int loc, int l, int r) {
if (l > r) swap(l, r);
if (x == 1) {
xx[tailx].no = loc;
if (loc < M) visx[loc] = 1;
xx[tailx].l = l;
xx[tailx++].r = r;
} else {
yy[taily].no = loc;
if (loc < M) visy[loc] = 1;
yy[taily].l = l;
yy[taily++].r = r;
}
}
int find(int ctl, int loc, int need) {
node *t;
int sum = 0;
t = xx;
if (ctl == 2) t = yy;
for (int i = 0;; i++)
if (t[i].no == loc) {
int j = 0, l = 0, r = 0;
while (1) {
if (t[i + j].l - sum >= need || t[i + j].no != t[i].no)
return sum + need;
if (t[i + j].l > r) {
l = t[i + j].l;
r = t[i + j].r;
} else
r = max(r, t[i + j].r);
sum += r - l;
l = r;
j++;
}
}
}
int main() {
ios::sync_with_stdio(0);
memset(visx, 0, sizeof(visx));
memset(visy, 0, sizeof(visy));
cin >> n >> m >> k;
int ans = 0;
if (n % 2 == 0) ans ^= m;
if (m % 2 == 0) ans ^= n;
while (k--) {
cin >> a >> b >> c >> d;
if (a == c)
add(1, a, b, d);
else
add(2, b, a, c);
}
sort(xx, xx + tailx, cmp);
sort(yy, yy + taily, cmp);
for (int i = 0; i < tailx; i++) {
if (!xx[i].no || xx[i].no == n) continue;
if (!i || xx[i].no != xx[i - 1].no) {
int t = m, j = 0, l = -1, r = -1;
while (xx[i + j].no == xx[i].no && i + j < tailx) {
if (xx[i + j].l > r) {
t -= r - l;
l = xx[i + j].l;
r = xx[i + j].r;
} else
r = max(r, xx[i + j].r);
j++;
}
t -= r - l;
if (xx[i].no < M) lenx[xx[i].no] = t;
ans = ans ^ m ^ t;
i += j - 1;
}
}
for (int i = 0; i < taily; i++) {
if (!yy[i].no || yy[i].no == m) continue;
if (!i || yy[i].no != yy[i - 1].no) {
int t = n, j = 0, l = -1, r = -1;
while (yy[i + j].no == yy[i].no && i + j < taily) {
if (yy[i + j].l > r) {
t -= r - l;
l = yy[i + j].l;
r = yy[i + j].r;
} else
r = max(r, yy[i + j].r);
j++;
}
t -= r - l;
if (yy[i].no < M) leny[yy[i].no] = t;
ans = ans ^ n ^ t;
i += j - 1;
}
}
if (!ans)
cout << "SECOND" << endl;
else {
cout << "FIRST" << endl;
for (int i = 1; i < n && i < M; i++) {
int tmp = m;
if (visx[i]) tmp = lenx[i];
if ((ans ^ tmp) <= tmp) {
int need = tmp - (ans ^ tmp);
if (tmp != m) need = find(1, i, need);
cout << i << ' ' << 0 << ' ' << i << ' ' << need << endl;
return 0;
}
}
for (int i = 1; i < m && i < M; i++) {
int tmp = n;
if (visy[i]) tmp = leny[i];
if ((ans ^ tmp) <= tmp) {
int need = tmp - (ans ^ tmp);
if (tmp != n) need = find(2, i, need);
cout << 0 << ' ' << i << ' ' << need << ' ' << i << endl;
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > vcuts, hcuts;
map<int, int> vlens, hlens;
int N, M, K;
int main() {
scanf("%d %d %d", &N, &M, &K);
int sum = 0;
if ((N - 1) & 1) sum ^= M;
if ((M - 1) & 1) sum ^= N;
for (int i = 0; i < K; ++i) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
if (a == c) {
if (b > d) swap(b, d);
vcuts[a].push_back(pair<int, int>(b, 1));
vcuts[a].push_back(pair<int, int>(d, -1));
} else if (b == d) {
if (a > c) swap(a, c);
hcuts[b].push_back(pair<int, int>(a, 1));
hcuts[b].push_back(pair<int, int>(c, -1));
}
}
for (typeof((vcuts).begin()) i = (vcuts).begin(), _i = (vcuts).end(); i != _i;
++i) {
vector<pair<int, int> > &v = i->second;
sort(v.begin(), v.end());
int prv = 0, cnt = 0, len = 0;
for (typeof((v).begin()) j = (v).begin(), _j = (v).end(); j != _j; ++j) {
int cur = j->first;
if (cnt == 0) len += cur - prv;
cnt += j->second;
prv = cur;
}
len += M - prv;
vlens[i->first] = len;
sum ^= M ^ len;
}
for (typeof((hcuts).begin()) i = (hcuts).begin(), _i = (hcuts).end(); i != _i;
++i) {
vector<pair<int, int> > &v = i->second;
sort(v.begin(), v.end());
int prv = 0, cnt = 0, len = 0;
for (typeof((v).begin()) j = (v).begin(), _j = (v).end(); j != _j; ++j) {
int cur = j->first;
if (cnt == 0) len += cur - prv;
cnt += j->second;
prv = cur;
}
len += N - prv;
hlens[i->first] = len;
sum ^= N ^ len;
}
if (sum == 0) {
printf("SECOND\n");
} else {
printf("FIRST\n");
int need = 1;
while ((need << 1) <= sum) need <<= 1;
int vfree = 0, vprv = 0;
for (typeof((vlens).begin()) it = (vlens).begin(), _it = (vlens).end();
it != _it; ++it) {
int i = it->first;
if (i != vprv + 1) vfree = vprv + 1;
vprv = i;
int len = it->second;
if (len & need) {
int res = len ^ sum;
int curlen = 0, cnt = 0, prv = 0;
int ind;
if (res) {
for (typeof((vcuts[i]).begin()) j = (vcuts[i]).begin(),
_j = (vcuts[i]).end();
j != _j; ++j) {
int cur = j->first;
if (cnt == 0) {
if (curlen + cur - prv >= res)
break;
else
curlen += cur - prv;
}
cnt += j->second;
prv = cur;
}
ind = prv + res - curlen;
} else
ind = 0;
printf("%d %d %d %d\n", i, ind, i, M);
return 0;
}
}
if (vprv < N - 1) vfree = N - 1;
if (vfree) {
if (M & need) {
int res = M ^ sum;
printf("%d %d %d %d\n", vfree, res, vfree, M);
return 0;
}
}
int hfree = 0, hprv = 0;
for (typeof((hlens).begin()) it = (hlens).begin(), _it = (hlens).end();
it != _it; ++it) {
int i = it->first;
if (i != hprv + 1) hfree = hprv + 1;
int len = it->second;
if (len & need) {
int res = len ^ sum;
int curlen = 0, cnt = 0, prv = 0;
int ind;
if (res) {
for (typeof((hcuts[i]).begin()) j = (hcuts[i]).begin(),
_j = (hcuts[i]).end();
j != _j; ++j) {
int cur = j->first;
if (cnt == 0) {
if (curlen + cur - prv >= res)
break;
else
curlen += cur - prv;
}
cnt += j->second;
prv = cur;
}
ind = prv + res - curlen;
} else
ind = 0;
printf("%d %d %d %d\n", ind, i, N, i);
return 0;
}
}
if (hprv < M - 1) hfree = M - 1;
if (hfree) {
if (N & need) {
int res = N ^ sum;
printf("%d %d %d %d\n", res, hfree, N, hfree);
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int normalize(vector<pair<int, int> > &H, int N) {
sort(H.begin(), H.end());
int tocut = 0;
int lastcut = 0;
for (auto &segment : H) {
if (segment.first > lastcut) lastcut = segment.first;
if (segment.second > lastcut) {
tocut += segment.second - lastcut;
lastcut = segment.second;
}
}
return N - tocut;
}
int solve(map<int, vector<pair<int, int> > > &H, int N, int M) {
int answer = 0;
for (map<int, vector<pair<int, int> > >::iterator it = H.begin();
it != H.end(); ++it) {
int realsize = normalize(it->second, N);
answer ^= realsize;
}
if ((M - 1 - H.size()) % 2) answer ^= N;
return answer;
}
pair<int, int> remove(int left, vector<pair<int, int> > &H, int N) {
sort(H.begin(), H.end());
int lastcut = 0;
int toerase = N - left;
for (auto &segment : H) {
if (segment.first > lastcut) lastcut = segment.first;
if (segment.second > lastcut) {
if (lastcut < toerase) toerase += segment.second - lastcut;
lastcut = segment.second;
}
}
return {0, toerase};
}
bool find(map<int, vector<pair<int, int> > > &H, int N, int M, int V,
bool reverse = false) {
for (map<int, vector<pair<int, int> > >::iterator it = H.begin();
it != H.end(); ++it) {
int realsize = normalize(it->second, N);
if ((realsize xor V) <= realsize) {
auto segment = remove(realsize xor V, it->second, realsize);
if (reverse)
cout << it->first << " " << segment.first << " " << it->first << " "
<< segment.second << "\n";
else
cout << segment.first << " " << it->first << " " << segment.second
<< " " << it->first << "\n";
return true;
}
}
for (int i = 1; i < M; ++i)
if (H.find(i) == H.end()) {
if ((N xor V) <= N) {
if (reverse)
cout << i << " " << 0 << " " << i << " " << N - (N xor V) << "\n";
else
cout << 0 << " " << i << " " << N - (N xor V) << " " << i << "\n";
return true;
} else {
break;
}
}
return false;
}
int main() {
int N, M, K;
cin >> N >> M >> K;
map<int, vector<pair<int, int> > > H, V;
for (int i = 0; i < K; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
V[x1].push_back({y1, y2});
}
if (y1 == y2) {
if (x1 > x2) swap(x1, x2);
H[y1].push_back({x1, x2});
}
}
int answer = solve(H, N, M);
answer ^= solve(V, M, N);
if (answer == 0) {
cout << "SECOND\n";
} else {
cout << "FIRST\n";
if (find(H, N, M, answer)) return 0;
find(V, M, N, answer, true);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x, y, z;
} node1[100100], node[100100];
int n, m, k, ans, X1, Y1, X2, Y2;
int a, b, c, d, tmp1, tmp2, tmp;
int p, q;
bool cmp(Node a, Node b) {
if (a.x != b.x)
return a.x < b.x;
else if (a.y != b.y)
return a.y < b.y;
else
return a.z < b.z;
}
int fuck;
map<int, bool> h1, h2;
map<int, int> X, Y, x, y;
vector<int> V1, V2;
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
p = q = 0;
ans = 0;
tmp1 = n - 1;
tmp2 = m - 1;
X1 = X2 = Y1 = Y2 = 0;
h1.clear();
h2.clear();
X.clear();
Y.clear();
x.clear();
y.clear();
V1.clear();
V2.clear();
for (int i = 1; i <= k; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a == c) {
node[++p].x = a;
node[p].y = min(b, d);
node[p].z = max(b, d);
} else {
node1[++q].x = b;
node1[q].y = min(a, c);
node1[q].z = max(a, c);
}
}
sort(node + 1, node + 1 + p, cmp);
sort(node1 + 1, node1 + 1 + q, cmp);
for (int i = 1; i <= p; i++) {
if (!h1[node[i].x]) {
tmp1--;
h1[node[i].x] = 1;
V1.push_back(node[i].x);
}
if (i == 1) {
tmp = node[i].y;
fuck = node[i].z;
x[node[1].x] = 1;
} else {
if (node[i].x == node[i - 1].x) {
if (node[i].y > fuck) tmp += node[i].y - fuck;
fuck = max(fuck, node[i].z);
} else {
x[node[i].x] = i;
tmp += m - fuck;
ans ^= tmp;
X[node[i - 1].x] = tmp;
tmp = node[i].y;
fuck = node[i].z;
}
}
if (i == p) {
tmp += m - fuck;
ans ^= tmp;
X[node[p].x] = tmp;
}
}
for (int i = 1; i <= q; i++) {
if (!h2[node1[i].x]) {
tmp2--;
h2[node1[i].x] = 1;
V2.push_back(node1[i].x);
}
if (i == 1) {
tmp = node1[i].y;
y[node1[i].x] = 1;
fuck = node1[i].z;
} else {
if (node1[i].x == node1[i - 1].x) {
if (node1[i].y > fuck) tmp += node1[i].y - fuck;
fuck = max(fuck, node1[i].z);
} else {
tmp += n - fuck;
ans ^= tmp;
Y[node1[i - 1].x] = tmp;
y[node1[i].x] = i;
tmp = node1[i].y;
fuck = node1[i].z;
}
}
if (i == q) {
tmp += n - fuck;
ans ^= tmp;
Y[node1[q].x] = tmp;
}
}
if (tmp1 & 1) ans ^= m;
if (tmp2 & 1) ans ^= n;
if (tmp1 && (ans ^ m) < m) {
for (int i = 1; i < n; i++)
if (!h1[i]) {
printf("FIRST\n");
printf("%d %d %d %d\n", i, ans ^ m, i, m);
break;
}
continue;
}
if (tmp2 && (ans ^ n) < n) {
for (int i = 1; i < m; i++)
if (!h2[i]) {
printf("FIRST\n");
printf("%d %d %d %d\n", ans ^ n, i, n, i);
break;
}
continue;
}
bool fang = 0;
int xie, e;
if (ans) {
printf("FIRST\n");
for (int i = 0; i < V1.size(); i++) {
tmp = V1[i];
if ((ans ^ X[tmp]) < X[tmp]) {
xie = X[tmp] - (ans ^ X[tmp]);
e = 0;
fuck = 0;
for (int j = x[tmp];; j++) {
if (node[j].y > fuck) {
e += node[j].y - fuck;
}
fuck = max(node[j].z, fuck);
if (e >= xie) {
printf("%d %d %d %d\n", tmp, 0, tmp, node[j].y - (e - xie));
fang = 1;
break;
}
if (fang) break;
if (node1[j].x != node1[j + 1].x) {
e = X[tmp];
printf("%d %d %d %d\n", tmp, 0, tmp, m - (ans ^ X[tmp]));
fang = 1;
break;
}
if (fang) break;
}
}
if (fang) break;
}
if (fang) break;
for (int i = 1; i <= q; i++) {
tmp = V2[i];
if ((ans ^ Y[tmp]) < Y[tmp]) {
xie = Y[tmp] - (ans ^ Y[tmp]);
e = 0;
fuck = 0;
for (int j = y[tmp];; j++) {
if (node1[j].y > fuck) {
e += node1[j].y - fuck;
}
fuck = max(node1[j].z, fuck);
if (e >= xie) {
printf("%d %d %d %d\n", 0, tmp, node1[j].y - (e - xie), tmp);
fang = 1;
break;
}
if (fang) break;
if (node1[j].x != node1[j + 1].x) {
e = Y[tmp];
printf("%d %d %d %d\n", 0, tmp, n - (ans ^ Y[tmp]), tmp);
fang = 1;
break;
}
if (fang) break;
}
}
if (fang) break;
}
} else
printf("SECOND\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MAXN = (int)1e6 + 10000;
struct seg {
int len;
int x1, x2, qwertyuiopasdfghjklzxcvbnm, y2;
seg(int x1 = 0, int x2 = 0, int qwertyuiopasdfghjklzxcvbnm = 0, int y2 = 0)
: x1(x1),
x2(x2),
qwertyuiopasdfghjklzxcvbnm(qwertyuiopasdfghjklzxcvbnm),
y2(y2) {
len = abs(x1 - x2) + abs(qwertyuiopasdfghjklzxcvbnm - y2);
};
};
seg segs[MAXN];
vector<int> x;
vector<int> y;
int n, m, k;
vector<pair<int, int> > segv[MAXN];
vector<pair<int, int> > segg[MAXN];
vector<int> lens;
seg vseg, gseg;
void out(int x1, int x2, int qwertyuiopasdfghjklzxcvbnm, int y2) {
printf("%d %d %d %d\n", x1, qwertyuiopasdfghjklzxcvbnm, x2, y2);
exit(0);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
int K = k;
k = 0;
for (int i = 0; i < K; i++) {
int x1, x2, qwertyuiopasdfghjklzxcvbnm, y2;
scanf("%d %d %d %d", &x1, &qwertyuiopasdfghjklzxcvbnm, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (qwertyuiopasdfghjklzxcvbnm > y2) swap(qwertyuiopasdfghjklzxcvbnm, y2);
segs[k++] = seg(x1, x2, qwertyuiopasdfghjklzxcvbnm, y2);
x.push_back(x1);
x.push_back(x2);
y.push_back(qwertyuiopasdfghjklzxcvbnm);
y.push_back(y2);
}
sort(x.begin(), x.end());
x.resize(unique(x.begin(), x.end()) - x.begin());
sort(y.begin(), y.end());
y.resize(unique(y.begin(), y.end()) - y.begin());
for (int i = 0; i < k; i++)
if (segs[i].qwertyuiopasdfghjklzxcvbnm == segs[i].y2) {
int Y = segs[i].qwertyuiopasdfghjklzxcvbnm;
int pos = lower_bound(y.begin(), y.end(), Y) - y.begin();
segv[pos].push_back(make_pair(segs[i].x1, 0));
segv[pos].push_back(make_pair(segs[i].x2, 1));
} else {
int X = segs[i].x1;
int pos = lower_bound(x.begin(), x.end(), X) - x.begin();
segg[pos].push_back(make_pair(segs[i].qwertyuiopasdfghjklzxcvbnm, 0));
segg[pos].push_back(make_pair(segs[i].y2, 1));
}
for (int i = 0; i < ((int)(y).size()); i++) {
if (y[i] == 0 || y[i] == m) continue;
segv[i].push_back(make_pair(0, 0));
segv[i].push_back(make_pair(0, 1));
segv[i].push_back(make_pair(n, 0));
segv[i].push_back(make_pair(n, 1));
sort(segv[i].begin(), segv[i].end());
int cnt = 0;
int len = 0;
for (int j = 0; j < ((int)(segv[i]).size()) - 1; j++) {
if (!segv[i][j].second)
cnt++;
else
cnt--;
if (cnt == 0) len += segv[i][j + 1].first - segv[i][j].first;
}
if (len > 0) lens.push_back(len);
}
for (int i = 0; i < ((int)(x).size()); i++) {
if (x[i] == 0 || x[i] == n) continue;
segg[i].push_back(make_pair(0, 0));
segg[i].push_back(make_pair(0, 1));
segg[i].push_back(make_pair(m, 0));
segg[i].push_back(make_pair(m, 1));
sort(segg[i].begin(), segg[i].end());
int cnt = 0;
int len = 0;
for (int j = 0; j < ((int)(segg[i]).size()) - 1; j++) {
if (!segg[i][j].second)
cnt++;
else
cnt--;
if (cnt == 0) len += segg[i][j + 1].first - segg[i][j].first;
}
if (len > 0) lens.push_back(len);
}
vseg = seg(-1, -1, -1, -1);
int cnt = m - 1 - ((int)(y).size());
if (!y.empty() && y[0] == 0) cnt++;
if (!y.empty() && *y.rbegin() == m) cnt++;
for (int i = 1; i < MAXN && cnt % 2 == 1 && cnt > 0; i++) {
int pos = lower_bound(y.begin(), y.end(), i) - y.begin();
if (pos == ((int)(y).size()) || y[pos] != i) {
vseg = seg(0, n, i, i);
lens.push_back(n);
break;
}
}
gseg = seg(-1, -1, -1, -1);
cnt = n - 1 - ((int)(x).size());
if (!x.empty() && x[0] == 0) cnt++;
if (!x.empty() && *x.rbegin() == n) cnt++;
for (int i = 1; i < MAXN && cnt % 2 == 1 && cnt > 0; i++) {
int pos = lower_bound(x.begin(), x.end(), i) - x.begin();
if (pos == ((int)(x).size()) || x[pos] != i) {
gseg = seg(i, i, 0, m);
lens.push_back(m);
break;
}
}
int res = 0;
for (int i = 0; i < ((int)(lens).size()); i++) res ^= lens[i];
if (res == 0) {
puts("SECOND");
return 0;
} else
puts("FIRST");
int bit = 0;
for (int i = 30; i >= 0; i--)
if (res & (1 << i)) {
bit = i;
break;
}
int need = 0;
int needlen = 0;
for (int i = 0; i < ((int)(lens).size()); i++)
if (lens[i] & (1 << bit)) {
need = lens[i] - (lens[i] ^ res);
needlen = lens[i];
break;
}
int x1, x2, qwertyuiopasdfghjklzxcvbnm, y2;
for (int i = 0; i < ((int)(y).size()); i++) {
if (y[i] == 0 || y[i] == m) continue;
int cnt = 0;
int len = 0;
x1 = 0;
qwertyuiopasdfghjklzxcvbnm = y2 = y[i];
for (int j = 0; j < ((int)(segv[i]).size()) - 1; j++) {
if (!segv[i][j].second)
cnt++;
else
cnt--;
if (cnt == 0) len += segv[i][j + 1].first - segv[i][j].first;
}
if (len != needlen) continue;
len = cnt = 0;
for (int j = 0; j < ((int)(segv[i]).size()) - 1; j++) {
if (!segv[i][j].second)
cnt++;
else
cnt--;
if (cnt == 0) {
len += segv[i][j + 1].first - segv[i][j].first;
if (len >= need) {
len -= segv[i][j + 1].first - segv[i][j].first;
x2 = segv[i][j].first + (need - len);
out(x1, x2, qwertyuiopasdfghjklzxcvbnm, y2);
}
}
}
}
for (int i = 0; i < ((int)(x).size()); i++) {
if (x[i] == 0 || x[i] == n) continue;
int cnt = 0;
int len = 0;
x1 = x2 = x[i];
qwertyuiopasdfghjklzxcvbnm = 0;
for (int j = 0; j < ((int)(segg[i]).size()) - 1; j++) {
if (!segg[i][j].second)
cnt++;
else
cnt--;
if (cnt == 0) len += segg[i][j + 1].first - segg[i][j].first;
}
if (len != needlen) continue;
len = cnt = 0;
for (int j = 0; j < ((int)(segg[i]).size()) - 1; j++) {
if (!segg[i][j].second)
cnt++;
else
cnt--;
if (cnt == 0) {
len += segg[i][j + 1].first - segg[i][j].first;
if (len >= need) {
len -= segg[i][j + 1].first - segg[i][j].first;
y2 = segg[i][j].first + (need - len);
out(x1, x2, qwertyuiopasdfghjklzxcvbnm, y2);
}
}
}
}
if (vseg.x1 != -1 && needlen == vseg.len)
out(vseg.x1, vseg.x1 + need, vseg.qwertyuiopasdfghjklzxcvbnm, vseg.y2);
out(gseg.x1, gseg.x1, gseg.qwertyuiopasdfghjklzxcvbnm,
gseg.qwertyuiopasdfghjklzxcvbnm + need);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct flusher {
~flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int CLOSE = -1;
const int OPEN = 1;
const int MAXN = 100228;
struct event {
int x, t;
event(int x, int t) : x(x), t(t) {}
event() {}
};
inline bool operator<(const event &a, const event &b) { return a.x < b.x; }
struct segment {
int level, x1, x2;
segment(int level, int x1, int x2) : level(level), x1(x1), x2(x2) {}
segment() {}
};
inline bool operator<(const segment &a, const segment &b) {
return a.level < b.level;
}
int n, m, k;
vector<segment> xs, ys;
vector<event> evx[MAXN], evy[MAXN];
int rx[MAXN], ry[MAXN], lenx[MAXN], leny[MAXN];
int main() {
n = readInt(), m = readInt(), k = readInt();
for (int i = 0; i < k; i++) {
int x1 = readInt(), y1 = readInt(), x2 = readInt(), y2 = readInt();
if (x1 > x2) {
swap(x1, x2);
}
if (y1 > y2) {
swap(y1, y2);
}
if (x1 == x2) {
ys.push_back(segment(x1, y1, y2));
} else {
xs.push_back(segment(y1, x1, x2));
}
}
sort((xs).begin(), (xs).end());
sort((ys).begin(), (ys).end());
int kx = 0;
for (int i = 0; i < (int)(xs).size(); i++) {
if (i == 0 || xs[i].level != xs[i - 1].level) {
evx[kx].resize(0);
evx[kx].push_back(event(xs[i].x1, OPEN));
evx[kx].push_back(event(xs[i].x2, CLOSE));
ry[kx] = xs[i].level;
kx++;
} else {
evx[kx - 1].push_back(event(xs[i].x1, OPEN));
evx[kx - 1].push_back(event(xs[i].x2, CLOSE));
}
}
int ky = 0;
for (int i = 0; i < (int)(ys).size(); i++) {
if (i == 0 || ys[i].level != ys[i - 1].level) {
evy[ky].resize(0);
evy[ky].push_back(event(ys[i].x1, OPEN));
evy[ky].push_back(event(ys[i].x2, CLOSE));
rx[ky] = ys[i].level;
ky++;
} else {
evy[ky - 1].push_back(event(ys[i].x1, OPEN));
evy[ky - 1].push_back(event(ys[i].x2, CLOSE));
}
}
int answer = 0;
if ((m - 1 - kx) % 2 == 1) {
answer ^= n;
}
if ((n - 1 - ky) % 2 == 1) {
answer ^= m;
}
for (int i = 0; i < kx; i++) {
sort((evx[i]).begin(), (evx[i]).end());
int curk = 0;
int lastx = 0;
lenx[i] = 0;
for (int j = 0; j < (int)(evx[i]).size(); j++) {
if (curk == 0) {
lenx[i] += evx[i][j].x - lastx;
}
curk += evx[i][j].t;
lastx = evx[i][j].x;
}
lenx[i] += n - lastx;
answer ^= lenx[i];
}
for (int i = 0; i < ky; i++) {
sort((evy[i]).begin(), (evy[i]).end());
int curk = 0;
int lastx = 0;
leny[i] = 0;
for (int j = 0; j < (int)(evy[i]).size(); j++) {
if (curk == 0) {
leny[i] += evy[i][j].x - lastx;
}
curk += evy[i][j].t;
lastx = evy[i][j].x;
}
leny[i] += m - lastx;
answer ^= leny[i];
}
if (answer == 0) {
writeWord("SECOND\n");
return 0;
}
writeWord("FIRST\n");
for (int i = 0; i < kx; i++) {
int need = (answer ^ lenx[i]);
if (need <= lenx[i]) {
need = lenx[i] - need;
int curk = 0;
int lastx = 0;
int curlen = 0;
for (int j = 0; j < (int)(evx[i]).size(); j++) {
if (curk == 0) {
curlen += evx[i][j].x - lastx;
}
if (curlen >= need) {
writeInt(0, ' ');
writeInt(ry[i], ' ');
writeInt(evx[i][j].x - (curlen - need), ' ');
writeInt(ry[i], '\n');
return 0;
}
curk += evx[i][j].t;
lastx = evx[i][j].x;
}
curlen += n - lastx;
writeInt(0, ' ');
writeInt(ry[i], ' ');
writeInt(n - (curlen - need), ' ');
writeInt(ry[i], '\n');
return 0;
}
}
for (int i = 0; i < ky; i++) {
int need = (answer ^ leny[i]);
if (need <= leny[i]) {
need = leny[i] - need;
int curk = 0;
int lastx = 0;
int curlen = 0;
for (int j = 0; j < (int)(evy[i]).size(); j++) {
if (curk == 0) {
curlen += evy[i][j].x - lastx;
}
if (curlen >= need) {
writeInt(rx[i], ' ');
writeInt(0, ' ');
writeInt(rx[i], ' ');
writeInt(evy[i][j].x - (curlen - need), '\n');
return 0;
}
curk += evy[i][j].t;
lastx = evy[i][j].x;
}
curlen += m - lastx;
writeInt(rx[i], ' ');
writeInt(0, ' ');
writeInt(rx[i], ' ');
writeInt(m - (curlen - need), '\n');
return 0;
}
}
int emptyx = -1;
if (n > 1 && ky == 0) {
emptyx = 1;
}
if (ky > 0 && rx[0] != 1) {
emptyx = 1;
}
for (int i = 0; i < ky; i++) {
if (rx[i] + 1 != rx[i + 1] && rx[i] + 1 != n) {
emptyx = rx[i] + 1;
}
}
int need = (answer ^ m);
if (need <= m && emptyx != -1) {
writeInt(emptyx, ' ');
writeInt(0, ' ');
writeInt(emptyx, ' ');
writeInt(m - need, '\n');
return 0;
}
int emptyy = -1;
if (m > 1 && kx == 0) {
emptyy = 1;
}
if (kx > 0 && ry[0] != 1) {
emptyy = 1;
}
for (int i = 0; i < kx; i++) {
if (ry[i] + 1 != ry[i + 1] && ry[i] + 1 != m) {
emptyy = ry[i] + 1;
}
}
need = (answer ^ n);
if (need <= n && emptyy != -1) {
writeInt(0, ' ');
writeInt(emptyy, ' ');
writeInt(n - need, ' ');
writeInt(emptyy, '\n');
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int nn, mm;
typedef struct {
int x, s, e;
} ele;
int cmp(ele a, ele b) { return a.x < b.x || (a.x == b.x && a.s < b.s); }
vector<ele> a[2];
template <class T>
int dcdc(T s, T e, int x) {
ele l = *s;
s++;
for (; s != e; s++) {
if (l.e >= s->s) {
l.e = max(l.e, s->e);
} else {
x -= l.e - l.s;
l = *s;
}
}
return x - (l.e - l.s);
}
template <class T>
int dcdc2(T s, T e, int x, int m, int t) {
ele l = (ele){s->x, 0, 0};
int ts = 0;
for (; s != e; s++) {
if (l.e >= s->s) {
l.e = max(l.e, s->e);
} else {
ts += s->s - l.e;
if (ts >= x) {
if (t == 0)
printf("%d %d %d %d\n", l.x, 0, l.x, s->s - (ts - x));
else
printf("%d %d %d %d\n", 0, l.x, s->s - (ts - x), l.x);
return 1;
}
l = *s;
}
}
if (l.e < m) {
ts += m - l.e;
if (ts >= x) {
if (t == 0)
printf("%d %d %d %d\n", l.x, 0, l.x, m - (ts - x));
else
printf("%d %d %d %d\n", 0, l.x, m - (ts - x), l.x);
}
return 1;
}
return 0;
}
int test(int t, int tox, int m) {
int tn = (int)a[t].size();
for (int i = 0; i < tn;) {
int j = i;
for (; i < tn && a[t][i].x == a[t][j].x; i++)
;
int tt = dcdc(a[t].begin() + j, a[t].begin() + i, m);
if (tt > (tox ^ tt)) {
if (dcdc2(a[t].begin() + j, a[t].begin() + i, tt - (tox ^ tt), m, t)) {
return 1;
}
}
}
return 0;
}
void sol() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int x, y, z, w;
scanf("%d %d %d %d", &x, &y, &z, &w);
if (x == z) {
if (y > w) swap(y, w);
a[0].push_back((ele){x, y, w});
} else {
if (x > z) swap(x, z);
a[1].push_back((ele){y, x, z});
}
}
nn = n - 1;
mm = m - 1;
int txo = ((nn & 1) * m) ^ ((mm & 1) * n);
for (int t = 0; t < 2; t++) {
sort(a[t].begin(), a[t].end(), cmp);
int tn = (int)a[t].size();
for (int i = 0; i < tn;) {
int j = i;
for (; i < tn && a[t][i].x == a[t][j].x; i++)
;
txo ^= m;
nn--;
txo ^= dcdc(a[t].begin() + j, a[t].begin() + i, m);
}
swap(n, m);
swap(nn, mm);
}
if (txo == 0) {
puts("SECOND");
} else {
puts("FIRST");
if (nn && m > (txo ^ m)) {
int tn = (int)a[0].size();
int ta = 1;
for (int i = 0; i < tn; i++) {
if (ta == a[0][i].x) ta++;
}
printf("%d %d %d %d\n", ta, 0, ta, m - (txo ^ m));
} else if (mm && n > (txo ^ n)) {
int tn = (int)a[1].size();
int ta = 1;
for (int i = 0; i < tn; i++) {
if (ta == a[1][i].x) ta++;
}
printf("%d %d %d %d\n", 0, ta, n - (txo ^ n), ta);
} else {
if (test(0, txo, m) == 0) test(1, txo, n);
}
}
a[0].clear();
a[1].clear();
}
int main() {
while (1) {
sol();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void normalize(vector<pair<pair<int, int>, int> >& in,
vector<pair<int, pair<int, int> > >& out) {
if (in.size() == 0) return;
sort(in.begin(), in.end());
pair<int, int> start;
int c = 0;
for (int i = 0; i < (in.size()); ++i) {
if (c == 0) {
start = in[i].first;
}
c += in[i].second;
if (c == 0) {
out.push_back(make_pair(
start.first, pair<int, int>(start.second, in[i].first.second)));
}
}
}
int result = 0;
int was[200000];
void go(vector<pair<int, pair<int, int> > >& V, int N, int M) {
int M2 = min(200000, M);
for (int i = 0; i < (M2); ++i) was[i] = false;
int left = N;
for (int i = 0; i < (V.size()); ++i) {
if (i > 0 && V[i].first != V[i - 1].first) {
result ^= left;
--M;
left = N;
}
left -= V[i].second.second - V[i].second.first;
if (V[i].first < 200000) was[V[i].first] = true;
}
if (V.size()) {
result ^= left;
--M;
}
if (M > 0) {
result ^= N * (M & 1);
}
}
pair<int, pair<int, int> > get(vector<pair<int, pair<int, int> > >& V, int cnt,
int row) {
vector<pair<int, int> > tmp;
for (int i = 0; i < (V.size()); ++i)
if (V[i].first == row) tmp.push_back(V[i].second);
tmp.push_back(pair<int, int>(1000000010, 1000000020));
int A = cnt, B = 0;
for (int i = 0; i < (tmp.size()); ++i) {
if (B + A <= tmp[i].first)
return make_pair(row, pair<int, int>(0, B + A));
else {
A -= (tmp[i].first - B);
B = tmp[i].second;
}
}
throw ":/";
return make_pair(0, pair<int, int>(0, 0));
}
pair<int, pair<int, int> > get2(vector<pair<int, pair<int, int> > >& V, int N,
int M, int cnt) {
int K = 1 << 30;
while (!(K & cnt)) K >>= 1;
int M2 = min(200000, M);
for (int i = 0; i < (M2); ++i) was[i] = false;
int left = N;
for (int i = 0; i < (V.size()); ++i) {
if (i > 0 && V[i].first != V[i - 1].first) {
if (left & K) return get(V, left - (cnt ^ left), V[i - 1].first);
--M;
left = N;
}
left -= V[i].second.second - V[i].second.first;
if (V[i].first < 200000) was[V[i].first] = true;
}
if (V.size()) {
--M;
if (left & K) return get(V, left - (cnt ^ left), V[V.size() - 1].first);
}
if (M > 0) {
if (N & K) {
for (int i = 0; i < (M2); ++i)
if (!was[i]) return get(V, N - (cnt ^ N), i);
}
}
return make_pair(-1, pair<int, int>(-1, -1));
}
vector<pair<pair<int, int>, int> > H, V;
vector<pair<int, pair<int, int> > > H2, V2;
int main() {
int N, M, K;
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < (K); ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (y2 < y1) swap(y1, y2);
if (x2 < x1) swap(x1, x2);
if (x1 == x2) {
V.push_back(make_pair(pair<int, int>(x1 - 1, y1), -1));
V.push_back(make_pair(pair<int, int>(x2 - 1, y2), 1));
} else {
H.push_back(make_pair(pair<int, int>(y1 - 1, x1), -1));
H.push_back(make_pair(pair<int, int>(y2 - 1, x2), 1));
}
}
normalize(H, H2);
normalize(V, V2);
result = 0;
go(H2, N, M - 1);
go(V2, M, N - 1);
if (result == 0) {
printf("SECOND\n");
} else {
printf("FIRST\n");
pair<int, pair<int, int> > res = get2(H2, N, M - 1, result);
if (res.first >= 0) {
printf("%d %d %d %d\n", res.second.first, res.first + 1,
res.second.second, res.first + 1);
} else {
res = get2(V2, M, N - 1, result);
printf("%d %d %d %d\n", res.first + 1, res.second.first, res.first + 1,
res.second.second);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int vc = 1, hc = 1, inv[100010], inh[100010];
map<int, int> vch, hch;
vector<pair<int, int> > V[100010], H[100010];
void input() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a > c) swap(a, c);
if (b > d) swap(b, d);
if (a == c) {
if (a == 0 || a == n) continue;
if (vch[a] == 0) vch[a] = vc++;
int x = vch[a] - 1;
inv[x] = a;
V[x].push_back(make_pair(b, d));
}
if (b == d) {
if (b == 0 || b == m) continue;
if (hch[b] == 0) hch[b] = hc++;
int x = hch[b] - 1;
inh[x] = b;
H[x].push_back(make_pair(a, c));
}
}
vc--, hc--;
}
int cnt[4 * 100010], c = 0;
void solve(vector<pair<int, int> > v, int x) {
sort(v.begin(), v.end());
int prv = 0;
cnt[c] = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
int l = it->first, r = it->second;
if (l > prv) cnt[c] += l - prv;
prv = max(prv, r);
}
if (x > prv) cnt[c] += x - prv;
c++;
}
int final(vector<pair<int, int> > v, int val) {
sort(v.begin(), v.end());
int prv = 0, sum = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
int l = it->first, r = it->second;
if (l > prv) {
if (sum + l - prv >= val) return prv + val - sum;
sum += l - prv;
}
prv = max(prv, r);
}
return prv + val - sum;
}
void calcu() {
for (int i = 0; i < vc; i++) solve(V[i], m);
for (int i = 0; i < hc; i++) solve(H[i], n);
if ((n - vc - 1) & 1) cnt[c] = m;
c++;
if ((m - hc - 1) & 1) cnt[c] = n;
c++;
int ans = 0;
for (int i = 0; i < c; i++) ans ^= cnt[i];
if (ans == 0) {
puts("SECOND");
return;
}
puts("FIRST");
for (int i = 0; i < vc; i++) {
if ((cnt[i] ^ ans) <= cnt[i]) {
printf("%d 0 %d %d\n", inv[i], inv[i],
final(V[i], cnt[i] - (cnt[i] ^ ans)));
return;
}
}
for (int i = vc; i < vc + hc; i++) {
if ((cnt[i] ^ ans) <= cnt[i]) {
printf("0 %d %d %d\n", inh[i - vc],
final(H[i - vc], cnt[i] - (cnt[i] ^ ans)), inh[i - vc]);
return;
}
}
if ((cnt[vc + hc] ^ ans) <= cnt[vc + hc]) {
set<int> che;
for (int i = 0; i < vc; i++) che.insert(inv[i]);
for (int i = 1; i <= n; i++) {
if (!che.count(i)) {
printf("%d 0 %d %d\n", i, i, cnt[vc + hc] - (cnt[vc + hc] ^ ans));
return;
}
}
}
if ((cnt[vc + hc + 1] ^ ans) <= cnt[vc + hc + 1]) {
set<int> che;
for (int i = 0; i < hc; i++) che.insert(inh[i]);
for (int i = 1; i <= m; i++)
if (!che.count(i)) {
printf("0 %d %d %d\n", i, cnt[vc + hc + 1] - (cnt[vc + hc + 1] ^ ans),
i);
return;
}
}
}
int main() {
input();
calcu();
}
|
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
map<long long, set<pair<long long, long long>>> horizont, vertical;
map<long long, long long> culled_h, culled_v;
void run() {
long long n, m, cuts;
cin >> n >> m >> cuts;
for (int k = cuts; k--;) {
long long x0, y0, x1, y1;
cin >> x0 >> y0 >> x1 >> y1;
if (x0 > x1 or y0 > y1) swap(x0, x1), swap(y0, y1);
if (x0 == x1 and y0 == y1 or x0 != x1 and y0 != y1) continue;
if (x0 == x1) {
vertical[x0].insert({y0, y1});
} else {
horizont[y0].insert({x0, x1});
}
}
long long game = 0;
if (n % 2 == 0) game ^= m;
if (m % 2 == 0) game ^= n;
for (auto i : horizont) {
long long left = 0, x = 0;
for (auto j : i.second) {
left += max(0ll, j.first - x);
x = max(x, j.second);
}
left += max(0ll, n - x);
culled_h[i.first] = n - left;
game ^= (n ^ left);
}
for (auto i : vertical) {
long long left = 0, y = 0;
for (auto j : i.second) {
left += max(0ll, j.first - y);
y = max(y, j.second);
}
left += max(0ll, m - y);
culled_v[i.first] = m - left;
game ^= (m ^ left);
}
cout << (game ? "FIRST" : "SECOND") << endl;
if (game) {
long long x0 = 0, y0 = 0, x1 = 0, y1 = 0;
set<int> possi;
for (auto const& i : horizont) possi.insert(i.first);
for (auto const& i : vertical) possi.insert(i.first);
for (int i = 1; i <= cuts + 10; i++) possi.insert(i);
for (int i : possi) {
if (not game) break;
if (game and i < m and (game ^ (n - culled_h[i])) < (n - culled_h[i])) {
long long need = (n - culled_h[i]) - (game ^ (n - culled_h[i]));
y0 = y1 = i;
horizont[i].insert(make_pair(n, n));
long long left = 0, x = 0;
for (auto j : horizont[i]) {
left += max(0ll, j.first - x);
x = max(x, j.second);
if (left >= need) {
x1 = j.first - (left - need);
game = 0;
break;
}
}
assert(not game);
}
if (game and i < n and (game ^ (m - culled_v[i])) < (m - culled_v[i])) {
long long need = (m - culled_v[i]) - (game ^ (m - culled_v[i]));
x0 = x1 = i;
vertical[i].insert(make_pair(m, m));
long long left = 0, y = 0;
for (auto j : vertical[i]) {
left += max(0ll, j.first - y);
y = max(y, j.second);
if (left >= need) {
y1 = j.first - (left - need);
game = 0;
break;
}
}
assert(not game);
}
}
cout << x0 << " " << y0 << " " << x1 << " " << y1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long l, r, pos;
};
vector<node> A, B;
long long need, summ, delta, sul, N, M, K, i, j, xx1, xx2, yy1, yy2;
long long lastt, ans, ll, rr, start, last, lena, lenb, t;
vector<pair<long long, long long> > d[1000000], db[1000000], D[1000000],
DB[1000000];
map<long long, long long> MA, MB;
long long SUMM[1000000], SUMMB[1000000], X[1000000], Y[1000000], SUMA[1000000],
SUMB[1000000];
bool cmp(pair<long long, long long> X, pair<long long, long long> Y) {
return (X.first < Y.first);
}
long long ans1;
int main() {
scanf("%I64d %I64d %I64d", &N, &M, &K);
for (i = 1; i <= K; i++) {
scanf("%I64d %I64d %I64d %I64d", &xx1, &yy1, &xx2, &yy2);
if (xx1 == xx2)
A.push_back((node){yy1, yy2, xx1});
else
B.push_back((node){xx1, xx2, yy1});
}
for (i = 0; i < A.size(); i++) {
if (A[i].l > A[i].r) swap(A[i].l, A[i].r);
if (!MA[A[i].pos]) {
lena++;
X[lena] = A[i].pos;
MA[A[i].pos] = lena;
d[lena].push_back(make_pair(A[i].l, A[i].r));
} else {
d[MA[A[i].pos]].push_back(make_pair(A[i].l, A[i].r));
}
}
for (i = 1; i <= lena; i++) {
sort(d[i].begin(), d[i].end(), cmp);
start = 0;
last = 0;
lastt = 0;
for (j = 0; j < d[i].size(); j++) {
ll = d[i][j].first;
rr = d[i][j].second;
if (ll > last) {
D[i].push_back(make_pair(last, ll));
SUMA[i] += ll - last;
start = ll;
last = rr;
} else {
last = max(last, rr);
}
}
if (M > last) {
D[i].push_back(make_pair(last, M));
SUMA[i] += M - last;
}
}
t = (N - 1 - lena + 4) % 2;
if (t) ans ^= M;
for (i = 0; i < B.size(); i++) {
if (B[i].l > B[i].r) swap(B[i].l, B[i].r);
if (!MB[B[i].pos]) {
lenb++;
Y[lenb] = B[i].pos;
MB[B[i].pos] = lenb;
db[lenb].push_back(make_pair(B[i].l, B[i].r));
} else {
db[MB[B[i].pos]].push_back(make_pair(B[i].l, B[i].r));
}
}
for (i = 1; i <= lenb; i++) {
sort(db[i].begin(), db[i].end(), cmp);
start = 0;
last = 0;
lastt = 0;
for (j = 0; j < db[i].size(); j++) {
ll = db[i][j].first;
rr = db[i][j].second;
if (ll > last) {
DB[i].push_back(make_pair(last, ll));
SUMB[i] += ll - last;
start = ll;
last = rr;
} else {
last = max(last, rr);
}
}
if (N > last) {
DB[i].push_back(make_pair(last, N));
SUMB[i] += N - last;
}
}
t = (M - 1 - lenb + 4) % 2;
if (t) ans ^= N;
for (i = 1; i <= lena; i++) {
summ = 0;
for (j = 0; j < D[i].size(); j++) summ += D[i][j].second - D[i][j].first;
ans ^= summ;
SUMM[i] = summ;
}
for (i = 1; i <= lenb; i++) {
summ = 0;
for (j = 0; j < DB[i].size(); j++) summ += DB[i][j].second - DB[i][j].first;
ans ^= summ;
SUMMB[i] = summ;
}
if (ans == 0) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
for (i = 1; i <= lena; i++)
if ((SUMM[i] ^ ans) <= SUMM[i]) {
sul = 0;
need = SUMM[i] - (SUMM[i] ^ ans);
for (j = 0; j < D[i].size(); j++) {
sul += D[i][j].second - D[i][j].first;
if (sul >= need)
if ((D[i][j].second - (sul - need)) > 0 &&
D[i][j].second - (sul - need) <= M) {
cout << X[i] << " " << 0 << " " << X[i] << " "
<< D[i][j].second - (sul - need) << endl;
return 0;
} else
break;
}
}
for (i = 1; i <= lenb; i++)
if ((SUMMB[i] ^ ans) <= SUMMB[i]) {
sul = 0;
need = SUMMB[i] - (SUMMB[i] ^ ans);
for (j = 0; j < DB[i].size(); j++) {
sul += DB[i][j].second - DB[i][j].first;
if (sul >= need)
if ((DB[i][j].second - (sul - need)) > 0 &&
DB[i][j].second - (sul - need) <= N) {
cout << 0 << " " << Y[i] << " " << DB[i][j].second - (sul - need)
<< " " << Y[i] << endl;
return 0;
} else
break;
}
}
for (i = 1; i <= lenb; i++)
if (!MB[Y[i] - 1] && Y[i] - 1 >= 1 && ((M - 1 - lenb + 4) % 2))
if ((ans ^ N) < N) {
cout << 0 << " " << Y[i] - 1 << " " << N - (ans ^ N) << " " << Y[i] - 1
<< endl;
return 0;
}
for (i = 1; i <= lenb; i++)
if (!MB[Y[i] + 1] && Y[i] + 1 < N && ((M - 1 - lenb + 4) % 2))
if ((ans ^ N) < N) {
cout << 0 << " " << Y[i] + 1 << " " << N - (ans ^ N) << " " << Y[i] + 1
<< endl;
return 0;
}
for (i = 1; i <= lena; i++)
if (!MA[X[i] - 1] && X[i] - 1 >= 1 && ((N - 1 - lena + 4) % 2))
if ((ans ^ M) < M) {
cout << X[i] - 1 << " " << 0 << " " << X[i] - 1 << " " << M - (M ^ ans)
<< endl;
return 0;
}
for (i = 1; i <= lena; i++)
if (!MA[X[i] + 1] && X[i] + 1 < M && ((N - 1 - lena + 4) % 2))
if ((ans ^ M) < M) {
cout << X[i] + 1 << " " << 0 << " " << X[i] + 1 << " " << M - (M ^ ans)
<< endl;
return 0;
}
if (lena == 0 && (M - (M ^ ans)) > 0) {
cout << 1 << " " << 0 << " " << 1 << " " << M - (M ^ ans) << endl;
return 0;
}
if (lenb == 0 && ((N - (N ^ ans)) > 0)) {
cout << 0 << " " << 1 << " " << N - (N ^ ans) << " " << 1 << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool Up(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool Down(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline int getus() {
int tmp, c;
while (tmp = fgetc(stdin), tmp < '0' || tmp > '9')
;
tmp -= '0';
while (c = fgetc(stdin), '0' <= c && c <= '9') tmp = tmp * 10 + c - '0';
return tmp;
}
inline int getint() {
int tmp, c, flag;
while (flag = fgetc(stdin), flag != '-' && (flag < '0' || flag > '9'))
;
if (flag == '-')
tmp = 0;
else
tmp = flag - '0';
while (c = fgetc(stdin), '0' <= c && c <= '9') tmp = tmp * 10 + c - '0';
return flag == '-' ? -tmp : tmp;
}
struct Seg {
int i, l, r;
Seg() : i(0), l(0), r(0) {}
Seg(int i, int l, int r) : i(i), l(l), r(r) {}
bool operator<(const Seg &rhs) const {
if (i != rhs.i) return i < rhs.i;
if (l != rhs.l) return l < rhs.l;
return r < rhs.r;
}
};
int N, M, sgSum = 0;
int ansI = -1, ansL = -1, ansR = -1;
vector<Seg> v, h;
set<int> hs, vs;
vector<Seg> change(vector<Seg> v, int tot) {
vector<Seg> ans(0);
int N = v.size();
sort(v.begin(), v.end());
for (int l = 0, r; l < N; l = r) {
int rest = tot, left = v[l].l, right = v[l].r;
for (r = l + 1; r < N && v[l].i == v[r].i; ++r) {
if (left <= v[r].l && v[r].l <= right)
Up(right, v[r].r);
else {
ans.push_back(Seg(v[l].i, left, right));
rest -= right - left;
left = v[r].l;
right = v[r].r;
}
}
ans.push_back(Seg(v[l].i, left, right));
rest -= right - left;
sgSum ^= rest;
}
return ans;
}
bool FindStep(vector<Seg> &v, int tot) {
int N = v.size();
for (int l = 0, r; l < N; l = r) {
int rest = tot;
for (r = l; r < N && v[l].i == v[r].i; ++r) rest -= v[r].r - v[r].l;
if (rest < (sgSum ^ rest)) continue;
vector<pair<int, int> > vp;
for (int i = (l); i < (r); ++i)
vp.push_back(pair<int, int>(v[i].l, v[i].r));
vp.push_back(pair<int, int>(tot, tot));
int lastPoint = 0, size = vp.size();
sgSum = rest - (sgSum ^ rest);
for (int i = (0); i < (size); ++i) {
int len = vp[i].first - lastPoint;
if (sgSum > len) {
sgSum -= len;
lastPoint = vp[i].second;
} else {
ansI = v[l].i;
ansL = 0;
ansR = lastPoint + sgSum;
return true;
}
}
}
return false;
}
int findMex(const set<int> &t) {
int i = 1;
for (set<int>::const_iterator itr = t.begin(); itr != t.end() && *itr == i;
++itr, ++i)
;
return i;
}
int main() {
int K, x0, y0, x1, y1;
scanf("%d %d %d", &N, &M, &K);
while (K--) {
scanf("%d %d %d %d", &x0, &y0, &x1, &y1);
if (x0 > x1) swap(x0, x1);
if (y0 > y1) swap(y0, y1);
if (y0 == y1) {
h.push_back(Seg(y0, x0, x1));
hs.insert(y0);
}
if (x0 == x1) {
v.push_back(Seg(x0, y0, y1));
vs.insert(x0);
}
}
if ((M - 1 - int(hs.size())) & 1) sgSum ^= N;
if ((N - 1 - int(vs.size())) & 1) sgSum ^= M;
h = change(h, N);
v = change(v, M);
if (sgSum == 0) {
puts("SECOND");
return 0;
}
puts("FIRST");
if ((M - 1 - int(hs.size())) > 0 && (sgSum ^ N) <= N) {
int y = findMex(hs);
printf("0 %d %d %d\n", y, N - (sgSum ^ N), y);
return 0;
}
if ((N - 1 - int(vs.size())) > 0 && (sgSum ^ M) <= M) {
int x = findMex(vs);
printf("%d 0 %d %d\n", x, x, M - (sgSum ^ M));
return 0;
}
if (FindStep(h, N)) {
printf("%d %d %d %d\n", ansL, ansI, ansR, ansI);
return 0;
}
if (FindStep(v, M)) {
printf("%d %d %d %d\n", ansI, ansL, ansI, ansR);
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct Node {
int l, r;
Node() {}
Node(int _l, int _r) : l(_l), r(_r) {}
bool operator<(const Node n) const { return l != n.l ? l < n.l : r < n.r; }
};
vector<Node> a[100005], b[100005];
int use[100005];
int n, m, k, cnt = 0;
map<int, int> row, col;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
if (col.find(x1) == col.end()) {
col[x1] = cnt++;
a[cnt - 1].push_back(Node(y1, y2));
} else {
a[col[x1]].push_back(Node(y1, y2));
}
} else {
if (x1 > x2) swap(x1, x2);
if (row.find(y1) == row.end()) {
row[y1] = cnt++;
a[cnt - 1].push_back(Node(x1, x2));
} else {
a[row[y1]].push_back(Node(x1, x2));
}
}
}
for (int i = 0; i < cnt; i++) {
sort(a[i].begin(), a[i].end());
int l = a[i][0].l, r = a[i][0].r;
for (int j = 1; j < a[i].size(); j++) {
if (a[i][j].l > r) {
b[i].push_back(Node(l, r));
use[i] += r - l;
l = a[i][j].l;
r = a[i][j].r;
} else {
r = max(r, a[i][j].r);
}
}
use[i] += r - l;
b[i].push_back(Node(l, r));
}
int ans = 0;
int r = m - 1 - row.size(), c = n - 1 - col.size();
if (r & 1) ans ^= n;
if (c & 1) ans ^= m;
for (map<int, int>::iterator it = row.begin(); it != row.end(); it++) {
int remain = n - use[it->second];
ans ^= remain;
}
for (map<int, int>::iterator it = col.begin(); it != col.end(); it++) {
int remain = m - use[it->second];
ans ^= remain;
}
if (ans == 0)
puts("SECOND");
else {
puts("FIRST");
for (int i = 1; i < n; i++) {
int remain;
if (col.find(i) == col.end()) {
remain = m;
if (remain >= (remain ^ ans)) {
int t = remain - (remain ^ ans);
printf("%d %d %d %d\n", i, 0, i, t);
return 0;
} else
break;
}
}
for (int i = 1; i < m; i++) {
int remain;
if (row.find(i) == row.end()) {
remain = n;
if (remain >= (remain ^ ans)) {
int t = remain - (remain ^ ans);
printf("%d %d %d %d\n", 0, i, t, i);
return 0;
} else
break;
}
}
for (map<int, int>::iterator it = row.begin(); it != row.end(); it++) {
int i = it->second, remain = n - use[i];
if (remain >= (remain ^ ans)) {
int t = remain - (remain ^ ans);
int sum = 0, pre = 0;
b[i].push_back(Node(n, n));
for (int j = 0; j < b[i].size(); j++) {
if (sum + b[i][j].l - pre >= t) {
printf("%d %d %d %d\n", 0, it->first, pre + t - sum, it->first);
break;
}
sum += b[i][j].l - pre;
pre = b[i][j].r;
}
return 0;
}
}
for (map<int, int>::iterator it = col.begin(); it != col.end(); it++) {
int i = it->second, remain = m - use[i];
if (remain >= (remain ^ ans)) {
int t = remain - (remain ^ ans);
int sum = 0, pre = 0;
b[i].push_back(Node(m, m));
for (int j = 0; j < b[i].size(); j++) {
if (sum + b[i][j].l - pre >= t) {
printf("%d %d %d %d\n", it->first, 0, it->first, pre + t - sum);
break;
}
sum += b[i][j].l - pre;
pre = b[i][j].r;
}
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class... S>
void dbs(string str, T t, S... s) {
int idx = str.find(',');
cout << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
using namespace std;
void manage(vector<pair<int, int> >& ranges) {
if (ranges.empty()) {
return;
}
vector<pair<int, int> > ret;
sort(ranges.begin(), ranges.end());
int curL = ranges[0].first, curR = ranges[0].second;
for (int i = 1; i < ranges.size(); i++) {
pair<int, int> now = ranges[i];
if (curR >= now.first) {
curR = max(now.second, curR);
} else {
ret.push_back({curL, curR});
curL = ranges[i].first, curR = ranges[i].second;
}
}
ret.push_back({curL, curR});
ranges = ret;
}
vector<vector<pair<int, int> > > intV, intH;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, M, K;
cin >> N >> M >> K;
set<int> huhx, huhy;
vector<pair<int, pair<int, int> > > cutV, cutH;
for (int i = 0; i < K; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 < x2) cutV.push_back({y1, {x1, x2}}), huhy.insert(y1);
if (y1 < y2) cutH.push_back({x1, {y1, y2}}), huhx.insert(x1);
}
map<int, int> compx, compy, icx, icy;
int cnt = 0;
for (int i : huhx) {
compx[i] = cnt;
icx[cnt] = i;
cnt++;
}
intH.resize(cnt);
cnt = 0;
for (int i : huhy) {
compy[i] = cnt;
icy[cnt] = i;
cnt++;
}
intV.resize(cnt);
for (auto u : cutV) {
intV[compy[u.first]].push_back(u.second);
}
for (auto u : cutH) {
intH[compx[u.first]].push_back(u.second);
}
for (auto& u : intV) {
manage(u);
}
for (auto& u : intH) {
manage(u);
}
int gr = 0;
if ((N - huhx.size()) % 2 == 0) {
gr ^= M;
}
if ((M - huhy.size()) % 2 == 0) {
gr ^= N;
}
vector<int> fucx, fucy;
for (int i = 0; i < intH.size(); i++) {
int xc = icx[i];
int lc = 0;
int xx = 0;
for (auto u : intH[i]) {
if (lc < u.first) {
xx += u.first - lc;
}
lc = u.second;
}
if (lc < M) {
xx += M - lc;
}
fucx.push_back(xx);
gr ^= xx;
}
for (int i = 0; i < intV.size(); i++) {
int yc = icy[i];
int lc = 0;
int xx = 0;
for (auto u : intV[i]) {
if (lc < u.first) {
xx += u.first - lc;
}
lc = u.second;
}
if (lc < N) {
xx += N - lc;
}
fucy.push_back(xx);
gr ^= xx;
}
int vx = -1;
for (int i = 1; i < N; i++) {
if (huhx.find(i) == huhx.end()) {
vx = i;
break;
}
}
int vy = -1;
for (int i = 1; i < M; i++) {
if (huhy.find(i) == huhy.end()) {
vy = i;
break;
}
}
vector<pair<int, pair<int, int> > > horz, verts;
if (vx != -1) {
horz.push_back({vx, {0, M}});
}
if (vy != -1) {
verts.push_back({vy, {0, N}});
}
if (gr == 0) {
cout << "SECOND";
} else {
cout << "FIRST\n";
if (verts.size() && (N ^ gr) < N) {
cout << 0 << ' ' << vy << ' ' << N - (N ^ gr) << ' ' << vy << endl;
return 0;
}
if (horz.size() && (M ^ gr) < M) {
cout << vx << ' ' << 0 << ' ' << vx << ' ' << M - (M ^ gr) << endl;
return 0;
}
for (int i = 0; i < huhx.size(); i++) {
if ((fucx[i] ^ gr) > fucx[i]) {
continue;
}
int xx = icx[i];
int req = fucx[i] - (fucx[i] ^ gr);
int st = 0, del = 0;
intH[i].push_back({M, M});
for (int j = 0; j < intH[i].size(); j++) {
if (st - del >= req) {
st = del + req;
break;
}
st = intH[i][j].first;
if (j) {
del += intH[i][j - 1].second - intH[i][j - 1].first;
}
}
if (st - del >= req) {
st = del + req;
}
cout << xx << ' ' << 0 << ' ' << xx << ' ' << st << endl;
return 0;
;
}
for (int i = 0; i < huhy.size(); i++) {
if ((fucy[i] ^ gr) > fucy[i]) {
continue;
}
int xx = icy[i];
int req = fucy[i] - (fucy[i] ^ gr);
int st = 0, del = 0;
intV[i].push_back({N, N});
for (int j = 0; j < intV[i].size(); j++) {
if (st - del >= req) {
st = del + req;
break;
}
st = intV[i][j].first;
if (j) {
del += intV[i][j - 1].second - intV[i][j - 1].first;
}
}
if (st - del >= req) {
st = del + req;
}
cout << 0 << ' ' << xx << ' ' << st << ' ' << xx << endl;
return 0;
;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ta, tb, sa, sb, now, ans;
pair<pair<int, int>, pair<int, int> > x[100005], y[100005], t;
void WORK() {
int p = -1;
now = 0;
if (ta == 0 || x[0].first.first != 1) p = 1;
if (x[ta - 1].first.first != n - 1) p = n - 1;
for (int i = 1; i <= ta; i++)
if (x[i].first.first != x[i - 1].first.first) {
if (x[i].first.first != x[i - 1].first.first + 1) {
p = x[i - 1].first.first + 1;
break;
}
int tmp = 0, sum = 0;
for (int j = now; j < i; j++)
if (tmp <= x[j].first.second) {
tmp = x[j].second.second;
sum += x[j].second.second - x[j].first.second;
} else if (tmp < x[j].second.second) {
sum += x[j].second.second - tmp;
tmp = x[j].second.second;
}
int T = ans ^ (m - sum);
tmp = 0;
int pre = 0;
if (m - sum < T) {
now = i;
continue;
}
for (int j = now; j < i; j++)
if (tmp <= x[j].first.second) {
if (x[j].first.second - tmp + pre >= m - sum - T) {
printf("%d %d %d %d\n", x[j].first.first, 0, x[j].first.first,
tmp + m - sum - T - pre);
return;
}
pre += x[j].first.second - tmp;
tmp = x[j].second.second;
} else if (tmp < x[j].second.second)
tmp = x[j].second.second;
if (m - tmp + pre >= m - sum - T) {
printf("%d %d %d %d\n", x[now].first.first, 0, x[now].first.first,
tmp + m - sum - T - pre);
return;
}
now = i;
}
if (p != -1 && m > (ans ^ m)) {
printf("%d %d %d %d\n", p, 0, p, m - (ans ^ m));
return;
}
p = -1;
now = 0;
if (tb == 0 || y[0].first.first != 1) p = 1;
if (y[tb - 1].first.first != m - 1) p = m - 1;
for (int i = 1; i <= tb; i++)
if (y[i].first.first != y[i - 1].first.first) {
if (y[i].first.first != y[i - 1].first.first + 1) {
p = y[i - 1].first.first + 1;
break;
}
int tmp = 0, sum = 0;
for (int j = now; j < i; j++)
if (tmp <= y[j].first.second) {
tmp = y[j].second.second;
sum += y[j].second.second - y[j].first.second;
} else if (tmp < y[j].second.second) {
sum += y[j].second.second - tmp;
tmp = y[j].second.second;
}
int T = ans ^ (n - sum);
tmp = 0;
int pre = 0;
if (n - sum < T) {
now = i;
continue;
}
for (int j = now; j < i; j++)
if (tmp <= y[j].first.second) {
if (y[j].first.second - tmp + pre >= n - sum - T) {
printf("%d %d %d %d\n", 0, y[j].first.first,
tmp + n - sum - T - pre, y[j].first.first);
return;
}
pre += y[j].first.second - tmp;
tmp = y[j].second.second;
} else if (tmp < y[j].second.second)
tmp = y[j].second.second;
if (n - tmp + pre >= n - sum - T) {
printf("%d %d %d %d\n", 0, y[now].first.first, tmp + n - sum - T - pre,
y[now].first.first);
return;
}
now = i;
}
printf("%d %d %d %d\n", 0, p, n - (ans ^ n), p);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
scanf("%d%d%d%d", &t.first.first, &t.first.second, &t.second.first,
&t.second.second);
if (t.first.first == t.second.first && t.first.second > t.second.second)
swap(t.first, t.second);
if (t.first.second == t.second.second && t.first.first > t.second.first)
swap(t.first, t.second);
if (t.first.first == t.second.first) x[ta++] = t;
if (t.first.second == t.second.second) {
swap(t.first.second, t.first.first);
swap(t.second.second, t.second.first);
y[tb++] = t;
}
}
ans = 0;
sort(x, x + ta);
x[ta].first.first = x[ta - 1].first.first + 1;
now = 0;
sa = 0;
for (int i = 1; i <= ta; i++)
if (x[i].first.first != x[i - 1].first.first) {
sa++;
int tmp = 0, sum = 0;
for (int j = now; j < i; j++)
if (tmp <= x[j].first.second) {
tmp = x[j].second.second;
sum += x[j].second.second - x[j].first.second;
} else if (tmp < x[j].second.second) {
sum += x[j].second.second - tmp;
tmp = x[j].second.second;
}
ans ^= (m - sum);
now = i;
}
if ((n - sa - 1) & 1) ans ^= m;
sort(y, y + tb);
y[tb].first.first = y[tb - 1].first.first + 1;
now = 0;
sb = 0;
for (int i = 1; i <= tb; i++)
if (y[i].first.first != y[i - 1].first.first) {
sb++;
int tmp = 0, sum = 0;
for (int j = now; j < i; j++)
if (tmp <= y[j].first.second) {
tmp = y[j].second.second;
sum += y[j].second.second - y[j].first.second;
} else if (tmp < y[j].second.second) {
sum += y[j].second.second - tmp;
tmp = y[j].second.second;
}
ans ^= (n - sum);
now = i;
}
if ((m - sb - 1) & 1) ans ^= n;
if (ans) {
printf("FIRST\n");
WORK();
} else
printf("SECOND\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
vector<pair<int, int> > BUFF[200100];
int bpos = 0;
int Val[200200];
int who[200200];
int key[200200];
int pos = 0;
void proc(map<int, vector<pair<int, int> > *> &mp, int cnt, int id) {
for (map<int, vector<pair<int, int> > *>::iterator it = mp.begin();
it != mp.end(); ++it) {
(it->second)->push_back(pair<int, int>(cnt, cnt));
int last = 0;
vector<pair<int, int> > &vec = *(it->second);
sort((vec).begin(), (vec).end());
int curr = 0;
for (int i = (0), ei = (vec.size()); i < ei; i++) {
pair<int, int> p = vec[i];
if (p.first > last) {
curr += p.first - last;
}
last = max(last, p.second);
}
Val[pos] = curr;
who[pos] = id;
key[pos] = it->first;
pos++;
}
}
int findAns(map<int, vector<pair<int, int> > *> &mp, int win, int need) {
int ans = -1;
int last = 0;
vector<pair<int, int> > &vec = *mp[key[win]];
int has = 0;
for (int i = (0), ei = (vec.size()); i < ei; i++) {
pair<int, int> p = vec[i];
if (p.first > last) {
int currLen = has + p.first - last;
if (currLen >= need) {
ans = last + (need - has);
break;
}
has = currLen;
}
last = max(last, p.second);
}
return ans;
}
void run() {
map<int, vector<pair<int, int> > *> hor;
map<int, vector<pair<int, int> > *> ver;
int n, m, k;
cin >> n >> m >> k;
for (int i = (0), ei = (k); i < ei; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
if (x1 == 0 || x1 == n) continue;
if (hor.find(x1) == hor.end()) {
hor[x1] = BUFF + bpos;
bpos++;
}
if (y1 > y2) swap(y1, y2);
hor[x1]->push_back(pair<int, int>(y1, y2));
} else {
if (y1 == 0 || y1 == m) continue;
if (ver.find(y1) == ver.end()) {
ver[y1] = BUFF + bpos;
bpos++;
}
if (x1 > x2) swap(x1, x2);
ver[y1]->push_back(pair<int, int>(x1, x2));
}
}
if (hor.size() < n && ((n - 1 - hor.size()) & 1)) {
for (int i = (1), ei = (n); i < ei; i++)
if (hor.find(i) == hor.end()) {
hor[i] = BUFF + bpos;
bpos++;
break;
}
}
if (ver.size() < m && ((m - 1 - ver.size()) & 1)) {
for (int i = (1), ei = (m); i < ei; i++)
if (ver.find(i) == ver.end()) {
ver[i] = BUFF + bpos;
bpos++;
break;
}
}
proc(hor, m, 0);
proc(ver, n, 1);
int res = 0;
for (int i = (0), ei = (pos); i < ei; i++) res ^= Val[i];
if (res == 0)
puts("SECOND");
else {
puts("FIRST");
int win = -1;
int need = -1;
for (int i = (0), ei = (pos); i < ei; i++) {
int left = Val[i] ^ res;
if (left < Val[i]) {
win = i;
need = Val[i] - left;
break;
}
}
if (who[win] == 0) {
int ans = findAns(hor, win, need);
printf("%d %d %d %d\n", key[win], 0, key[win], ans);
} else {
int ans = findAns(ver, win, need);
printf("%d %d %d %d\n", 0, key[win], ans, key[win]);
}
}
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, vector<pair<long long, long long> > > row, col;
map<long long, long long> rr, cc;
bool INSECT(long long x1, long long y1, long long x2, long long y2) {
return x1 <= x2 && x2 <= y1 || x1 <= y2 && y2 <= y1 || x2 <= x1 && x1 <= y2 ||
x2 <= y1 && y1 <= y2;
}
long long SEG(vector<pair<long long, long long> > &x) {
long long a(x[0].first), b(x[0].second), tot(0);
vector<pair<long long, long long> > tmp;
for (long long i = 0; i < x.size(); ++i) {
if (INSECT(a, b, x[i].first, x[i].second)) {
a = min(a, x[i].first), b = max(b, x[i].second);
} else {
tmp.push_back(make_pair((a), (b)));
tot += b - a;
a = x[i].first, b = x[i].second;
}
}
tmp.push_back(make_pair((a), (b)));
tot += b - a;
x.swap(tmp);
return tot;
}
void UNIQ(map<long long, vector<pair<long long, long long> > > &xx,
map<long long, long long> &yy, const long long n) {
for (map<long long, vector<pair<long long, long long> > >::iterator it =
xx.begin();
it != xx.end(); ++it) {
sort(it->second.begin(), it->second.end());
it->second.erase(unique(it->second.begin(), it->second.end()),
it->second.end());
yy[it->first] = n - SEG(it->second);
}
}
void GAO(bool foo, map<long long, vector<pair<long long, long long> > > xx,
const long long n, long long i, long long j) {
long long st(0), ed, sum(0);
vector<pair<long long, long long> > tmp(xx[i]);
if (tmp.empty()) {
ed = j;
} else {
tmp.push_back(make_pair((0), (0)));
tmp.push_back(make_pair((n), (n)));
sort(tmp.begin(), tmp.end());
for (long long k = 0; k + 1 < tmp.size(); ++k) {
if (sum + tmp[k + 1].first - tmp[k].second >= j) {
ed = tmp[k].second + j - sum;
break;
} else {
sum += tmp[k + 1].first - tmp[k].second;
}
}
}
if (foo)
cout << st << ' ' << i << ' ' << ed << ' ' << i << endl;
else
cout << i << ' ' << st << ' ' << i << ' ' << ed << endl;
}
int main() {
long long i, j, k;
long long m, n;
long long xb, yb, xe, ye;
long long tot(0);
cin >> n >> m >> k;
for (i = 0; i < k; ++i) {
cin >> xb >> yb >> xe >> ye;
if (xb == xe)
col[xb].push_back(make_pair((min(yb, ye)), (max(yb, ye))));
else
row[yb].push_back(make_pair((min(xb, xe)), (max(xb, xe))));
}
UNIQ(row, rr, n);
UNIQ(col, cc, m);
for (map<long long, long long>::iterator it = rr.begin(); it != rr.end();
++it)
tot ^= it->second;
if ((m - 1 - rr.size()) & 1) tot ^= n;
for (map<long long, long long>::iterator it = cc.begin(); it != cc.end();
++it)
tot ^= it->second;
if ((n - 1 - cc.size()) & 1) tot ^= m;
if (tot == 0) {
puts("SECOND");
} else {
puts("FIRST");
i = -1, j = -1;
for (map<long long, long long>::iterator it = rr.begin(); it != rr.end();
++it)
if ((it->second ^ tot) < it->second) {
i = it->first, j = it->second - (it->second ^ tot);
break;
}
if (i == -1 && (n ^ tot) < n) {
for (k = 1; k < m; ++k)
if (!rr.count(k)) {
i = k, j = n - (n ^ tot);
break;
}
}
if (i != -1)
GAO(true, row, n, i, j);
else {
for (map<long long, long long>::iterator it = cc.begin(); it != cc.end();
++it)
if ((it->second ^ tot) < it->second) {
i = it->first, j = it->second - (it->second ^ tot);
break;
}
if (i == -1 && (m ^ tot) < m) {
for (k = 1; k < n; ++k)
if (!cc.count(k)) {
i = k, j = m - (m ^ tot);
break;
}
}
GAO(false, col, m, i, j);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class segment {
int _pos;
int _len;
public:
segment(int pos, int len) {
this->_pos = pos;
this->_len = len;
}
int pos() { return _pos; }
int len() { return _len; }
bool isintersected(segment s2) {
return (pos() <= s2.pos() + s2.len()) && (s2.pos() <= pos() + len());
}
};
bool cmp(segment s1, segment s2) {
if (s1.pos() != s2.pos()) {
return s1.pos() < s2.pos();
}
return s1.len() < s2.len();
}
class line {
private:
list<segment> l;
int max;
void canonize() {
list<segment>::iterator it1, it2;
l.sort(cmp);
for (it1 = l.begin(); it1 != l.end();) {
it2 = it1;
++it2;
if (it2 != l.end()) {
if (it1->isintersected(*it2)) {
l.insert(
it1,
segment(
((it1->pos()) < (it2->pos()) ? (it1->pos()) : (it2->pos())),
((it1->pos() + it1->len()) > (it2->pos() + it2->len())
? (it1->pos() + it1->len())
: (it2->pos() + it2->len())) -
((it1->pos()) < (it2->pos()) ? (it1->pos())
: (it2->pos()))));
it2++;
it1 = l.erase(it1, it2);
it1--;
continue;
}
}
it1++;
}
}
public:
line(int max) { this->max = max; }
void add(int st, int en) { l.push_back(segment(st, en - st)); }
int getenum() {
canonize();
int full = 0;
for (list<segment>::iterator it = l.begin(); it != l.end(); ++it) {
full += it->len();
}
return max - full;
}
int getinterval(int s) {
canonize();
int s1 = 0;
int cur = 0;
for (list<segment>::iterator it = l.begin(); it != l.end() && s1 < s;
++it) {
if (it->pos() - cur >= s - s1) return cur + s - s1;
s1 += it->pos() - cur;
cur = it->pos() + it->len();
}
return cur + s - s1;
}
};
class grid {
private:
int n;
int m;
map<int, line> lines;
int getindex(bool is_hor, int i) { return is_hor ? i : i + n; }
bool ishor(int index) { return index < n; }
map<long, long> getheaps() {
map<long, long> res;
map<long, long>::iterator rit;
int ne = n - 1, me = m - 1;
for (map<int, line>::iterator it = lines.begin(); it != lines.end(); ++it) {
int e_num = it->second.getenum();
rit = res.find(e_num);
int count = rit != res.end() ? rit->second + 1 : 1;
if (rit != res.end()) res.erase(rit);
res.insert(pair<long, long>(e_num, count));
if (ishor(it->first))
ne--;
else
me--;
}
if (ne) {
rit = res.find(m);
int count = rit != res.end() ? rit->second + ne : ne;
if (rit != res.end()) res.erase(rit);
res.insert(pair<long, long>(m, count));
}
if (me) {
rit = res.find(n);
int count = rit != res.end() ? rit->second + me : me;
if (rit != res.end()) res.erase(rit);
res.insert(pair<long, long>(n, count));
}
return res;
}
public:
grid(int n, int m) {
this->n = n;
this->m = m;
}
void add(int xb, int yb, int xe, int ye) {
map<int, line>::iterator it;
if (xb == xe) {
if (yb > ye) {
int t = ye;
ye = yb;
yb = t;
}
it = lines.find(getindex(true, xb));
if (it == lines.end()) {
it = lines.insert(pair<int, line>(getindex(true, xb), line(m))).first;
}
it->second.add(yb, ye);
} else {
assert(yb == ye);
if (xb > xe) {
int t = xe;
xe = xb;
xb = t;
}
it = lines.find(getindex(false, yb));
if (it == lines.end()) {
it = lines.insert(pair<int, line>(getindex(false, yb), line(n))).first;
}
it->second.add(xb, xe);
}
}
string calc() {
for (int i = 1; i < n; i++) {
if (lines.find(getindex(true, i)) == lines.end()) {
map<int, line>::iterator it =
lines.insert(pair<int, line>(getindex(true, i), line(m))).first;
it->second.add(0, 0);
break;
}
}
for (int i = 1; i < m; i++) {
if (lines.find(getindex(false, i)) == lines.end()) {
map<int, line>::iterator it =
lines.insert(pair<int, line>(getindex(false, i), line(n))).first;
it->second.add(0, 0);
break;
}
}
map<long, long> H;
H = getheaps();
int sum = 0;
string res;
for (map<long, long>::iterator it = H.begin(); it != H.end(); ++it) {
if ((it->second & 1) == 1) sum ^= it->first;
}
if (sum == 0) {
res = "SECOND\n";
return res;
} else {
res = "FIRST\n";
}
for (map<int, line>::iterator it = lines.begin(); it != lines.end(); ++it) {
int e_num = it->second.getenum();
if (e_num >= (sum ^ e_num)) {
stringstream stout;
int t = it->second.getinterval(e_num - (sum ^ e_num));
if (ishor(it->first)) {
stout << it->first << " 0 " << it->first << " " << t << endl;
} else {
stout << "0 " << it->first - n << " " << t << " " << it->first - n
<< endl;
}
res += stout.str();
return res;
}
}
assert(false);
return res;
}
};
int main() {
int n, m, k;
cin >> n >> m >> k;
grid G(n, m);
for (int i = 0; i < k; i++) {
int xb, yb, xe, ye;
cin >> xb >> yb >> xe >> ye;
G.add(xb, yb, xe, ye);
}
cout << G.calc();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool Up(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool Down(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline int getus() {
int tmp, c;
while (tmp = fgetc(stdin), tmp < '0' || tmp > '9')
;
tmp -= '0';
while (c = fgetc(stdin), '0' <= c && c <= '9') tmp = tmp * 10 + c - '0';
return tmp;
}
inline int getint() {
int tmp, c, flag;
while (flag = fgetc(stdin), flag != '-' && (flag < '0' || flag > '9'))
;
if (flag == '-')
tmp = 0;
else
tmp = flag - '0';
while (c = fgetc(stdin), '0' <= c && c <= '9') tmp = tmp * 10 + c - '0';
return flag == '-' ? -tmp : tmp;
}
struct Seg {
int i, l, r;
Seg() : i(0), l(0), r(0) {}
Seg(int i, int l, int r) : i(i), l(l), r(r) {}
bool operator<(const Seg &rhs) const {
if (i != rhs.i) return i < rhs.i;
if (l != rhs.l) return l < rhs.l;
return r < rhs.r;
}
};
bool specialCase = false;
int N, M;
vector<Seg> v, h;
int sgSum = 0;
int ansI = -1, ansL = -1, ansR = -1;
set<int> hs, vs;
vector<Seg> change(vector<Seg> v, int tot) {
vector<Seg> ans(0);
int N = v.size();
sort(v.begin(), v.end());
for (int l = 0, r; l < N; l = r) {
int rest = tot;
for (r = l + 1; r < N && v[l].i == v[r].i; ++r)
;
int left = v[l].l, right = v[l].r;
for (int i = (l + 1); i < (r); ++i) {
if (left <= v[i].l && v[i].l <= right)
Up(right, v[i].r);
else {
ans.push_back(Seg(v[l].i, left, right));
rest -= right - left;
left = v[i].l;
right = v[i].r;
}
}
ans.push_back(Seg(v[l].i, left, right));
rest -= right - left;
sgSum ^= rest;
}
return ans;
}
bool FindStep(vector<Seg> &v, int tot) {
int N = v.size();
for (int l = 0, r; l < N; l = r) {
int rest = tot;
for (r = l + 1; r < N && v[l].i == v[r].i; ++r)
;
for (int i = (l); i < (r); ++i) rest -= v[i].r - v[i].l;
if (rest < (sgSum ^ rest)) continue;
if (specialCase)
printf("rest = %d, sgSum = %d, xor = %d\n", rest, sgSum, rest ^ sgSum);
sgSum ^= rest;
vector<pair<int, int> > vp;
for (int i = (l); i < (r); ++i)
vp.push_back(pair<int, int>(v[i].l, v[i].r));
vp.push_back(pair<int, int>(tot, tot));
int lastPoint = 0;
int tmp = vp.size();
sgSum = rest - sgSum;
if (specialCase) printf("sgSum = %d\n", sgSum);
for (int i = (0); i < (tmp); ++i) {
int len = vp[i].first - lastPoint;
if (sgSum > len) {
sgSum -= len;
lastPoint = vp[i].second;
} else {
len = sgSum;
int right = lastPoint + len;
ansI = v[l].i;
ansL = 0;
ansR = right;
break;
}
}
return true;
}
return false;
}
int findMex(const set<int> &t) {
int i = 1;
set<int>::const_iterator itr = t.begin();
for (;; ++i) {
if (*itr != i) break;
if (++itr == t.end()) {
++i;
break;
}
}
return i;
}
int main() {
int K;
scanf("%d %d %d", &N, &M, &K);
while (K--) {
int x0, y0, x1, y1;
scanf("%d %d %d %d", &x0, &y0, &x1, &y1);
if (y0 == y1) {
if (x0 > x1) swap(x0, x1);
h.push_back(Seg(y0, x0, x1));
hs.insert(y0);
}
if (x0 == x1) {
if (y0 > y1) swap(y0, y1);
v.push_back(Seg(x0, y0, y1));
vs.insert(x0);
}
}
if ((M - 1 - int(hs.size())) & 1) sgSum ^= N;
if ((N - 1 - int(vs.size())) & 1) sgSum ^= M;
h = change(h, N);
v = change(v, M);
if (sgSum == 0) {
puts("SECOND");
return 0;
}
puts("FIRST");
if ((M - 1 - int(hs.size())) > 0 && (sgSum ^ N) <= N) {
int y = findMex(hs);
printf("0 %d %d %d\n", y, N - (sgSum ^ N), y);
if (specialCase) {
puts("1");
printf("%d\n", (M - 1 - int(hs.size())));
}
return 0;
}
if ((N - 1 - int(vs.size())) > 0 && (sgSum ^ M) <= M) {
int x = findMex(vs);
printf("%d 0 %d %d\n", x, x, M - (sgSum ^ M));
if (specialCase) {
puts("2");
printf("%d\n", (N - 1 - int(vs.size())));
}
return 0;
}
if (FindStep(h, N)) {
printf("%d %d %d %d\n", ansL, ansI, ansR, ansI);
return 0;
}
if (FindStep(v, M)) {
printf("%d %d %d %d\n", ansI, ansL, ansI, ansR);
return 0;
}
assert(0);
puts("WRONG!!!");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, set<pair<int, int> > > l, c;
vector<pair<int, int> > lvals, cvals;
int findcutsize(set<pair<int, int> > &s, int val) {
int cnt = 0;
int lastend = 0;
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); it++) {
if (cnt + (it->second - lastend) >= val) {
return lastend + val - cnt;
} else {
cnt += it->second - lastend;
lastend = it->first;
}
}
return lastend + val - cnt;
}
void addseg(int b, int e, set<pair<int, int> > &s) {
set<pair<int, int> >::iterator it1 = s.lower_bound(make_pair(b, 0));
set<pair<int, int> >::iterator it2 = s.lower_bound(make_pair(e, 0));
int newe = e, newb = b;
bool erase1 = 0, erase2 = 0;
if (it1 == s.end()) {
s.insert(make_pair(e, b));
} else {
if (it1->second < newb) {
newb = it1->second;
erase1 = 1;
}
if (it2 != s.end() and it2->second <= e) {
newe = it2->first;
erase2 = 1;
}
if (erase1 and erase2) {
if (it1 != it2) {
s.erase(it1);
s.erase(it2);
} else {
s.erase(it1);
}
} else {
if (erase1) {
s.erase(it1);
}
if (erase2) {
s.erase(it2);
}
}
set<pair<int, int> >::iterator er1, er2, aux;
er1 = s.lower_bound(make_pair(newb, 0));
er2 = s.upper_bound(make_pair(newe, 0));
while (er1 != er2) {
aux = er1;
aux++;
s.erase(er1);
er1 = aux;
}
s.insert(make_pair(newe, newb));
}
}
int calcxor(int val, int times) {
if (times == 0) {
return 0;
} else if (times == 1)
return val;
else {
int ret = calcxor(val, times / 2);
ret = ret ^ ret;
if (times % 2) ret = ret ^ val;
return ret;
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
addseg(min(y1, y2), max(y1, y2), c[x1]);
} else {
addseg(min(x1, x2), max(x1, x2), l[y1]);
}
}
int leftc = n - 1 - c.size();
int leftl = m - 1 - l.size();
int xorc = calcxor(m, leftc);
int xorl = calcxor(n, leftl);
for (map<int, set<pair<int, int> > >::iterator it1 = c.begin();
it1 != c.end(); it1++) {
int cur = m;
for (set<pair<int, int> >::iterator it2 = it1->second.begin();
it2 != it1->second.end(); it2++) {
cur -= it2->first - it2->second;
}
cvals.push_back(make_pair(cur, it1->first));
}
for (map<int, set<pair<int, int> > >::iterator it1 = l.begin();
it1 != l.end(); it1++) {
int cur = n;
for (set<pair<int, int> >::iterator it2 = it1->second.begin();
it2 != it1->second.end(); it2++) {
cur -= it2->first - it2->second;
}
lvals.push_back(make_pair(cur, it1->first));
}
int ans = 0;
for (int i = 0; i < cvals.size(); i++) {
ans = ans ^ cvals[i].first;
}
for (int i = 0; i < lvals.size(); i++) {
ans = ans ^ lvals[i].first;
}
ans = ans ^ xorl ^ xorc;
if (ans == 0) {
cout << "SECOND" << endl;
} else {
cout << "FIRST" << endl;
int digit;
for (int i = 0; i < 32; i++) {
if ((ans >> i) & 1) {
digit = i;
}
}
if (leftc and ((m >> digit) & 1)) {
int tocut = m - (m ^ ans);
int cutcol;
for (int i = 1; i <= 100003; i++) {
if (c.find(i) == c.end()) {
cutcol = i;
break;
}
}
cout << cutcol << " " << 0 << " " << cutcol << " " << tocut << endl;
} else if (leftl and ((n >> digit) & 1)) {
int tocut = n - (n ^ ans);
int cutline;
for (int i = 1; i <= 100003; i++) {
if (l.find(i) == l.end()) {
cutline = i;
break;
}
}
cout << 0 << " " << cutline << " " << tocut << " " << cutline << endl;
} else {
for (int i = 0; i < cvals.size(); i++) {
if ((cvals[i].first >> digit) & 1) {
int cutcol;
int tocut = cvals[i].first - (cvals[i].first ^ ans);
cutcol = cvals[i].second;
int cutsize = findcutsize(c[cutcol], tocut);
cout << cutcol << " " << 0 << " " << cutcol << " " << cutsize << endl;
exit(0);
}
}
for (int i = 0; i < lvals.size(); i++) {
if ((lvals[i].first >> digit) & 1) {
int cutline;
int tocut = lvals[i].first - (lvals[i].first ^ ans);
cutline = lvals[i].second;
int cutsize = findcutsize(l[cutline], tocut);
cout << 0 << " " << cutline << " " << cutsize << " " << cutline
<< endl;
exit(0);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
map<int, vector<pair<int, int> > > lie;
map<int, vector<pair<int, int> > > ha;
map<int, bool> vl;
map<int, bool> vh;
map<int, int> hl;
map<int, int> hh;
int xa, ya, xb, yb;
int hhh = 0;
int ll = 0;
int ans = 0;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d%d%d", &xa, &ya, &xb, &yb);
if (xa == xb) {
if (vl.find(xa) == vl.end()) vl[xa] = 1, ll++;
if (ya > yb) swap(ya, yb);
lie[xa].push_back(make_pair(ya, yb));
} else {
if (vh.find(ya) == vh.end()) vh[ya] = 1, hhh++;
if (xa > xb) swap(xa, xb);
ha[ya].push_back(make_pair(xa, xb));
}
}
ll = n - 1 - ll;
hhh = m - 1 - hhh;
if (ll % 2) ans ^= m;
if (hhh % 2) ans ^= n;
for (int i = 1; i < n; i++) {
if (vl.find(i) == vl.end()) {
hl[i] = m;
break;
}
}
for (int i = 1; i < m; i++) {
if (vh.find(i) == vh.end()) {
hh[i] = n;
break;
}
}
for (auto &i : lie) {
sort(i.second.begin(), i.second.end());
int pp = 0;
pp = i.second[0].second - i.second[0].first;
int tt = i.second[0].second;
for (int k = 1; k < i.second.size(); k++) {
if (i.second[k].first <= tt) {
if (i.second[k].second > tt)
pp += i.second[k].second - tt, tt = i.second[k].second;
} else {
pp += i.second[k].second - i.second[k].first;
tt = i.second[k].second;
}
}
hl[i.first] = m - pp;
ans ^= (m - pp);
}
for (auto &i : ha) {
sort(i.second.begin(), i.second.end());
int pp = 0;
pp = i.second[0].second - i.second[0].first;
int tt = i.second[0].second;
for (int k = 1; k < i.second.size(); k++) {
if (i.second[k].first <= tt) {
if (i.second[k].second > tt)
pp += i.second[k].second - tt, tt = i.second[k].second;
} else {
pp += i.second[k].second - i.second[k].first;
tt = i.second[k].second;
}
}
hh[i.first] = n - pp;
ans ^= (n - pp);
}
if (ans) {
cout << "FIRST" << endl;
for (auto &i : hh) {
int pp = ans ^ i.second;
if (pp <= i.second) {
pp = i.second - pp;
if (ha.find(i.first) == ha.end()) {
printf("%d %d %d %d\n", 0, i.first, pp, i.first);
} else {
printf("%d %d ", 0, i.first);
int yy = 0;
if (ha[i.first][0].first >= pp) {
printf("%d %d\n", pp, i.first);
return 0;
}
yy = ha[i.first][0].first;
pp -= yy;
yy = ha[i.first][0].second;
for (int k = 1; k < ha[i.first].size(); k++) {
if (ha[i.first][k].first <= yy) {
yy = max(yy, ha[i.first][k].second);
} else {
if (ha[i.first][k].first - yy >= pp) {
yy += pp;
printf("%d %d\n", yy, i.first);
return 0;
} else {
pp -= ha[i.first][k].first - yy;
yy = max(yy, ha[i.first][k].second);
}
}
}
yy += pp;
printf("%d %d\n", yy, i.first);
}
return 0;
}
}
for (auto &i : hl) {
int pp = ans ^ i.second;
if (pp <= i.second) {
pp = i.second - pp;
if (lie.find(i.first) == lie.end()) {
printf("%d %d %d %d\n", i.first, 0, i.first, pp);
} else {
printf("%d %d %d ", i.first, 0, i.first);
int yy = 0;
if (lie[i.first][0].first >= pp) {
printf("%d\n", pp);
return 0;
}
yy = lie[i.first][0].first;
pp -= yy;
yy = lie[i.first][0].second;
for (int k = 1; k < lie[i.first].size(); k++) {
if (lie[i.first][k].first <= yy) {
yy = max(yy, lie[i.first][k].second);
} else {
if (lie[i.first][k].first - yy >= pp) {
yy += pp;
printf("%d\n", yy);
return 0;
} else {
pp -= lie[i.first][k].first - yy;
yy = max(yy, lie[i.first][k].second);
}
}
}
yy += pp;
printf("%d\n", yy);
}
return 0;
}
}
} else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
bool cmp_second(const pair<T, U> &a, const pair<T, U> &b) {
return a.second < b.second;
}
pair<int, int> operator+(const pair<int, int> &a, const pair<int, int> &b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<int, int> operator-(const pair<int, int> &a, const pair<int, int> &b) {
return make_pair(a.first - b.first, a.second - b.second);
}
pair<int, int> &operator+=(pair<int, int> &a, const pair<int, int> &b) {
a.first += b.first;
a.second += b.second;
return a;
}
pair<int, int> &operator-=(pair<int, int> &a, const pair<int, int> &b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
inline int sg(int x) { return x ? (x > 0 ? 1 : -1) : 0; }
class Segment {
public:
int r1, r2, c1, c2;
void input() {
scanf("%d %d %d %d", &r1, &c1, &r2, &c2);
if (r1 > r2) swap(r1, r2);
if (c1 > c2) swap(c1, c2);
}
};
int rn, cn, k;
vector<Segment> rseg, cseg;
bool cmpr(Segment a, Segment b) {
if (a.r1 != b.r1) return a.r1 < b.r1;
return a.c1 < b.c1;
}
bool cmpc(Segment a, Segment b) {
if (a.c1 != b.c1) return a.c1 < b.c1;
return a.r1 < b.r1;
}
const int inf = 1000000500;
inline int cut(vector<pair<int, int> > segs, int todo = inf) {
int rb = 0, ret = 0;
for (int i = 0; i < segs.size(); i++) {
int a = max(segs[i].first, rb) - rb;
if (ret + a >= todo) {
return rb + (todo - ret);
}
ret += a;
rb = max(rb, segs[i].second);
}
return ret;
}
inline int getnim(int ans = -1) {
int nim = 0;
vector<int> rseen, cseen;
for (int i = 0, j = 0; i < rseg.size(); i = j) {
vector<pair<int, int> > segs;
for (j = i; j < rseg.size() && rseg[i].r1 == rseg[j].r1; j++)
segs.push_back(make_pair(rseg[j].c1, rseg[j].c2));
segs.push_back(make_pair(cn, cn));
int totl = cut(segs);
if (ans >= 0 && (totl ^ ans) < totl) {
int todo = totl - (totl ^ ans);
int x = cut(segs, todo);
printf("%d %d %d %d\n", rseg[i].r1, 0, rseg[i].r1, x);
return -1;
}
nim ^= totl;
rseen.push_back(rseg[i].r1);
}
for (int i = 0, j = 0; i < cseg.size(); i = j) {
vector<pair<int, int> > segs;
for (j = i; j < cseg.size() && cseg[i].c1 == cseg[j].c1; j++)
segs.push_back(make_pair(cseg[j].r1, cseg[j].r2));
segs.push_back(make_pair(rn, rn));
int totl = cut(segs);
if (ans >= 0 && (totl ^ ans) < totl) {
int todo = totl - (totl ^ ans);
int x = cut(segs, todo);
printf("%d %d %d %d\n", 0, cseg[i].c1, x, cseg[i].c1);
return -1;
}
nim ^= totl;
cseen.push_back(cseg[i].c1);
}
if ((rn - 1 - rseen.size()) & 1) nim ^= cn;
if ((cn - 1 - cseen.size()) & 1) nim ^= rn;
if (ans >= 0 && rseen.size() < rn - 1 && (cn ^ ans) < cn) {
int todo = cn - (cn ^ ans);
int z;
for (z = 1; z <= rseen.size(); z++)
if (rseen[z - 1] != z) break;
printf("%d %d %d %d\n", z, 0, z, todo);
return -1;
}
if (ans >= 0 && cseen.size() < cn - 1 && (rn ^ ans) < rn) {
int todo = rn - (rn ^ ans);
int z;
for (z = 1; z <= cseen.size(); z++)
if (cseen[z - 1] != z) break;
printf("%d %d %d %d\n", 0, z, todo, z);
return -1;
}
return nim;
}
bool solve() {
sort(rseg.begin(), rseg.end(), cmpr);
sort(cseg.begin(), cseg.end(), cmpc);
int nim = getnim();
if (!nim) return 0;
puts("FIRST");
getnim(nim);
return 1;
}
int main(void) {
scanf("%d %d %d", &rn, &cn, &k);
for (int i = 0; i < k; i++) {
Segment s;
s.input();
if (s.r1 == s.r2)
rseg.push_back(s);
else
cseg.push_back(s);
}
if (!solve()) puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
char Gc() {
static char now[1 << 20], *S, *T;
if (T == S) {
T = (S = now) + std::fread(now, 1, 1 << 20, stdin);
if (T == S) return EOF;
}
return *S++;
}
template <typename T>
void Read(T &x) {
x = 0;
int f = 1;
char c;
while ((c = Gc()) < '0' || c > '9')
if (c == '-') f = -1;
x = c - '0';
while ((c = Gc()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= f;
}
template <typename T, typename... Args>
void Read(T &x, Args &...args) {
Read(x);
Read(args...);
}
template <typename T>
void checkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void checkmin(T &x, T y) {
if (x > y) x = y;
}
int n, m, k;
std::vector<std::pair<int, std::pair<int, int>>> r, c, nim;
std::vector<int> a, b;
std::vector<std::pair<int, int>> va[100005], vb[100005];
std::unordered_set<int> visa, visb;
int main(int argc, char const *argv[]) {
Read(n, m, k);
for (int i = 1; i <= k; i++) {
int x1, y1, x2, y2;
Read(x1, y1, x2, y2);
if (x1 == x2) {
r.emplace_back(x1, std::make_pair(std::min(y1, y2), std::max(y1, y2)));
a.emplace_back(x1);
visa.emplace(x1);
} else {
c.emplace_back(y1, std::make_pair(std::min(x1, x2), std::max(x1, x2)));
b.emplace_back(y1);
visb.emplace(y1);
}
}
std::sort(a.begin(), a.end());
std::sort(b.begin(), b.end());
a.erase(std::unique(a.begin(), a.end()), a.end());
b.erase(std::unique(b.begin(), b.end()), b.end());
if (n - 1 > static_cast<int>(a.size()))
for (int i = 1; i < n; i++)
if (!visa.count(i)) {
a.emplace_back(i);
visa.emplace(i);
if ((n - 1 - a.size()) & 1)
for (int j = i + 1; j < n; j++)
if (!visa.count(j)) {
a.emplace_back(j);
visa.emplace(j);
break;
}
break;
}
if (m - 1 > static_cast<int>(b.size()))
for (int i = 1; i < m; i++)
if (!visb.count(i)) {
b.emplace_back(i);
visb.emplace(i);
if ((m - 1 - b.size()) & 1)
for (int j = i + 1; j < m; j++)
if (!visb.count(j)) {
b.emplace_back(j);
visb.emplace(j);
break;
}
break;
}
std::sort(a.begin(), a.end());
std::sort(b.begin(), b.end());
for (auto &&i : r)
va[std::lower_bound(a.begin(), a.end(), i.first) - a.begin()].emplace_back(
i.second);
for (auto &&i : c)
vb[std::lower_bound(b.begin(), b.end(), i.first) - b.begin()].emplace_back(
i.second);
for (std::size_t i = 0; i < a.size(); i++) {
std::sort(va[i].begin(), va[i].end());
int len = 0, l = 0, r = 0;
for (auto &&j : va[i])
if (j.first <= r) {
checkmax(r, j.second);
} else {
len += r - l;
l = j.first;
r = j.second;
}
len += r - l;
nim.emplace_back(m - len, std::make_pair(0, a[i]));
}
for (std::size_t i = 0; i < b.size(); i++) {
std::sort(vb[i].begin(), vb[i].end());
int len = 0, l = 0, r = 0;
for (auto &&j : vb[i])
if (j.first <= r) {
checkmax(r, j.second);
} else {
len += r - l;
l = j.first;
r = j.second;
}
len += r - l;
nim.emplace_back(n - len, std::make_pair(1, b[i]));
}
int ans = 0;
for (auto &&i : nim) ans ^= i.first;
if (!ans) {
std::printf("SECOND");
return 0;
}
std::printf("FIRST\n");
for (auto &&i : nim)
if ((i.first ^ ans) < i.first) {
ans = i.first - (ans ^ i.first);
std::vector<std::pair<int, int>> tmp;
if (!i.second.first) {
std::printf("%d 0 %d ", i.second.second, i.second.second);
int r = 0, sum = 0;
for (auto &&j :
va[std::lower_bound(a.begin(), a.end(), i.second.second) -
a.begin()]) {
if (j.first <= r) {
checkmax(r, j.second);
} else {
tmp.emplace_back(r, j.first);
r = j.second;
}
}
if (r < m) tmp.emplace_back(r, m);
for (auto &&j : tmp)
if (sum + j.second - j.first < ans) {
sum += j.second - j.first;
} else {
std::printf("%d", j.first + ans - sum);
return 0;
}
} else {
std::printf("0 %d ", i.second.second);
int r = 0, sum = 0;
for (auto &&j :
vb[std::lower_bound(b.begin(), b.end(), i.second.second) -
b.begin()]) {
if (j.first <= r) {
checkmax(r, j.second);
} else {
tmp.emplace_back(r, j.first);
r = j.second;
}
}
if (r < n) tmp.emplace_back(r, n);
for (auto &&j : tmp)
if (sum + j.second - j.first < ans) {
sum += j.second - j.first;
} else {
std::printf("%d %d", j.first + ans - sum, i.second.second);
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tcut {
int x1, x2, y, len;
int type;
} v[100500];
struct trow {
int l, r;
int xr;
} row[100500];
bool tcut_less(const tcut &a, const tcut &b) {
return (a.type < b.type) || (a.type == b.type && a.y < b.y);
}
int x, y, k, n;
int row_count;
set<int> xset, yset;
int xcount;
int ycount;
int best, rmx, lmx;
pair<int, int> o[100500 * 2];
int get_grandy_value(int l, int r) {
int start;
int open = 0;
int total = v[l].len;
k = 0;
for (int i = l; i < r; ++i) {
o[k++] = make_pair(v[i].x1, -1);
o[k++] = make_pair(v[i].x2, 1);
}
sort(o, o + k);
for (int i = 0; i < k; ++i) {
if (o[i].second == -1 && open == 0) {
start = o[i].first;
} else if (o[i].second == 1 && open == 1) {
total -= (o[i].first - start);
}
open += -o[i].second;
}
row[row_count].l = l;
row[row_count].r = r;
row[row_count].xr = total;
row_count++;
return total;
}
int get_total(int a) {
int start;
int open = 0;
int total = v[lmx].len;
for (int i = 0; i < k; ++i) {
if (o[i].first >= a) break;
if (o[i].second == -1 && open == 0) {
start = o[i].first;
} else if (o[i].second == 1 && open == 1) {
total -= (o[i].first - start);
}
open += -o[i].second;
}
if (open)
total -= v[lmx].len - start;
else
total -= v[lmx].len - a;
return total;
}
int main() {
scanf("%i %i %i", &x, &y, &n);
for (int i = 0; i < n; ++i) {
int xx1, xx2, yy1, yy2;
scanf("%i %i %i %i", &xx1, &yy1, &xx2, &yy2);
if (xx1 > xx2) swap(xx1, xx2);
if (yy1 > yy2) swap(yy1, yy2);
if (xx1 == xx2) {
v[k].x1 = yy1;
v[k].x2 = yy2;
v[k].y = xx1;
v[k].len = y;
v[k].type = 0;
xset.insert(xx1);
} else {
v[k].x1 = xx1;
v[k].x2 = xx2;
v[k].y = yy1;
v[k].len = x;
v[k].type = 1;
yset.insert(yy1);
}
k++;
}
sort(v, v + n, tcut_less);
xcount = x - 1;
ycount = y - 1;
int ans = 0;
for (int i = 0; i < n;) {
int j = i;
for (j = i; j < n && v[j].type == v[i].type && v[j].y == v[i].y; ++j)
;
ans = ans ^ get_grandy_value(i, j);
if (v[i].type == 0)
xcount--;
else
ycount--;
i = j;
}
if (xcount & 1) {
ans ^= y;
}
if (ycount & 1) {
ans ^= x;
}
if (!ans)
printf("SECOND\n");
else {
printf("FIRST\n");
if (xcount && y > (ans ^ y)) {
ans ^= y;
for (int i = 1; i < x; ++i)
if (xset.find(i) == xset.end()) {
printf("%i %i %i %i\n", i, ans, i, y);
break;
}
} else if (ycount && x > (ans ^ x)) {
ans ^= x;
for (int i = 1; i < y; ++i)
if (yset.find(i) == yset.end()) {
printf("%i %i %i %i\n", ans, i, x, i);
break;
}
} else
for (int i = 0; i < row_count; ++i) {
lmx = row[i].l;
rmx = row[i].r;
if ((ans ^ row[i].xr) >= row[i].xr) continue;
ans = ans ^ row[i].xr;
get_grandy_value(lmx, rmx);
int A = 0;
int B = v[lmx].len;
while (B - A > 1) {
int C = (A + B) / 2;
if (get_total(C) > ans)
B = C;
else
A = C;
}
if (get_total(A) != ans) A = B;
if (v[lmx].type == 0) {
printf("%i %i %i %i\n", v[lmx].y, A, v[lmx].y, v[lmx].len);
} else {
printf("%i %i %i %i\n", A, v[lmx].y, v[lmx].len, v[lmx].y);
}
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<pair<int, pair<int, int> > > H, V;
class Pile {
public:
int Remsiz;
int startX, startY;
vector<int> piece;
Pile(int _x, int _y) {
Remsiz = 0;
startX = _x;
startY = _y;
piece = vector<int>();
}
void add(int l, int r) {
piece.push_back(l);
piece.push_back(r);
Remsiz += r - l;
}
int partials(int D) {
int v = 0;
for (int i = 0; i < ((int)(piece).size()); i += 2)
v += min(piece[i + 1], D) - min(D, piece[i]);
return v;
}
void output(int D) {
if (startX == 0)
printf("%d %d %d %d\n", 0, startY, D, startY);
else
printf("%d %d %d %d\n", startX, 0, startX, D);
}
};
int main(void) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int xb, yb, xe, ye;
scanf("%d%d%d%d", &xb, &yb, &xe, &ye);
if (xb > xe) swap(xb, xe);
if (yb > ye) swap(yb, ye);
if (xb == xe && yb == ye) continue;
if (xb == xe) {
V.push_back(make_pair(xb, make_pair(yb, 1)));
V.push_back(make_pair(xb, make_pair(ye, -1)));
}
if (yb == ye) {
H.push_back(make_pair(yb, make_pair(xb, 1)));
H.push_back(make_pair(yb, make_pair(xe, -1)));
}
}
sort(H.begin(), H.end());
sort(V.begin(), V.end());
int HasN = m, HasM = n, NimVal = ((m % 2 == 0) * n) ^ ((n % 2 == 0) * m),
upY = 0, upX = 0;
int lastX = 0, lastY = 0, lev = 0;
vector<Pile> piece;
Pile nowpile(0, 0);
for (__typeof((H).begin()) it = (H).begin(); it != (H).end(); it++) {
if (it->first != lastY) {
if (lastY && lastX < n) nowpile.add(lastX, n);
if (nowpile.Remsiz) piece.push_back(nowpile);
if (it->first > lastY + 1) upY = lastY + 1;
NimVal ^= n;
NimVal ^= nowpile.Remsiz;
nowpile = Pile(0, it->first);
lastY = it->first;
lastX = 0;
HasN--;
}
if (lev == 0 && it->second.first > lastX)
nowpile.add(lastX, it->second.first);
lastX = it->second.first;
lev += it->second.second;
}
if (lastY && lastX < n) nowpile.add(lastX, n);
if (nowpile.Remsiz) {
piece.push_back(nowpile);
NimVal ^= nowpile.Remsiz;
}
if (lastY + 1 < m) upY = m - 1;
if (upY) {
nowpile = Pile(0, upY);
nowpile.add(0, n);
piece.push_back(nowpile);
}
lastX = lastY = lev = 0;
nowpile = Pile(0, 0);
for (__typeof((V).begin()) it = (V).begin(); it != (V).end(); it++) {
if (it->first != lastX) {
if (lastX && lastY < m) nowpile.add(lastY, m);
if (nowpile.Remsiz) piece.push_back(nowpile);
if (it->first > lastX + 1) upX = lastX + 1;
NimVal ^= m;
NimVal ^= nowpile.Remsiz;
nowpile = Pile(it->first, 0);
lastY = 0;
lastX = it->first;
HasM--;
}
if (lev == 0 && it->second.first > lastY)
nowpile.add(lastY, it->second.first);
lastY = it->second.first;
lev += it->second.second;
}
if (lastX && lastY < m) nowpile.add(lastY, m);
if (nowpile.Remsiz) {
piece.push_back(nowpile);
NimVal ^= nowpile.Remsiz;
}
if (lastX + 1 < n) upX = n - 1;
if (upX) {
nowpile = Pile(upX, 0);
nowpile.add(0, m);
piece.push_back(nowpile);
}
puts(NimVal ? "FIRST" : "SECOND");
if (NimVal) {
for (__typeof((piece).begin()) it = (piece).begin(); it != (piece).end();
it++) {
int R = it->Remsiz;
if ((R ^ NimVal) <= R) {
R = R - (R ^ NimVal);
int l = 0, r = (it->startX == 0 ? n : m);
while (l <= r) {
int mid = (l + r) / 2, v = it->partials(mid);
if (v < R) {
l = mid + 1;
} else if (v > R) {
r = mid - 1;
} else {
it->output(mid);
break;
}
}
if (l <= r) break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > hors, vers;
vector<vector<int> > pieces;
vector<pair<int, bool> > position;
vector<int> total;
int W, H, k;
void addPieces(vector<pair<int, int> >& cuts, int sz, int coordinate,
bool orientation) {
pieces.push_back(vector<int>());
position.push_back(make_pair(coordinate, orientation));
total.push_back(0);
sort(cuts.begin(), cuts.end());
int nearest = 0, furthest = 0;
for (int i = 0; i < cuts.size(); i++) {
if (cuts[i].first > furthest) {
pieces.back().push_back(furthest - nearest);
pieces.back().push_back(cuts[i].first - furthest);
total.back() += pieces.back().back();
nearest = cuts[i].first;
}
furthest = max(furthest, cuts[i].second);
}
pieces.back().push_back(furthest - nearest);
pieces.back().push_back(sz - furthest);
total.back() += pieces.back().back();
return;
}
void addPieces(map<int, vector<pair<int, int> > >& cuts, int sz,
bool orientation) {
for (__typeof((cuts).begin()) it = (cuts).begin(); it != (cuts).end(); it++)
addPieces(it->second, sz, it->first, orientation);
return;
}
int getMsb(int x) {
while (x != (x & -x)) x -= (x & -x);
return x;
}
int main() {
int c, c2;
scanf("%d%d%d", &W, &H, &k);
for (c = 0; c < k; c++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2)
vers[x1].push_back(make_pair(y1, y2));
else
hors[y1].push_back(make_pair(x1, x2));
}
int emptyhor = H - 1, emptyver = W - 1;
int hor = 1;
for (__typeof((hors).begin()) it = (hors).begin(); it != (hors).end(); it++)
if (hor != it->first) {
emptyhor = hor;
break;
} else
hor++;
int ver = 1;
for (__typeof((vers).begin()) it = (vers).begin(); it != (vers).end(); it++)
if (ver != it->first) {
emptyver = ver;
break;
} else
ver++;
if ((W - vers.size() - 1) & 1) vers[emptyver];
if ((H - hors.size() - 1) & 1) hors[emptyhor];
addPieces(hors, W, 0);
addPieces(vers, H, 1);
int ret = 0;
for (c = 0; c < pieces.size(); c++) ret ^= total[c];
if (!ret)
printf("SECOND\n");
else {
printf("FIRST\n");
int msb = getMsb(ret);
int i;
for (c = 0; c < pieces.size(); c++)
if (total[c] & msb) i = c;
int next = total[i] ^ ret;
int remove = total[i] - next;
int x1 = 0, y1 = position[i].first;
int x2 = x1, y2 = y1;
for (c = 0; remove > 0; c += 2) {
x2 += pieces[i][c];
x2 += min(pieces[i][c + 1], remove);
remove -= pieces[i][c + 1];
}
if (position[i].second) {
swap(x1, y1);
swap(x2, y2);
}
printf("%d %d %d %d\n", x1, y1, x2, y2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
vector<pair<int, int> > row[maxn];
vector<pair<int, int> > col[maxn];
map<int, int> pr;
map<int, int> pc;
set<int> q1, q2;
int d1[maxn];
int d2[maxn];
int n, m, k, f;
void solve1(int sum, int i) {
int r = pr[i];
int w = 0;
int Maxe = 0, sx, sy;
for (int j = 0; j < row[r].size(); j++) {
sx = row[r][j].first;
sy = row[r][j].second;
if (sx >= Maxe) {
w += sx - Maxe;
Maxe = sy;
} else if (sy >= Maxe) {
Maxe = sy;
}
if (w >= sum) {
printf("%d %d %d %d\n", i, sx - (w - sum), i, m);
return;
}
}
w += m - Maxe;
printf("%d %d %d %d\n", i, m - (w - sum), i, m);
}
void solve2(int sum, int i) {
int r = pc[i];
int w = 0;
int Maxe = 0;
int sx, sy;
for (int j = 0; j < col[r].size(); j++) {
sx = col[r][j].first;
sy = col[r][j].second;
if (sx >= Maxe) {
w += sx - Maxe;
Maxe = sy;
} else if (sy >= Maxe) {
Maxe = sy;
}
if (w >= sum) {
printf("%d %d %d %d\n", sx - (w - sum), i, n, i);
return;
}
w += n - Maxe;
printf("%d %d %d %d\n", (n - (w - sum)), i, n, i);
}
}
int main() {
cin >> n >> m >> k;
int sum = 0;
int c1 = 0, c2 = 0;
while (k--) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
q1.insert(x1);
if (pr.find(x1) == pr.end()) pr[x1] = ++c1;
row[pr[x1]].push_back(make_pair(y1, y2));
} else {
if (x1 > x2) swap(x1, x2);
q2.insert(y1);
if (pc.find(y1) == pc.end()) pc[y1] = ++c2;
col[pc[y1]].push_back(make_pair(x1, x2));
}
}
int sx, sy, s = 0;
set<int>::iterator it;
for (it = q1.begin(); it != q1.end(); it++) {
int i = *it;
if (pr.count(i) == 0) continue;
int r = pr[i];
sort(row[r].begin(), row[r].end());
int w = 0;
int Maxe = 0;
for (int j = 0; j < row[r].size(); j++) {
sx = row[r][j].first;
sy = row[r][j].second;
if (sx >= Maxe) {
w += sy - sx;
Maxe = sy;
} else if (sy >= Maxe) {
w += sy - Maxe;
Maxe = sy;
}
}
if (sy >= Maxe) w += sy - Maxe;
d1[r] = m - w;
s ^= (m - w);
}
for (it = q2.begin(); it != q2.end(); it++) {
int i = *it;
if (pc.count(i) == 0) continue;
int r = pc[i];
sort(col[r].begin(), col[r].end());
int w = 0;
int Maxe = 0;
for (int j = 0; j < col[r].size(); j++) {
sx = col[r][j].first;
sy = col[r][j].second;
if (sx >= Maxe) {
w += sy - sx;
Maxe = sy;
} else if (sy >= Maxe) {
w += sy - Maxe;
Maxe = sy;
}
}
if (sy >= Maxe) w += sy - Maxe;
d2[r] = n - w;
s ^= (n - w);
}
if ((n - pr.size() - 1) & 1) s ^= m;
if ((m - pc.size() - 1) & 1) s ^= n;
f = s;
if (s == 0) {
puts("SECOND");
} else {
puts("FIRST");
if (pr.size() < n - 1)
for (int i = 1;; i++) {
if (q1.find(i) != q1.end()) continue;
if ((s ^ m) < m) {
printf("%d %d %d %d", i, 0, i, m - (s ^ m));
return 0;
}
break;
}
if (pc.size() < m - 1)
for (int i = 1;; i++) {
if (q2.find(i) != q2.end()) continue;
if ((s ^ n) < n) {
printf("%d %d %d %d", 0, i, n - (s ^ n), i);
return 0;
}
break;
}
for (it = q1.begin(); it != q1.end(); it++) {
int i = *it;
if ((s ^ d1[pr[i]]) < d1[pr[i]]) {
solve1(s ^ d1[pr[i]], i);
return 0;
}
}
for (it = q2.begin(); it != q2.end(); it++) {
int i = *it;
if ((s ^ d2[pc[i]]) < d2[pc[i]]) {
solve2(s ^ d2[pc[i]], i);
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
int n, m, k;
map<int, vector<pair<int, int> > > lx, ly;
map<int, vector<pair<int, int> > >::iterator it;
set<int> visx, visy;
vector<pair<int, int> > X, Y;
int sg = 0;
vector<pair<int, int> > merge(vector<pair<int, int> > &v) {
sort(v.begin(), v.end());
vector<pair<int, int> > w;
for (int i = 0; i < (int)v.size(); ++i) {
if (w.empty()) {
w.push_back(v[i]);
} else if (w.back().first <= v[i].first && v[i].first <= w.back().second) {
checkmax(w.back().second, v[i].second);
} else {
w.push_back(v[i]);
}
}
return w;
}
int calc(vector<pair<int, int> > &v) {
int ans = 0;
for (int i = 0; i < (int)v.size(); ++i) ans += v[i].second - v[i].first;
return ans;
}
void init() {
read(n);
read(m);
read(k);
for (int i = 1; i <= k; ++i) {
int x1, x2, jzyakioi, hcyakioi;
read(x1);
read(jzyakioi);
read(x2);
read(hcyakioi);
if (x1 == x2) {
if (jzyakioi > hcyakioi) swap(jzyakioi, hcyakioi);
lx[x1].push_back(make_pair(jzyakioi, hcyakioi));
visx.insert(x1);
} else {
if (x1 > x2) swap(x1, x2);
ly[jzyakioi].push_back(make_pair(x1, x2));
visy.insert(jzyakioi);
}
}
for (it = lx.begin(); it != lx.end(); ++it) {
vector<pair<int, int> > now = it->second;
now = merge(now);
it->second = now;
int num = m - calc(now);
X.push_back(make_pair(it->first, num));
sg ^= num;
}
if ((int)visx.size() <= n - 1) {
for (int i = 1; i < n; ++i)
if (!visx.count(i)) {
X.push_back(make_pair(i, m));
break;
}
if ((n - 1 - (int)visx.size()) & 1) sg ^= m;
}
for (it = ly.begin(); it != ly.end(); ++it) {
vector<pair<int, int> > now = it->second;
now = merge(now);
it->second = now;
int num = n - calc(now);
Y.push_back(make_pair(it->first, num));
sg ^= num;
}
if ((int)visy.size() <= m - 1) {
for (int i = 1; i < m; ++i)
if (!visy.count(i)) {
Y.push_back(make_pair(i, n));
break;
}
if ((m - 1 - (int)visy.size()) & 1) sg ^= n;
}
}
void print(int cur, vector<pair<int, int> > &v, int k, int typ) {
int l = 0, tot = typ == 0 ? m : n;
;
vector<pair<int, int> > w;
if (v.empty()) {
w.push_back(make_pair(0, tot));
} else {
if (v[0].first > 0) w.push_back(make_pair(0, v[0].first));
v.push_back(make_pair(tot, tot));
for (int i = 0; i < (int)v.size() - 1; ++i) {
if (v[i].second <= v[i + 1].first) {
w.push_back(make_pair(v[i].second, v[i + 1].first));
}
}
}
for (auto x : w) {
l += x.second - x.first;
if (l >= k) {
int pos = x.second - l + k;
if (typ == 0)
printf("%d 0 %d %d\n", cur, cur, pos);
else
printf("0 %d %d %d\n", cur, pos, cur);
return;
}
}
}
void solve() {
if (sg == 0) {
printf("SECOND\n");
return;
}
printf("FIRST\n");
int pos = -1;
for (int i = 0; i < (int)X.size(); ++i) {
if ((sg ^ X[i].second) <= X[i].second) {
pos = i;
break;
}
}
if (~pos) {
int num = X[pos].first;
print(num, lx[num], X[pos].second - (sg ^ X[pos].second), 0);
return;
}
pos = -1;
for (int i = 0; i < (int)Y.size(); ++i) {
if ((sg ^ Y[i].second) <= Y[i].second) {
pos = i;
break;
}
}
if (~pos) {
int num = Y[pos].first;
print(num, ly[num], Y[pos].second - (sg ^ Y[pos].second), 1);
return;
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > x;
map<int, vector<pair<int, int> > > y;
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (b == d) {
if (a > c) swap(a, c);
y[b].push_back(make_pair(a, c));
} else if (a == c) {
if (b > d) swap(b, d);
x[a].push_back(make_pair(b, d));
}
}
int num_pile, ans = 0;
num_pile = n - 1;
for (auto i = x.begin(); i != x.end(); i++) {
sort(i->second.begin(), i->second.end());
int tmp = 0, num = 0;
for (int j = 0; j < i->second.size(); j++) {
int s1 = i->second[j].first;
int s2 = i->second[j].second;
if (s2 < tmp) {
} else if (s1 < tmp) {
num += (s2 - tmp);
tmp = s2;
} else {
num += (s2 - s1);
tmp = s2;
}
}
ans = ans ^ (m - num);
num_pile--;
}
if (num_pile % 2) ans ^= m;
num_pile = m - 1;
for (auto i = y.begin(); i != y.end(); i++) {
sort(i->second.begin(), i->second.end());
int tmp = 0, num = 0;
for (int j = 0; j < i->second.size(); j++) {
int s1 = i->second[j].first;
int s2 = i->second[j].second;
if (s2 < tmp) {
} else if (s1 < tmp) {
num += (s2 - tmp);
tmp = s2;
} else {
num += (s2 - s1);
tmp = s2;
}
}
ans = ans ^ (n - num);
num_pile--;
}
if (num_pile % 2) ans ^= n;
if (ans == 0)
puts("SECOND");
else {
puts("FIRST");
for (auto i = x.begin(); i != x.end(); i++) {
int tmp = 0, num = 0;
for (int j = 0; j < i->second.size(); j++) {
int s1 = i->second[j].first;
int s2 = i->second[j].second;
if (s2 < tmp) {
} else if (s1 < tmp) {
num += (s2 - tmp);
tmp = s2;
} else {
num += (s2 - s1);
tmp = s2;
}
}
int sz = m - num;
if ((ans ^ sz) < sz) {
int num2 = sz - (ans ^ sz);
tmp = 0;
for (int j = 0; j < i->second.size(); j++) {
int s1 = i->second[j].first;
int s2 = i->second[j].second;
if (s2 < tmp) {
} else if (s1 < tmp) {
tmp = s2;
} else {
if (s1 - tmp >= num2) {
cout << i->first << " " << 0 << " " << i->first << " "
<< tmp + num2 << endl;
return 0;
} else {
num2 -= (s1 - tmp);
}
tmp = s2;
}
}
if (m - tmp >= num2) {
cout << i->first << " " << 0 << " " << i->first << " " << tmp + num2
<< endl;
return 0;
}
}
}
for (auto i = y.begin(); i != y.end(); i++) {
int tmp = 0, num = 0;
for (int j = 0; j < i->second.size(); j++) {
int s1 = i->second[j].first;
int s2 = i->second[j].second;
if (s2 < tmp) {
} else if (s1 < tmp) {
num += (s2 - tmp);
tmp = s2;
} else {
num += (s2 - s1);
tmp = s2;
}
}
int sz = n - num;
if ((ans ^ sz) < sz) {
int num2 = sz - (ans ^ sz);
tmp = 0;
for (int j = 0; j < i->second.size(); j++) {
int s1 = i->second[j].first;
int s2 = i->second[j].second;
if (s2 < tmp) {
} else if (s1 < tmp) {
tmp = s2;
} else {
if (s1 - tmp >= num2) {
cout << 0 << " " << i->first << " " << tmp + num2 << " "
<< i->first << endl;
return 0;
} else {
num2 -= (s1 - tmp);
}
tmp = s2;
}
}
if (n - tmp >= num2) {
cout << 0 << " " << i->first << " " << tmp + num2 << " " << i->first
<< endl;
return 0;
}
}
}
if ((ans ^ m) < m) {
for (int i = 1; i < n; i++)
if (x.count(i) == 0) {
cout << i << " " << 0 << " " << i << " " << (m - (ans ^ m)) << endl;
return 0;
}
} else if ((ans ^ n) < n) {
for (int j = 1; j < m; j++)
if (y.count(j) == 0) {
cout << 0 << " " << j << " " << (n - (ans ^ n)) << " " << j << endl;
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
const double EPS = 1e-10;
const int INF = 1000 * 1000 * 1000;
const long long LINF = INF * 1ll * INF;
const double PI = 3.1415926535897932384626433832795;
long long sign(int a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
struct line {
int x0, asdy0, x2, y2;
vector<pair<int, int> > evs;
vector<pair<int, int> > pos;
int cnt;
int len;
void add(int a, int b) {
evs.push_back(make_pair(a, -1));
evs.push_back(make_pair(b, 1));
}
void process() {
len = abs(x2 - x0) + abs(y2 - asdy0);
sort((evs).begin(), (evs).end());
int d = 0;
int p = 0;
cnt = 0;
for (int i = 0; i < (((int)(evs).size())); ++i) {
int x = evs[i].first;
if (!d && x > p) {
pos.push_back(make_pair(p, x));
cnt += x - p;
}
d += evs[i].second;
if (!d) p = x;
}
if (p < len) {
pos.push_back(make_pair(p, len));
cnt += len - p;
}
}
void print_cut(int s) {
int i = 0;
while (pos[i].second - pos[i].first < s) {
s -= pos[i].second - pos[i].first;
++i;
}
int p = pos[i].first + s;
cout << x0 << ' ' << asdy0 << ' ' << x0 + p * sign(x2 - x0) << ' '
<< asdy0 + p * sign(y2 - asdy0) << '\n';
}
};
line ls[210000];
int lc;
map<int, int> rows;
map<int, int> cols;
int W, H;
line &get_row(int a) {
if (rows.count(a)) return ls[rows[a]];
line &res = ls[lc++];
res.x0 = 0;
res.x2 = W;
res.asdy0 = res.y2 = a;
rows[a] = lc - 1;
return res;
}
line &get_col(int a) {
if (cols.count(a)) return ls[cols[a]];
line &res = ls[lc++];
res.asdy0 = 0;
res.y2 = H;
res.x0 = res.x2 = a;
cols[a] = lc - 1;
return res;
}
int main() {
int k;
cin >> W >> H >> k;
for (int i = 0; i < (k); ++i) {
int x0, x2, asdy0, y2;
scanf("%d%d%d%d", &x0, &asdy0, &x2, &y2);
if (x2 < x0) swap(x0, x2);
if (y2 < asdy0) swap(asdy0, y2);
if (x0 == x2)
get_col(x0).add(asdy0, y2);
else
get_row(asdy0).add(x0, x2);
}
int q = 0;
for (int i = 1; i < W; ++i) {
if (q >= 2 && (W - 1 - ((int)(cols).size())) % 2 == 0) break;
if (cols.count(i)) continue;
get_col(i);
++q;
}
q = 0;
for (int i = 1; i < H; ++i) {
if (q >= 2 && (H - 1 - ((int)(rows).size())) % 2 == 0) break;
if (rows.count(i)) continue;
get_row(i);
++q;
}
int x = 0;
for (int i = 0; i < (lc); ++i) {
ls[i].process();
x ^= ls[i].cnt;
}
if (!x) {
cout << "SECOND";
return 0;
}
cout << "FIRST\n";
for (int i = 0; i < (lc); ++i) {
int y = x ^ ls[i].cnt;
if (y < ls[i].cnt) {
ls[i].print_cut(ls[i].cnt - y);
return 0;
}
}
exit(123);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp1, mp2;
struct node {
int dir;
int x1;
int y1;
int y2;
int len;
int nd;
} p[100011] = {0};
vector<node> v1[100011], v2[100011];
int siz1[100011], siz2[100011];
bool cmp(node a, node b) { return a.nd < b.nd; }
int main() {
int n, m, k;
while (scanf("%d%d%d", &n, &m, &k) > 0) {
for (int i = 0; i < k; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a == c) {
node temp;
if (b > d) swap(b, d);
temp.dir = 0;
temp.y1 = b;
temp.y2 = d;
temp.x1 = a;
temp.len = d - b;
temp.nd = b;
p[i] = temp;
int siz = mp1.size();
int k;
if (mp1[a] == 0)
k = mp1[a] = siz + 1;
else
k = mp1[a];
v1[k].push_back(temp);
} else {
node temp;
if (a > c) swap(a, c);
temp.dir = 1;
temp.y1 = a;
temp.y2 = c;
temp.x1 = b;
temp.len = c - a;
temp.nd = a;
int siz = mp2.size();
int k;
if (mp2[b] == 0)
k = mp2[b] = siz + 1;
else
k = mp2[b];
p[i] = temp;
v2[k].push_back(temp);
}
}
int x = mp1.size();
int y = mp2.size();
for (int i = 1; i <= mp1.size(); i++) sort(v1[i].begin(), v1[i].end(), cmp);
for (int i = 1; i <= mp2.size(); i++) sort(v2[i].begin(), v2[i].end(), cmp);
int res = 0;
res ^= ((n - 1 - mp1.size()) % 2) * m;
res ^= ((m - 1 - mp2.size()) % 2) * n;
for (int i = 1; i <= mp1.size(); i++) {
int now = 0;
int get = 0;
for (int j = 0; j < v1[i].size(); j++) {
node temp = v1[i][j];
if (temp.y1 > now) {
get += temp.y1 - now;
}
if (temp.y2 > now) now = temp.y2;
}
if (now < m) {
get += m - now;
}
res ^= get;
siz1[i] = get;
}
for (int i = 1; i <= mp2.size(); i++) {
int now = 0;
int get = 0;
int flag = (n == 200000 && v2[i][0].x1 == 17);
for (int j = 0; j < v2[i].size(); j++) {
node temp = v2[i][j];
if (temp.y1 > now) {
get += temp.y1 - now;
}
if (temp.y2 > now) now = temp.y2;
}
if (now < n) {
get += n - now;
}
res ^= get;
siz2[i] = get;
}
puts(res ? "FIRST" : "SECOND");
if (res) {
if (n - 1 > mp1.size()) {
int x = 1;
while (mp1[x]) x++;
mp1.erase(x);
if ((res ^ m) <= m) {
printf("%d %d %d %d\n", x, 0, x, m - (res ^ m));
goto loop;
}
}
if (m - 1 > mp2.size()) {
int x = 1;
while (mp2[x]) x++;
mp2.erase(x);
if ((res ^ n) <= n) {
printf("%d %d %d %d\n", 0, x, n - (res ^ n), x);
goto loop;
}
}
{
for (int i = 1; i <= mp1.size(); i++) {
if ((res ^ siz1[i]) <= siz1[i]) {
int tp = siz1[i] - (res ^ siz1[i]);
int now = 0;
int ress = 0;
int go = v1[i][0].x1;
for (int j = 0; j < v1[i].size(); j++) {
node temp = v1[i][j];
if (temp.y1 > now) ress += temp.y1 - now;
if (temp.y2 > now) now = temp.y2;
if (ress >= tp) {
printf("%d %d %d %d\n", go, 0, go, temp.y1 - (ress - tp));
goto loop;
}
}
printf("%d %d %d %d\n", go, 0, go, now - ress + tp);
goto loop;
}
}
for (int i = 1; i <= mp2.size(); i++) {
if ((res ^ siz2[i]) <= siz2[i]) {
int tp = siz2[i] - (res ^ siz2[i]);
int now = 0;
int ress = 0;
int go = v2[i][0].x1;
for (int j = 0; j < v2[i].size(); j++) {
node temp = v2[i][j];
if (temp.y1 > now) ress += temp.y1 - now;
if (temp.y2 > now) now = temp.y2;
if (ress >= tp) {
printf("%d %d %d %d\n", 0, go, temp.y1 - (ress - tp), go);
goto loop;
}
}
printf("%d %d %d %d\n", 0, go, now - ress + tp, go);
goto loop;
}
}
}
}
loop:;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > hr, vr;
struct node {
int ind;
bool is_hor;
int value;
vector<pair<int, int> > v;
};
void function_lel_it(vector<pair<int, int> > &v, vector<node> &n, bool is_hor,
int ind, int limit) {
node nd;
nd.value = limit;
nd.ind = ind;
nd.is_hor = is_hor;
sort(v.begin(), v.end());
int sz = 0;
int cnt = 0;
int last;
nd.v.push_back(pair<int, int>(0, 0));
for (int i = 0; i < v.size(); i++) {
if (!cnt) {
last = v[i].first;
}
cnt -= 2 * v[i].second - 1;
if (!cnt) {
nd.value -= (v[i].first - last), sz += (v[i].first - last);
nd.v.push_back(pair<int, int>(v[i].first - sz, v[i].first));
}
}
n.push_back(nd);
}
vector<node> vn;
int main() {
int n, m, k;
cin >> n >> m >> k;
while (k--) {
int i1, i2, j1, j2;
cin >> i1 >> j1 >> i2 >> j2;
if (i1 == i2) {
hr[i2].push_back(pair<int, int>(min(j1, j2), 0));
hr[i2].push_back(pair<int, int>(max(j1, j2), 1));
} else {
vr[j1].push_back(pair<int, int>(min(i1, i2), 0));
vr[j2].push_back(pair<int, int>(max(i1, i2), 1));
}
}
int lr = n - 1 - hr.size();
int lh = m - 1 - vr.size();
if (lr & 1) {
for (int i = 1; i < n; i++) {
if (hr.find(i) == hr.end()) {
hr[i];
break;
}
}
}
if (lh & 1) {
for (int i = 1; i < m; i++) {
if (vr.find(i) == vr.end()) {
vr[i];
break;
}
}
}
for (auto &it : hr) {
function_lel_it(it.second, vn, 1, it.first, m);
}
for (auto &it : vr) {
function_lel_it(it.second, vn, 0, it.first, n);
}
int ret = 0;
for (int i = 0; i < vn.size(); i++) {
ret ^= vn[i].value;
}
cout << ((ret != 0) ? "FIRST" : "SECOND") << endl;
if (ret == 0) return 0;
int backup = ret;
while ((backup & (backup - 1))) {
backup -= (backup & (-backup));
}
int first;
for (int i = 0; i < vn.size(); i++) {
if (vn[i].value & backup) {
first = i;
break;
}
}
int sheel = vn[first].value - (vn[first].value ^ ret);
int ind = int(upper_bound(vn[first].v.begin(), vn[first].v.end(),
pair<int, int>(sheel, (1 << 30))) -
vn[first].v.begin()) -
1;
int last = vn[first].v[ind].second + (sheel - (vn[first].v[ind].first));
if (vn[first].is_hor) {
cout << vn[first].ind << " " << 0 << " " << vn[first].ind << " " << last
<< endl;
} else
cout << 0 << " " << vn[first].ind << " " << last << " " << vn[first].ind
<< endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct p {
int start;
int end;
};
bool operator<(p a, p b) { return a.start < b.start; }
int N, M, K;
map<int, int> vx;
map<int, int> hy;
int revmv[100000];
int revmh[100000];
vector<p> vcuts[100000];
vector<p> hcuts[100000];
int main() {
cin >> N >> M >> K;
int vind = 0, hind = 0;
for (int i = 0; i < K; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a == c) {
if (b > d) {
b ^= d;
d ^= b;
b ^= d;
}
if (vx.find(a) == vx.end()) {
vx[a] = vind;
revmv[vind] = a;
vind++;
}
p j = {b, d};
vcuts[vx[a]].push_back(j);
}
if (b == d) {
if (a > c) {
a ^= c;
c ^= a;
a ^= c;
}
if (hy.find(b) == hy.end()) {
hy[b] = hind;
revmh[hind] = b;
hind++;
}
p j = {a, c};
hcuts[hy[b]].push_back(j);
}
}
int v[vind], h[hind];
for (int i = 0; i < vind; i++) {
sort(vcuts[i].begin(), vcuts[i].end());
v[i] = M;
}
for (int i = 0; i < hind; i++) {
sort(hcuts[i].begin(), hcuts[i].end());
h[i] = N;
}
int s, e;
for (int i = 0; i < vind; i++) {
s = vcuts[i][0].start;
e = vcuts[i][0].end;
for (vector<p>::iterator it = vcuts[i].begin() + 1; it < vcuts[i].end();
it++) {
if (it->start > e) {
v[i] -= e - s;
s = it->start;
e = it->end;
} else if (it->end > e) {
e = it->end;
}
}
v[i] -= e - s;
}
for (int i = 0; i < hind; i++) {
s = hcuts[i][0].start;
e = hcuts[i][0].end;
for (vector<p>::iterator it = hcuts[i].begin() + 1; it < hcuts[i].end();
it++) {
if (it->start > e) {
h[i] -= e - s;
s = it->start;
e = it->end;
} else if (it->end > e) {
e = it->end;
}
}
h[i] -= e - s;
}
int nimsum = 0;
for (int i = 0; i < vind; i++) {
nimsum ^= v[i];
}
for (int i = 0; i < hind; i++) {
nimsum ^= h[i];
}
if ((N - 1 - vind) % 2 != 0) {
nimsum ^= M;
}
if ((M - 1 - hind) % 2 != 0) {
nimsum ^= N;
}
if (nimsum == 0) {
cout << "SECOND";
return 0;
}
cout << "FIRST\n";
for (int i = 0; i < vind; i++) {
if ((v[i] ^ nimsum) < v[i]) {
if (v[i] == nimsum) {
cout << revmv[i] << " 0 " << revmv[i] << " " << M;
return 0;
}
s = 0;
e = 0;
int tot = 0;
for (vector<p>::iterator it = vcuts[i].begin(); it < vcuts[i].end();
it++) {
if (it->start > e) {
tot += (it->start) - e;
if (v[i] - tot <= (v[i] ^ nimsum)) {
cout << revmv[i] << " 0 " << revmv[i] << " "
<< ((it->start) - (tot - v[i] + (v[i] ^ nimsum)));
return 0;
}
s = it->start;
e = it->end;
} else if (it->end > e) {
e = it->end;
}
}
tot += M - e;
if (v[i] - tot <= (v[i] ^ nimsum)) {
cout << revmv[i] << " 0 " << revmv[i] << " "
<< (M - (tot - v[i] + (v[i] ^ nimsum)));
return 0;
}
}
}
for (int i = 0; i < hind; i++) {
if ((h[i] ^ nimsum) < h[i]) {
if (h[i] == nimsum) {
cout << "0 " << revmh[i] << " " << N << " " << revmh[i];
return 0;
}
s = 0;
e = 0;
int tot = 0;
for (vector<p>::iterator it = hcuts[i].begin(); it < hcuts[i].end();
it++) {
if (it->start > e) {
tot += (it->start) - e;
if (h[i] - tot <= (h[i] ^ nimsum)) {
cout << "0 " << revmh[i] << " "
<< ((it->start) - (tot - h[i] + (h[i] ^ nimsum))) << " "
<< revmh[i];
return 0;
}
s = it->start;
e = it->end;
} else if (it->end > e) {
e = it->end;
}
}
tot += M - e;
if (h[i] - tot <= (h[i] ^ nimsum)) {
cout << "0 " << revmh[i] << " " << (N - (tot - h[i] + (h[i] ^ nimsum)))
<< " " << revmh[i];
return 0;
}
}
}
if (vind < N - 1 && (M ^ nimsum) < M) {
for (int i = 1; i <= vind + 1; i++) {
if (vx.find(i) == vx.end()) {
cout << i << " 0 " << i << " " << (M - (M ^ nimsum));
return 0;
}
}
}
if (hind < M - 1 && (N ^ nimsum) < N) {
for (int i = 1; i <= hind + 1; i++) {
if (hy.find(i) == hy.end()) {
cout << "0 " << i << " " << (N - (N ^ nimsum)) << " " << i;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int>>> mp;
map<int, int> cntmp;
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int xl, yl, xr, yr;
cin >> xl >> yl >> xr >> yr;
int num, l, r;
if (xl == xr) {
num = xl - 1;
l = min(yl, yr);
r = max(yl, yr);
} else {
num = n - 1 + yl - 1;
l = min(xl, xr);
r = max(xl, xr);
}
mp[num].push_back(make_pair(l, r));
}
int sum = (((m - 1) % 2) * n) ^ (((n - 1) % 2) * m);
for (auto& iter : mp) {
sort(iter.second.begin(), iter.second.end());
int last = 0;
int cnt = 0;
for (auto& pr : iter.second) {
if (pr.first >= last) {
cnt += pr.second - pr.first;
last = pr.second;
} else if (pr.second >= last) {
cnt += pr.second - last;
last = pr.second;
}
}
cntmp[iter.first] = (iter.first < n - 1) ? m - cnt : n - cnt;
}
for (auto& iter : cntmp) {
sum = sum ^ ((iter.first < n - 1) ? m : n) ^ iter.second;
}
if (sum == 0) {
cout << "SECOND\n";
} else {
cout << "FIRST\n";
int next = 0;
auto iter = mp.begin();
if ((sum ^ m) < m) {
for (; iter != mp.end() && iter->first < n - 1; ++iter) {
if (next != iter->first) {
break;
}
next++;
}
if (next != n - 1) {
cout << next + 1 << " " << 0 << " " << next + 1 << " " << m - (sum ^ m)
<< "\n";
return 0;
}
}
if ((sum ^ n) < n) {
next = n - 1;
for (; iter != mp.end() && iter->first < n - 1; ++iter) {
}
for (; iter != mp.end() && iter->first < n + m - 2; ++iter) {
if (next != iter->first) {
break;
}
next++;
}
if (next != n + m - 2) {
cout << 0 << " " << next - n + 2 << " " << n - (sum ^ n) << " "
<< next - n + 2 << "\n";
return 0;
}
}
for (auto& iter : cntmp) {
if ((sum ^ iter.second) < iter.second) {
int black = 0;
int white = mp[iter.first].begin()->first;
int left = iter.second - (sum ^ iter.second);
int last = 0;
for (auto& pr : mp[iter.first]) {
if (left <= white) {
if (iter.first < n - 1) {
cout << iter.first + 1 << " " << 0 << " " << iter.first + 1 << " "
<< left + black << "\n";
} else {
cout << 0 << " " << iter.first - n + 2 << " " << left + black
<< " " << iter.first - n + 2 << "\n";
}
return 0;
}
if (pr.first >= last) {
black += pr.second - pr.first;
white += pr.first - last;
last = pr.second;
} else if (pr.second >= last) {
black += pr.second - last;
last = pr.second;
}
}
if (iter.first < n - 1) {
cout << iter.first + 1 << " " << 0 << " " << iter.first + 1 << " "
<< left + black << "\n";
} else {
cout << 0 << " " << iter.first - n + 2 << " " << left + black << " "
<< iter.first - n + 2 << "\n";
}
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
unordered_map<int, vector<int>> vcut, hcut;
unordered_map<int, int> vrem, hrem;
bool cmp(int x, int y) {
int ax = abs(x), ay = abs(y);
return ax < ay || (ax == ay && x < y);
}
int remaining(vector<int> &a, int last) {
int cur = 0, cnt = 0, ret = 0;
for (int x : a) {
int nxt = abs(x);
if (cnt == 0) ret += nxt - cur;
if (x < 0)
cnt--;
else
cnt++;
cur = nxt;
}
ret += last - cur;
return ret;
}
int find_cut(vector<int> &a, int target, int last) {
int lo = 0, hi = last - 1;
a.push_back(-last);
while (true) {
int mid = (lo + hi) / 2;
auto it = lower_bound(a.begin(), a.end(), mid, cmp);
it = a.insert(it, mid);
int rem = remaining(a, last);
a.erase(it);
if (rem == target) {
a.pop_back();
return mid;
} else if (rem < target)
lo = mid + 1;
else
hi = mid - 1;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
int xb, yb, xe, ye;
scanf("%d%d%d%d", &xb, &yb, &xe, &ye);
if (xb == xe) {
hcut[xb].push_back(min(yb, ye));
hcut[xb].push_back(-max(yb, ye));
} else {
vcut[yb].push_back(min(xb, xe));
vcut[yb].push_back(-max(xb, xe));
}
}
int grundy = 0;
if ((n - 1 - hcut.size()) % 2 == 1) grundy ^= m;
if ((m - 1 - vcut.size()) % 2 == 1) grundy ^= n;
for (auto &p : hcut) {
sort(p.second.begin(), p.second.end(), cmp);
hrem[p.first] = remaining(p.second, m);
grundy ^= hrem[p.first];
}
for (auto &p : vcut) {
sort(p.second.begin(), p.second.end(), cmp);
vrem[p.first] = remaining(p.second, n);
grundy ^= vrem[p.first];
}
if (grundy == 0) {
printf("SECOND\n");
return 0;
}
printf("FIRST\n");
if ((grundy ^ m) < m)
for (int i = 1; i < n; i++)
if (!hcut.count(i)) {
printf("%d %d %d %d\n", i, grundy ^ m, i, m);
return 0;
}
if ((grundy ^ n) < n)
for (int i = 1; i < m; i++)
if (!vcut.count(i)) {
printf("%d %d %d %d\n", grundy ^ n, i, n, i);
return 0;
}
for (auto &p : hcut) {
int target = grundy ^ hrem[p.first];
if (target < hrem[p.first]) {
printf("%d %d %d %d\n", p.first, find_cut(p.second, target, m), p.first,
m);
return 0;
}
}
for (auto &p : vcut) {
int target = grundy ^ vrem[p.first];
if (target < vrem[p.first]) {
printf("%d %d %d %d\n", find_cut(p.second, target, n), p.first, n,
p.first);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
map<int, vector<pair<int, int> > > sh, sv;
int fst(map<int, vector<pair<int, int> > >& m) {
if (!m.size()) return 1;
auto i = m.begin();
if (i->first > 1) return 1;
auto j = i;
j++;
while (j != m.end()) {
if (j->first > i->first + 1) return i->first + 1;
i++;
j++;
}
return m.rbegin()->first + 1;
}
int rm(vector<pair<int, int> >& v, int x) {
int tot = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i].first - tot >= x) return v[i].first - ((v[i].first - tot) - x);
tot += v[i].second - v[i].first;
}
int lft = x - (v.back().second - tot);
return lft + v.back().second;
}
int sum(vector<pair<int, int> >& v) {
int tot = 0;
for (int i = 0; i < v.size(); i++) tot += v[i].second - v[i].first;
return tot;
}
int fix(vector<pair<int, int> >& v) {
sort(v.begin(), v.end());
stack<pair<int, int> > ans;
ans.push(v[0]);
for (int i = 1; i < v.size(); i++) {
pair<int, int>& tp = ans.top();
pair<int, int>& p = v[i];
if (p.first <= tp.second)
tp.second = max(tp.second, p.second);
else
ans.push(p);
}
v.resize(ans.size());
for (int i = v.size() - 1; i >= 0; i--) {
v[i] = ans.top();
ans.pop();
}
return sum(v);
}
inline bool isg(int n, int m) { return ((m ^ n) < m); }
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
while (k--) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (y1 > y2) swap(y1, y2);
if (x1 > x2) swap(x1, x2);
if (x1 == x2)
sv[x1].push_back(make_pair(y1, y2));
else
sh[y1].push_back(make_pair(x1, x2));
}
int nim = 0;
for (__typeof((sv).begin()) i = (sv).begin(); i != (sv).end(); i++)
nim ^= m - fix(i->second);
if ((n - 1 - sv.size()) % 2 == 1) nim ^= m;
for (__typeof((sh).begin()) i = (sh).begin(); i != (sh).end(); i++)
nim ^= n - fix(i->second);
if ((m - 1 - sh.size()) % 2 == 1) nim ^= n;
if (nim == 0) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
if ((m - 1 - sh.size()) && isg(nim, n)) {
int x = fst(sh);
int r = n - (nim ^ n);
cout << 0 << ' ' << x << ' ' << r << ' ' << x << endl;
return 0;
}
if ((n - 1 - sv.size()) && isg(nim, m)) {
int x = fst(sv);
int r = m - (nim ^ m);
cout << x << ' ' << 0 << ' ' << x << ' ' << r << endl;
return 0;
}
for (__typeof((sv).begin()) i = (sv).begin(); i != (sv).end(); i++) {
int x = m - sum(i->second);
if (isg(nim, x)) {
int z = rm(i->second, (x - (nim ^ x)));
cout << (i->first) << ' ' << 0 << ' ' << (i->first) << ' ' << z << endl;
return 0;
}
}
for (__typeof((sh).begin()) i = (sh).begin(); i != (sh).end(); i++) {
int x = n - sum(i->second);
if (isg(nim, x)) {
int z = rm(i->second, (x - (nim ^ x)));
cout << 0 << ' ' << (i->first) << ' ' << z << ' ' << i->first << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct segm {
bool vert;
bool valid;
int sx, sy, ex, ey;
int len;
segm(int _sx = 0, int _sy = 0, int _ex = 0, int _ey = 0) {
sx = _sx;
sy = _sy;
ex = _ex;
ey = _ey;
build();
}
void build() {
if (sx > ex) swap(sx, ex);
if (sy > ey) swap(sy, ey);
vert = (sx == ex);
valid = 1;
recLen();
}
void recLen() { len = ex + ey - sx - sy; }
void merge(segm& other) {
if (vert != other.vert) return;
if (vert) {
if (other.sx != sx) return;
if (other.sy <= ey) {
valid = 0;
other.sy = sy;
other.ey = max(ey, other.ey);
}
} else {
if (other.sy != sy) return;
if (other.sx <= ex) {
valid = 0;
other.sx = sx;
other.ex = max(ex, other.ex);
}
}
recLen();
other.recLen();
}
};
bool operator<(const segm& s1, const segm& s2) {
if (s1.vert && !s2.vert) return true;
if (!s1.vert && s2.vert) return false;
if (s1.vert) {
if (s1.sx != s2.sx) return s1.sx < s2.sx;
return s1.sy < s2.sy;
}
if (s1.sy != s2.sy) return s1.sy < s2.sy;
return s1.sx < s2.sx;
}
const int MAXVAL = 100005;
int leftLengthW[100005], leftLengthH[100005];
vector<segm> segmsVert[100005], segmsHor[100005];
int main() {
clock_t cl = clock();
vector<segm> segms;
int w, h, k;
scanf("%d%d%d", &w, &h, &k);
segms.resize(k);
for (int i = (0), endi = (k); i < endi; i++) {
scanf("%d%d%d%d", &(segms[i].sx), &(segms[i].sy), &(segms[i].ex),
&(segms[i].ey));
segms[i].build();
}
sort((segms).begin(), (segms).end());
for (int i = (0), endi = (MAXVAL); i < endi; i++) {
leftLengthW[i] = w;
leftLengthH[i] = h;
}
map<int, int> lengthsW, lengthsH;
for (int i = (0), endi = (k); i < endi; i++) {
if (i < k - 1) segms[i].merge(segms[i + 1]);
if (segms[i].valid) {
if (segms[i].vert) {
if (segms[i].sx < MAXVAL) {
leftLengthH[segms[i].sx] -= segms[i].len;
segmsVert[segms[i].sx].push_back(segms[i]);
}
if (lengthsH.find(segms[i].sx) == lengthsH.end()) {
lengthsH[segms[i].sx] = h - segms[i].len;
} else
lengthsH[segms[i].sx] -= segms[i].len;
}
if (!segms[i].vert) {
if (segms[i].sy < MAXVAL) {
leftLengthW[segms[i].sy] -= segms[i].len;
segmsHor[segms[i].sy].push_back(segms[i]);
}
if (lengthsW.find(segms[i].sy) == lengthsW.end()) {
lengthsW[segms[i].sy] = w - segms[i].len;
} else
lengthsW[segms[i].sy] -= segms[i].len;
}
}
}
int leftW = (h - 1 - lengthsW.size());
int leftH = (w - 1 - lengthsH.size());
int xorSum = 0;
if (leftW & 1) xorSum ^= w;
if (leftH & 1) xorSum ^= h;
for (map<int, int>::iterator it = lengthsW.begin(), itEnd = lengthsW.end();
it != itEnd; it++) {
xorSum ^= it->second;
}
for (map<int, int>::iterator it = lengthsH.begin(), itEnd = lengthsH.end();
it != itEnd; it++) {
xorSum ^= it->second;
}
if (xorSum) {
printf("FIRST\n");
int sx, sy, ex, ey;
bool found = 0;
for (int i = (1), endi = (min(MAXVAL, w)); i < endi; i++) {
if (found) break;
int cVal = h;
if (lengthsH.find(i) != lengthsH.end()) {
cVal = lengthsH.find(i)->second;
}
if (cVal >= (cVal ^ xorSum)) {
found = 1;
sx = ex = i;
sy = 0;
ey = 0;
int segmsLen = 0;
int needed = cVal - (cVal ^ xorSum);
for (int j = (0), endj = (segmsVert[i].size()); j < endj; j++) {
if (segmsVert[i][j].sy - segmsLen >= needed) break;
segmsLen += segmsVert[i][j].len;
}
ey = needed + segmsLen;
}
}
for (int i = (1), endi = (min(MAXVAL, h)); i < endi; i++) {
if (found) break;
int cVal = w;
if (lengthsW.find(i) != lengthsW.end()) {
cVal = lengthsW.find(i)->second;
}
if (cVal >= (cVal ^ xorSum)) {
found = 1;
sy = ey = i;
sx = 0;
ex = 0;
int segmsLen = 0;
int needed = cVal - (cVal ^ xorSum);
for (int j = (0), endj = (segmsHor[i].size()); j < endj; j++) {
if (segmsHor[i][j].sx - segmsLen >= needed) break;
segmsLen += segmsHor[i][j].len;
}
ex = needed + segmsLen;
}
}
printf("%d %d %d %d\n", sx, sy, ex, ey);
} else {
printf("SECOND\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int tt = 100005;
struct vl {
int a, b, c;
vl() {}
vl(int aa, int bb, int cc) { a = aa, b = bb, c = cc; }
bool operator<(const vl &y) const { return c < y.c || c == y.c && a < y.a; }
} x[tt], y[tt];
struct gs {
int ps, sg;
gs() {}
gs(int p, int g) { ps = p, sg = g; }
} px[tt], py[tt];
int main() {
int n, m, k, i, a, b, c, d, k1 = 0, k2 = 0, t1 = 0, t2 = 0, sg, lst, xx, yy,
mi, til;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < k; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a > c) swap(a, c);
if (b > d) swap(b, d);
if (b == d)
x[k1++] = vl(a, c, b);
else
y[k2++] = vl(b, d, a);
}
sort(x, x + k1);
sort(y, y + k2);
sg = (n % 2 ? 0 : m) ^ (m % 2 ? 0 : n);
for (lst = xx = 0, i = 0; i <= k1; i++) {
if (i == k1 && lst != m - 1 || i != k1 && x[i].c > lst + 1) xx = lst + 1;
if (i == k1 || x[i].c != lst) {
if (i) {
sg ^= n - mi;
px[t1++] = gs(x[i - 1].c, n - mi);
}
til = mi = 0;
if (i == k1) break;
sg ^= n;
}
if (x[i].b > til) {
mi += x[i].b - max(til, x[i].a);
til = x[i].b;
}
lst = x[i].c;
}
for (lst = yy = 0, i = 0; i <= k2; i++) {
if (i == k2 && lst != n - 1 || i != k2 && y[i].c > lst + 1) yy = lst + 1;
if (i == k2 || y[i].c != lst) {
if (i) {
sg ^= m - mi;
py[t2++] = gs(y[i - 1].c, m - mi);
}
til = mi = 0;
if (i == k2) break;
sg ^= m;
}
if (y[i].b > til) {
mi += y[i].b - max(til, y[i].a);
til = y[i].b;
}
lst = y[i].c;
}
if (xx) px[t1++] = gs(xx, n);
if (yy) py[t2++] = gs(yy, m);
if (sg == 0)
puts("SECOND");
else {
puts("FIRST");
for (i = 0; i < t1; i++)
if ((sg ^ px[i].sg) < px[i].sg) break;
if (i == t1) {
for (i = 0; i < t2; i++)
if ((sg ^ py[i].sg) < py[i].sg) break;
yy = py[i].ps, lst = py[i].sg - (sg ^ py[i].sg);
printf("%d 0 ", yy);
for (til = 0, i = 0; i < k2; i++)
if (y[i].c == yy) {
if (y[i].a > til) {
if (lst <= y[i].a - til)
break;
else
lst -= y[i].a - til;
}
if (y[i].b > til) til = y[i].b;
}
printf("%d %d\n", yy, til + lst);
} else {
xx = px[i].ps, lst = px[i].sg - (sg ^ px[i].sg);
printf("0 %d ", xx);
for (til = 0, i = 0; i < k1; i++)
if (x[i].c == xx) {
if (x[i].a > til) {
if (lst <= x[i].a - til)
break;
else
lst -= x[i].a - til;
}
if (x[i].b > til) til = x[i].b;
}
printf("%d %d\n", til + lst, xx);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > mx, my;
map<int, int> mp;
vector<pair<int, int> > event;
vector<pair<int, int> > vx, vy;
void func(int type, int id, int X, vector<pair<int, int> > v) {
int i;
event.clear();
event.push_back(make_pair(0, 1));
event.push_back(make_pair(X, -1));
for ((i) = 0; (i) < (int)(v.size()); (i)++) {
event.push_back(make_pair(v[i].first, -1));
event.push_back(make_pair(v[i].second, 1));
}
int total = 0;
int cur = 0;
int sz = event.size();
sort(event.begin(), event.end());
for ((i) = 0; (i) < (int)(sz - 1); (i)++) {
cur += event[i].second;
if (cur > 0) total += event[i + 1].first - event[i].first;
}
if (type == 0) {
vx.push_back(make_pair(id, total));
} else {
vy.push_back(make_pair(id, total));
}
mp[X]--;
mp[total]++;
}
int cut_x(int x, int target) {
int i;
vector<pair<int, int> > v = mx[x];
event.clear();
event.push_back(make_pair(0, 1));
event.push_back(make_pair(1000000000, -1));
for ((i) = 0; (i) < (int)(v.size()); (i)++) {
event.push_back(make_pair(v[i].first, -1));
event.push_back(make_pair(v[i].second, 1));
}
int total = 0;
int cur = 0;
int sz = event.size();
sort(event.begin(), event.end());
for ((i) = 0; (i) < (int)(sz - 1); (i)++) {
cur += event[i].second;
if (cur > 0) {
int d = event[i + 1].first - event[i].first;
if (d >= target) {
return event[i].first + target;
} else {
target -= d;
}
}
}
return -1;
}
int cut_y(int y, int target) {
int i;
vector<pair<int, int> > v = my[y];
event.clear();
event.push_back(make_pair(0, 1));
event.push_back(make_pair(1000000000, -1));
for ((i) = 0; (i) < (int)(v.size()); (i)++) {
event.push_back(make_pair(v[i].first, -1));
event.push_back(make_pair(v[i].second, 1));
}
int total = 0;
int cur = 0;
int sz = event.size();
sort(event.begin(), event.end());
for ((i) = 0; (i) < (int)(sz - 1); (i)++) {
cur += event[i].second;
if (cur > 0) {
int d = event[i + 1].first - event[i].first;
if (d >= target) {
return event[i].first + target;
} else {
target -= d;
}
}
}
return -1;
}
int freex(int X) {
int i;
for (i = 1; i < X; i++) {
if (i > 100010) break;
if (mx.find(i) == mx.end()) return i;
}
return -1;
}
int freey(int Y) {
int i;
for (i = 1; i < Y; i++) {
if (i > 100010) break;
if (my.find(i) == my.end()) return i;
}
return -1;
}
int main(void) {
int X, Y, N, x1, x2, y1, y2, i;
cin >> X >> Y >> N;
for ((i) = 0; (i) < (int)(N); (i)++) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
mx[x1].push_back(make_pair(y1, y2));
} else {
if (x1 > x2) swap(x1, x2);
my[y1].push_back(make_pair(x1, x2));
}
}
mp[X] += Y - 1;
mp[Y] += X - 1;
for (__typeof((mx).begin()) itr = (mx).begin(); itr != (mx).end(); itr++)
func(0, (itr->first), Y, (itr->second));
for (__typeof((my).begin()) itr = (my).begin(); itr != (my).end(); itr++)
func(1, (itr->first), X, (itr->second));
int nim = 0;
for (__typeof((mp).begin()) itr = (mp).begin(); itr != (mp).end(); itr++)
if ((itr->second) % 2 == 1) nim ^= (itr->first);
if (nim == 0) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
int tmp = freex(X);
if (tmp != -1 && (Y ^ nim) < Y) {
cout << tmp << ' ' << 0 << ' ' << tmp << ' ' << Y - (Y ^ nim) << endl;
return 0;
}
tmp = freey(Y);
if (tmp != -1 && (X ^ nim) < X) {
cout << 0 << ' ' << tmp << ' ' << X - (X ^ nim) << ' ' << tmp << endl;
return 0;
}
for ((i) = 0; (i) < (int)(vx.size()); (i)++) {
int x = vx[i].first;
int total = vx[i].second;
if ((total ^ nim) < total) {
int tmp = cut_x(x, total - (total ^ nim));
cout << x << ' ' << 0 << ' ' << x << ' ' << tmp << endl;
return 0;
}
}
for ((i) = 0; (i) < (int)(vy.size()); (i)++) {
int y = vy[i].first;
int total = vy[i].second;
if ((total ^ nim) < total) {
int tmp = cut_y(y, total - (total ^ nim));
cout << 0 << ' ' << y << ' ' << tmp << ' ' << y << endl;
return 0;
}
}
cout << "failed" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int size(T &a) {
return (int)a.size();
}
template <typename T>
T sqr(T a) {
return a * a;
}
int getBit(int mask, int pos) { return ((mask >> pos) & 1); }
struct Segment {
int xs, ys, xe, ye;
Segment() {}
Segment(int xs, int ys, int xe, int ye) : xs(xs), ys(ys), xe(xe), ye(ye) {
norm();
}
bool operator<(const Segment &s) const {
if (xs != s.xs) return xs < s.xs;
if (ys != s.ys) return ys < s.ys;
if (xe != s.xe) return xe < s.xe;
return ye < s.ye;
}
void norm() {
if (vert() && ys > ye) {
swap(ys, ye);
} else if (!vert() && xs > xe) {
swap(xs, xe);
}
}
bool vert() { return ys != ye; }
};
map<int, vector<Segment> > vert, hor;
int n, m, k;
int getFree(map<int, vector<Segment> > &m, int n) {
int ret = 1;
while (ret < n && size(m[ret]) > 0) ret++;
if (ret >= n) ret = -1;
return ret;
}
int getSize(vector<Segment> &v, int m) {
sort(v.begin(), v.end());
int ret = 0;
int start = 0;
for (int i = (0); i < (size(v)); ++i) {
if (v[i].vert()) {
ret += max(0, v[i].ys - start);
start = max(start, v[i].ye);
} else {
ret += max(0, v[i].xs - start);
start = max(start, v[i].xe);
}
}
ret += max(0, m - start);
return ret;
}
bool getMove(vector<Segment> &v, int m, int len, pair<int, int> &move) {
int start = 0;
for (int i = (0); i < (size(v)); ++i) {
if (v[i].vert()) {
int d = max(0, v[i].ys - start);
if (d >= len) {
start += len;
len = 0;
break;
}
len -= d;
start = max(start, v[i].ye);
} else {
int d = max(0, v[i].xs - start);
if (d >= len) {
start += len;
len = 0;
break;
}
len -= d;
start = max(start, v[i].xe);
}
}
{
int d = max(0, m - start);
if (d >= len) {
start += len;
}
len -= d;
}
if (len > 0) return false;
move = make_pair(0, start);
return true;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = (0); i < (k); ++i) {
int xs, ys, xe, ye;
scanf("%d %d %d %d", &xs, &ys, &xe, &ye);
if (xs == xe) {
vert[xs].push_back(Segment(xs, ys, xe, ye));
} else {
hor[ys].push_back(Segment(xs, ys, xe, ye));
}
}
int sum = 0;
if (((n - 1) - size(vert)) & 1) sum ^= m;
if (((m - 1) - size(hor)) & 1) sum ^= n;
for (map<int, vector<Segment> >::iterator it = vert.begin(); it != vert.end();
it++) {
sum ^= getSize(it->second, m);
}
for (map<int, vector<Segment> >::iterator it = hor.begin(); it != hor.end();
it++) {
sum ^= getSize(it->second, n);
}
if (sum) {
puts("FIRST");
} else {
puts("SECOND");
return 0;
}
int bitMove = 31;
while (bitMove >= 0) {
if (getBit(sum, bitMove)) break;
bitMove--;
}
assert(bitMove >= 0);
int freeX = getFree(vert, n);
int freeY = getFree(hor, m);
pair<int, int> move;
bool ok = false;
if (!ok) {
int x = -1;
if (freeX >= 0 && getBit(m, bitMove)) {
ok = getMove(vert[freeX], m, m - (sum ^ m), move);
assert(ok);
x = freeX;
} else {
for (map<int, vector<Segment> >::iterator it = vert.begin();
it != vert.end(); it++) {
int sz = getSize(it->second, m);
if (getBit(sz, bitMove)) {
ok = getMove(it->second, m, sz - (sum ^ sz), move);
assert(ok);
x = it->first;
break;
}
}
}
if (ok) {
printf("%d %d %d %d\n", x, move.first, x, move.second);
}
}
if (!ok) {
int y = -1;
if (freeY >= 0 && getBit(n, bitMove)) {
ok = getMove(hor[freeY], n, n - (sum ^ n), move);
assert(ok);
y = freeY;
} else {
for (map<int, vector<Segment> >::iterator it = hor.begin();
it != hor.end(); it++) {
int sz = getSize(it->second, n);
if (getBit(sz, bitMove)) {
ok = getMove(it->second, n, sz - (sz ^ sum), move);
assert(ok);
y = it->first;
break;
}
}
}
printf("%d %d %d %d\n", move.first, y, move.second, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100007;
int n, m, k;
int a[MAXN][3], b[MAXN][3];
void Add(int a[][3], int x, int y1, int y2) {
a[0][0]++;
int t = a[0][0];
if (y1 > y2) swap(y1, y2);
y2--;
a[t][0] = x;
a[t][1] = y1;
a[t][2] = y2;
}
int ans = 0;
map<int, int> r1, r2;
inline int cmp(const void *a, const void *b) {
int t = ((int *)a)[0] - ((int *)b)[0];
if (t != 0) return t;
return ((int *)a)[1] - ((int *)b)[1];
}
int ma;
bool chk(int a[][3], int l, int r, int rl, int mid) {
int l0 = ma - mid;
for (int j = l; j <= r; j++) {
int rr = a[j][2], ed2 = j;
while (ed2 < r && a[ed2 + 1][1] <= rr + 1) {
rr = max(rr, a[ed2 + 1][2]);
ed2++;
}
int ll = a[j][1];
if (ll < mid) ll = mid;
if (rr - ll + 1 > 0) l0 -= rr - ll + 1;
j = ed2;
}
return l0 >= rl;
}
int solve(int a[][3], int x, int rl) {
for (int p = 1; p <= a[0][0]; p++) {
if (a[p][0] == x) {
int l, r;
l = p;
for (int i = p;; i++) {
if (a[i][0] != x) {
r = i - 1;
break;
}
}
int cl = 1, cr = max(n, m);
while (cl < cr) {
int mid = (cl + cr + 1) >> 1;
if (chk(a, l, r, rl, mid))
cl = mid;
else
cr = mid - 1;
}
return cl;
}
}
return ma - rl;
}
void work() {
qsort(a + 1, a[0][0], sizeof(a[0]), cmp);
qsort(b + 1, b[0][0], sizeof(b[0]), cmp);
for (int i = 1; i <= a[0][0]; i++) {
int ed = i;
while (ed < a[0][0] && a[ed + 1][0] == a[i][0]) ed++;
int l0 = m;
for (int j = i; j <= ed; j++) {
int r = a[j][2], ed2 = j;
while (ed2 < ed && a[ed2 + 1][1] <= r + 1) {
r = max(r, a[ed2 + 1][2]);
ed2++;
}
l0 -= r - a[j][1] + 1;
j = ed2;
}
i = ed;
r1[a[i][0]] = l0;
ans ^= m ^ l0;
}
for (int i = 1; i <= b[0][0]; i++) {
int ed = i;
while (ed < b[0][0] && b[ed + 1][0] == b[i][0]) ed++;
int l0 = n;
for (int j = i; j <= ed; j++) {
int r = b[j][2], ed2 = j;
while (ed2 < ed && b[ed2 + 1][1] <= r + 1) {
r = max(r, b[ed2 + 1][2]);
ed2++;
}
l0 -= r - b[j][1] + 1;
j = ed2;
}
i = ed;
ans ^= n ^ l0;
r2[b[i][0]] = l0;
}
if (ans == 0)
printf("SECOND\n");
else {
printf("FIRST\n");
for (int i = 1; i <= min(n - 1, k + 10); i++) {
int rl = m;
if (r1.count(i)) rl = r1[i];
if ((ans ^ rl) < rl) {
ma = m;
cout << i << ' ' << 0 << ' ' << i << ' '
<< min(solve(a, i, (ans ^ rl)), m) << endl;
exit(0);
}
}
for (int i = 1; i <= min(m - 1, k + 10); i++) {
int rl = n;
if (r2.count(i)) rl = r2[i];
if ((ans ^ rl) < rl) {
ma = n;
cout << 0 << ' ' << i << ' ' << min(solve(b, i, (ans ^ rl)), n) << ' '
<< i << endl;
exit(0);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2)
Add(a, x1, y1, y2);
else
Add(b, y1, x1, x2);
}
if (n % 2 == 0) ans ^= m;
if (m % 2 == 0) ans ^= n;
work();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int nmax = 100100;
vector<pair<int, int> > seg[2][nmax];
vector<pair<int, int> > sg[2][nmax];
int val[2][nmax];
map<int, int> M[2];
map<int, int> f;
void upd(int i, int d) {
for (; i < 1000000000 + 100; i |= i + 1) f[i] += d;
}
int sum(int r) {
int res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res += f[r];
return res;
}
int main() {
int n, m, k;
int x1, x2, y1, y2, x, y;
int idx;
scanf("%d%d%d", &n, &m, &k);
for (int(i) = 0; (i) < (k); ++(i)) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2) {
x = x1;
if (M[0].count(x)) {
idx = M[0][x];
} else {
idx = (int((M[0]).size()));
M[0][x] = idx;
}
val[0][idx] = x;
seg[0][idx].push_back(make_pair((y1), (-1)));
seg[0][idx].push_back(make_pair((y2), (+1)));
} else {
y = y1;
if (M[1].count(y)) {
idx = M[1][y];
} else {
idx = (int((M[1]).size()));
M[1][y] = idx;
}
val[1][idx] = y;
seg[1][idx].push_back(make_pair((x1), (-1)));
seg[1][idx].push_back(make_pair((x2), (+1)));
}
}
int count[2] = {(int((M[0]).size())), (int((M[1]).size()))};
int xum = (((m - 1) & 1) * n) ^ (((n - 1) & 1) * m);
for (int(t) = 0; (t) < (2); ++(t)) {
for (int(i) = 0; (i) < (count[t]); ++(i)) {
sort((seg[t][i]).begin(), (seg[t][i]).end());
int l = -1000000000;
int open = 0;
int lenDel = 0;
for (int(j) = 0; (j) < (int((seg[t][i]).size())); ++(j)) {
if (open == 0) {
l = seg[t][i][j].first;
}
open -= seg[t][i][j].second;
if (open == 0) {
sg[t][i].push_back(make_pair((l), (seg[t][i][j].first)));
lenDel += seg[t][i][j].first - l;
}
}
if (t == 0) {
xum ^= m;
xum ^= (m - lenDel);
} else {
xum ^= n;
xum ^= (n - lenDel);
}
}
}
if (xum == 0) {
printf("SECOND\n");
return 0;
} else {
printf("FIRST\n");
for (int(t) = 0; (t) < (2); ++(t)) {
if (t == 0) {
int rest = m;
int needleft = rest ^ xum;
int needdel = rest - needleft;
if (count[t] < n - 1 && needleft < rest) {
for (int i = 1;; ++i) {
if (M[t].count(i) == 0) {
printf("%d %d %d %d\n", i, 0, i, needdel);
return 0;
}
}
}
} else {
int rest = n;
int needleft = rest ^ xum;
int needdel = rest - needleft;
if (count[t] < m - 1 && needleft < rest) {
for (int i = 1;; ++i) {
if (M[t].count(i) == 0) {
printf("%d %d %d %d\n", 0, i, needdel, i);
return 0;
}
}
}
}
for (int(i) = 0; (i) < (count[t]); ++(i)) {
int lenDel = 0;
for (int(j) = 0; (j) < (int((sg[t][i]).size())); ++(j)) {
lenDel += sg[t][i][j].second - sg[t][i][j].first;
}
int rest;
if (t == 0) {
rest = m - lenDel;
} else {
rest = n - lenDel;
}
int needleft = rest ^ xum;
int needdel = rest - needleft;
if (needleft < rest) {
vector<pair<int, int> > res;
res.push_back(make_pair((0), (sg[t][i][0].first)));
for (int(j) = 0; (j) < (int((sg[t][i]).size())); ++(j))
if (j != 0) {
res.push_back(
make_pair((sg[t][i][j - 1].second), (sg[t][i][j].first)));
}
res.push_back(
make_pair((sg[t][i].rbegin()[0].second), (t == 0 ? m : n)));
int curlen = 0;
int R = -1000000000;
for (int(j) = 0; (j) < (int((res).size())); ++(j)) {
if (curlen + (res[j].second - res[j].first) >= needdel) {
R = res[j].first + (needdel - curlen);
break;
}
curlen += res[j].second - res[j].first;
}
if (t == 0) {
printf("%d %d %d %d\n", val[t][i], 0, val[t][i], R);
} else {
printf("%d %d %d %d\n", 0, val[t][i], R, val[t][i]);
}
return 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > x2, y2, t;
vector<pair<int, pair<int, int> > > x, y;
int cal(int len, int want) {
sort(t.begin(), t.end());
t.push_back(make_pair(len, len));
vector<pair<int, int> > s;
int now = 0, i;
for (i = 0; i < t.size(); i++) {
if (now < t[i].first) s.push_back(make_pair(now, t[i].first));
now = max(now, t[i].second);
}
for (i = 0; i < s.size(); i++) {
if (want <= s[i].second - s[i].first) return s[i].first + want;
want -= s[i].second - s[i].first;
}
return -1;
}
int main() {
int i, j, n, m, k, xa, xb, ya, yb, gran = 0;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
scanf("%d %d %d %d", &xa, &ya, &xb, &yb);
if (xa == xb) {
if (ya > yb) swap(ya, yb);
x.push_back(make_pair(xa, make_pair(ya, yb)));
}
if (ya == yb) {
if (xa > xb) swap(xa, xb);
y.push_back(make_pair(ya, make_pair(xa, xb)));
}
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
x.push_back(make_pair(1234567890, make_pair(0, 0)));
y.push_back(make_pair(1234567890, make_pair(0, 0)));
int sum = 0, now = 0;
for (i = 0; i < x.size(); i++) {
if (i > 0 && x[i].first > x[i - 1].first) {
x2.push_back(make_pair(x[i - 1].first, m - sum));
sum = now = 0;
}
sum += max(0, x[i].second.second - max(now, x[i].second.first));
now = max(now, x[i].second.second);
}
sum = now = 0;
for (i = 0; i < y.size(); i++) {
if (i > 0 && y[i].first > y[i - 1].first) {
y2.push_back(make_pair(y[i - 1].first, n - sum));
sum = now = 0;
}
sum += max(0, y[i].second.second - max(now, y[i].second.first));
now = max(now, y[i].second.second);
}
int xs = x2.size(), ys = y2.size(), xe = -1, ye = -1;
for (i = 0; i < xs; i++) gran ^= x2[i].second;
if ((n - 1 - xs) % 2 > 0) gran ^= m;
for (i = 0; i < ys; i++) gran ^= y2[i].second;
if ((m - 1 - ys) % 2 > 0) gran ^= n;
if (gran < 1) {
cout << "SECOND" << endl;
return 0;
}
cout << "FIRST" << endl;
if (xs < 1) xe = 1;
if (xs > 0 && n - 1 - xs > 0) {
if (x2[0].first > 1) xe = 1;
if (x2[xs - 1].first < n - 1) xe = n - 1;
for (i = 0; i < xs - 1; i++) {
if (x2[i].first + 1 < x2[i + 1].first) xe = x2[i].first + 1;
}
}
if (ys < 1) ye = 1;
if (ys > 0 && n - 1 - ys > 0) {
if (y2[0].first > 1) ye = 1;
if (y2[ys - 1].first < n - 1) ye = n - 1;
for (i = 0; i < ys - 1; i++) {
if (y2[i].first + 1 < y2[i + 1].first) ye = y2[i].first + 1;
}
}
if (n - 1 - xs > 0 && (m ^ gran) < m) {
cout << xe << " 0 " << xe << ' ' << (m - (m ^ gran)) << endl;
return 0;
}
if (m - 1 - ys > 0 && (n ^ gran) < n) {
cout << "0 " << ye << ' ' << (n - (n ^ gran)) << ' ' << ye << endl;
return 0;
}
for (i = 0; i < xs; i++) {
if ((x2[i].second ^ gran) < x2[i].second) {
for (j = 0; j < x.size(); j++) {
if (x[j].first == x2[i].first) t.push_back(x[j].second);
}
cout << x2[i].first << " 0 " << x2[i].first << ' '
<< cal(m, x2[i].second - (x2[i].second ^ gran)) << endl;
return 0;
}
}
for (i = 0; i < ys; i++) {
if ((y2[i].second ^ gran) < y2[i].second) {
for (j = 0; j < y.size(); j++) {
if (y[j].first == y2[i].first) t.push_back(y[j].second);
}
cout << "0 " << y2[i].first << ' '
<< cal(n, y2[i].second - (y2[i].second ^ gran)) << ' ' << y2[i].first
<< endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct Line {
vector<int> points;
vector<pair<int, int> > seg;
bool hor;
int id;
int getlen() {
int ans = 0;
int bal = 0;
vector<pair<int, int> > evs;
for (int i = 0; i < (int)seg.size(); i++) {
evs.push_back(make_pair(seg[i].first, 1));
evs.push_back(make_pair(seg[i].second, -1));
}
evs.push_back(make_pair(0, 0));
evs.push_back(make_pair(hor ? m : n, -1000));
sort(evs.begin(), evs.end());
points.clear();
for (int i = 0; i < (int)evs.size(); i++) {
bal += evs[i].second;
if (bal == 0) {
ans += evs[i + 1].first - evs[i].first;
points.push_back(evs[i].first);
points.push_back(evs[i + 1].first);
}
}
return ans;
}
void getkth(int k, int& x, int& y) {
assert(k >= 0);
x = id;
y = -1;
for (int i = 0; i < (int)points.size(); i += 2)
if (k <= points[i + 1] - points[i]) {
y = points[i] + k;
break;
} else {
k -= points[i + 1] - points[i];
}
assert(y != -1);
if (!hor) swap(x, y);
}
};
map<int, int> horid;
vector<Line> hor;
map<int, int> vertid;
vector<Line> vert;
int getid(map<int, int>& a, int b) {
if (a.find(b) == a.end()) {
int t = a.size();
a[b] = t;
}
return a[b];
}
int main() {
scanf("%d %d", &n, &m);
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2) {
int id = getid(horid, x1);
if (id == (int)hor.size()) {
hor.push_back(Line());
hor.back().id = x1;
hor.back().hor = true;
}
assert(id < (int)hor.size());
hor[id].seg.push_back(make_pair(y1, y2));
} else {
int id = getid(vertid, y1);
if (id == (int)vert.size()) {
vert.push_back(Line());
vert.back().id = y1;
vert.back().hor = false;
}
assert(id < (int)vert.size());
vert[id].seg.push_back(make_pair(x1, x2));
}
}
int cnt = 2 - (n - hor.size() + 1) % 2;
for (int i = 1; i <= n - 1 && cnt > 0; i++)
if (horid.find(i) == horid.end()) {
hor.push_back(Line());
hor.back().id = i;
hor.back().hor = true;
cnt--;
}
cnt = 2 - (m - vert.size() + 1) % 2;
for (int i = 1; i <= m - 1 && cnt > 0; i++)
if (vertid.find(i) == vertid.end()) {
vert.push_back(Line());
vert.back().id = i;
vert.back().hor = false;
cnt--;
}
int g = 0;
for (int i = 0; i < (int)hor.size(); i++) {
int t = hor[i].getlen();
;
g ^= t;
}
for (int i = 0; i < (int)vert.size(); i++) {
int t = vert[i].getlen();
;
g ^= t;
}
if (g == 0) {
puts("SECOND");
return 0;
}
puts("FIRST");
for (int i = 0; i < (int)hor.size(); i++) {
int t = hor[i].getlen();
if ((t ^ g) < t) {
int x, y;
hor[i].getkth(t - (t ^ g), x, y);
printf("%d %d %d %d\n", x, 0, x, y);
return 0;
}
}
for (int i = 0; i < (int)vert.size(); i++) {
int t = vert[i].getlen();
if ((t ^ g) < t) {
int x, y;
vert[i].getkth(t - (t ^ g), x, y);
printf("%d %d %d %d\n", 0, y, x, y);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mx, my;
vector<int> a;
int shx[100005], shy[100005];
vector<pair<int, int> > vx[100005], vy[100005];
int cntx, cnty, m, n;
void vertical(int x, int y1, int y2) {
if (y1 > y2) swap(y1, y2);
if (mx.find(x) == mx.end()) mx[x] = cntx++;
shx[mx[x]] = x;
vx[mx[x]].push_back(make_pair(y1, y2));
}
void horizontal(int y, int x1, int x2) {
if (x1 > x2) swap(x1, x2);
if (my.find(y) == my.end()) my[y] = cnty++;
shy[my[y]] = y;
vy[my[y]].push_back(make_pair(x1, x2));
}
void init() {
for (int i = 0; i < (cntx); i++) {
sort(vx[i].begin(), vx[i].end());
int last = -1;
int s = 0;
for (int j = 0; j < (vx[i].size()); j++) {
pair<int, int> P = vx[i][j];
if (P.second > last) {
if (P.first >= last)
s += P.second - P.first;
else
s += P.second - last;
last = P.second;
}
}
a.push_back(m - s);
}
if ((n - 1 - cntx) % 2) {
for (int i = (1); i <= (cntx + 1); i++)
if (mx.find(i) == mx.end()) {
mx[i] = cntx++;
shx[mx[i]] = i;
a.push_back(m);
break;
}
}
for (int i = 0; i < (cnty); i++) {
sort(vy[i].begin(), vy[i].end());
int last = -1;
int s = 0;
for (int j = 0; j < (vy[i].size()); j++) {
pair<int, int> P = vy[i][j];
if (P.second > last) {
if (P.first >= last)
s += P.second - P.first;
else
s += P.second - last;
last = P.second;
}
}
a.push_back(n - s);
}
if ((m - 1 - cnty) % 2) {
for (int i = (1); i <= (cnty + 1); i++)
if (my.find(i) == my.end()) {
my[i] = cnty++;
shy[my[i]] = i;
a.push_back(n);
break;
}
}
}
void print_x(int sh, int x) {
int d = 0, c;
int last = 0;
vx[sh].push_back(make_pair(m, m));
for (int i = 0; i < (vx[sh].size()); i++) {
pair<int, int> P = vx[sh][i];
if (P.first > last) {
int len = P.first - last;
if (len >= x) {
c = last + x;
cout << shx[sh] << ' ' << d << ' ' << shx[sh] << ' ' << c << endl;
return;
}
x -= len;
}
last = max(P.second, last);
}
}
void print_y(int sh, int x) {
int d = 0, c;
int last = 0;
vy[sh].push_back(make_pair(n, n));
for (int i = 0; i < (vy[sh].size()); i++) {
pair<int, int> P = vy[sh][i];
if (P.first > last) {
int len = P.first - last;
if (len >= x) {
c = last + x;
cout << d << ' ' << shy[sh] << ' ' << c << ' ' << shy[sh] << endl;
return;
}
x -= len;
}
last = max(P.second, last);
}
}
void process() {
int g = 0;
for (int i = 0; i < (a.size()); i++) {
g ^= a[i];
}
if (g == 0)
cout << "SECOND" << endl;
else {
cout << "FIRST" << endl;
for (int i = 0; i < (a.size()); i++)
if ((g ^ a[i]) < a[i]) {
int x = g ^ a[i];
if (i < cntx) {
print_x(i, a[i] - x);
} else
print_y(i - cntx, a[i] - x);
break;
}
}
}
int main() {
int k;
cin >> n >> m >> k;
for (int i = 0; i < (k); i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2)
vertical(x1, y1, y2);
else
horizontal(y1, x1, x2);
}
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Xseg {
int y, x1, x2;
bool operator<(const Xseg &p) const { return y != p.y ? y < p.y : x1 < p.x1; }
} X[101000];
struct Yseg {
int x, y1, y2;
bool operator<(const Yseg &p) const { return x != p.x ? x < p.x : y1 < p.y1; }
} Y[101000];
int n, m, k, CX, CY, ccx, ccy, P, cx[101000], cy[101000], Mn, Mm;
void DoX(int a) {
int i, x1 = 0, x2, s = 0, o = cx[a] - (cx[a] ^ P), t = 0;
x2 = o;
for (i = 0; i < CX; i++)
if (X[i].y == a) break;
for (i = i; i < CX; i++) {
if (t < X[i].x1) s += X[i].x1 - t;
if (t < X[i].x2) t = X[i].x2;
if (s >= o) {
x2 = X[i].x1 + o - s;
break;
}
if (X[i].y != X[i + 1].y) {
x2 = t + o - s;
break;
}
}
printf("%d %d %d %d\n", x1, a, x2, a);
}
void DoY(int a) {
int i, y1 = 0, y2, s = 0, o = cy[a] - (cy[a] ^ P), t = 0;
y2 = o;
for (i = 0; i < CY; i++)
if (Y[i].x == a) break;
for (i = i; i < CY; i++) {
if (t < Y[i].y1) s += Y[i].y1 - t;
if (t < Y[i].y2) t = Y[i].y2;
if (s >= o) {
y2 = Y[i].y1 + o - s;
break;
}
if (Y[i].x != Y[i + 1].x) {
y2 = t + o - s;
break;
}
}
printf("%d %d %d %d\n", a, y1, a, y2);
}
int main() {
int xx1, xx2, yy1, yy2, t = 0, s = 0, i;
scanf("%d%d%d", &n, &m, &k);
Mn = n, Mm = m;
if (Mn > 100000) Mn = k + 2;
if (Mm > 100000) Mm = k + 2;
for (i = 0; i < k; i++) {
scanf("%d%d%d%d", &xx1, &yy1, &xx2, &yy2);
if (xx1 > xx2) swap(xx1, xx2);
if (yy1 > yy2) swap(yy1, yy2);
if (xx1 == xx2)
Y[CY].x = xx1, Y[CY].y1 = yy1, Y[CY++].y2 = yy2;
else
X[CX].y = yy1, X[CX].x1 = xx1, X[CX++].x2 = xx2;
}
sort(X, X + CX);
sort(Y, Y + CY);
ccx = m - 1, ccy = n - 1, t = 0;
for (i = 1; i < Mm; i++) cx[i] = n;
for (i = 1; i < Mn; i++) cy[i] = m;
for (i = 0; i < CX; i++) {
if (t < X[i].x1) s += X[i].x1 - t;
if (t < X[i].x2) t = X[i].x2;
if (X[i].y != X[i + 1].y) {
ccx--;
if (X[i].y < Mm) cx[X[i].y] = s + n - t;
P ^= (s + n - t);
s = 0, t = 0;
}
}
for (i = 0; i < CY; i++) {
if (t < Y[i].y1) s += Y[i].y1 - t;
if (t < Y[i].y2) t = Y[i].y2;
if (Y[i].x != Y[i + 1].x) {
ccy--;
if (Y[i].x < Mn) cy[Y[i].x] = s + m - t;
P ^= (s + m - t);
s = 0, t = 0;
}
}
if (ccx & 1) P ^= n;
if (ccy & 1) P ^= m;
if (P) {
printf("FIRST\n");
for (i = 1; i < Mm; i++)
if ((cx[i] ^ P) < cx[i]) break;
if (i < Mm) {
DoX(i);
return 0;
}
for (i = 1; i < Mn; i++)
if ((cy[i] ^ P) < cy[i]) break;
DoY(i);
} else
printf("SECOND\n");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[100000], h[100000];
int fv[100000], fh[100000], ov[100000], oh[100000];
map<int, int> idv, idh;
int count(vector<pair<int, int> > &p) {
int i, last = 0, ans = 0;
for (i = 0; i < p.size(); i++)
if (p[i].second > last) {
ans += p[i].second - max(last, p[i].first);
last = p[i].second;
}
return ans;
}
int search(vector<pair<int, int> > &p, int key) {
int i, last = 0, val = 0;
for (i = 0; i < p.size(); i++) {
if (p[i].first > last) {
val += p[i].first - last;
if (val >= key) return p[i].first - (val - key);
}
last = max(last, p[i].second);
}
return last + (key - val);
}
int main() {
int n, m, k, i, x, y, X, Y, H = 0, V = 0, ans = 0;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
cin >> x >> y >> X >> Y;
if (x == X) {
if (!idv.count(x)) {
ov[V] = x;
idv[x] = V++;
}
if (y > Y) swap(y, Y);
v[idv[x]].push_back(pair<int, int>(y, Y));
}
if (y == Y) {
if (!idh.count(y)) {
oh[H] = y;
idh[y] = H++;
}
if (x > X) swap(x, X);
h[idh[y]].push_back(pair<int, int>(x, X));
}
}
for (i = 0; i < V; i++) sort(v[i].begin(), v[i].end());
for (i = 0; i < H; i++) sort(h[i].begin(), h[i].end());
if ((m - 1 - H) % 2) ans ^= n;
if ((n - 1 - V) % 2) ans ^= m;
for (i = 0; i < V; i++) {
fv[i] = m - count(v[i]);
ans ^= fv[i];
}
for (i = 0; i < H; i++) {
fh[i] = n - count(h[i]);
ans ^= fh[i];
}
if (ans == 0)
cout << "SECOND" << endl;
else {
cout << "FIRST" << endl;
if ((ans ^ m) < m) {
for (i = 1; i < n; i++)
if (!idv.count(i)) break;
if (i != n) {
printf("%d %d %d %d\n", i, 0, i, m - (ans ^ m));
return 0;
}
}
if ((ans ^ n) < n) {
for (i = 1; i < m; i++)
if (!idh.count(i)) break;
if (i != m) {
printf("%d %d %d %d\n", 0, i, n - (ans ^ n), i);
return 0;
}
}
for (i = 0; i < V; i++)
if ((ans ^ fv[i]) < fv[i]) break;
if (i != V) {
printf("%d %d %d %d\n", ov[i], 0, ov[i],
search(v[i], fv[i] - (ans ^ fv[i])));
return 0;
}
for (i = 0; i < H; i++)
if ((ans ^ fh[i]) < fh[i]) break;
if (i != H) {
printf("%d %d %d %d\n", 0, oh[i], search(h[i], fh[i] - (ans ^ fh[i])),
oh[i]);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
int l = v.size();
for (int i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
void tr() { cout << endl; }
template <typename S, typename... Strings>
void tr(S x, const Strings&... rest) {
cout << x << ' ';
tr(rest...);
}
const int K = 100100;
int n, m, k;
map<int, vector<pair<int, int> > > row, col;
map<int, int> crow, ccol;
void merge(vector<pair<int, int> >& v) {
int l = v.size();
vector<pair<int, int> > res;
pair<int, int> cur = v[0];
for (int i = 1; i < l; i++) {
if (v[i].first <= cur.second)
cur.second = max(cur.second, v[i].second);
else {
res.push_back(cur);
cur = v[i];
}
}
res.push_back(cur);
v = res;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int x1, y1, x2, y2;
for (int i = 0; i < k; i++) {
scanf("%d%d", &x1, &y1);
scanf("%d%d", &x2, &y2);
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
row[x1].push_back(make_pair(y1, y2));
} else {
if (x1 > x2) swap(x1, x2);
col[y1].push_back(make_pair(x1, x2));
}
}
int nim = 0, rem = 0, tot = 0;
rem = n - 1 - (int)row.size();
if (rem % 2) nim ^= m;
rem = m - 1 - (int)col.size();
if (rem % 2) nim ^= n;
for (__typeof(row.begin()) r(row.begin()); r != row.end(); r++) {
sort((r->second).begin(), (r->second).end());
merge(r->second);
int cnt = m;
for (__typeof((r->second).begin()) it((r->second).begin());
it != (r->second).end(); it++)
cnt -= it->second - it->first;
nim ^= cnt;
crow[r->first] = cnt;
}
for (__typeof(col.begin()) c(col.begin()); c != col.end(); c++) {
sort((c->second).begin(), (c->second).end());
merge(c->second);
int cnt = n;
for (__typeof((c->second).begin()) it((c->second).begin());
it != (c->second).end(); it++)
cnt -= it->second - it->first;
nim ^= cnt;
ccol[c->first] = cnt;
}
if (nim == 0) {
puts("SECOND");
return 0;
}
puts("FIRST");
for (__typeof(row.begin()) r(row.begin()); r != row.end(); r++) {
int s = crow[r->first];
if ((s ^ nim) < s) {
int val = s ^ nim;
int rem = s - val;
vector<pair<int, int> >& v = (r->second);
int cur = min(v[0].first, rem), e = v[0].first;
if (cur < e) e = cur;
int i = 1;
v.push_back(make_pair(m, m));
while (cur < rem and i < v.size()) {
cur += v[i].first - v[i - 1].second;
e = v[i].first;
if (cur >= rem) {
e -= (cur - rem);
break;
}
i++;
}
if (cur < rem) continue;
printf("%d %d %d %d\n", r->first, 0, r->first, e);
assert(e <= m);
return 0;
}
}
for (__typeof(col.begin()) c(col.begin()); c != col.end(); c++) {
int s = ccol[c->first];
if ((s ^ nim) < s) {
int val = s ^ nim;
int rem = s - val;
vector<pair<int, int> >& v = (c->second);
int cur = min(v[0].first, rem), e = v[0].first;
if (cur < e) e = cur;
int i = 1;
v.push_back(make_pair(n, n));
while (cur < rem and i < v.size()) {
cur += v[i].first - v[i - 1].second;
e = v[i].first;
if (cur >= rem) {
e -= (cur - rem);
break;
}
i++;
}
if (cur < rem) continue;
printf("%d %d %d %d\n", 0, c->first, e, c->first);
assert(e <= n);
return 0;
}
}
if ((m - (m ^ nim)) > 0) {
for (int i = 1; i < n; i++) {
if (!row.count(i)) {
printf("%d %d %d %d\n", i, 0, i, m - (m ^ nim));
return 0;
}
}
}
for (int i = 1; i < m; i++) {
if (!col.count(i)) {
printf("%d %d %d %d\n", 0, i, n - (n ^ nim), i);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > mx, my;
map<int, int> lx, ly;
int get_len(vector<pair<int, int> > &v) {
sort(v.begin(), v.end());
int ans = 0, pre = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
int l = it->first, r = it->second;
if (r <= pre) continue;
ans += r - max(pre, l);
pre = r;
}
return ans;
}
int solve(vector<pair<int, int> > &v, int l) {
int pre = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
if (it->second <= pre) continue;
if (it->first <= pre) {
pre = it->second;
continue;
}
if (it->first - pre < l) {
l -= it->first - pre;
pre = it->second;
} else {
return pre + l;
}
}
return pre + l;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
while (k--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2)
mx[x1].push_back(make_pair(y1, y2));
else if (y1 == y2)
my[y1].push_back(make_pair(x1, x2));
else
puts("QQ");
}
for (int i = 1; i < n; i++)
if (!mx.count(i)) {
mx[i].clear();
break;
}
for (int i = 1; i < m; i++)
if (!my.count(i)) {
my[i].clear();
break;
}
for (__typeof((mx).begin()) it = (mx).begin(); it != (mx).end(); it++)
lx[it->first] = get_len(it->second);
for (__typeof((my).begin()) it = (my).begin(); it != (my).end(); it++)
ly[it->first] = get_len(it->second);
int sg = 0;
if ((n - 1 - ((int)(lx).size())) % 2 != 0) sg ^= m;
if ((m - 1 - ((int)(ly).size())) % 2 != 0) sg ^= n;
for (__typeof((lx).begin()) it = (lx).begin(); it != (lx).end(); it++)
sg ^= m - it->second;
for (__typeof((ly).begin()) it = (ly).begin(); it != (ly).end(); it++)
sg ^= n - it->second;
if (sg == 0)
puts("SECOND");
else {
puts("FIRST");
for (__typeof((lx).begin()) it = (lx).begin(); it != (lx).end(); it++) {
int r = m - it->second;
if ((sg ^ r) < r) {
printf("%d %d %d %d\n", it->first, 0, it->first,
solve(mx[it->first], r - (sg ^ r)));
return 0;
}
}
for (__typeof((ly).begin()) it = (ly).begin(); it != (ly).end(); it++) {
int r = n - it->second;
if ((sg ^ r) < r) {
printf("%d %d %d %d\n", 0, it->first,
solve(my[it->first], r - (sg ^ r)), it->first);
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long sg;
map<int, set<pair<int, int> > > row, column;
map<int, int> rowLength, columnLength;
void cut(map<int, set<pair<int, int> > > &part, int x, int y1, int y2, int n) {
if (part.find(x) == part.end()) {
part[x].insert(make_pair(n, 0));
}
set<pair<int, int> > &s = part[x];
set<pair<int, int> >::iterator it = s.lower_bound(make_pair(y1 + 1, -1)), jt;
while (it != s.end() && it->second < y2) {
jt = it;
jt++;
int l = it->second, r = it->first;
s.erase(it);
if (l < y1) {
s.insert(make_pair(y1, l));
}
if (y2 < r) {
s.insert(make_pair(r, y2));
}
it = jt;
}
}
int calcLength(const set<pair<int, int> > &part) {
int res = 0;
for (typeof((part).begin()) it = (part).begin(); it != (part).end(); it++) {
res += it->first - it->second;
}
return res;
}
bool flag;
void drawRow(int x, int totalLength, const set<pair<int, int> > &part) {
if (flag) return;
long long length = totalLength - (sg ^ totalLength);
if (0 < length && length <= totalLength) {
flag = true;
for (typeof((part).begin()) it = (part).begin(); it != (part).end(); it++) {
if (length > it->first - it->second) {
length -= it->first - it->second;
} else {
printf("%d 0 %d %d\n", x, x, (int)(it->second + length));
break;
}
}
}
}
void drawColumn(int x, int totalLength, const set<pair<int, int> > &part) {
if (flag) return;
long long length = totalLength - (sg ^ totalLength);
if (0 < length && length <= totalLength) {
flag = true;
for (typeof((part).begin()) it = (part).begin(); it != (part).end(); it++) {
if (length > it->first - it->second) {
length -= it->first - it->second;
} else {
printf("0 %d %d %d\n", x, (int)(it->second + length), x);
break;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (n > 1) {
row[1].insert(make_pair(m, 0));
row[n - 1].insert(make_pair(m, 0));
}
if (m > 1) {
column[1].insert(make_pair(n, 0));
column[m - 1].insert(make_pair(n, 0));
}
for (int i = 0; i < k; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2) {
cut(row, x1, y1, y2, m);
} else {
cut(column, y1, x1, x2, n);
}
}
for (typeof((row).begin()) it = (row).begin(); it != (row).end(); it++) {
rowLength[it->first] = calcLength(it->second);
sg ^= rowLength[it->first];
}
if ((n - 1 - ((int)(row).size())) & 1) {
sg ^= m;
}
for (typeof((column).begin()) it = (column).begin(); it != (column).end();
it++) {
columnLength[it->first] = calcLength(it->second);
sg ^= columnLength[it->first];
}
if ((m - 1 - ((int)(column).size())) & 1) {
sg ^= n;
}
puts(sg ? "FIRST" : "SECOND");
if (sg) {
int prev;
set<pair<int, int> > s;
for (typeof((row).begin()) it = (row).begin(); it != (row).end(); it++) {
drawRow(it->first, rowLength[it->first], it->second);
}
prev = -1;
s.clear();
s.insert(make_pair(m, 0));
for (typeof((row).begin()) it = (row).begin(); it != (row).end(); it++) {
if (prev != -1) {
if (prev + 1 != it->first) {
drawRow(prev + 1, m, s);
break;
}
}
prev = it->first;
}
for (typeof((column).begin()) it = (column).begin(); it != (column).end();
it++) {
drawColumn(it->first, columnLength[it->first], it->second);
}
prev = -1;
s.clear();
s.insert(make_pair(n, 0));
for (typeof((column).begin()) it = (column).begin(); it != (column).end();
it++) {
if (prev != -1) {
if (prev + 1 != it->first) {
drawColumn(prev + 1, n, s);
break;
}
}
prev = it->first;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 11;
bool mark[MAXN];
map<int, vector<pair<int, int> > > xmap, ymap;
set<int> xsp, ysp;
set<pair<int, int> > xs, ys;
int calc(vector<pair<int, int> > line) {
vector<pair<int, int> > r;
for (int i = 0; i < line.size(); i++) {
r.push_back(make_pair(line[i].first, 0));
r.push_back(make_pair(line[i].second, 1));
}
sort(r.begin(), r.end());
int ans = 0, cnt = 0, prev = -1;
for (int i = 0; i < r.size(); i++) {
if (prev == -1) prev = r[i].first;
if (cnt > 0) ans += r[i].first - prev;
if (r[i].second == 0)
cnt++;
else
cnt--;
prev = r[i].first;
}
return ans;
}
pair<int, int> move(vector<pair<int, int> > line, int len) {
if (line.size() == 0) return make_pair(0, len);
vector<pair<int, int> > r;
for (int i = 0; i < line.size(); i++) {
r.push_back(make_pair(line[i].first, 1));
r.push_back(make_pair(line[i].second, 0));
}
sort(r.begin(), r.end());
int ans = 0, cnt = 0, prev = 0, help = 0;
for (int i = 0; i < r.size(); i++) {
if (cnt >= 0) ans += r[i].first - prev;
if (ans >= len) {
return make_pair(0, r[i].first - (ans - len));
}
if (r[i].second == 0)
cnt++;
else
cnt--;
prev = r[i].first;
help = r[i].first;
}
return make_pair(0, help + (len - ans));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
xmap[x1].push_back(make_pair(min(y1, y2), max(y1, y2)));
xsp.insert(x1);
} else {
ymap[y1].push_back(make_pair(min(x1, x2), max(x1, x2)));
ysp.insert(y1);
}
}
long long ans = 0;
for (auto it = xmap.begin(); it != xmap.end(); it++) {
int a = m - calc((*it).second);
ans ^= a;
xs.insert(make_pair((*it).first, a));
}
for (auto it = ymap.begin(); it != ymap.end(); it++) {
int a = n - calc((*it).second);
ans ^= a;
ys.insert(make_pair((*it).first, a));
}
ans ^= ((n - xmap.size() - 1) % 2 == 0 ? 0 : m);
ans ^= ((m - ymap.size() - 1) % 2 == 0 ? 0 : n);
for (int i = 1; i <= n - 1; i++)
if (xsp.find(i) == xsp.end()) {
xs.insert(make_pair(i, m));
break;
}
for (int i = 1; i <= m - 1; i++)
if (ysp.find(i) == ysp.end()) {
ys.insert(make_pair(i, n));
break;
}
if (ans == 0) {
cout << "SECOND" << endl;
return 0;
} else {
cout << "FIRST" << endl;
int bit = -1;
for (int i = 40; i >= 0 and bit < 0; i--)
if ((ans >> i) & 1) bit = i;
for (auto it = xs.begin(); it != xs.end(); it++) {
int a = (*it).first, b = (*it).second;
if ((b >> bit) & 1) {
int c = b;
for (int j = 0; j <= bit; j++)
if ((ans >> j) & 1)
if ((c >> j) & 1)
c -= (1 << j);
else
c += (1 << j);
pair<int, int> ANS = move(xmap[a], b - c);
cout << a << " " << ANS.first << " " << a << " " << ANS.second << endl;
return 0;
}
}
for (auto it = ys.begin(); it != ys.end(); it++) {
int a = (*it).first, b = (*it).second;
if ((b >> bit) & 1) {
int c = b;
for (int j = 0; j <= bit; j++)
if ((ans >> j) & 1)
if ((c >> j) & 1)
c -= (1 << j);
else
c += (1 << j);
pair<int, int> ANS = move(ymap[a], b - c);
cout << ANS.first << " " << a << " " << ANS.second << " " << a << endl;
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void _checkmax(T &t, T x) {
if (t == -1 || x > t) t = x;
}
template <class T>
void _checkmin(T &t, T x) {
if (t == -1 || x < t) t = x;
}
long long power_mod(long long a, int b, int p) {
long long ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = ret * a % p;
a = a * a % p;
}
return ret;
}
pair<int, int> getPair(vector<pair<int, int> > vec, int need) {
vector<pair<int, int> > v;
int r = -1;
for (__typeof((vec).begin()) it = (vec).begin(); it != (vec).end(); it++) {
if (it->first > r)
v.push_back(*it);
else {
checkmax(v[v.size() - 1].second, it->second);
}
r = v[v.size() - 1].second;
}
r = 0;
for (size_t i = 0; i < v.size(); i++) {
if (v[i].first - r >= need) {
return make_pair(0, r + need);
}
need -= v[i].first - r;
r = v[i].second;
}
return make_pair(0, r + need);
}
int m, n, c;
map<int, vector<pair<int, int> > > h;
map<int, int> value_h;
map<int, vector<pair<int, int> > > v;
map<int, int> value_v;
int main() {
scanf("%d%d%d", &m, &n, &c);
for (int i = 0; i < (int)(c); i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a == c && b == d) continue;
if (a == c) {
h[a].push_back(make_pair(min(b, d), max(b, d)));
} else if (b == d) {
v[b].push_back(make_pair(min(a, c), max(a, c)));
}
}
int ans = 0;
for (__typeof((h).begin()) it = (h).begin(); it != (h).end(); it++) {
vector<pair<int, int> > &vec = it->second;
sort(vec.begin(), vec.end());
int r = -1;
int now = 0;
for (__typeof((vec).begin()) i = (vec).begin(); i != (vec).end(); i++) {
if (i->first > r) {
now += i->second - i->first;
} else if (i->second > r) {
now += i->second - r;
}
r = max(i->second, r);
}
now = n - now;
ans ^= now;
value_h[it->first] = now;
}
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
vector<pair<int, int> > &vec = it->second;
sort(vec.begin(), vec.end());
int r = -1;
int now = 0;
for (__typeof((vec).begin()) i = (vec).begin(); i != (vec).end(); i++) {
if (i->first > r) {
now += i->second - i->first;
} else if (i->second > r) {
now += i->second - r;
}
r = max(i->second, r);
}
now = m - now;
ans ^= now;
value_v[it->first] = now;
}
if (h.size() < m - 1) {
if ((m - 1 - h.size()) & 1) ans ^= n;
for (int i = 1; i < m; i++)
if (!h.count(i)) {
value_h[i] = n;
h[i].clear();
break;
}
}
if (v.size() < n - 1) {
if ((n - 1 - v.size()) & 1) ans ^= m;
for (int i = 1; i < n; i++)
if (!v.count(i)) {
value_v[i] = m;
v[i].clear();
break;
}
}
if (!ans) {
puts("SECOND");
} else {
puts("FIRST");
pair<int, int> res;
for (__typeof((value_h).begin()) it = (value_h).begin();
it != (value_h).end(); it++) {
int i = it->second;
if ((i ^ ans) < i) {
res = getPair(h[it->first], i - (i ^ ans));
printf("%d %d %d %d\n", it->first, res.first, it->first, res.second);
return 0;
}
}
for (__typeof((value_v).begin()) it = (value_v).begin();
it != (value_v).end(); it++) {
int i = it->second;
if ((i ^ ans) < i) {
res = getPair(v[it->first], i - (i ^ ans));
printf("%d %d %d %d\n", res.first, it->first, res.second, it->first);
return 0;
}
}
while (1)
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll llinf = (1ll << 61) - 1;
using SS = stringstream;
struct Dbg {
static constexpr ostream &os = cout;
template <class C>
static auto dud(C *first) -> decltype(os << *first, 0);
template <class C>
static char dud(...);
template <class C>
typename enable_if<sizeof dud<C>(0) != 1, Dbg &>::type operator<<(
const C &first) {
os << first;
return *this;
}
template <class C>
Dbg &dump(C b, C e) {
*this << "\n[";
int cur = 0;
for (C i = b; i != e and cur < 30; i++, cur++)
*this << ", " + 2 * (i == b) << *i;
return *this << "]";
}
template <class C>
typename enable_if<sizeof dud<C>(0) == 1, Dbg &>::type operator<<(
const C &first) {
return dump(begin(first), end(first));
}
template <class C, size_t X>
typename enable_if<sizeof(C) != 1, Dbg &>::type operator<<(C (&first)[X]) {
return dump(begin(first), end(first));
}
template <class B, class C>
Dbg &operator<<(const pair<B, C> &first) {
return *this << "{" << first.first << ", " << first.second << "}";
}
Dbg &operator<<(ostream &(*first)(std::ostream &)) {
os << first;
return *this;
}
} dbg;
void err(SS *ss) { delete ss; }
template <class C, class... A>
void err(SS *ss, const C &val, const A &...args) {
string name;
*ss >> name;
if (name.back() == ',') name.pop_back();
dbg << name << " = " << val << "; ", err(ss, args...);
}
const int inf = 1000000007, mxn = 100005;
int n, m, K, T, Q, cn;
vector<pair<int, pair<int, int>>> ver, hor;
vector<pair<int, int>> piles, piles2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.precision(11);
cin >> n >> m >> K;
for (auto i = 1; i <= K; i += 1) {
int xb, xe, yb, ye;
cin >> xb >> yb >> xe >> ye;
if (xb > xe) swap(xb, xe);
if (yb > ye) swap(yb, ye);
if (yb == ye)
ver.push_back({yb, {xb, xe}});
else
hor.push_back({xb, {yb, ye}});
}
sort(begin(ver), end(ver)), sort(begin(hor), end(hor));
int os = m, last, prv = -1, nim = 0, hc = n - 1, vc = m - 1, pile = -inf,
pile2 = -inf;
for (auto &i : hor) {
if (i.first == prv)
os += max(0, i.second.second - max(last, i.second.first)),
last = max(last, i.second.second);
else {
os = m - os, nim ^= os;
if (prv > 0 and prv < n) piles.emplace_back(prv, os);
if (i.first != prv + 1 and i.first > 1) pile = i.first - 1;
hc--, os = i.second.second - i.second.first, last = i.second.second,
prv = i.first;
}
}
os = m - os, nim ^= os ^ ((hc & 1) * m);
42;
if (prv > 0 and prv < n) piles.emplace_back(prv, os);
if (hc) {
if (pile == -inf) pile = n - 1;
piles.emplace_back(pile, m);
}
os = n, prv = -1;
for (auto &i : ver) {
if (i.first == prv)
os += max(0, i.second.second - max(last, i.second.first)),
last = max(last, i.second.second);
else {
os = n - os, nim ^= os;
if (prv > 0 and prv < m) piles2.emplace_back(prv, os);
if (i.first != prv + 1 and i.first > 1) pile2 = i.first - 1;
vc--, os = i.second.second - i.second.first, last = i.second.second,
prv = i.first;
}
}
if (vc) {
if (pile2 == -inf) pile2 = m - 1;
piles2.emplace_back(pile2, n);
}
os = n - os, nim ^= os ^ ((vc & 1) * n);
42;
if (prv > 0 and prv < m) piles2.emplace_back(prv, os);
if (!nim) return cout << "SECOND\n", 0;
cout << "FIRST\n";
42;
for (auto &i : piles)
if ((i.second ^ nim) < i.second) {
int j = lower_bound(begin(hor), end(hor),
pair<int, pair<int, int>>(i.first, {-inf, -inf})) -
hor.begin(),
need = i.second - (i.second ^ nim);
last = 0;
for (; j < hor.size() and hor[j].first == i.first; j++) {
need -= max(0, hor[j].second.first - last);
42;
if (need <= 0) {
need += hor[j].second.first - last;
break;
}
last = max(last, hor[j].second.second);
}
cout << i.first << ' ' << 0 << ' ' << i.first << ' ' << last + need
<< '\n',
exit(0);
}
for (auto &i : piles2)
if ((i.second ^ nim) < i.second) {
int j = lower_bound(begin(ver), end(ver),
pair<int, pair<int, int>>(i.first, {-inf, -inf})) -
ver.begin(),
need = i.second - (i.second ^ nim);
last = 0;
for (; j < ver.size() and ver[j].first == i.first; j++) {
need -= max(0, ver[j].second.first - last);
if (need <= 0) {
need += ver[j].second.first - last;
break;
}
last = max(last, ver[j].second.second);
}
cout << 0 << ' ' << i.first << ' ' << last + need << ' ' << i.first
<< '\n',
exit(0);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int Tots[100010];
void TheSolution(istream& input, ostream& output) {
int n, m, k, xb, xe, yb, ye;
input >> n >> m >> k;
vector<pair<int, int> > novo;
vector<vector<pair<int, int> > > G;
vector<int> T;
map<int, int> mapa;
set<int> seti;
int cnt = 0;
int a = 0, b = 0;
for (int i = 0; i < k; ++i) {
input >> xb >> yb >> xe >> ye;
if (xb == xe) {
if (!mapa.count(-xb))
mapa[-xb] = cnt++, G.push_back(novo), T.push_back(-xb), a++;
G[mapa[-xb]].push_back(make_pair(min(yb, ye), max(yb, ye)));
seti.insert(-xb);
} else {
if (!mapa.count(yb))
mapa[yb] = cnt++, G.push_back(novo), T.push_back(yb), b++;
G[mapa[yb]].push_back(make_pair(min(xb, xe), max(xb, xe)));
seti.insert(yb);
}
}
int res = 0;
int maxi = -1, xoy = 0, pos = 0;
if ((n - a) % 2 == 0) {
for (int i = 1; i < n; ++i)
if (!seti.count(-i)) {
T.push_back(-i);
break;
}
Tots[cnt++] = m;
G.push_back(novo);
}
if ((m - b) % 2 == 0) {
for (int i = 1; i < m; ++i)
if (!seti.count(i)) {
T.push_back(i);
break;
}
Tots[cnt++] = n;
G.push_back(novo);
}
for (int i = 0; i < cnt; ++i) {
sort((G[i]).begin(), (G[i]).end());
int fin = 0, tot = 0;
for (int j = 0; j < G[i].size(); ++j) {
tot += G[i][j].second - G[i][j].first;
if (G[i][j].first < fin)
tot -= min(fin - G[i][j].first, G[i][j].second - G[i][j].first);
fin = max(G[i][j].second, fin);
}
if (T[i] < 0) {
res ^= (m - tot);
Tots[i] = m - tot;
} else {
res ^= (n - tot);
Tots[i] = n - tot;
}
}
if (res == 0)
output << "SECOND\n";
else {
for (int i = 0; i < cnt; ++i) {
if ((res ^ Tots[i]) <= Tots[i]) {
int l = 0, mid, h = T[i] < 0 ? m : n;
while (l + 1 < h) {
mid = (l + h) >> 1;
int c = mid, tot = 0, fin = 0;
for (int j = 0; j < G[i].size(); ++j)
if (G[i][j].first < mid) {
tot += min(G[i][j].second, mid) - G[i][j].first;
if (G[i][j].first < fin)
tot -= min(fin - G[i][j].first,
min(G[i][j].second, mid) - G[i][j].first);
fin = max(G[i][j].second, fin);
if (fin >= mid) break;
}
if (mid - tot >= Tots[i] - (res ^ Tots[i]))
h = mid;
else
l = mid;
}
output << "FIRST\n";
if (T[i] < 0)
output << -T[i] << " 0 " << -T[i] << " " << h << "\n";
else
output << "0 " << T[i] << " " << h << " " << T[i] << "\n";
break;
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
TheSolution(cin, cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n[2];
int k;
map<int, vector<pair<int, int> > > line[2];
int calc(int len, vector<pair<int, int> > &vec) {
sort(vec.begin(), vec.end());
int l = 0, r = 0;
for (int i = int(0); i < int(vec.size()); ++i) {
if (r < vec[i].first) l = r = vec[i].first;
len += r;
r = max(r, vec[i].second);
len -= r;
}
return len;
}
pair<int, int> cut(int len, vector<pair<int, int> > &vec, int sg) {
int _sg = calc(len, vec);
sg ^= _sg;
sg = _sg - sg;
if (sg < 0) return make_pair(0, -1);
int l = 0, r = 0, tmp = 0;
for (int i = int(0); i < int(vec.size()); ++i) {
if (r < vec[i].first) {
tmp += vec[i].first - r;
l = r = vec[i].first;
}
if (tmp >= sg) break;
r = max(r, vec[i].second);
}
return make_pair(0, l - (tmp - sg));
}
int main() {
cin >> n[0] >> n[1] >> k;
for (int i = int(0); i < int(k); ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2)
line[1][x1].push_back(make_pair(y1, y2));
else
line[0][y1].push_back(make_pair(x1, x2));
}
int sg = 0;
for (int i = int(0); i < int(2); ++i) {
if ((n[i ^ 1] - line[i].size()) % 2 == 0) {
for (int j = int(1); j < int(n[i ^ 1]); ++j)
if (!line[i].count(j)) {
line[i][j];
break;
}
}
for (map<int, vector<pair<int, int> > >::iterator it = line[i].begin();
it != line[i].end(); ++it) {
it->second.push_back(make_pair(n[i], n[i]));
sg ^= calc(n[i], it->second);
}
}
if (sg) {
cout << "FIRST" << endl;
for (int i = int(0); i < int(2); ++i) {
for (map<int, vector<pair<int, int> > >::iterator it = line[i].begin();
it != line[i].end(); ++it) {
pair<int, int> se = cut(n[i], it->second, sg);
if (se.first <= se.second) {
if (i)
cout << it->first << " " << se.first << " " << it->first << " "
<< se.second << endl;
else
cout << se.first << " " << it->first << " " << se.second << " "
<< it->first << endl;
return 0;
}
}
}
} else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ppp {
int k, l, r;
} a[220000];
int i, j, k, l, n, m, ans, tot1, tot2, x1, y1_, x2, y2;
ppp make(int k, int l, int r) {
if (l > r) swap(l, r);
ppp res = {k, l, r};
return res;
}
bool cmp(const ppp &a, const ppp &b) {
return a.k < b.k || a.k == b.k && a.l < b.l;
}
void answer(int dir, int k, int l, int r) {
if (dir == 0)
printf("%d %d %d %d\n", k, l, k, r);
else
printf("%d %d %d %d\n", l, k, r, k);
exit(0);
}
void work(int dir, int l, int r, int N, int M, int fl) {
int i, j, R, res, num = 0, O = 0;
if (N && (l > r || a[l].k != 1)) O = 1;
for (i = l; i <= r; i = j) {
res = 0;
R = 0;
for (j = i; a[j].k == a[i].k; ++j) {
if (a[j].l > R)
res += a[j].l - R, R = a[j].r;
else
R = max(R, a[j].r);
}
res += M - R;
if (fl) {
if (res >= (res ^ ans)) {
int Res = 0, need = res - (res ^ ans);
R = 0;
for (int k = i; k < j; ++k) {
if (a[k].l > R) {
if (a[k].l - R < need)
need -= a[k].l - R;
else {
answer(dir, a[k].k, 0, R + need);
}
R = a[k].r;
} else
R = max(R, a[k].r);
}
answer(dir, a[i].k, 0, R + need);
}
}
if (!fl) ans ^= res;
num++;
if (a[i].k != N && a[i].k + 1 != a[j].k) O = a[i].k + 1;
}
if (!fl)
if ((N - num) & 1)
ans ^= M;
else
;
else {
if (O && M >= (M ^ ans)) answer(dir, O, 0, M - (M ^ ans));
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
tot1 = 0;
tot2 = k;
for (i = 1; i <= k; ++i) {
scanf("%d%d%d%d", &x1, &y1_, &x2, &y2);
if (x1 == x2)
a[++tot1] = make(x1, y1_, y2);
else
a[++tot2] = make(y1_, x1, x2);
}
sort(a + 1, a + tot1 + 1, cmp);
sort(a + k + 1, a + tot2 + 1, cmp);
work(0, 1, tot1, n - 1, m, 0);
work(1, k + 1, tot2, m - 1, n, 0);
if (ans) {
printf("FIRST\n");
work(0, 1, tot1, n - 1, m, 1);
work(1, k + 1, tot2, m - 1, n, 1);
} else
printf("SECOND\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
struct side {
vector<pair<int, pair<int, int> > > have;
vector<pair<int, int> > res;
vector<pair<int, vector<pair<int, int> > > > e;
int n, len;
bool rv;
void add(int x, int l, int r) {
if (l > r) swap(l, r);
have.push_back(make_pair(x, make_pair(l, r)));
}
void check(vector<pair<int, int> > &e, int x, int ll, int rs) {
if ((ll ^ rs) > ll) return;
int w = (ll ^ rs);
int st = 0;
int fin = 0;
int now = 0;
for (int i = 0; i < (int)(e.size()); i++) {
if (e[i].second - e[i].first + now < w) {
now += e[i].second - e[i].first;
continue;
}
fin = e[i].first + w - now;
puts("FIRST");
if (rv) {
printf("%d %d %d %d", x, fin, x, len);
} else {
printf("%d %d %d %d", fin, x, len, x);
}
exit(0);
}
exit(1);
}
void find(int rs) {
int cnt = n - res.size();
if (cnt > 0) {
int w = 1, pos = 0;
while (pos < res.size() && res[pos].first == w) {
pos++;
w++;
}
vector<pair<int, int> > q;
q.push_back(make_pair(0, len));
check(q, w, len, rs);
}
for (int i = 0; i < (int)(e.size()); i++) {
check(e[i].second, res[i].first, res[i].second, rs);
}
}
void recalc() {
sort(have.begin(), have.end());
for (int i = 0; i < (int)(have.size()); i++) {
int now = have[i].second.first, pos = have[i].second.second;
int j = i + 1;
vector<pair<int, int> > e1;
e1.push_back(make_pair(0, have[i].second.first));
while (j < have.size() && have[j].first == have[i].first) {
int w = have[j].second.first;
if (w <= pos) {
pos = max(pos, have[j].second.second);
} else {
now += w - pos;
e1.push_back(make_pair(pos, w));
pos = have[j].second.second;
}
j++;
}
now += len - pos;
e1.push_back(make_pair(pos, len));
e.push_back(make_pair(have[i].first, e1));
res.push_back(make_pair(have[i].first, now));
i = j - 1;
}
}
int getNim() {
int nim = 0;
int cnt = n - res.size();
if (cnt & 1) nim ^= len;
for (int i = 0; i < (int)(res.size()); i++) nim ^= res[i].second;
return nim;
}
};
side a, b;
int n, m, k;
int main() {
cin >> n >> m >> k;
a.n = n - 1;
a.len = m;
a.rv = 1;
b.n = m - 1;
b.len = n;
b.rv = 0;
for (int i = 0; i < (int)(k); i++) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 == x2)
a.add(x1, y1, y2);
else
b.add(y1, x1, x2);
}
a.recalc();
b.recalc();
int res = a.getNim() ^ b.getNim();
cerr << res << endl;
if (res == 0) {
puts("SECOND");
exit(0);
}
a.find(res);
b.find(res);
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > mx, my;
map<int, int> lx, ly;
int get_len(vector<pair<int, int> > &v) {
sort(v.begin(), v.end());
int ans = 0, pre = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
int l = it->first, r = it->second;
if (r <= pre) continue;
ans += r - max(pre, l);
pre = r;
}
return ans;
}
int solve(vector<pair<int, int> > &v, int l) {
int pre = 0;
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); it++) {
if (it->second <= pre) continue;
if (it->first <= pre) {
pre = it->second;
continue;
}
if (it->first - pre < l) {
l -= it->first - pre;
pre = it->second;
} else {
return pre + l;
}
}
return pre + l;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
while (k--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2)
mx[x1].push_back(make_pair(y1, y2));
else if (y1 == y2)
my[y1].push_back(make_pair(x1, x2));
else
puts("QQ");
}
for (int i = 1; i < n; i++)
if (!mx.count(i)) {
mx[i].clear();
break;
}
for (int i = 1; i < m; i++)
if (!my.count(i)) {
my[i].clear();
break;
}
for (__typeof((mx).begin()) it = (mx).begin(); it != (mx).end(); it++)
lx[it->first] = get_len(it->second);
for (__typeof((my).begin()) it = (my).begin(); it != (my).end(); it++)
ly[it->first] = get_len(it->second);
int sg = 0;
if ((n - 1 - ((int)(lx).size())) % 2 != 0) sg ^= m;
if ((m - 1 - ((int)(ly).size())) % 2 != 0) sg ^= n;
for (__typeof((lx).begin()) it = (lx).begin(); it != (lx).end(); it++)
sg ^= m - it->second;
for (__typeof((ly).begin()) it = (ly).begin(); it != (ly).end(); it++)
sg ^= n - it->second;
if (sg == 0)
puts("SECOND");
else {
puts("FIRST");
for (__typeof((lx).begin()) it = (lx).begin(); it != (lx).end(); it++) {
int r = m - it->second;
if ((sg ^ r) < r) {
printf("%d %d %d %d\n", it->first, 0, it->first,
solve(mx[it->first], r - (sg ^ r)));
return 0;
}
}
for (__typeof((ly).begin()) it = (ly).begin(); it != (ly).end(); it++) {
int r = n - it->second;
if ((sg ^ r) < r) {
printf("%d %d %d %d\n", 0, it->first,
solve(my[it->first], r - (sg ^ r)), it->first);
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
map<int, vector<pair<int, int> > > vert;
map<int, vector<pair<int, int> > > hor;
vector<pair<int, int> > vs;
vector<pair<int, int> > hs;
int getSize(vector<pair<int, int> >& x) {
int ant = 0;
int res = 0;
for (int i = 0; i < ((int)x.size()); i++) {
int a = max(x[i].first, ant);
if (a < x[i].second) {
res += x[i].second - a;
ant = x[i].second;
}
}
return res;
}
void cortev(int ind, int tam) {
int x = ind;
int yb = 0;
int ye = 0;
int res = 0;
vector<pair<int, int> > vec = vert[ind];
vec.push_back(make_pair(m, m));
sort(vec.begin(), vec.end());
for (int i = 0; i < ((int)vec.size()); i++) {
int a = vec[i].first;
if (a >= ye) {
if (res + a - ye >= tam) {
ye += tam - res;
break;
}
res += a - ye;
}
ye = max(ye, vec[i].second);
}
printf("%d %d %d %d\n", x, yb, x, ye);
}
void corteh(int ind, int tam) {
int y = ind;
int xb = 0;
int xe = 0;
int res = 0;
vector<pair<int, int> > vec = hor[ind];
vec.push_back(make_pair(n, n));
sort(vec.begin(), vec.end());
for (int i = 0; i < ((int)vec.size()); i++) {
int a = vec[i].first;
if (a >= xe) {
if (res + a - xe >= tam) {
xe += tam - res;
break;
}
res += a - xe;
}
xe = max(xe, vec[i].second);
}
printf("%d %d %d %d\n", xb, y, xe, y);
}
void findv(int tam) {
map<int, vector<pair<int, int> > >::iterator it;
int ant = 1;
for (it = vert.begin(); it != vert.end(); it++) {
if (it->first > ant) {
printf("%d %d %d %d\n", ant, 0, ant, tam);
return;
} else {
ant++;
}
}
printf("%d %d %d %d\n", ant, 0, ant, tam);
}
void findh(int tam) {
map<int, vector<pair<int, int> > >::iterator it;
int ant = 1;
for (it = hor.begin(); it != hor.end(); it++) {
if (it->first > ant) {
printf("%d %d %d %d\n", 0, ant, tam, ant);
return;
} else {
ant++;
}
}
printf("%d %d %d %d\n", 0, ant, tam, ant);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
vs.clear();
hs.clear();
vert.clear();
hor.clear();
for (int i = 0; i < (k); i++) {
int xb, yb, xe, ye;
scanf("%d %d %d %d", &xb, &yb, &xe, &ye);
if (xb == xe) {
vert[xb].push_back(make_pair(min(yb, ye), max(yb, ye)));
} else {
hor[yb].push_back(make_pair(min(xb, xe), max(xb, xe)));
}
}
int res = 0;
if (((n - 1) - (int)vert.size()) % 2 != 0) {
res = res ^ m;
}
if (((m - 1) - (int)hor.size()) % 2 != 0) {
res = res ^ n;
}
map<int, vector<pair<int, int> > >::iterator it;
vector<pair<int, int> > x;
for (it = vert.begin(); it != vert.end(); it++) {
x = it->second;
sort(x.begin(), x.end());
int y = m - getSize(x);
vs.push_back(make_pair(y, it->first));
res = res ^ y;
}
for (it = hor.begin(); it != hor.end(); it++) {
x = it->second;
sort(x.begin(), x.end());
int y = n - getSize(x);
hs.push_back(make_pair(y, it->first));
res = res ^ y;
}
if (res == 0) {
printf("SECOND\n");
} else {
printf("FIRST\n");
for (int i = 0; i < ((int)vs.size()); i++) {
int y = res ^ vs[i].first;
if (y < vs[i].first) {
cortev(vs[i].second, vs[i].first - y);
return 0;
}
}
for (int i = 0; i < ((int)hs.size()); i++) {
int y = res ^ hs[i].first;
if (y < hs[i].first) {
corteh(hs[i].second, hs[i].first - y);
return 0;
}
}
if ((int)vs.size() < n - 1) {
int y = res ^ m;
if (y < m) {
findv(m - y);
return 0;
}
}
if ((int)hs.size() < m - 1) {
int y = res ^ n;
if (y < n) {
findh(n - y);
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int length(set<pair<int, int> >& s) {
int last = 0, len = 0;
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); ++it) {
if (last <= it->first) {
len += it->second - it->first;
last = it->second;
} else if (it->second >= last) {
len += it->second - last;
last = it->second;
}
}
return len;
}
int Buscar(set<pair<int, int> >& s, int obj) {
int last = 0, len = 0;
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); ++it) {
if (it->first >= last) {
len += it->first - last;
last = it->second;
if (len >= obj) {
return it->first - (len - obj);
}
} else
last = max(last, it->second);
}
return last - (len - obj);
}
int main() {
int w, h, k;
cin >> w >> h >> k;
map<int, set<pair<int, int> > > hcuts, vcuts;
for (int i = 0; i < k; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2)
vcuts[x1].insert(pair<int, int>(min(y1, y2), max(y1, y2)));
else
hcuts[y1].insert(pair<int, int>(min(x1, x2), max(x1, x2)));
}
int nim = 0;
nim ^= h * ((w - 1 - vcuts.size()) % 2);
nim ^= w * ((h - 1 - hcuts.size()) % 2);
vector<pair<int, int> > hc, vc;
for (map<int, set<pair<int, int> > >::iterator it = hcuts.begin();
it != hcuts.end(); ++it) {
hc.push_back(pair<int, int>(it->first, w - length(it->second)));
nim ^= hc.back().second;
}
for (map<int, set<pair<int, int> > >::iterator it = vcuts.begin();
it != vcuts.end(); ++it) {
vc.push_back(pair<int, int>(it->first, h - length(it->second)));
nim ^= vc.back().second;
}
if (nim) {
cout << "FIRST" << endl;
bool found = false;
int last = 0, nvc = vc.size();
for (int j = 0; j < nvc and not found; ++j) {
int col = vc[j].first;
if (col > last + 1) {
if ((nim ^ h) <= h) {
cout << last + 1 << " 0 " << last + 1 << " " << h - (nim ^ h) << endl;
found = true;
}
}
if (not found) {
int libre = vc[j].second;
if ((nim ^ libre) <= libre) {
cout << col << " " << Buscar(vcuts[col], nim ^ libre) << " " << col
<< " " << h << endl;
found = true;
}
}
last = col;
}
if (not found and w > last + 1) {
if ((nim ^ h) <= h) {
cout << last + 1 << " 0 " << last + 1 << " " << h - (nim ^ h) << endl;
found = true;
}
}
last = 0;
int nhc = hc.size();
for (int j = 0; j < nhc and not found; ++j) {
int row = hc[j].first;
if (row > last + 1) {
if ((nim ^ w) <= w) {
cout << "0 " << last + 1 << " " << w - (nim ^ w) << " " << last + 1
<< endl;
found = true;
}
}
if (not found) {
int libre = hc[j].second;
if ((nim ^ libre) <= libre) {
cout << Buscar(hcuts[row], nim ^ libre) << " " << row << " " << w
<< " " << row << endl;
found = true;
}
}
last = row;
}
if (not found and h > last + 1) {
if ((nim ^ w) <= w) {
cout << "0 " << last + 1 << " " << w - (nim ^ w) << " " << last + 1
<< endl;
found = true;
}
}
} else
cout << "SECOND" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<int, int> > > row, col;
map<int, int> rr, cc;
bool INSECT(int x1, int y1, int x2, int y2) {
return x1 <= x2 && x2 <= y1 || x1 <= y2 && y2 <= y1 || x2 <= x1 && x1 <= y2 ||
x2 <= y1 && y1 <= y2;
}
int SEG(vector<pair<int, int> > &x) {
int a(x[0].first), b(x[0].second), tot(0);
vector<pair<int, int> > tmp;
for (int i = 0; i < x.size(); ++i) {
if (INSECT(a, b, x[i].first, x[i].second)) {
a = min(a, x[i].first), b = max(b, x[i].second);
} else {
tmp.push_back(make_pair((a), (b)));
tot += b - a;
a = x[i].first, b = x[i].second;
}
}
tmp.push_back(make_pair((a), (b)));
tot += b - a;
x.swap(tmp);
return tot;
}
void UNIQ(map<int, vector<pair<int, int> > > &xx, map<int, int> &yy,
const int n) {
for (map<int, vector<pair<int, int> > >::iterator it = xx.begin();
it != xx.end(); ++it) {
sort(it->second.begin(), it->second.end());
it->second.erase(unique(it->second.begin(), it->second.end()),
it->second.end());
yy[it->first] = n - SEG(it->second);
}
}
void GAO(bool foo, map<int, vector<pair<int, int> > > xx, const int n, int i,
int j) {
int st(0), ed, sum(0);
vector<pair<int, int> > tmp(xx[i]);
if (tmp.empty()) {
ed = j;
} else {
tmp.push_back(make_pair((0), (0)));
tmp.push_back(make_pair((n), (n)));
sort(tmp.begin(), tmp.end());
for (int k = 0; k + 1 < tmp.size(); ++k) {
if (sum + tmp[k + 1].first - tmp[k].second >= j) {
ed = tmp[k].second + j - sum;
break;
} else {
sum += tmp[k + 1].first - tmp[k].second;
}
}
}
if (foo)
printf("%d %d %d %d\n", st, i, ed, i);
else
printf("%d %d %d %d\n", i, st, i, ed);
}
int main() {
int i, j, k;
int m, n;
int xb, yb, xe, ye;
int tot(0);
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < k; ++i) {
scanf("%d%d%d%d", &xb, &yb, &xe, &ye);
if (xb == xe)
col[xb].push_back(make_pair((min(yb, ye)), (max(yb, ye))));
else
row[yb].push_back(make_pair((min(xb, xe)), (max(xb, xe))));
}
UNIQ(row, rr, n);
UNIQ(col, cc, m);
for (map<int, int>::iterator it = rr.begin(); it != rr.end(); ++it)
tot ^= it->second;
if ((m - 1 - rr.size()) & 1) tot ^= n;
for (map<int, int>::iterator it = cc.begin(); it != cc.end(); ++it)
tot ^= it->second;
if ((n - 1 - cc.size()) & 1) tot ^= m;
if (tot == 0) {
puts("SECOND");
} else {
puts("FIRST");
i = -1, j = -1;
for (map<int, int>::iterator it = rr.begin(); it != rr.end(); ++it)
if ((it->second ^ tot) < it->second) {
i = it->first, j = it->second - (it->second ^ tot);
break;
}
if (i == -1 && (n ^ tot) < n) {
for (k = 1; k < m; ++k)
if (!rr.count(k)) {
i = k, j = n - (n ^ tot);
break;
}
}
if (i != -1)
GAO(true, row, n, i, j);
else {
for (map<int, int>::iterator it = cc.begin(); it != cc.end(); ++it)
if ((it->second ^ tot) < it->second) {
i = it->first, j = it->second - (it->second ^ tot);
break;
}
if (i == -1 && (m ^ tot) < m) {
for (k = 1; k < n; ++k)
if (!cc.count(k)) {
i = k, j = m - (m ^ tot);
break;
}
}
GAO(false, col, m, i, j);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1E9 + 7;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
long long n, m, k, len[2], ile[2], val;
pair<long long, long long> best;
map<pair<long long, long long>, vector<pair<long long, long long> > > M;
map<long long, pair<long long, long long> > kto;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
len[0] = m;
len[1] = n;
while (k--) {
long long x, y, xx, yy;
cin >> x >> y >> xx >> yy;
if (x == xx) {
M[pair<long long, long long>(x, 0)].push_back(
pair<long long, long long>(min(y, yy), 1));
M[pair<long long, long long>(x, 0)].push_back(
pair<long long, long long>(max(y, yy), -1));
} else {
M[pair<long long, long long>(y, 1)].push_back(
pair<long long, long long>(min(x, xx), 1));
M[pair<long long, long long>(y, 1)].push_back(
pair<long long, long long>(max(x, xx), -1));
}
}
for (__typeof((M).begin()) i = ((M).begin()); i != (M).end(); ++i) {
ile[i->first.second]++;
vector<pair<long long, long long> > v = i->second;
sort((v).begin(), (v).end());
long long cnt = 0, act = 0, last = 0;
for (__typeof((v).begin()) j = ((v).begin()); j != (v).end(); ++j) {
if (j->first != last) {
if (act == 0) cnt += j->first - last;
last = j->first;
}
act += j->second;
}
cnt += len[i->first.second] - last;
kto[cnt] = i->first;
val ^= cnt;
}
for (long long i = 0; i < (2); ++i)
if ((len[1 - i] - 1 - ile[i]) % 2) {
pair<long long, long long> p = pair<long long, long long>(1, i);
while (M.count(p)) p.first++;
kto[len[i]] = p;
val ^= len[i];
}
if (val == 0)
cout << "SECOND" << endl;
else {
cout << "FIRST" << endl;
long long usun, naj;
for (__typeof((kto).begin()) i = ((kto).begin()); i != (kto).end(); ++i) {
naj = i->first;
usun = naj - (val ^ naj);
if (1 <= usun && usun <= naj) {
best = i->second;
break;
}
}
vector<pair<long long, long long> > v = M[best];
sort((v).begin(), (v).end());
assert(usun > 0);
long long cnt = 0, act = 0, last = 0;
for (__typeof((v).begin()) j = ((v).begin()); j != (v).end(); ++j) {
if (j->first != last) {
if (act == 0) {
long long jest = j->first - last;
if (jest >= usun) goto kon;
usun -= jest;
}
last = j->first;
}
act += j->second;
}
kon:
long long zak = last + usun;
if (best.second == 0)
cout << best.first << " " << 0 << " " << best.first << " " << zak << endl;
else
cout << 0 << " " << best.first << " " << zak << " " << best.first << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
map<int, vector<pair<int, int> > > v, h;
vector<int> parse(map<int, vector<pair<int, int> > > &mp, int n, int m,
int tpp) {
int full = n - 1;
vector<int> sz;
for (map<int, vector<pair<int, int> > >::iterator it = mp.begin();
it != mp.end(); it++) {
int x = it->first;
if (x > 0 && x < n) {
full--;
vector<pair<int, int> > t = it->second;
sort((t).begin(), (t).end());
int c = 0;
int to = 0;
for (int i = (0); i < (t.size()); i++) {
if (t[i].first > to) c += t[i].first - to;
to = max(to, t[i].second);
}
c += m - to;
sz.push_back(c);
}
}
if (full > 2) {
int x = (full - 2) / 2;
full -= x * 2;
}
for (int i = (0); i < (full); i++) sz.push_back(m);
return sz;
}
bool dohorstep(int len, int x, int n, int m) {
if (v.count(x)) {
vector<pair<int, int> > t = v[x];
sort((t).begin(), (t).end());
int to = 0, c = 0;
for (int i = (0); i < (t.size()); i++) {
if (t[i].first > to) c += t[i].first - to;
to = max(to, t[i].second);
}
c += m - to;
int a = c - (c ^ len);
if (a > 0 && a <= c) {
to = 0, c = 0;
for (int i = (0); i < (t.size()); i++) {
if (t[i].first > to) {
c += t[i].first - to;
if (c >= a) {
cout << x << ' ' << 0 << ' ' << x << ' ' << t[i].first - (c - a)
<< endl;
return 1;
}
}
to = max(to, t[i].second);
}
c += m - to;
if (c >= a) {
cout << x << ' ' << 0 << ' ' << x << ' ' << m - (c - a) << endl;
return 1;
}
}
} else {
int a = m - (m ^ len);
if (a > 0 && a <= m) {
cout << x << ' ' << 0 << ' ' << x << ' ' << a << endl;
return 1;
}
}
return 0;
}
bool doverstep(int len, int x, int n, int m) {
if (h.count(x)) {
vector<pair<int, int> > t = h[x];
sort((t).begin(), (t).end());
int to = 0, c = 0;
for (int i = (0); i < (t.size()); i++) {
if (t[i].first > to) c += t[i].first - to;
to = max(to, t[i].second);
}
c += m - to;
int a = c - (c ^ len);
if (a > 0 && a <= c) {
to = 0, c = 0;
for (int i = (0); i < (t.size()); i++) {
if (t[i].first > to) {
c += t[i].first - to;
if (c >= a) {
cout << 0 << ' ' << x << ' ' << t[i].first - (c - a) << ' ' << x
<< endl;
return 1;
}
}
to = max(to, t[i].second);
}
c += m - to;
if (c >= a) {
cout << 0 << ' ' << x << ' ' << m - (c - a) << ' ' << x << endl;
return 1;
}
}
} else {
int a = m - (m ^ len);
if (a > 0 && a <= m) {
cout << 0 << ' ' << x << ' ' << a << ' ' << x << endl;
return 1;
}
}
return 0;
}
int main() {
cin >> n >> m >> k;
for (int i = (0); i < (k); i++) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
if (x1 == x2)
v[x1].push_back(pair<int, int>(min(y1, y2), max(y1, y2)));
else
h[y1].push_back(pair<int, int>(min(x1, x2), max(x1, x2)));
}
vector<int> v1 = parse(v, n, m, 0);
vector<int> v2 = parse(h, m, n, 1);
int xr = 0;
for (int i = (0); i < (v1.size()); i++) xr ^= v1[i];
for (int i = (0); i < (v2.size()); i++) xr ^= v2[i];
if (xr == 0)
puts("SECOND");
else {
puts("FIRST");
for (int i = 1; i < min(n, 100111); i++)
if (dohorstep(xr, i, n, m)) return 0;
for (int i = 1; i < min(m, 100111); i++)
if (doverstep(xr, i, m, n)) return 0;
puts("FUCK");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct linie {
int x1, y1, x2, y2;
};
const int N = 110000;
int n, m, k, px, py;
linie lx[N], ly[N];
vector<int> gr;
bool cmp(linie a, linie b) {
if (a.x1 == b.x1) {
return a.y1 < b.y1;
}
return a.x1 < b.x1;
}
void calc(linie x[], int px, int size, int elad, bool veee) {
int i, j, nr = 0, last, freex = 1, lastx = 0;
linie temp;
for (i = 1; i <= px; ++i) {
if (x[i].x1 - lastx > 1) freex = x[i].x1 - 1;
lastx = x[i].x1;
for (j = i + 1; j <= px && x[i].x1 == x[j].x1; ++j)
;
--j;
last = 0;
int sum = 0;
for (int k = i; k <= j; ++k) {
if (x[k].y1 - last > 0) {
sum += x[k].y1 - last;
}
last = max(last, x[k].y2);
}
if (elad - last) {
sum += elad - last;
}
gr.push_back(sum);
i = j;
++nr;
}
if (size - lastx > 1) freex = size - 1;
if ((size - 1 - nr) & 1) gr.push_back(elad);
}
int endprog = 0;
void del(linie x[], int px, int size, int elad, bool veee, int nrd, int gri) {
int i, j, nr = 0, last, freex = 1, lastx = 0;
linie temp;
for (i = 1; i <= px; ++i) {
if (x[i].x1 - lastx > 1) freex = x[i].x1 - 1;
lastx = x[i].x1;
for (j = i + 1; j <= px && x[i].x1 == x[j].x1; ++j)
;
--j;
last = 0;
int sum = 0;
for (int k = i; k <= j; ++k) {
if (x[k].y1 - last > 0) {
sum += x[k].y1 - last;
}
last = max(last, x[k].y2);
}
if (elad - last) {
sum += elad - last;
}
if (sum == gri) {
sum = 0;
last = 0;
endprog = 1;
for (int k = i; k <= j; ++k) {
if (x[k].y1 - last > 0) {
sum += x[k].y1 - last;
if (sum >= nrd) {
if (veee) {
cout << "0 " << x[i].x1 << " " << x[k].y1 - (sum - nrd) << " "
<< x[i].x1;
} else
cout << x[i].x1 << " 0 " << x[i].x1 << " "
<< x[k].y1 - (sum - nrd);
return;
}
}
last = max(last, x[k].y2);
}
if (elad - last) {
sum += elad - last;
}
if (veee) {
cout << "0 " << x[i].x1 << " " << elad - (sum - nrd) << " " << x[i].x1;
} else
cout << x[i].x1 << " 0 " << x[i].x1 << " " << elad - (sum - nrd);
return;
}
i = j;
++nr;
}
if (size - lastx > 1) freex = size - 1;
if ((size - 1 - nr) & 1) {
if (elad == gri) {
endprog = 1;
if (veee) {
cout << "0 " << freex << " " << nrd << " " << freex;
} else
cout << freex << " 0 " << freex << " " << nrd;
}
}
}
int main() {
int i;
cin >> n >> m >> k;
for (i = 1; i <= k; ++i) {
linie a;
cin >> a.x1 >> a.y1 >> a.x2 >> a.y2;
if (a.x1 == a.x2) {
if (a.y1 > a.y2) swap(a.y1, a.y2);
lx[++px] = a;
} else {
if (a.x1 > a.x2) swap(a.x1, a.x2);
swap(a.x1, a.y1);
swap(a.x2, a.y2);
ly[++py] = a;
}
}
sort(lx + 1, lx + px + 1, cmp);
sort(ly + 1, ly + py + 1, cmp);
calc(lx, px, n, m, 0);
calc(ly, py, m, n, 1);
int so = 0;
for (i = 0; i < gr.size(); ++i) so ^= gr[i];
int lb = 0;
for (int lastb = 0; lastb <= 30; ++lastb)
if (so & (1 << lastb)) lb = lastb;
if (!so)
cout << "SECOND";
else {
cout << "FIRST\n";
for (i = 0; i < gr.size(); ++i)
if (gr[i] & (1 << lb)) {
del(lx, px, n, m, 0, gr[i] - (so ^ gr[i]), gr[i]);
if (endprog) return 0;
del(ly, py, m, n, 1, gr[i] - (so ^ gr[i]), gr[i]);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long INFLL = 1001001001001001001LL;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
int xb[100050], yb[100050], xe[100050], ye[100050];
struct cut {
int A, B1, B2;
} C1[100050], C2[100050];
bool operator<(const cut& a, const cut& b) { return a.A < b.A; }
pair<int, int> P[200050];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int c1 = 0, c2 = 0;
for (int i = 0; i < k; ++i) {
scanf("%d%d%d%d", &xb[i], &yb[i], &xe[i], &ye[i]);
if (xb[i] == xe[i]) {
C1[c1].A = xb[i];
C1[c1].B1 = min(yb[i], ye[i]);
C1[c1].B2 = max(yb[i], ye[i]);
++c1;
} else {
C2[c2].A = yb[i];
C2[c2].B1 = min(xb[i], xe[i]);
C2[c2].B2 = max(xb[i], xe[i]);
++c2;
}
}
sort(C1, C1 + c1);
sort(C2, C2 + c2);
int ns = m - 1, ms = n - 1;
vector<int> rem1, xx, rem2, yy;
vector<vector<pair<int, int> > > sp1, sp2;
for (int i = 0; i < c1;) {
int j = i;
while (j < c1 && C1[i].A == C1[j].A) ++j;
int ps = 0;
for (int k = i; k < j; ++k) {
P[ps++] = make_pair(C1[k].B1, +1);
P[ps++] = make_pair(C1[k].B2, -1);
}
sort(P, P + ps);
int prev = 0, s = 0, r = 0;
sp1.push_back(vector<pair<int, int> >());
for (int k = 0; k < ps; ++k) {
if (s == 0) {
sp1.back().push_back(make_pair(prev, P[k].first));
r += P[k].first - prev;
}
s += P[k].second;
prev = P[k].first;
}
sp1.back().push_back(make_pair(prev, m));
r += m - prev;
rem1.push_back(r);
xx.push_back(C1[i].A);
--ms;
i = j;
}
for (int i = 0; i < c2;) {
int j = i;
while (j < c2 && C2[i].A == C2[j].A) ++j;
int ps = 0;
for (int k = i; k < j; ++k) {
P[ps++] = make_pair(C2[k].B1, +1);
P[ps++] = make_pair(C2[k].B2, -1);
}
sort(P, P + ps);
int prev = 0, s = 0, r = 0;
sp2.push_back(vector<pair<int, int> >());
for (int k = 0; k < ps; ++k) {
if (s == 0) {
sp2.back().push_back(make_pair(prev, P[k].first));
r += P[k].first - prev;
}
s += P[k].second;
prev = P[k].first;
}
sp2.back().push_back(make_pair(prev, n));
r += n - prev;
rem2.push_back(r);
yy.push_back(C2[i].A);
--ns;
i = j;
}
unsigned X = 0;
if (ms % 2 == 1) X ^= m;
if (ns % 2 == 1) X ^= n;
for (int i = 0; i < (int)rem1.size(); ++i) {
X ^= rem1[i];
}
for (int i = 0; i < (int)rem2.size(); ++i) {
X ^= rem2[i];
}
if (X == 0) {
puts("SECOND");
} else {
puts("FIRST");
if (ms > 0 && (unsigned)m > (unsigned)(m ^ X)) {
int mx = 1;
for (int i = 0; i < (int)xx.size(); ++i) {
if (xx[i] == mx) {
++mx;
}
}
int am = (unsigned)m - (unsigned)(m ^ X);
printf("%d 0 %d %d\n", mx, mx, am);
return 0;
} else if (ns > 0 && (unsigned)n > (unsigned)(n ^ X)) {
int ny = 1;
for (int i = 0; i < (int)yy.size(); ++i) {
if (yy[i] == ny) {
++ny;
}
}
int am = (unsigned)n - (unsigned)(n ^ X);
printf("0 %d %d %d\n", ny, am, ny);
return 0;
} else {
for (int i = 0; i < (int)rem1.size(); ++i) {
if ((unsigned)rem1[i] > (unsigned)(rem1[i] ^ X)) {
int am = (unsigned)rem1[i] - (unsigned)(rem1[i] ^ X);
int cur = 0;
for (int j = 0; j < (int)sp1[i].size(); ++j) {
int ss = sp1[i][j].second - sp1[i][j].first;
if (cur + ss >= am) {
int pt = am - cur + sp1[i][j].first;
printf("%d 0 %d %d\n", xx[i], xx[i], pt);
return 0;
}
cur += ss;
}
}
}
for (int i = 0; i < (int)rem2.size(); ++i) {
if ((unsigned)rem2[i] > (unsigned)(rem2[i] ^ X)) {
int am = (unsigned)rem2[i] - (unsigned)(rem2[i] ^ X);
int cur = 0;
for (int j = 0; j < (int)sp2[i].size(); ++j) {
int ss = sp2[i][j].second - sp2[i][j].first;
if (cur + ss >= am) {
int pt = am - cur + sp2[i][j].first;
printf("0 %d %d %d\n", yy[i], pt, yy[i]);
return 0;
}
cur += ss;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 17, inf = 1e9 + 17;
int n, m, dp[MAXN][MAXN];
pair<int, int> par[MAXN][MAXN];
vector<int> adj[MAXN], ans1, ans2;
void bfs() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dp[i][j] = inf;
dp[1][n] = 0;
queue<pair<int, int> > q;
q.push({1, n});
while (q.size()) {
pair<int, int> fr = q.front();
q.pop();
for (auto i : adj[fr.first])
for (auto j : adj[fr.second])
if (i != j && dp[fr.first][fr.second] + 1 < dp[i][j]) {
dp[i][j] = dp[fr.first][fr.second] + 1;
par[i][j] = {fr.first, fr.second};
q.push({i, j});
}
}
}
void pp(int i = n, int j = 1) {
ans1.push_back(i);
ans2.push_back(j);
if (i == 1 && j == n) return;
pp(par[i][j].first, par[i][j].second);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int v, u;
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
}
bfs();
if (dp[n][1] == inf) return cout << -1 << endl, 0;
cout << dp[n][1] << endl;
pp();
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (auto i : ans1) cout << i << ' ';
cout << endl;
for (auto i : ans2) cout << i << ' ';
cout << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.