oj.uz

답안 #424898

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
424898 2021-06-12T11:23:50 Z donentseto Vision Program (IOI19_vision) C++14
12 / 100
 24 ms 2088 KB 
#include <bits/stdc++.h>
#include "vision.h"
using namespace std;

void construct_network (int h, int w, int k){

	vector <int> idx, idx1, last;
	int curr, curr1 = h * w;

	if (h > k){
		for (int i = 0; i < h; i ++){
			for (int j = 0; j < w; j ++) idx.push_back (i * w + j);
			add_or (idx);
			idx.clear ();
		}
		for (int i = 0; i < h; i ++) idx.push_back (h * w + i);
		idx1.push_back (add_xor (idx));
		idx.clear ();
		for (int i = 0; i < h - k; i ++){
			for (int j = 0; j <= k; j ++) idx.push_back (h * w + i + j);
			add_or (idx);
			curr = add_not (add_xor (idx));
			idx1.push_back (add_and ({curr - 2, curr}));
			idx.clear ();
		}
		curr1 = add_or (idx1);
		last.push_back (curr1);
		idx1.clear ();
		curr1 ++;
	}
	if (w > k){
		for (int i = 0; i < w; i ++){
			for (int j = 0; j < h; j ++) idx.push_back (j * w + i);
			add_or (idx);
			idx.clear ();
		}
		for (int i = 1; i < w; i ++) idx.push_back (curr1 + i);
		idx1.push_back (add_xor (idx));
		idx.clear ();
		for (int i = 0; i < w - k; i ++){
			for (int j = 0; j <= k; j ++) idx.push_back (curr1 + i + j);
			add_or (idx);
			curr = add_not (add_xor (idx));
			idx1.push_back (add_and ({curr - 2, curr}));
			idx.clear ();
		}
		curr1 = add_or (idx1);
		last.push_back (curr1);
		idx1.clear ();
		curr1 ++;
	}
	for (int i = 1 - w; i < h; i ++){
		for (int j = 0; j < h; j ++) if (j - i >= 0 && j - i < w) idx.push_back (j * w + j - i);
		add_or (idx);
		idx.clear ();
	}
	int n = h + w - 1;
	for (int i = 0; i < n - k; i ++){
		idx1.push_back (add_and ({curr1 + i, curr1 + i + k}));
	}
	curr1 = add_or (idx1) + 1;
	idx1.clear ();

	for (int i = 0; i < n; i ++){
		for (int j = 0; j < h; j ++) if (i - j >= 0 && i - j < w) idx.push_back (j * w + i - j);
		add_or (idx);
		idx.clear ();
	}
	for (int i = 0; i < n - k; i ++){
		idx1.push_back (add_and ({curr1 + i, curr1 + i + k}));
	}
	last.push_back (add_or ({curr1 - 1, add_or (idx1)}));
	add_and (last);

}

