제출 #799062

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
799062		esomer	Vision Program (IOI19_vision)	C++17	100 / 100	90 ms	10564 KiB

vision

#include<bits/stdc++.h>
#include "vision.h"

using namespace std;

// #define endl "\n"

typedef long long ll;

int h, w;

void calc(int n, vector<int>& dist, int k, bool type){
	vector<int> val(n); //Whether each row has at least one black.
	for(int i = 0; i < n; i++){
		vector<int> nws;
		if(type == 0){
			for(int j = 0; j < w; j++){
				nws.push_back(i * w + j);
			}
		}else{
			for(int j = 0; j < h; j++){
				nws.push_back(j * w + i);
			}
		}
		val[i] = add_or(nws);
	}
	vector<int> previous((int)dist.size());
	dist[0] = add_xor(val);
	vector<int> all_others = {dist[0]};
	int org = n;
	if(n > 160){
		for(int i = 160; i < n; i++){
			vector<int> possibilities;
			for(int j = 0; j + i < n; j++){
				possibilities.push_back(add_and({val[j], val[j+i]}));
			}
			dist[i] = add_or(possibilities);
			all_others.push_back(dist[i]);
		}
		n = 160;
	}
	int orr1 = add_or(all_others);
	for(int q = 2; q < n; q++){
		bool prime = 1;
		for(int k = 2; k * k <= q; k++){
			if((q % k) == 0){
				prime = 0;
			}
		}
		if(prime){
			vector<int> powers = {q};
			int x = q * q;
			while(x < n){
				powers.push_back(x);
				x *= q;
			}
			int before = orr1;
			vector<vector<int>> all_res((int)powers.size());
			for(int i = 0; i < org; i++){
				vector<bool> done(org, 0);
				int lst = -1;
				for(int l = 0; l < (int)powers.size(); l++){
					if(i + powers[l] >= org || i >= powers[l]) continue;
					vector<int> nws;
					for(int j = 0; j < org; j++){
						if(j % powers[l] != i && done[j] == 0){
							done[j] = 1;
							nws.push_back(val[j]);
						}
					}
					int orr;
					if(lst == -1){
						orr = add_or(nws);
					}else{
						nws.push_back(lst);
						orr = add_or(nws);
					}
					lst = orr;
					all_res[l].push_back(orr);
				}
			}
			for(int l = (int)powers.size() - 1; l >= 0; l--){
				int orr = add_not(add_and(all_res[l]));
				int nott = add_not(before);
				previous[powers[l]] = add_and({orr, nott});
				before = add_or({before, previous[powers[l]]});
			}
		}
	}
	int before = orr1;
	for(int d = n - 1; d > 0; d--){
		if(d == 1){
			//It's only 1 if it is not any of the previous.
			int nott = add_not(before);
			dist[d] = add_and({nott, add_not(dist[0])});
			continue;
		}
		vector<int> all_res;
		int x = d;
		for(int k = 2; k * k <= x; k++){
			ll crr = 1;
			while(x % k == 0){
				crr *= k;
				x /= k;
			}
			if(crr != 1){
				all_res.push_back(previous[crr]);
			}
		}
		if(x > 1){
			all_res.push_back(previous[x]);
		}
		int orr = add_and(all_res);
		//Now, I'm one if and(orr, not(orr_before)) is 1, so I'm one and no one before is one).
		int nott = add_not(before);
		dist[d] = add_and({orr, nott});
		before = add_or({before, dist[d]});
	}
}

void construct_network(int H, int W, int K){
	//Now, I want to get the value of each row.
	h = H;
	w = W;
	vector<int> distr(H, 0);
	vector<int> distc(W, 0);
	calc(H, distr, K, 0);
	calc(W, distc, K, 1);
	vector<int> possibilities;
	for(int i = 0; i < (int)distr.size() && i <= K; i++){
		int j = K - i;
		if(j >= (int)distc.size()) continue;
		possibilities.push_back(add_and({distr[i], distc[j]}));
	}
	add_or(possibilities);
}

// 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){
// 			cout << "type "<< type << endl;
// 			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();
// 	}

// 	int get_total_input(){
// 		return total_inputs;
// 	}
// };


// 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);
// 		// printf("Total queries: %d\n", (int)memory_cells.size() - H * W);
// 		for(int i = 0; i < (int)memory_cells.size(); i++){
// 			fprintf(log_file, "i: %d", i);
// 			fprintf(log_file, (i ? " %d" : "%d"), memory_cells[i]);
// 			fprintf(log_file, "\n");
// 		}
// 		// printf("Total input: %d\n", instructionNetwork.get_total_input());
// 		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: 10 / 10
• Subtask 2: 11 / 11
• Subtask 3: 11 / 11
• Subtask 4: 15 / 15
• Subtask 5: 12 / 12
• Subtask 6: 8 / 8
• Subtask 7: 14 / 14
• Subtask 8: 19 / 19