oj.uz

Submission #1005293

# Submission time Handle Problem Language Result Execution time Memory
1005293 2024-06-22T09:56:04 Z j_vdd16 Worm Worries (BOI18_worm) C++17
77 / 100
 1004 ms 9932 KB 
#include <algorithm>
#include <array>
#include <bitset>
#include <cstdint>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

//#define int long long
#define loop(X, N) for(int X = 0; X < (N); X++)
#define all(V) V.begin(), V.end()
#define rall(V) V.rbegin(), V.rend()

using namespace std;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;

typedef uint64_t u64;
typedef int64_t i64;

int a, b, c, q;
void answer(int x, int y, int z)
{
	cout << "! " << x << ' ' << y << ' ' << z << endl;
}

map<tuple<int, int, int>, int> results;
inline int ask(int x, int y, int z)
{
	if (x <= 0 || x > a || y <= 0 || y > b || z <= 0 || z > c)
		return 1;

	if (results.count({ x, y, z }))
		return results[{x, y, z}];

	q--;
	if (q < 0)
	{
		//answer(-2, -2, -2);
		exit(0);
	}

	cout << "? " << x << ' ' << y << ' ' << z << endl;

	int res = x + y * z;
	cin >> res;
	results[{x, y, z}] = res;

	if (res == -1)
	{
		//answer(-3, -3, -3);
		exit(0);
	}

	return res;
}
void solveGreedy()
{
	int x = 1, y = 1, z = 1;
	while (true)
	{
		int val = ask(x, y, z);

		if (ask(x + 1, y, z) > val)
			x++;
		else if (ask(x - 1, y, z) > val)
			x--;
		else if (ask(x, y + 1, z) > val)
			y++;
		else if (ask(x, y - 1, z) > val)
			y--;
		else if (ask(x, y, z + 1) > val)
			z++;
		else if (ask(x, y, z - 1) > val)
			z--;
		else
			break;
	}

	answer(x, y, z);
}


inline int ask(const array<int, 3>& pos, const array<int, 3>& perm)
{
	return ask(pos[perm[0]], pos[perm[1]], pos[perm[2]]);
}

array<int, 3> solve(ii bx, ii by, ii bz, int maxX, int maxY, int maxZ, array<int, 3> perm)
{
	while (true)
	{
		int dx = bx.second - bx.first;
		int dy = by.second - by.first;
		int dz = bz.second - bz.first;
		if (dx <= 2 && dy <= 2 && dz <= 2)
		{
			array<int, 3> res = { maxX, maxY, maxZ };
			return { res[perm[0]], res[perm[1]], res[perm[2]] };
		}

		if (dy >= dx && dy >= dz)
		{
			swap(dx, dy);
			swap(bx, by);
			swap(maxX, maxY);

			if (perm[0] == 2)
				swap(perm[1], perm[2]);
			else if (perm[1] == 2)
				swap(perm[0], perm[2]);
			else
				swap(perm[0], perm[1]);
		}
		else if (dz >= dx && dz >= dy)
		{
			swap(dx, dz);
			swap(bx, bz);
			swap(maxX, maxZ);

			if (perm[0] == 1)
				swap(perm[1], perm[2]);
			else if (perm[1] == 1)
				swap(perm[0], perm[2]);
			else
				swap(perm[0], perm[1]);
		}

		int maxVal = ask({ maxX, maxY, maxZ }, perm);
		int x = bx.first + dx / 2;
		for (int y = by.first + 1; y < by.second; y++)
		{
			for (int z = bz.first + 1; z < bz.second; z++)
			{
				int val = ask({ x, y, z }, perm);
				if (val > maxVal)
				{
					maxVal = val;
					maxX = x;
					maxY = y;
					maxZ = z;
				}
			}
		}

		if (maxX != x)
		{
			if (maxX < x)
				bx.second = x;
			else
				bx.first = x;
		}
		else
		{
			int val1 = ask({ maxX - 1, maxY, maxZ }, perm);
			int val2 = ask({ maxX + 1, maxY, maxZ }, perm);
			if (maxVal >= val1 && maxVal >= val2)
			{
				array<int, 3> res = { maxX, maxY, maxZ };
				return { res[perm[0]], res[perm[1]], res[perm[2]] };
			}
			else if (val1 > maxVal)
			{
				bx.second = x;
				maxX -= 1;
			}
			else// if (val2 > maxVal)
			{
				bx.first = x;
				maxX += 1;
			}
		}
	}
}

