Codechef January Challenge 2021 Division 3 部分题解

January Challenge 2021 Division 3

Chef and Ants

如果只有一根线，两只蚂蚁相撞可以看成沿着原路前进，这和两只蚂蚁都掉头显然等价。答案就是蚂蚁相撞的次数：负半轴蚂蚁数量 ( imes) 正半轴蚂蚁数量

有了这样的转化，多条轴的问题也容易解决了

如果两只蚂蚁不是在中心相撞，这种情况和一根线的一样处理

如果在中心相撞，要注意两个点：

原本在答案中算多此的现在算一次，减去多余

对于每根轴上的蚂蚁，原本是和另一半还没过界的蚂蚁相撞，现在改为和身后的蚂蚁相撞

也就是在原来的基础上稍作修改即可

#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
// #define int long long
void read (int &x) {
    char ch = getchar(); x = 0; int f = 0;
    while (!isdigit(ch)) { if (ch == '-') f = 1; ch = getchar(); }
    while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
    if (f) x = -x;
} const int N = 2e5 + 5, M = 5e5 + 5;
int n, m, c[N], b[M]; vector<int> a[N]; unordered_map<int, int> mp;
signed main() {
    int T; read (T);
    while (T--) {
        read (n); long long res = 0; mp.clear();
        for (int i = 1; i <= n; ++i) a[i].clear();
        for (int i = 1; i <= n; ++i) {
            read (c[i]); a[i].resize (c[i] + 1); int cnt = 0;
            for (int j = 1; j <= c[i]; ++j)
                read (a[i][j]), cnt += (a[i][j] < 0), ++mp[abs (a[i][j])];
            res += 1ll * cnt * (c[i] - cnt);
        }
        // cout << res << endl;
        for (int i = 1; i <= n; ++i) {
            int cnt = 0;
            for (int j = 1; j <= c[i]; ++j)
                b[j] = a[i][j], cnt += (b[j] < 0);
            for (int j = 1, k = c[i]; j <= cnt; ++j) {
                while (k > cnt && b[k] + b[j] >= 0) --k;
                if (mp[abs (b[j])] > 1) {
                    res += j - 1 - (c[i] - k);
                    // cout << j << ' ' << j - 1 - (c[i] - k) << endl;
                }
            }
            for (int j = c[i], k = 1; j > cnt; --j) {
                while (k <= cnt && b[k] + b[j] < 0) ++k;
                if (mp[b[j]] > 1) {
                    res += c[i] - j - (k - 1);
                    // cout << j << ' ' << c[i] - j - (k - 1) << endl;
                }
            }
        } //res /= 2;
        for (auto i : mp) if (i.second > 1) ++res;
        printf ("%lld
", res);
    }
    return 0;
}

Guess the Tiling

如果想要知道答案，显然要让一个 (2 imes 2) 的方格内的线处于特殊位置（形成正方形），这样 (ask) 后答案会改变，就可以判断了

我们采取“边缘包围中心”的策略，就是先把左上角四个才出来，然后猜最上面一层和最左边一层，中间的都很好判断了。具体怎么判断还是很好想的

主要的难点：平均每个格子只能询问 (4) 次，这就要求严格的乱搞能力，也就是说在枚举周围格子状态（用二进制表示）的时候，每次只能改变一个二进制位。对于左上角的四个，以嘴上角的那个为“关键点”（根据操作它后答案是否改变来判断是否形成正方形），要枚举其他三个的状态，(2^3=8)，给出一种顺序使相邻两个只有一个二进制位不同：(0, 1, 3, 2, 6, 4, 5, 7)，而对于最左侧和最右侧（两层），每次推进一层，以最左侧为例：以左上的为关键点，右上的已经猜出来，直接转到关键状态，剩下两个的状态要枚举：(0,1,3,2)。中间的每次处理一个，其他三个都已知，直接转到目标状态，一次询问即可

代码的四个注释简短的体现了四种情况

#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, q, cnt, la, a[N][N]; 
void ask (int x, int y) {
    printf ("1 %d %d
", x, y);
    fflush (stdout); a[x][y] ^= 1;
    cin >> cnt;
}
int k[8] = {0, 1, 3, 2, 6, 4, 5, 7}, p[3] = {1, 2, 4};
signed main() {
    ios_base::sync_with_stdio (0);
    cin.tie (0); //cout.tie (0);
    int T; cin >> T;
    while (T--) {
        cin >> n >> q >> cnt;
        memset (a, 0, sizeof (a));
/*
左上角
x 0
1 2
*/
        for (int i = 0; i < 8; ++i) {
            for (int j = 0, x, y; j < 3; ++j) {
                if (j == 0) x = 1, y = 2;
                if (j == 1) x = 2, y = 1;
                if (j == 2) x = y = 2;
                if ((k[i] & p[j]) && !a[x][y]) ask (x, y);
                else if (!(k[i] & p[j]) && a[x][y]) ask (x, y);
            }
            la = cnt, ask (1, 1);
                if (cnt == la + 1) {
                a[1][1] = a[2][2] = 0;
                a[1][2] = a[2][1] = 1;
                break;
            }
            if (cnt == la - 1) {
                a[1][1] = a[2][1] = a[1][2] = 1;
                a[2][2] = 0; break;
            }
        }
/*
左边缘
x 定
0 1
*/
        for (int t = 3; t <= n; ++t) {
            if (!a[t - 1][2]) ask (t - 1, 2);
            for (int i = 0; i < 4; ++i) {
                for (int j = 0; j < 2; ++j) {
                    if ((k[i] & p[j]) && !a[t][j + 1]) ask (t, j + 1);
                    else if (!(k[i] & p[j]) && a[t][j + 1]) ask (t, j + 1);
                }
                la = cnt, ask (t - 1, 1);
                if (cnt == la + 1) {
                    a[t - 1][1] = a[t][2] = 0;
                    a[t - 1][2] = a[t][1] = 1; break;
                }
                if (cnt == la - 1) {
                    a[t - 1][1] = a[t - 1][2] = a[t][1] = 1;
                    a[t][2] = 0; break;
                }
            }
        }
/*
右边缘
x 0
定 1
*/
        for (int t = 3; t <= n; ++t) {
            if (!a[2][t - 1]) ask (2, t - 1);
            for (int i = 0; i < 4; ++i) {
                for (int j = 0; j < 2; ++j) {
                    if ((k[i] & p[j]) && !a[j + 1][t]) ask (j + 1, t);
                    else if (!(k[i] & p[j]) && a[j + 1][t]) ask (j + 1, t);
                }
                la = cnt, ask (1, t - 1);
                if (cnt == la + 1) {
                    a[1][t - 1] = a[2][t] = 0;
                    a[2][t - 1] = a[1][t] = 1; break;
                }
                if (cnt == la - 1) {
                    a[1][t - 1] = a[2][t - 1] = a[1][t] = 1;
                    a[2][t] = 0; break;
                }
            }
        }
/*
定 定
定 x
*/
        for (int i = 3; i <= n; ++i)
            for (int j = 3; j <= n; ++j) {
                if (a[i - 1][j - 1]) ask (i - 1, j - 1);
                if (!a[i][j - 1]) ask (i, j - 1);
                if (!a[i - 1][j]) ask (i - 1, j);
                la = cnt, ask (i, j);
                a[i][j] = (cnt < la);
            }
        puts ("2");
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j)
                putchar ('0' + a[i][j]), putchar (' '); puts ("");
        } fflush (stdout); cin >> cnt;
    }
}

