Codeforces 1642F bitset / Trie

题意

传送门 Coodeforces 1642F Two Arrays

题解

bitset

将数组按照 $w$ 升序排序。std::bitset 维护存在值 $a_{i,j}$ 的数组 $i$ 的集合。枚举数组，$O(m)$ 处理出与其存在相同元素的数组集合。时空复杂度均为 $O(n^{2}m/32)$。可以通过将包含较少元素的集合暴力处理，较多元素的集合用 std::bitset 维护的方法，降低空间开销。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E5 + 5, MAXM = 5, SZ = MAXN * MAXM, INF = 2e9 + 5;
int N, M, A[MAXN][MAXM], B[MAXN][MAXM], W[MAXN];
int ord[MAXN], sx[SZ], sxn;
vector<bitset<MAXN>> mask[SZ];
vector<int> idx[SZ];

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
            cin >> A[i][j], sx[sxn++] = A[i][j];
        cin >> W[i];
    }
    for (int i = 0; i < N; ++i)
        ord[i] = i;
    sort(ord, ord + N, [&](const int i, const int j)
         { return W[i] < W[j]; });
    for (int i = 0; i < N; ++i)
        memcpy(B[i], A[ord[i]], sizeof(B[i]));
    for (int i = 0; i < N; ++i)
        memcpy(A[i], B[i], sizeof(A[i]));
    sort(W, W + N);
    sort(sx, sx + sxn);
    sxn = unique(sx, sx + sxn) - sx;
    for (int i = 0; i < N; ++i)
        for (int j = 0; j < M; ++j)
            A[i][j] = lower_bound(sx, sx + sxn, A[i][j]) - sx;
    int res = INF;
    int lim = 2000;
    for (int i = 0; i < N; ++i)
        for (int j = 0; j < M; ++j)
            idx[A[i][j]].push_back(i);
    for (int i = 0; i < sxn; ++i)
        if ((int)idx[i].size() > lim)
        {
            bitset<MAXN> t;
            t.set();
            for (auto j : idx[i])
                t[j] = 0;
            mask[i].push_back(t);
        }
    for (int i = 0; i < N; ++i)
    {
        bitset<MAXN> t;
        t.set();
        for (int j = 0; j < M; ++j)
        {
            if (mask[A[i][j]].size())
                t &= mask[A[i][j]][0];
            else
            {
                for (int k : idx[A[i][j]])
                    t[k] = 0;
            }
        }
        int pos = t._Find_first();
        if (pos < N)
            res = min(res, W[i] + W[pos]);
    }
    cout << (res == INF ? -1 : res) << '\n';
    return 0;
}

类似于上述思想的还有另一种实现方式。将数组分批处理，每批规模为 $64$，使用 unsigned long long 维护集合；处理每一批数组时，枚举所有数组，求解这批数组中满足条件的最小 $w$。时间复杂度 $O(n^{2}m/64)$，空间复杂度 $O(nm)$。

#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = l, _ = r; i < _; ++i)
typedef unsigned long long ull;
const int MAXN = 1E5 + 5, MAXM = 5, SZ = MAXN * MAXM, INF = 2e9 + 5;
int N, M, A[MAXN][MAXM], B[MAXN][MAXM], W[MAXN];
ull mask[SZ];
int ord[MAXN], sx[SZ], sxn;

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
            cin >> A[i][j], sx[sxn++] = A[i][j];
        cin >> W[i];
    }
    for (int i = 0; i < N; ++i)
        ord[i] = i;
    sort(ord, ord + N, [&](const int i, const int j)
         { return W[i] < W[j]; });
    for (int i = 0; i < N; ++i)
        memcpy(B[i], A[ord[i]], sizeof(B[i]));
    for (int i = 0; i < N; ++i)
        memcpy(A[i], B[i], sizeof(A[i]));
    sort(W, W + N);
    sort(sx, sx + sxn);
    sxn = unique(sx, sx + sxn) - sx;
    for (int i = 0; i < N; ++i)
        for (int j = 0; j < M; ++j)
            A[i][j] = lower_bound(sx, sx + sxn, A[i][j]) - sx;
    int res = INF;
    int batch = 64;
    ull fl = -1;
    for (int l = 0; l < N; l += batch)
    {
        int r = min(N, l + batch);
        for (int i = l; i < r; ++i)
            for (int j = 0; j < M; ++j)
                mask[A[i][j]] |= 1ull << (i - l);
        rep(i, 0, N)
        {
            ull t = 0;
            rep(j, 0, M)
                t |= mask[A[i][j]];
            if (t == fl)
                continue;
            int pos = __builtin_ctzll(t ^ fl) + l;
            if (pos < N)
                res = min(res, W[i] + W[pos]);
        }
        for (int i = l; i < r; ++i)
            for (int j = 0; j < M; ++j)
                mask[A[i][j]] = 0;
    }
    cout << (res == INF ? -1 : res) << '\n';
    return 0;
}

Trie

考虑到 $w_i+w_j$ 的最小性，使数组有序后，若 $(i,j)$ 是一个可行解，那么随着 $j$ 增大，更优的答案应该取 $i^{\prime }<i$ 。对于数组 $i$，考虑如何高效的判断多个数组中是否存在不包含相同元素的 $j$。

将数组有序后枚举子集，用 Trie 维护。对于数组 $i$，若存在子集 $s$ 出现在 Trie 中，令出现的次数为 $cn{t}_s$，按照子集大小的奇偶性分别贡献 $cn{t}_s$ 的正值或负值。根据 $\sum (1-1{)}^n={\sum }_k(-1{)}^k\left(\genfrac{}{}{0ex}{}{n}{k}\right)=[n=0]$，则存在相同元素的数组贡献为 0，不存在相同元素的元素贡献都为 1 或 -1。

求出满足条件的第一组 $(i,j)$，双指针求解即可。总时间复杂度 $O(n{2}^m\log n)$。

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const int MAXN = 1E5 + 5, MAXM = 5, SZ = MAXN * (1 << (MAXM - 1)) * MAXM;
struct P
{
    int a[MAXM], w;
    bool operator<(const P &o) { return w < o.w; }
} ps[MAXN];
int N, M, rt, tot, ed[SZ];
map<int, int> ch[SZ];

void init() { rt = tot++; }

void add(P &p, int x, int u = rt, int k = 0)
{
    if (k == M)
    {
        ed[u] += x;
        return;
    }
    add(p, x, u, k + 1);
    if (!ch[u].count(p.a[k]))
        ch[u][p.a[k]] = tot++;
    add(p, x, ch[u][p.a[k]], k + 1);
}

int ask(P &p, int u = rt, int k = 0)
{
    if (k == M)
        return ed[u];
    int res = ask(p, u, k + 1);
    if (ch[u].count(p.a[k]))
        res -= ask(p, ch[u][p.a[k]], k + 1);
    return res;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
            cin >> ps[i].a[j];
        cin >> ps[i].w;
        sort(ps[i].a, ps[i].a + M);
    }
    sort(ps, ps + N);
    init();
    int l, r;
    r = 0;
    while (r < N && ask(ps[r]) == 0)
        add(ps[r++], 1);
    if (r == N)
    {
        cout << "-1\n";
        return 0;
    }
    l = r;
    while (l && ask(ps[r]) != 0)
        add(ps[--l], -1);
    int res = ps[l].w + ps[r].w;
    for (; r < N && l >= 0; ++r)
    {
        while (l && ask(ps[r]) != 0)
            add(ps[--l], -1);
        res = min(res, ps[l].w + ps[r].w);
    }
    cout << res << '\n';
    return 0;
}