/*
static const int MAX_INSTRUCTIONS = 10000;
static const int MAX_INPUTS = 1000000;

static const int _AND = 0;
static const int _OR = 1;
static const int _XOR = 2;
static const int _NOT = 3;

static inline bool increasing(int a, int b, int c) {
	return a <= b && b <= c;
}

[[noreturn]] static inline void error(string message) {
	printf("%s\n", message.c_str());
	exit(0);
}

class InstructionNetwork {

	struct Instruction {
		int type;
		vector<int> input_indexes;

		inline Instruction(int _type, const vector<int>& _input_indexes):
			type(_type), input_indexes(_input_indexes) {
			}

		inline int apply(int a, int b) const {
			switch (type) {
				case _AND:
					return a & b;
				case _OR:
					return a | b;
				case _XOR:
					return a ^ b;
				default:
					return 0;
			}
		}

		inline int compute(const vector<int>& memory_cells) const {
			int r = memory_cells[input_indexes[0]];
			if (type == _NOT)
				return 1 - r;
			for (int j = 1; j < (int)input_indexes.size(); j++)
				r = apply(r, memory_cells[input_indexes[j]]);
			return r;
		}
	};

	int input_size;
	int total_inputs;
	vector<Instruction> instructions;

	public:

	inline void init(int _input_size) {
		this->input_size = _input_size;
		this->total_inputs = 0;
		this->instructions.clear();
	}

	inline int add_instruction(int type, const vector<int>& input_indexes) {
		if (input_indexes.size() == 0)
			error("Instruction with no inputs");

		if (instructions.size() + 1 > MAX_INSTRUCTIONS)
			error("Too many instructions");

		if (total_inputs + input_indexes.size() > MAX_INPUTS)
			error("Too many inputs");

		instructions.emplace_back(type, input_indexes);
		total_inputs += input_indexes.size();
		int new_index = input_size + (int)instructions.size() - 1;

		for (int input_index : input_indexes)
			if (!increasing(0, input_index, new_index-1))
				error("Invalid index");

		return new_index;
	}

	inline int compute(vector<int> &memory_cells) const {
		for (auto &instruction : instructions)
			memory_cells.push_back(instruction.compute(memory_cells));
		return memory_cells.back();
	}
};


static InstructionNetwork instructionNetwork;

int main() {
	int H, W, K;
	assert(3 == scanf("%d%d%d", &H, &W, &K));

	FILE *log_file = fopen("log.txt","w");

	instructionNetwork.init(H * W);
	construct_network(H, W, K);

	while (true) {
		int rowA, colA, rowB, colB;
		assert(1 == scanf("%d", &rowA));
		if (rowA == -1)
			break;
		assert(3 == scanf("%d%d%d", &colA, &rowB, &colB));

		if ((!increasing(0, rowA, H-1)) ||
				(!increasing(0, colA, W-1)) ||
				(!increasing(0, rowB, H-1)) ||
				(!increasing(0, colB, W-1)) ||
				(rowA == rowB && colA == colB)) {
			printf("-1\n");
			fprintf(log_file, "-1\n");
			fflush(stdout);
			fflush(log_file);
			continue;
		}

		vector<int> memory_cells;
		for (int row = 0; row < H; row++)
			for (int col = 0; col < W; col++) {
				bool active = (row == rowA && col == colA) || (row == rowB && col == colB);
				memory_cells.push_back(active ? 1 : 0);
			}
		int computation_result = instructionNetwork.compute(memory_cells);

		printf("%d\n", computation_result);
		fflush(stdout);

		for(int i = 0; i < (int)memory_cells.size(); i++)
			fprintf(log_file, (i ? " %d" : "%d"), memory_cells[i]);
		fprintf(log_file, "\n");
		fflush(log_file);
	}
	fclose(stdin);
}

int add_and(vector<int> Ns) {
	return instructionNetwork.add_instruction(_AND, Ns);
}

int add_or(vector<int> Ns) {
	return instructionNetwork.add_instruction(_OR, Ns);
}

int add_xor(vector<int> Ns) {
	return instructionNetwork.add_instruction(_XOR, Ns);
}

int add_not(int N) {
	vector<int> Ns = {N};
	return instructionNetwork.add_instruction(_NOT, Ns);
}
*/

Subtask #1
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Incorrect 1 ms 204 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
6 Halted 0 ms 0 KB -

Subtask #2
0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Incorrect 1 ms 204 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
6 Halted 0 ms 0 KB -

Subtask #3
0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Incorrect 1 ms 204 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
6 Halted 0 ms 0 KB -

Subtask #4
0 / 15.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Incorrect 1 ms 204 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
6 Halted 0 ms 0 KB -

Subtask #5
12.0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 332 KB Output is correct
2 Correct 3 ms 460 KB Output is correct
3 Correct 4 ms 460 KB Output is correct
4 Correct 1 ms 332 KB Output is correct
5 Correct 2 ms 332 KB Output is correct
6 Correct 3 ms 460 KB Output is correct
7 Correct 3 ms 460 KB Output is correct
8 Correct 1 ms 332 KB Output is correct
9 Correct 1 ms 332 KB Output is correct
10 Correct 3 ms 460 KB Output is correct
11 Correct 3 ms 460 KB Output is correct
12 Correct 5 ms 460 KB Output is correct
13 Correct 3 ms 460 KB Output is correct
14 Correct 1 ms 332 KB Output is correct
15 Correct 2 ms 332 KB Output is correct
16 Correct 4 ms 460 KB Output is correct
17 Correct 4 ms 460 KB Output is correct
18 Correct 3 ms 460 KB Output is correct
19 Correct 3 ms 460 KB Output is correct
20 Correct 1 ms 332 KB Output is correct
21 Correct 1 ms 204 KB Output is correct
22 Correct 0 ms 204 KB Output is correct

Subtask #6
0 / 8.0

# 결과 실행 시간 메모리 Grader output
1 Incorrect 1 ms 204 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
2 Halted 0 ms 0 KB -

Subtask #7
0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 24 ms 2088 KB Output is correct
2 Incorrect 1 ms 288 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
3 Halted 0 ms 0 KB -

Subtask #8
0 / 19.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 204 KB Output is correct
2 Correct 1 ms 204 KB Output is correct
3 Correct 1 ms 204 KB Output is correct
4 Correct 0 ms 204 KB Output is correct
5 Incorrect 1 ms 204 KB on inputs (0, 0), (1, 0), expected 1, but computed 0
6 Halted 0 ms 0 KB -