And-Or Game

如果只有一种 (|) 运算，显然如果每次操作都发生更改，最多更改 (20) 次，做 (20) 次 (fwt)

同样，可以把一堆 (|) 和一堆 (&) 看成一次运算，每次也只能变多，这样也最多更改 (20) 次，一共 (40) 遍 (fwt)，卡卡常就好了

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
void read (int &x) {
    char ch = getchar(); x = 0; while (!isdigit(ch)) ch = getchar();
    while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
} const int N = 1024 * 1024 * 2 + 5, mod = 1e9 + 7;
int n, m, mx, lim; ll f[N], g[N], res[N], la[N];
#define up(x, y) ((x += y) >= mod && (x -= mod))
void fwt_or (ll *a, int opt) {
    for (int i = 1; i < lim; i <<= 1)
        for (int j = 0; j < lim; j += (i << 1))
            for (int k = 0; k < i; ++k)
                if (opt == 1) up (a[i + j + k], a[j + k]);
                else up (a[i + j + k], mod - a[j + k]);
}
void fwt_and (ll *a, int opt) {
    for (int i = 1; i < lim; i <<= 1)
        for (int j = 0; j < lim; j += (i << 1))
            for (int k = 0; k < i; ++k)
                if (opt == 1) up (a[j + k], a[i + j + k]);
                else up (a[j + k], mod - a[i + j + k]);
}
ll qpow (ll x, int y) {
    ll t = 1; while (y) { if (y & 1) t = t * x % mod; x = x * x % mod, y >>= 1; } return t;
}
signed main() {
    int T; read (T);
    while (T--) {
        read (n), read (m); lim = 1, mx = 0;
        for (int i = 1, x; i <= n; ++i)
            read (x), mx = max (mx, x), f[x] = 1;
        for (int i = 1, x; i <= m; ++i)
            read (x), mx = max (mx, x), g[x] = 1;
        while (lim <= mx) lim <<= 1;
        f[0] = res[0] = 1, g[lim - 1]= 1;
        fwt_or (f, 1), fwt_and (g, 1);
        for (int i = 0; i < lim; ++i) f[i] = qpow (f[i], 21);
        for (int i = 0; i < lim; ++i) g[i] = qpow (g[i], 21);
        while (1) {
            memcpy (la, res, sizeof (res));
            int tag = 0;
            fwt_or (res, 1);
            for (int i = 0; i < lim; ++i) res[i] = res[i] * f[i] % mod;
            fwt_or (res, -1);
            fwt_and (res, 1);
            for (int i = 0; i < lim; ++i) res[i] = res[i] * g[i] % mod;
            fwt_and (res, -1);
            for (int i = 0; i < lim; ++i)
                if (!la[i] && res[i]) { tag = 1; break; }
            if (!tag) break;
        }
        int cnt = 0;
        for (int i = 0; i < lim; ++i) if (res[i]) ++cnt;
        printf ("%d
", cnt);
        for (int i = 0; i < lim; ++i) f[i] = g[i] = res[i] = 0;
    }
    return 0;
}

Blackjack

这题最后还是没想出正解。。。写了个 (O(frac{n^3log_n}{w})) 卡过去了，正解是 (O(frac{n^3}{w})) 的

题意就是枚举一个边界 (x)，然后在右侧选 (y) 个，左侧选 (x-y) 个，和在 ([l,r]) 内，使 (y) 最小

前后缀背包是肯定要做的，(L_{i,j,k}) 表示前 (i) 个物品，选 (j) 个，和为 (k) 是否可行，(R) 同理。

只有 (0/1) 状态显然是可以用 (bitset) 优化的，推完一遍是 (O(frac{n^3}{w}))。

brute solution：

枚举边界 (x)，枚举 (L) 的个数 (j)，然后每一个可行的 (k) 在 (R) 中对应一段区间，这个也是可以 (bitset) 优化的（初始一个一段是 (1) 的，(&) 一下看一下有没有 (1)），应该是(O(frac{n^4}{w}))

my solution：

先把 (L,R) 的二 、三两维翻转，变成 (L_{i,j,k}) 表示前 (i) 个物品，和为 (j)，选 (k) 个是否可行

同样枚举 (x)，对于 (L) 中每一种和，在 (R) 中对应一段下标，可以用数据结构维护（st表，线段树...）。然后用 (\_Find\_first()) 找第一个 (1)，即最小的答案

有一个需要注意的地方是由于 (L) 和 (R) 选的物品要满足数量和是个定值，在推 (L) 的时候会发生一些改变，(L) 和 (R) 的方程式不太一样

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
// using namespace std;
void read (int &x) {
    char ch = getchar(); x = 0; while (!isdigit(ch)) ch = getchar();
    while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
} const int N = 1005;
int n, res, mx, L, R, len, a[N], lg[N];
std::bitset<505> f[N][N], g[N][N], tmp, c[12][N];
void build (int k) {
    for (int i = 0; i<= R; ++i) c[0][i] = g[k][i];
    // for (int i = R + 1; i <= R + (1 << len); ++i) c[0][i].reset();
    for (int i = 1; i <= len; ++i) {
        int lim = R - (1 << i);
        for (int j = 0; j <= lim; ++j)
            c[i][j] = c[i - 1][j] | c[i - 1][j + (1 << (i - 1))];
    }
}
void query (int l, int r) {
    l = std::max (l, 0), r = std::min (r, R); int t = lg[r - l + 1];
    tmp |= c[t][l] | c[t][r - (1 << t) + 1];
}
int get (int x) {
    int ans = 10000; build (x + 1);
    for (int i = 0; i <= R; ++i) {
        // int l = L - i, r = R - i;
        tmp.reset(); query (L - i, R - i); tmp &= f[x][i];
        ans = std::min (ans, (int)tmp._Find_first());
    }
    return ans;
}
signed main() {
    int T; read (T); lg[0] = -1;
    for (int i = 1; i <= 1000; ++i) lg[i] = lg[i >> 1] + 1;
    while (T--) {
        read (n), read (L), read (R);
        int zero = 0, ss = 0; mx = R;
        for (int i = 1; i <= n; ++i) read (a[i]);
        for (int i = 1; i <= n; ++i) {
            ss += a[i]; if (ss >= L && ss <= R) { zero = 1; break; }
        }
        if (zero) { puts ("0"); continue; }
        for (int i = 0; i <= mx; ++i)
            f[0][i].reset(), g[n + 1][i].reset();
        // for (int i = 0; i <= 1000) qwq[i].reset();
        f[0][0][0] = g[n + 1][0][0] = 1;
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= mx; ++j) f[i][j] = f[i - 1][j] << 1;
            for (int j = mx; j >= a[i]; --j)
                f[i][j] |= f[i - 1][j - a[i]];
        }
        for (int i = n; i >= 1; --i) {
            for (int j = 0; j <= mx; ++j) g[i][j] = g[i + 1][j];
            for (int j = mx; j >= a[i]; --j)
                g[i][j] |= g[i + 1][j - a[i]] << 1;
        }
        len = lg[R - L + 1]; res = 100000;
        for (int i = 1; i < n; ++i)
            res = std::min (res, get (i));
        if (res > n / 2) res = -1;
        printf ("%d
", res);
    }
    return 0;
}

