Submission #1175530

#	Time	Username	Problem	Language	Result	Execution time	Memory
1175530		TrendBattles	Snake Escaping (JOI18_snake_escaping)	C++17	12 / 100	141 ms	48240 KiB

snake_escaping

#include <bits/stdc++.h>
using namespace std;
using lli = long long int;

#define INFILE "snake.inp"
#define OUTFILE "snake.out"


namespace SUBTASK_small_L {
    void main(int L, int Q, string digits) {
        vector <int> pow_3(L + 1);
        pow_3[0] = 1;
        for (int i = 1; i <= L; ++i) {
            pow_3[i] = pow_3[i - 1] * 3;
        }

        const int M = pow_3[L];
        vector <int> mask_3(1 << L);
        vector <int> finale(M), value(1 << L);
        
        for (int m = 1; m < (1 << L); ++m) {
            int p = m & -m;

            mask_3[m] = mask_3[m ^ p] + pow_3[__builtin_ctz(p)];
        }

        for (int m = 0; m < (1 << L); ++m) {
            value[m] = digits[m] - '0';
            finale[mask_3[m]] = value[m];
        }

        for (int b = 0; b < L; ++b) {
            for (int m = 0; m < M; ++m) {
                if (m / pow_3[b] % 3 != 2) continue;

                finale[m] += finale[m - pow_3[b]] + finale[m - pow_3[b] * 2];
            }
        }

        for (int _ = 0; _ < Q; ++_) {
            string que; cin >> que;
            int m = 0;
            for (int i = 0; i < L; ++i) {
                if (que[i] == '1') m += pow_3[L - i - 1];
                else if (que[i] == '?') m += pow_3[L - i - 1] * 2;
            }
            cout << finale[m] << '\n';
        }
    }
}

// namespace SUBTASK_small_Q {
//     const int HIGH_BIT = 20, MAX_MASK = 1 << HIGH_BIT;
//     int sum_A[MAX_MASK], sum_B[MAX_MASK];
//     int bit_cnt[MAX_MASK];
//     void main(int L, int Q, string digits) {
//         for (int m = 0; m < (1 << L); ++m) {
//             sum_A[m] = digits[m] - '0';
//             sum_B[~(-1 << L) ^ m] = sum_A[m];

//             bit_cnt[m] = bit_cnt[m >> 1] ^ (m & 1);
//         }
        
//         for (int b = 0; b < L; ++b) {
//             for (int m = 0; m < (1 << L); ++m) {
//                 if ((m >> b & 1) == 0) {
//                     sum_A[m] += sum_A[m ^ (1 << b)];
//                     sum_B[m] += sum_B[m ^ (1 << b)];
//                 }
//             }
//         }

//         for (int _ = 0; _ < Q; ++_) {
//             string que; cin >> que;
//             int ans = 0;
//             if (count(que.begin(), que.end(), '0') <= L / 2) {
//                 int allowed = 0, banned = 0;
//                 for (int i = 0; i < L; ++i) {
//                     if (que[i] == '1') allowed ^= 1 << (L - i - 1);
//                     if (que[i] == '0') banned ^= 1 << (L - i - 1);
//                 }

//                 for (int p = banned; p >= 0; p = (p - 1) & banned) {
//                     if (bit_cnt[p]) {
//                         ans -= sum_A[allowed ^ p];
//                     } else {
//                         ans += sum_A[allowed ^ p];
//                     }

//                     if (p == 0) break;
//                 }
//             } else {
//                 int allowed = 0, banned = 0;
//                 for (int i = 0; i < L; ++i) {
//                     if (que[i] == '0') allowed ^= 1 << (L - i - 1);
//                     if (que[i] == '1') banned ^= 1 << (L - i - 1);
//                 }

//                 for (int p = banned; p >= 0; p = (p - 1) & banned) {
//                     if (bit_cnt[p]) {
//                         ans -= sum_B[allowed ^ p];
//                     } else {
//                         ans += sum_B[allowed ^ p];
//                     }

//                     if (p == 0) break;
//                 }
//             }
//             cout << ans << '\n';
//         }
//     }
// }

