2024牛客暑期多校训练营2 补题BGI

已于 2024-07-25 09:44:44 修改
阅读量466 收藏 10
点赞数 6
分类专栏： 牛客2024暑假多校 文章标签： 算法 动态规划 数据结构
于 2024-07-25 09:42:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ldcode11/article/details/140679674
版权

B

根号分治，如果题目中总数据量是一个定值，那么在询问中大数据的数量不会很多，故可以尝试找到一个分界线将询问分为大数据询问和小数据询问并用不同的方法解答出来。
题目中的询问要求是给定一个图中点集的子集S，求该子集的最小生成树，不难想到如果能快速找到所有的合法边 （也就是两端点都是该子集的点），就可以跑kruskal将其解出。如果说暴力找边那么时间复杂度是O(m),这显然是不可接受的，对于点较少的子集,可以采用枚举两个端点的方式找边时间复杂度是O(|S| ^ 2),分界点可以采用sqrt (n)。
感悟：不难发现根号分治在点集较小的时候，采用的是纯与点集大小相关的算法，这样可以保证在点集较小的时候能有效优化算法，而大于某个上限的时候，要采用时间复杂度较稳定的算法，可以是暴力之类的算法。
代码

#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define endl '\n'
#define int long long
typedef long double f128;
typedef long long i64;
typedef unsigned long long u64;
typedef pair<int, int> pii;
const int INF = 0x3f3f3f3f, mod = 1e9 + 7;
const i64 inf = 2e18;
//-------------------------------------------

struct node
{
    int x, y, w;
};

struct DSU
{
    std::vector<int> f, siz;

    DSU() {}
    DSU(int n)
    {
        init(n);
    }

    void init(int n)
    {
        f.resize(n);
        std::iota(f.begin(), f.end(), 0);
        siz.assign(n, 1);
    }

    int find(int x)
    {
        while (x != f[x])
        {
            x = f[x] = f[f[x]];
        }
        return x;
    }

    bool same(int x, int y)
    {
        return find(x) == find(y);
    }