very good solution：

其实和普通 (dp) 优化方法是一样的，记录 (0/1) 状态往往产生很多浪费，即使有 (bitset) 加持。

这种时候可以想一想转向记录最佳状态。

(L,R) 还是按照上面那样翻转二、三维

用 (L'_{i,j}) 表示选了和为 (j)，选了 (i) 个数，满足 (L_{x,i,j}=1) 的最小的 (x)

(R'_{i,j}) 表示和为 (j)，选了 (i) 个数，满足 (R_{x,i,j}=1) 的最大的 (x)

在原来递推求 (L,R) 的基础上，每次计算 (L_x xor L_{x-1})，多出来的 (1) 就是新产生的可行方案，在 (L') 中修改。找所有的 (1) 依然可以用 (bitset) 优化遍历，求出 (L',R') 的复杂度依然是 (O(frac{n^3}{w}))

有了 (L',R')，枚举 (R') 的每一个 (i,j)，此时 (L') 中的 (i’) 在一段区间内，(j') 随意（所以可以把所有 (j') 缩到一起变成一维数组），如果存在 (L'_{i',j'}<R'_{i,j})，则答案可以为 (j)。这个过程同样可以数据结构优化，复杂度 (O(n^2log_n))

所以复杂度为 (O(n^2log_n+frac{n^3}{w}))，此问题得到完美解决，然而代码还没有写。。。