int sum_A[1 << 14][729];
int pow_3[7], mask_3[1 << 6], bit_cnt[1 << 10];

const int MAX_Q = 1 << 20;
int finale[MAX_Q];
int16_t zero_mask[MAX_Q], state[MAX_Q];

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    if (fopen(INFILE, "r")) {
        freopen(INFILE, "r", stdin);
        freopen(OUTFILE, "w", stdout);
    }

    int L, Q; cin >> L >> Q;
    string digits; cin >> digits;

    if (L <= 10) {
        SUBTASK_small_L::main(L, Q, digits);
        return 0;
    }

    pow_3[0] = 1;
    for (int i = 1; i <= 6; ++i) {
        pow_3[i] = pow_3[i - 1] * 3;
    }
    for (int m = 1; m < (1 << 6); ++m) {
        int p = m & -m;
        mask_3[m] = mask_3[m ^ p] + pow_3[__builtin_ctz(p)];
    }

    for (int m = 0; m < (1 << 10); ++m) {
        bit_cnt[m] = bit_cnt[m >> 1] ^ (m & 1);
    }

    for (int m = 0; m < (1 << L); ++m) {
        int a = m;

        int x = digits[m] - '0';
        for (int p = 0; p < (1 << 6); ++p) {
            sum_A[a >> 6][(mask_3[p] << 1) + mask_3[a & 63 & ~p]] += x;
        }
    }

    
    for (int _ = 0; _ < Q; ++_) {
        string que; cin >> que;

        if (count(que.begin(), que.begin() + L - 6, '?') <= (L - 6) / 2) {
            int origin_mask = 0, added = 0, behind_mask = 0;
            for (int i = 0; i < L - 6; ++i) {
                if (que[i] == '1') origin_mask ^= 1 << L - i - 1;
                if (que[i] == '?') added ^= 1 << L - i - 1;
            }
            for (int i = L - 6; i < L; ++i) {
                if (que[i] == '1') behind_mask += pow_3[L - i - 1];
                if (que[i] == '?') behind_mask += pow_3[L - i - 1] << 1;
            }

            zero_mask[_] = state[_] = -1;
            
            for (int p = added; p >= 0; p = (p - 1) & added) {
                finale[_] += sum_A[origin_mask ^ p][behind_mask];
                if (p == 0) break;
            }

            continue;
        }

        for (int i = 0; i < L - 6; ++i) {
            if (que[i] == '0') zero_mask[i] ^= 1 << L - i - 1;
        }
        for (int i = L - 6; i < L; ++i) {
            if (que[i] == '1') state[_] += pow_3[L - i - 1];
            if (que[i] == '?') state[_] += pow_3[L - i - 1] << 1;
        }
    }

    for (int b = 0; b < L - 6; ++b) {
        for (int m = 0; m < (1 << L - 6); ++m) {
            if ((m >> b & 1)) continue;

            for (int s = 0; s < 729; ++s) {
                sum_A[m][s] += sum_A[m ^ (1 << b)][s];
            }
        }
    }
    
    for (int _ = 0; _ < Q; ++_) {
        if (zero_mask[_] != -1) {
            int full = (1 << L - 6) - 1;
            int zero = zero_mask[_];
            
            for (int p = zero; p >= 0; p = (p - 1) & zero) {
                if (bit_cnt[p] != bit_cnt[zero]) {
                    finale[_] -= sum_A[full ^ p][state[_]];
                } else {
                    finale[_] += sum_A[full ^ p][state[_]];
                }

                if (p == 0) break;
            }
        }

        cout << finale[_] << '\n';
    }
    return 0;
}

Compilation message (stderr)

snake_escaping.cpp: In function 'int main()':
snake_escaping.cpp:124:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  124 |         freopen(INFILE, "r", stdin);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~
snake_escaping.cpp:125:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  125 |         freopen(OUTFILE, "w", stdout);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~

• Subtask 1: 5 / 5
• Subtask 2: 7 / 7
• Subtask 3: 0 / 10
• Subtask 4: 0 / 53
• Subtask 5: 0 / 25