signed main()
{
	//ios::sync_with_stdio(0);
	//cin.tie(0);

	cin >> a >> b >> c >> q;
	
	if (a == 1 && b == 1 && c == 1)
	{
		answer(1, 1, 1);
	}
	else if (b == 1 && c == 1)
	{
		//f * f = (1 - f)
		//f^2 + f - 1 = 0
		//f = (-1 + sqrt(5)) / 2
		double f = (-1.0 + sqrt(5.0)) / 2.0;

		int l = 0, r = a + 1;
		int pos1 = -1, pos2 = -1;

		pos1 = l + (int)round(double(r - l) * (1 - f));
		pos2 = l + (int)round(double(r - l) * f);
		while (true)
		{
			if (r == l)
			{
				answer(l, 1, 1);
				break;
			}
			else if (r - l == 1)
			{
				if (ask(l, 1, 1) > ask(r, 1, 1))
					answer(l, 1, 1);
				else
					answer(r, 1, 1);

				break;
			}

			if (pos1 == -1)
				pos1 = l + (int)round(double(pos2 - l) * f);
			else if (pos2 == -1)
				pos2 = pos1 + (int)round(double(r - pos1) * (1 - f));

			int val1 = ask(pos1, 1, 1);
			int val2 = ask(pos2, 1, 1);

			if (val1 > val2)
			{
				r = pos2;
				pos2 = pos1;
				pos1 = -1;
			}
			else
			{
				l = pos1;
				pos1 = pos2;
				pos2 = -1;
			}
		}
	}
	else if (a == 1 || b == 1 || c == 1 || (a <= 100 && b <= 100 && c <= 100))
	{
		auto [x, y, z] = solve({ 0, a + 1 }, { 0, b + 1 }, { 0, c + 1 }, 1, 1, 1, { 0, 1, 2 });
		answer(x, y, z);
	}
	else
	{
		solveGreedy();
	}

	return 0;
}

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 0 ms 344 KB Output is correct
3 Correct 0 ms 344 KB Output is correct
4 Correct 0 ms 344 KB Output is correct
5 Correct 0 ms 344 KB Output is correct

Subtask #2
22.0 / 22.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 344 KB Output is correct
2 Correct 0 ms 344 KB Output is correct
3 Correct 0 ms 344 KB Output is correct
4 Correct 1 ms 372 KB Output is correct
5 Correct 0 ms 344 KB Output is correct
6 Correct 1 ms 344 KB Output is correct
7 Correct 0 ms 344 KB Output is correct
8 Correct 0 ms 344 KB Output is correct
9 Correct 0 ms 344 KB Output is correct
10 Correct 0 ms 344 KB Output is correct
11 Correct 0 ms 344 KB Output is correct

Subtask #3
12.0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 344 KB Output is correct
2 Correct 3 ms 344 KB Output is correct
3 Correct 3 ms 344 KB Output is correct
4 Correct 4 ms 344 KB Output is correct
5 Correct 3 ms 344 KB Output is correct
6 Correct 1 ms 344 KB Output is correct
7 Correct 3 ms 456 KB Output is correct

Subtask #4
19.0 / 19.0

# Verdict Execution time Memory Grader output
1 Correct 16 ms 536 KB Output is correct
2 Correct 10 ms 592 KB Output is correct
3 Correct 13 ms 740 KB Output is correct
4 Correct 15 ms 844 KB Output is correct
5 Correct 12 ms 788 KB Output is correct
6 Correct 19 ms 600 KB Output is correct
7 Correct 11 ms 588 KB Output is correct
8 Correct 12 ms 592 KB Output is correct
9 Correct 11 ms 560 KB Output is correct
10 Correct 13 ms 600 KB Output is correct
11 Correct 15 ms 588 KB Output is correct
12 Correct 14 ms 596 KB Output is correct
13 Correct 21 ms 724 KB Output is correct
14 Correct 17 ms 592 KB Output is correct
15 Correct 24 ms 592 KB Output is correct
16 Correct 21 ms 592 KB Output is correct
17 Correct 14 ms 596 KB Output is correct
18 Correct 16 ms 488 KB Output is correct
19 Correct 14 ms 844 KB Output is correct
20 Correct 9 ms 340 KB Output is correct
21 Correct 13 ms 600 KB Output is correct
22 Correct 19 ms 724 KB Output is correct
23 Correct 15 ms 600 KB Output is correct
24 Correct 14 ms 596 KB Output is correct
25 Correct 18 ms 708 KB Output is correct

Subtask #5
14.0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 146 ms 1928 KB Output is correct
2 Correct 126 ms 1848 KB Output is correct
3 Correct 114 ms 2424 KB Output is correct
4 Correct 159 ms 1888 KB Output is correct
5 Correct 147 ms 2160 KB Output is correct
6 Correct 128 ms 1816 KB Output is correct

Subtask #6
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 5 ms 344 KB Output is correct
3 Correct 0 ms 344 KB Output is correct
4 Incorrect 1004 ms 9932 KB invalid format (must have DIMS+1 tokens). input:
5 Halted 0 ms 0 KB -