oj.uz

답안 #727291

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
727291 2023-04-20T11:29:18 Z SanguineChameleon 육각형 영역 (APIO21_hexagon) C++17
47 / 100
 778 ms 67808 KB 
#include "hexagon.h"
#include <bits/stdc++.h>
using namespace std;

#ifdef KAMIRULEZ
	const bool local = true;
	const int subtask = 8;
#else
	const bool local = false;
	const int subtask = -1;
#endif

const long long mod = 1e9 + 7;
const long long one_half = (mod + 1) / 2;
const long long one_third = (mod + 1) / 3;
const int dx[7] = {0, 0, 1, 1, 0, -1, -1};
const int dy[7] = {0, 1, 1, 0, -1, -1, 0};

struct point {
	long long x, y;

	point() {};

	point(long long _x, long long _y): x(_x), y(_y) {};

	point operator*(long long d) {
		return point(x * d, y * d);
	}

	point operator+(point p2) {
		return point(x + p2.x, y + p2.y);
	}

	long long operator^(point p2) {
		return x * p2.y - y * p2.x;
	}
};

point dv[7] = {point(0, 0), point(0, 1), point(1, 1), point(1, 0), point(0, -1), point(-1, -1), point(-1, 0)};

ostream& operator<<(ostream &out, point p) {
	out << "(" << p.x << "," << p.y << ")";
	return out;
}

struct line {
	int type, dir, len, id;
	point p1, p2;

	line() {};

	line(int _type, int _dir, point _p1, point _p2, int _id): type(_type), dir(_dir), p1(_p1), p2(_p2), id(_id) {
		len = p2.x - p1.x + 1;
	};

	long long calc() {
		long long res = 0;
		long long Ly = p1.y;
		long long Ry = p1.y + (dir == 1 ? 0 : len - 1);
		if (type == 1) {
			Ly = 1 - Ly;
			Ry = 1 - Ry;
		}
		return (Ly + Ry) % mod * len % mod * one_half % mod;
	}

	long long eval_x(long long x) {
		if (dir == 1) {
			return p1.y;
		}
		else {
			return p1.y + (x - p1.x);
		}
	}
};

ostream& operator<<(ostream &out, line L) {
	if (L.type == 1) {
		out << "(bottom,";
	}
	else {
		out << "(top,";
	}
	out << L.p1 << "," << L.p2 << ")";
	return out;
}

bool operator<(line L1, line L2) {
	int max_x = max(L1.p1.x, L2.p1.x);
	int v1 = L1.eval_x(max_x);
	int v2 = L2.eval_x(max_x);
	if (v1 != v2) {
		return v1 < v2;
	}
	else {
		return L1.type < L2.type;
	}
};

