제출 #797983

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
797983		esomer	Vision Program (IOI19_vision)	C++17	10 / 100	13 ms	1832 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, bool type){
	vector<int> val(n);
	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);
		//~ cout << "i " << i << " val " << val[i] << endl;
	}
	int curr = 1;
	int mx = 0;
	while(curr < n){
		curr *= 2; mx++;
	}
	curr /= 2; mx--;
	vector<int> prev(n);
	//~ cout << "Type " << type << endl;
	while(curr > 0){
		vector<int> answers;
		for(int start = 0; start < curr; start++){
			vector<int> nws;
			vector<int> ind;
			for(int i = start; i < n; i++){
				if(((i-start) / curr) % 2 == 0) {nws.push_back(val[i]); ind.push_back(i);}
			}
			//~ cout << "start "<< start << " curr " << curr << " nws " << endl;
			//~ for(int i = 0; i < (int)nws.size(); i++){
				//~ cout << "ind "<< ind[i] << " val " << nws[i] << endl;
			//~ }
			answers.push_back(add_xor(nws));
		}
		//It has the bit if the blacks aren't in the same array.
		prev[curr] = add_and(answers);
		//~ cout << "curr " << curr <<" dist " << dist[curr] << endl;
		curr /= 2;
	}
	dist[0] = add_xor(val);
	for(int i = 1; i < n; i++){
		vector<int> have;
		vector<int> others = {dist[0]};
		for(int j = 0; j <= mx; j++){
			if((1 << j) & i) have.push_back(prev[(1 << j)]);
			else others.push_back(prev[(1 << j)]);
		}
		dist[i] = add_and({add_and(have), add_not(add_or(others))});
	}
}

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, -1);
	vector<int> distc(W, -1);
	calc(H, distr, 0);
	calc(W, distc, 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)
			//~ 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() {
	//~ freopen("in.txt", "r", stdin);
	//~ 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\n", i);
			//~ fprintf(log_file, (i ? " %d" : "%d"), memory_cells[i]);
			//~ fprintf(log_file, "\n");
		//~ }
		//~ 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: 0 / 11
• Subtask 3: 0 / 11
• Subtask 4: 0 / 15
• Subtask 5: 0 / 12
• Subtask 6: 0 / 8
• Subtask 7: 0 / 14
• Subtask 8: 0 / 19