Submission #778557

#	Time	Username	Problem	Language	Result	Execution time	Memory
778557		kamelfanger83	Vision Program (IOI19_vision)	C++14	18 / 100	10 ms	1644 KiB

vision

#include "vision.h"
#include <cassert>

using namespace std;

int log2(int n){
    int res = 0, tres = 1;
    while(tres < n){
        tres <<= 1;
        res++;
    }
    return res;
}

void construct_network(int H, int W, int K) {
    if (H * W == 2) {
        add_and({0, 1});
        return;
    }
    int log2H = log2(H);
    int log2W = log2(W);
    int z = add_and({0,1,2});
    int o = add_not(z);
    vector<int> rows;
    for (int x = 0; x < H; ++x) {
        vector<int> tr;
        for (int y = 0; y < W; ++y) {
            tr.push_back(x * W + y);
        }
        rows.push_back(add_xor(tr));
    }
    vector<int> cols;
    for (int y = 0; y < W; ++y) {
        vector<int> tc;
        for (int x = 0; x < H; ++x) {
            tc.push_back(x * W + y);
        }
        cols.push_back(add_xor(tc));
    }
    vector<int> Hind;
    int a = z;
    for (int divs = 0; divs < log2H; divs++) {
        vector<int> tN;
        for (int x = 0; x < H; ++x) {
            if ((x >> divs) & 1) tN.push_back(rows[x]);
        }
        int raw = add_xor(tN);
        if (divs != 0 && 1 << divs < H){
            vector<int> hmm;
            vector<int> before;
            vector<int> afters;
            for (int x = 0; x < (1 << (divs - 1)) && x < H; ++x) {
                afters.push_back(rows[x]);
            }
            for (int cen = 1 << divs; cen < H; cen += 1 << divs) {
                for (int x = cen - (1 << (divs - 1)); x < cen; ++x) {
                    before.push_back(rows[x]);
                }
                int prebefore = add_xor(before);
                int preafter = add_xor(afters);
                int npreafter = add_not(preafter);
                hmm.push_back(add_and({prebefore, npreafter}));
                for (int x = cen; x < cen + (1 << (divs - 1)) && x < H; ++x) {
                    afters.push_back(rows[x]);
                }
            }
            hmm.push_back(a);
            int flip = add_or(hmm);
            Hind.push_back(add_xor({raw, flip}));
            int nraw = add_not(raw);
            a = add_and({nraw, flip});
        }
        else {
            Hind.push_back(raw);
        }
    }
    for (int i = 0; i < log2W - log2H; ++i) {
        Hind.push_back(add_and({z}));
    }
    vector<int> Wind;
    a = z;
    for (int divs = 0; divs < log2W; divs++) {
        vector<int> tN;
        for (int y = 0; y < W; ++y) {
            if ((y >> divs) & 1) tN.push_back(cols[y]);
        }
        int raw = add_xor(tN);
        if (divs != 0 && 1 << divs < W){
            vector<int> hmm;
            vector<int> before;
            vector<int> afters;
            for (int x = 0; x < (1 << (divs - 1)) && x < W; ++x) {
                afters.push_back(cols[x]);
            }
            for (int cen = 1 << divs; cen < W; cen += 1 << divs) {
                for (int y = cen - (1 << (divs - 1)); y < cen; ++y) {
                    before.push_back(cols[y]);
                }
                int prebefore = add_xor(before);
                int preafter = add_xor(afters);
                int npreafter = add_not(preafter);
                hmm.push_back(add_and({prebefore, npreafter}));
                for (int y = cen; y < cen + (1 << (divs - 1)) && y < W; ++y) {
                    afters.push_back(cols[y]);
                }
            }
            hmm.push_back(a);
            int flip = add_or(hmm);
            Wind.push_back(add_xor({raw, flip}));
            int nraw = add_not(raw);
            a = add_and({nraw, flip});
        }
        else{
            Wind.push_back(raw);
        }
    }
    for (int i = 0; i < log2H - log2W; ++i) {
        Wind.push_back(add_and({z}));
    }

    assert(Hind.size() == Wind.size());

    int addbits = max(log2H, log2W);
    vector<int> addeds, carries;
    addeds.push_back(add_xor({Wind[0], Hind[0]}));
    carries.push_back(add_and({Wind[0], Hind[0]}));
    for (int i = 1; i < addbits; ++i) {
        addeds.push_back(add_xor({Wind[i], Hind[i], carries[i - 1]}));
        int o1 = add_and({Wind[i], Hind[i]});
        int o2 = add_and({carries[i - 1], Hind[i]});
        int o3 = add_and({Wind[i], carries[i - 1]});
        carries.push_back(add_or({o1, o2, o3}));
    }
    addeds.push_back(add_and({carries.back()}));
    vector<int> Kbits;
    for (int i = 0; i < addeds.size(); ++i) {
        if (K & 1) Kbits.push_back(add_and({o}));
        else Kbits.push_back(add_and({z}));
        K >>=1;
    }
    assert(K == 0);
    vector<int> XORS;
    for (int i = 0; i < addeds.size(); ++i) {
        XORS.push_back(add_xor({addeds[i], Kbits[i]}));
    }
    vector<int> NOTS;
    for (int i = 0; i < XORS.size(); ++i) {
        NOTS.push_back(add_not(XORS[i]));
    }
    add_and(NOTS);
}

Compilation message (stderr)

vision.cpp: In function 'void construct_network(int, int, int)':
vision.cpp:136:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  136 |     for (int i = 0; i < addeds.size(); ++i) {
      |                     ~~^~~~~~~~~~~~~~~
vision.cpp:143:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  143 |     for (int i = 0; i < addeds.size(); ++i) {
      |                     ~~^~~~~~~~~~~~~~~
vision.cpp:147:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  147 |     for (int i = 0; i < XORS.size(); ++i) {
      |                     ~~^~~~~~~~~~~~~

• Subtask 1: 10 / 10
• Subtask 2: 0 / 11
• Subtask 3: 0 / 11
• Subtask 4: 0 / 15
• Subtask 5: 0 / 12
• Subtask 6: 8 / 8
• Subtask 7: 0 / 14
• Subtask 8: 0 / 19