int draw_territory(int N, int A, int B, vector<int> D, vector<int> L) {
	if (N == 3 && (!local || subtask == 1 || subtask == 2)) {
		int len = L[0] + 1;
		long long A_sum = 1LL * len * (len + 1) % mod * one_half % mod;
		long long B_sum = 1LL * len * (len - 1) % mod * one_half % mod + (len - 1) * len % mod * (len * 2 - 1) % mod * one_half % mod * one_third % mod;
		return (A_sum * A + B_sum * B) % mod;
	}
	long long L_sum = 0;
	for (int i = 0; i < N; i++) {
		L_sum += L[i];
	}
	if (L_sum <= 2000 && (!local || subtask == 3)) {
		vector<vector<bool>> border(4069, vector<bool>(4069, false));
		vector<vector<int>> dist(4069, vector<int>(4069, -1));
		int cx = 0;
		int cy = 0;
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < L[i]; j++) {
				cx += dx[D[i]];
				cy += dy[D[i]];
				border[cx + 2023][cy + 2023] = true;
			}
		}
		deque<pair<int, int>> q = {{0, 0}};
		dist[0][0] = -2;
		while (!q.empty()) {
			cx = q.front().first;
			cy = q.front().second;
			q.pop_front();
			for (int d = 1; d <= 6; d++) {
				int nx = cx + dx[d];
				int ny = cy + dy[d];
				if (0 <= nx && nx < 4069 && 0 <= ny && ny < 4069 && !border[nx][ny] && dist[nx][ny] == -1) {
					dist[nx][ny] = -2;
					q.push_back({nx, ny});
				}
			}
		}
		q.push_back({2023, 2023});
		dist[2023][2023] = 0;
		long long res = 0;
		while (!q.empty()) {
			cx = q.front().first;
			cy = q.front().second;
			res += 1LL * B * dist[cx][cy] + A;
			res %= mod;
			q.pop_front();
			for (int d = 1; d <= 6; d++) {
				int nx = cx + dx[d];
				int ny = cy + dy[d];
				if (0 <= nx && nx < 4069 && 0 <= ny && ny < 4069 && dist[nx][ny] == -1) {
					dist[nx][ny] = dist[cx][cy] + 1;
					q.push_back({nx, ny});
				}
			}
		}
		return res;
	}
	long long area = 0;
	point cur = point(0, 0);
	vector<point> poly(N);
	for (int i = 0; i < N; i++) {
		poly[i] = cur;
		cur = cur + (dv[D[i]] * L[i]);
	}
	for (int i = 0; i < N; i++) {
		area += poly[i] ^ poly[(i + 1) % N];
	}
	if (area < 0) {
		reverse(D.begin(), D.end());
		for (int i = 0; i < N; i++) {
			if (D[i] <= 3) {
				D[i] += 3;
			}
			else {
				D[i] -= 3;
			}
		}
		reverse(L.begin(), L.end());
		cur = point(0, 0);
		for (int i = 0; i < N; i++) {
			poly[i] = cur;
			cur = cur + (dv[D[i]] * L[i]);
		}
	}
	vector<line> lines;
	vector<int> prv_x;
	for (int i = 0; i < N; i++) {
		point prv = poly[(i + (N - 1)) % N];
		point cur = poly[i];
		point nxt1 = poly[(i + 1) % N];
		point nxt2 = poly[(i + 2) % N];
		if (cur.x < nxt1.x) {
			point p1 = cur;
			point p2 = nxt1;
			int dir = (cur.y == nxt1.y ? 1 : 2);
			if (prv.x < cur.x) {
				if (dir == 1) {
					p1 = p1 + point(1, 0);
				}
				else {
					p1 = p1 + point(1, 1);
				}
			}
			if (prv.x == cur.x && prv.y < cur.y) {
				if (dir == 1) {
					p1 = p1 + point(1, 0);
				}
				else {
					p1 = p1 + point(1, 1);
				}
			}
			if (nxt1.x == nxt2.x && nxt1.y > nxt2.y) {
				if (dir == 1) {
					p2 = p2 + point(-1, 0);
				}
				else {
					p2 = p2 + point(-1, -1);
				}
			}
			if (p1.x <= p2.x) {
				lines.emplace_back(1, dir, p1, p2, lines.size());
				prv_x.push_back(p1.x);
			}
		}
		if (cur.x > nxt1.x) {
			point p1 = nxt1;
			point p2 = cur;
			int dir = (cur.y == nxt1.y ? 1 : 2);
			if (prv.x > cur.x) {
				if (dir == 1) {
					p2 = p2 + point(-1, 0);
				}
				else {
					p2 = p2 + point(-1, -1);
				}
			}
			if (prv.x == cur.x && prv.y > cur.y) {
				if (dir == 1) {
					p2 = p2 + point(-1, 0);
				}
				else {
					p2 = p2 + point(-1, -1);
				}
			}
			if (nxt1.x == nxt2.x && nxt1.y < nxt2.y) {
				if (dir == 1) {
					p1 = p1 + point(1, 0);
				}
				else {
					p1 = p1 + point(1, 1);
				}
			}
			if (p1.x <= p2.x) {
				lines.emplace_back(2, dir, p1, p2, lines.size());
				prv_x.push_back(p1.x);
			}
		}
	}
	if (B == 0 && (!local || subtask == 4 || subtask == 5)) {
		long long res = 0;
		for (auto L: lines) {
			res += L.calc();
			res %= mod;
		}
		if (res < 0) {
			res += mod;
		}
		res = res * A % mod;
		return res;
	}
	vector<pair<int, pair<int, line>>> events;
	for (auto L: lines) {
		events.push_back({L.p1.x, {0, L}});
		events.push_back({L.p2.x, {1, L}});
	}
	sort(events.begin(), events.end());
	set<line, less<>> S;
	for (auto e: events) {
		int cur_x = e.first;
		int type = e.second.first;
		line L = e.second.second;
		auto it = (type == 0 ? S.insert(L).first : S.lower_bound(L));
		if (it->type == 1 && next(it) != S.end()) {
			auto bottom = it;
			auto top = next(it);
			if (prv_x[bottom->id] <= cur_x && prv_x[top->id] <= cur_x) {
				assert(prv_x[bottom->id] == prv_x[top->id]);
				prv_x[bottom->id] = cur_x + 1;
				prv_x[top->id] = cur_x + 1;
			}
		}
		if (it->type == 2 && it != S.begin()) {
			auto bottom = prev(it);
			auto top = it;
			if (prv_x[bottom->id] <= cur_x && prv_x[top->id] <= cur_x) {
				assert(prv_x[bottom->id] == prv_x[top->id]);
				prv_x[bottom->id] = cur_x + 1;
				prv_x[top->id] = cur_x + 1;
			}
		}
		if (type == 1) {
			S.erase(it);
		}
	}
	return 0;
}

Compilation message