    bool merge(int x, int y)
    {
        x = find(x);
        y = find(y);
        if (x == y)
        {
            return false;
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }

    int size(int x)
    {
        return siz[find(x)];
    }
};

void solve()
{
    int n, m, q;
    cin >> n >> m >> q;
    map<pii, int> mp;
    for (int i = 1; i <= m; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        if (u > v)
            swap(u, v);
        mp[{u, v}] = w;
    }

    int base = sqrt(n);

    while (q--)
    {
        vector<int> S;
        int k, idx = 0;
        cin >> k;
        map<int, int> id;
        for (int i = 1, x; i <= k; i++)
        {
            cin >> x;
            id[x] = ++idx;
            S.push_back(x);
        }
        sort(S.begin(), S.end());
        vector<node> edge;
        if (S.size() <= base)
        {
            for (int i = 0; i < S.size(); i++)
                for (int j = i + 1; j < S.size(); j++)
                    if (mp.count({S[i], S[j]}))
                        edge.push_back({id[S[i]], id[S[j]], mp[{S[i], S[j]}]});
        }
        else
        {
            for (auto t : mp)
            {
                auto p = t.x;
                if (id.count(p.x) && id.count(p.y))
                    edge.push_back({id[p.x], id[p.y], t.y});
            }
        }

        sort(edge.begin(), edge.end(), [&](node a, node b)
             { return a.w < b.w; });

        DSU dsu(S.size() + 1);
        int sz = S.size(), ans = 0;

        for (auto e : edge)
        {
            if (dsu.merge(e.x, e.y))
                ans += e.w, sz--;
            if (sz == 1)
                break;
        }
        if (sz != 1)
            cout << -1 << endl;
        else
            cout << ans << endl;
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    //cin >> T;
    for (int i = 1; i <= T; i++)
        solve();
    return 0;
}

I

动态规划
动态规划最重要的要求之一就是要满足拓扑序，也就当前状态所需的前置状态都是已经计算过的,而计算前置状态时又不会用到当前状态，设 1, 2, …, n 的位置分别是 (l1, r1),(l2, r2), …,(ln, rn)，再设 f(i) 是区间 [ li,ri ]的答案，最重要的一点是将i按 ri - li + 1 排序，因为区间长度大的区间会包含小区间，反之则不成立，这就完美满足了拓扑序。
转移方程
请添加图片描述
代码

#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define endl '\n'
#define int long long
typedef long double f128;
typedef long long i64;
typedef unsigned long long u64;
typedef pair<int, int> pii;
const int INF = 0x3f3f3f3f, mod = 1e9 + 7;
const i64 inf = 2e18;
//-------------------------------------------
const int N = 3e3 + 10;
int n;
int a[2 * N], f[2 * N], l[N], r[N];
int ans = 0;

void solve()
{
    cin >> n;
    vector<int> b(n + 1);
    for (int i = 1; i <= 2 * n; i++)
    {
        cin >> a[i];
        if (l[a[i]] == 0)
            l[a[i]] = i;
        else
            r[a[i]] = i;
    }

    for (int i = 1; i <= n; i++)
        b[i] = i;
    l[0] = 0, r[0] = 2 * n + 1;

    sort(b.begin(), b.end(), [&](int a, int b)
         { return r[a] - l[a] < r[b] - l[b]; });

    for (auto x : b)
    {
        vector<int> g(2 * n + 2);
        for (int j = l[x] + 1; j < r[x]; j++)
        {
            g[j] = g[j - 1] + x;
            if (l[a[j]] > l[x] && r[a[j]] == j)
                g[j] = max(g[j], g[l[a[j]] - 1] + f[a[j]]);
        }
        f[x] = g[r[x] - 1] + 2 * x;
    }

    cout << f[0] << endl;
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    for (int i = 1; i <= T; i++)
        solve();
    return 0;
}

G

动态规划
首先这是个集合问题，而集合问题自然联想到也许可以用dp。
1.如果一个数x每个质因子的指数都是偶数，那么开根一定可以转化为一个整数，故当该因子指数从奇数变为偶数时可以提出来。
2.小于sqrt(1000)只有11个质因子{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31}，这代表大于31的质因子的指数最大为1，且最多有一个，因此把所有数按除这11个质因子以外的因子分组，可以采用11 + 1位状态压缩，每一组都必须取偶数个(除了1那一组)。
代码

#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define endl '\n'
#define int long long
typedef long double f128;
typedef long long i64;
typedef unsigned long long u64;
typedef pair<int, int> pii;
const int INF = 0x3f3f3f3f, mod = 1e9 + 7;
const i64 inf = 2e18;

//-------------------------------------------

template <const int T>
struct ModInt
{
    const static int mod = T;
    int x;
    ModInt(int x = 0) : x(x % mod) {}
    // ModInt(long long x) : x(int(x % mod)) {}
    int val() { return x; }
    ModInt operator+(const ModInt &a) const
    {
        int x0 = x + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }
    ModInt operator-(const ModInt &a) const
    {
        int x0 = x - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }
    ModInt operator*(const ModInt &a) const { return ModInt(1LL * x * a.x % mod); }
    ModInt operator/(const ModInt &a) const { return *this * a.inv(); }
    bool operator==(const ModInt &a) const { return x == a.x; };
    bool operator!=(const ModInt &a) const { return x != a.x; };
    void operator+=(const ModInt &a)
    {
        x += a.x;
        if (x >= mod)
            x -= mod;
    }
    void operator-=(const ModInt &a)
    {
        x -= a.x;
        if (x < 0)
            x += mod;
    }
    void operator*=(const ModInt &a) { x = 1LL * x * a.x % mod; }
    void operator/=(const ModInt &a) { *this = *this / a; }
    friend ModInt operator+(int y, const ModInt &a)
    {
        int x0 = y + a.x;
        return ModInt(x0 < mod ? x0 : x0 - mod);
    }
    friend ModInt operator-(int y, const ModInt &a)
    {
        int x0 = y - a.x;
        return ModInt(x0 < 0 ? x0 + mod : x0);
    }
    friend ModInt operator*(int y, const ModInt &a) { return ModInt(1LL * y * a.x % mod); }
    friend ModInt operator/(int y, const ModInt &a) { return ModInt(y) / a; }
    friend ostream &operator<<(ostream &os, const ModInt &a) { return os << a.x; }
    friend istream &operator>>(istream &is, ModInt &t) { return is >> t.x; }

    ModInt pow(int64_t n) const
    {
        if (n == 0)
            return 1;
        ModInt res(1), mul(x);
        while (n)
        {
            if (n & 1)
                res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }

    ModInt inv() const
    {
        int a = x, b = mod, u = 1, v = 0;
        while (b)
        {
            int t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        if (u < 0)
            u += mod;
        return u;
    }
};
using mint = ModInt<mod>; // 要取余的数

const int N = 1010, M = 1ll << 11;

int a[N], st[N], maxp[N];
mint f[M][2][2], w[N];
void solve()
{
    int n;
    cin >> n;
    map<int, vector<int>> g;
    int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        int x = a[i];
        w[i] = 1;
        for (int j = 0; j < 11; j++)
        {
            while (x % prime[j] == 0)
            {
                x /= prime[j];
                st[i] ^= (1 << j);
                if (!(st[i] & (1 << j)))
                    w[i] *= prime[j];
            }
        }
        g[x].push_back(i);
    }

    int cur = 0;

    auto cal = [&](int a, int b)
    {
        int c = a & b, mul = 1;
        for (int i = 0; i < 11; i++)
            if (c & (1 << i))
                mul = mul * prime[i];
        return mul;
    };

    for (auto t : g[1])
    {
        for (int j = 0; j < M; j++)
            f[j][0][cur ^ 1] = f[j][0][cur];
        for (int j = 0; j < M; j++)
            f[j ^ st[t]][0][cur ^ 1] += f[j][0][cur] * cal(j, st[t]) * w[t];
        f[st[t]][0][cur ^ 1] += w[t];
        cur ^= 1;
    }
    g.erase(1);
    for (auto k : g)
    {
        auto v = k.y;
        for (int j = 0; j < M; j++) // 每个组取奇数个的清0
            f[j][1][cur] = 0;
        for (auto t : v)
        {
            for (int j = 0; j < M; j++)
            {
                f[j][0][cur ^ 1] = f[j][0][cur];
                f[j][1][cur ^ 1] = f[j][1][cur];
            }
            for (int j = 0; j < M; j++)
            { 
                f[j ^ st[t]][0][cur ^ 1] += f[j][1][cur] * cal(j, st[t]) * w[t] * k.x; // 提出指数变为偶数的数
                f[j ^ st[t]][1][cur ^ 1] += f[j][0][cur] * cal(j, st[t]) * w[t];
            }
            f[st[t]][1][cur ^ 1] += w[t]; // 加入只有a[t]一个数的集合
            cur ^= 1;
        }
    }

    cout << f[0][0][cur] << endl;
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    // cin >> T;
    for (int i = 1; i <= T; i++)
        solve();
    return 0;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值