hexagon.cpp: In constructor 'line::line(int, int, point, point, int)':
hexagon.cpp:48:12: warning: 'line::p2' will be initialized after [-Wreorder]
   48 |  point p1, p2;
      |            ^~
hexagon.cpp:47:22: warning:   'int line::id' [-Wreorder]
   47 |  int type, dir, len, id;
      |                      ^~
hexagon.cpp:52:2: warning:   when initialized here [-Wreorder]
   52 |  line(int _type, int _dir, point _p1, point _p2, int _id): type(_type), dir(_dir), p1(_p1), p2(_p2), id(_id) {
      |  ^~~~
hexagon.cpp: In member function 'long long int line::calc()':
hexagon.cpp:57:13: warning: unused variable 'res' [-Wunused-variable]
   57 |   long long res = 0;
      |             ^~~

Subtask #1
3.0 / 3.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct

Subtask #2
6.0 / 6.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 0 ms 212 KB Output is correct
12 Correct 1 ms 212 KB Output is correct

Subtask #3
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 620 ms 67532 KB Output is correct
2 Correct 645 ms 67660 KB Output is correct
3 Correct 662 ms 67660 KB Output is correct
4 Correct 610 ms 67532 KB Output is correct
5 Correct 650 ms 67540 KB Output is correct
6 Correct 624 ms 67524 KB Output is correct
7 Correct 610 ms 67560 KB Output is correct
8 Correct 643 ms 67532 KB Output is correct
9 Correct 632 ms 67796 KB Output is correct
10 Correct 608 ms 67792 KB Output is correct
11 Correct 778 ms 67684 KB Output is correct
12 Correct 695 ms 67596 KB Output is correct
13 Correct 592 ms 67660 KB Output is correct
14 Correct 638 ms 67804 KB Output is correct
15 Correct 623 ms 67524 KB Output is correct
16 Correct 630 ms 67668 KB Output is correct
17 Correct 686 ms 67564 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 0 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct

Subtask #4
12.0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 2 ms 1060 KB Output is correct
3 Correct 1 ms 468 KB Output is correct
4 Correct 1 ms 340 KB Output is correct
5 Correct 2 ms 724 KB Output is correct
6 Correct 2 ms 1064 KB Output is correct
7 Correct 8 ms 2912 KB Output is correct
8 Correct 1 ms 340 KB Output is correct
9 Correct 0 ms 340 KB Output is correct
10 Correct 1 ms 340 KB Output is correct
11 Correct 12 ms 5084 KB Output is correct
12 Correct 10 ms 3532 KB Output is correct
13 Correct 9 ms 3424 KB Output is correct
14 Correct 11 ms 5212 KB Output is correct
15 Correct 1 ms 340 KB Output is correct
16 Correct 1 ms 340 KB Output is correct
17 Correct 1 ms 212 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 0 ms 212 KB Output is correct

Subtask #5
15.0 / 15.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 2 ms 1060 KB Output is correct
5 Correct 1 ms 468 KB Output is correct
6 Correct 1 ms 340 KB Output is correct
7 Correct 2 ms 724 KB Output is correct
8 Correct 3 ms 1064 KB Output is correct
9 Correct 7 ms 2992 KB Output is correct
10 Correct 1 ms 340 KB Output is correct
11 Correct 1 ms 340 KB Output is correct
12 Correct 1 ms 340 KB Output is correct
13 Correct 11 ms 5084 KB Output is correct
14 Correct 10 ms 3552 KB Output is correct
15 Correct 11 ms 3424 KB Output is correct
16 Correct 12 ms 5212 KB Output is correct
17 Correct 1 ms 340 KB Output is correct
18 Correct 1 ms 340 KB Output is correct
19 Correct 0 ms 212 KB Output is correct
20 Correct 18 ms 6064 KB Output is correct
21 Correct 3 ms 1064 KB Output is correct
22 Correct 1 ms 676 KB Output is correct
23 Correct 25 ms 10328 KB Output is correct
24 Correct 36 ms 12404 KB Output is correct
25 Correct 38 ms 12632 KB Output is correct
26 Correct 19 ms 6364 KB Output is correct
27 Correct 14 ms 5596 KB Output is correct
28 Correct 9 ms 3348 KB Output is correct
29 Correct 48 ms 19916 KB Output is correct
30 Correct 39 ms 13140 KB Output is correct
31 Correct 38 ms 13136 KB Output is correct
32 Correct 44 ms 19812 KB Output is correct
33 Correct 19 ms 6560 KB Output is correct
34 Correct 10 ms 3376 KB Output is correct
35 Correct 0 ms 212 KB Output is correct
36 Correct 0 ms 212 KB Output is correct
37 Correct 0 ms 212 KB Output is correct

Subtask #6
0 / 19.0

# 결과 실행 시간 메모리 Grader output
1 Correct 625 ms 67660 KB Output is correct
2 Correct 625 ms 67568 KB Output is correct
3 Correct 614 ms 67668 KB Output is correct
4 Correct 612 ms 67664 KB Output is correct
5 Correct 636 ms 67536 KB Output is correct
6 Correct 604 ms 67568 KB Output is correct
7 Correct 623 ms 67780 KB Output is correct
8 Correct 652 ms 67660 KB Output is correct
9 Correct 609 ms 67560 KB Output is correct
10 Correct 609 ms 67540 KB Output is correct
11 Correct 601 ms 67676 KB Output is correct
12 Correct 700 ms 67564 KB Output is correct
13 Correct 643 ms 67648 KB Output is correct
14 Correct 620 ms 67576 KB Output is correct
15 Correct 651 ms 67680 KB Output is correct
16 Correct 609 ms 67664 KB Output is correct
17 Correct 599 ms 67564 KB Output is correct
18 Correct 0 ms 212 KB Output is correct
19 Correct 2 ms 1060 KB Output is correct
20 Correct 1 ms 468 KB Output is correct
21 Correct 1 ms 340 KB Output is correct
22 Correct 2 ms 724 KB Output is correct
23 Correct 3 ms 1064 KB Output is correct
24 Correct 7 ms 2988 KB Output is correct
25 Correct 1 ms 340 KB Output is correct
26 Correct 1 ms 468 KB Output is correct
27 Correct 1 ms 340 KB Output is correct
28 Correct 11 ms 5084 KB Output is correct
29 Correct 11 ms 3524 KB Output is correct
30 Correct 9 ms 3424 KB Output is correct
31 Correct 12 ms 5200 KB Output is correct
32 Correct 1 ms 340 KB Output is correct
33 Correct 1 ms 340 KB Output is correct
34 Incorrect 0 ms 212 KB Output isn't correct
35 Halted 0 ms 0 KB -

Subtask #7
0 / 18.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Incorrect 1 ms 212 KB Output isn't correct
6 Halted 0 ms 0 KB -

Subtask #8
0 / 16.0

# 결과 실행 시간 메모리 Grader output
1 Correct 631 ms 67560 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 622 ms 67808 KB Output is correct
7 Correct 664 ms 67660 KB Output is correct
8 Correct 600 ms 67548 KB Output is correct
9 Correct 623 ms 67652 KB Output is correct
10 Correct 611 ms 67664 KB Output is correct
11 Correct 585 ms 67792 KB Output is correct
12 Correct 604 ms 67516 KB Output is correct
13 Correct 613 ms 67548 KB Output is correct
14 Correct 616 ms 67672 KB Output is correct
15 Correct 597 ms 67664 KB Output is correct
16 Correct 609 ms 67772 KB Output is correct
17 Correct 620 ms 67784 KB Output is correct
18 Correct 599 ms 67568 KB Output is correct
19 Correct 626 ms 67680 KB Output is correct
20 Correct 657 ms 67672 KB Output is correct
21 Correct 609 ms 67652 KB Output is correct
22 Correct 0 ms 212 KB Output is correct
23 Correct 2 ms 1060 KB Output is correct
24 Correct 1 ms 468 KB Output is correct
25 Correct 1 ms 340 KB Output is correct
26 Correct 1 ms 724 KB Output is correct
27 Correct 3 ms 1064 KB Output is correct
28 Correct 9 ms 2992 KB Output is correct
29 Correct 1 ms 340 KB Output is correct
30 Correct 0 ms 340 KB Output is correct
31 Correct 1 ms 340 KB Output is correct
32 Correct 11 ms 5084 KB Output is correct
33 Correct 11 ms 3536 KB Output is correct
34 Correct 10 ms 3376 KB Output is correct
35 Correct 12 ms 5212 KB Output is correct
36 Correct 1 ms 340 KB Output is correct
37 Correct 1 ms 340 KB Output is correct
38 Correct 0 ms 212 KB Output is correct
39 Correct 17 ms 6052 KB Output is correct
40 Correct 2 ms 1064 KB Output is correct
41 Correct 3 ms 676 KB Output is correct
42 Correct 24 ms 10244 KB Output is correct
43 Correct 36 ms 12336 KB Output is correct
44 Correct 38 ms 12636 KB Output is correct
45 Correct 21 ms 6392 KB Output is correct
46 Correct 14 ms 5596 KB Output is correct
47 Correct 10 ms 3348 KB Output is correct
48 Correct 56 ms 19876 KB Output is correct
49 Correct 38 ms 13136 KB Output is correct
50 Correct 37 ms 13148 KB Output is correct
51 Correct 44 ms 19916 KB Output is correct
52 Correct 19 ms 6620 KB Output is correct
53 Correct 10 ms 3424 KB Output is correct
54 Incorrect 1 ms 212 KB Output isn't correct
55 Halted 0 ms 0 KB -