其他分享
首页 > 其他分享> > 2022.7.28 模拟赛

2022.7.28 模拟赛

作者:互联网

T1 数据结构

第一个操作很好实现,只需要增加 \(x^k\) 即可

第二个操作是瓶颈,暴力做是不行的

瓶颈在操作 \(2\),若是可以减少操作 \(2\) 的复杂度,就可以通过本题

怎么做呢?我们知道每个数到底被加了几次,就可以一次性算出它的贡献

我们每次操作 \(2\) 使用一个懒标记,加入 \(x\) 就是加入 \(x-tag\)

预处理组合数,如此一来复杂度就在 \(O(mk)\) 了

#include <iostream>
#include <cstdio>
#define int long long
using namespace std;
inline int rd()
{
    int ret = 0, f = 1;
    char c;
    while (c = getchar(), !isdigit(c))
        f = c == '-' ? -1 : 1;
    while (isdigit(c))
        ret = ret * 10 + c - '0', c = getchar();
    return ret * f;
}
const int MAXN = 55;
const int MOD = 1e9 + 7;
int k, m, sum[MAXN], f[MAXN][MAXN];
int s;
void solve()
{
    int x, y;
    y = rd();
    if (y == 0)
    {
        x = rd() - s;
        if (x < 0)
            x += MOD;
        int tmp = 1;
        for (int i = 0; i <= k; i++)
        {
            (sum[i] += tmp;) %= MOD;
            (tmp *= x) %= MOD;
        }
    }
    else
        s++;
    int ans = 0, tmp = 1;
    for (int i = k; i >= 0; i--)
    {
        (ans += (f[k][i] * sum[i]) % MOD * tmp % MOD) %= MOD;
        (tmp *= s) %= MOD;
    }
    cout << ans << endl;
}
signed main()
{
    m = rd();
    k = rd();
    f[0][0] = 1;
    for (int i = 1; i <= 50; i++)
    {
        f[i][0] = 1;
        for (int j = 1; j <= 50; j++)
        {
            f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % MOD;
        }
    }
    while (m--)
        solve();
    return 0;
}

T2 商店购物

考虑一个判定问题:给出一个 \([k,2k]\) 判断是否可行。

对于每个元素 \(x\) :

若 \(x>2k\) ,则 \(x\) 对判定 \(k\) 无效

若 \(x∈[k,2k]\) ,则 \(k\) 一定可行

若 \(x<k\),需要继续讨论

我们关注小于 \(k\) 的 \(x\) ,记它们的和 \(\sum_{x<k}{x}\) 为 \(S\)

若 \(S<2k\),则 \(k\) 不可行

若 \(S∈[k,2k]\) ,则 \(k\) 可行(我们找到了一种方案)

若 \(S>2k\) ,则 \(k\) 可行

为什么?因为每个 \(x\) 均小于 \(k\) ,记 \(s'=s-x\)

\(S'>k\) 恒成立,故 \(S'\) 不可能小于 \(k\) 而使得 \(k\) 不可行

若 \(S'∈[k,2k]\),则 \(k\) 可行(我们找到了一种方案)

若 \(S'>2k\) ,那么可以继续重复此过程,直到可行

因此,只需要记录前缀和,算出所有的区间并,就是最终答案

#include <iostream>
#include <cstdio>
#define int long long
using namespace std;
const int MAXN = 100005;
int a[MAXN], n, ans;
signed main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    sort(a + 1, a + 1 + n);
    int sum = 0, lst = 0;
    for (int i = 0; i <= n; i++)
    {
        sum += a[i];
        while (a[i + 1] == a[i])
            sum += a[++i];
        ans += sum - max(lst, (a[i] + 1) / 2 - 1);
        lst = sum;
    }
    cout << ans << endl;
    return 0;
}

T3 植物大战僵尸

什么时候玩家必败?

如果存在形如 \(11,2222,33333333,...\) 的情况,那么玩家显然必败

也就是说,如果有 \(2^n\) 个 \(n\) 位置的僵尸,那么玩家是必败的

我们发现,位置 \(n\) 的权重是 \(n-1\) 位置的一半,换句话说,后面最多只有一半的僵尸能到达下一个位置

我们可以把这个序列用每个元素的权重表示出来,如果我们认为 \(n\) 的权重是 \(2^n\) 的话,那么玩家必败当且仅当我们可以把序列分成两部分 \(A,B\),使得 \(A≥\frac{1}{2}\) 且 \(B≥\frac{1}{2}\)

于是现在的问题就是,给定 \(n\) 个分数组成的集合,求把它们划分为两个 \(sum≥\frac{1}{2}\) 的集合的方案数

这样不好求,可以容斥一下,求把它们划分成至少有一个 \(sum<\frac{1}{2}\) 的方案数,这就是一个背包问题了

#include <algorithm>
#include <cstring>
#include <iostream>
#include <cstdio>
#define int long long
using namespace std;
inline int rd()
{
    int ret = 0, f = 1;
    char c;
    while (c = getchar(), !isdigit(c))
        f = c == '-' ? -1 : 1;
    while (isdigit(c))
        ret = ret * 10 + c - '0', c = getchar();
    return ret * f;
}
void _(int x)
{
    if (x == 0)
        return;
    _(x / 10);
    putchar('0' + x % 10);
}
void out(int x)
{
    if (!x)
        return;
    _(x);
}
const int MAXN = 100005;
const int MOD = 1e9 + 7;
int T, n;
int a[MAXN], f[MAXN];
void init()
{
    memset(f, 0, sizeof(f));
}
int qpow(int x, int y)
{
    int ret = 1ll;
    while (y)
    {
        if (y & 1)
            (ret *= x) %= MOD;
        (x *= x) %= MOD;
        y >>= 1ll;
    }
    return ret;
}
void solve()
{
    n = rd();
    for (int i = 1; i <= n; i++)
        a[i] = rd();
    sort(a + 1, a + 1 + n);
    int V = 0, cur = a[n];
    f[0] = 1;
    for (int i = n; i >= 1; i--)
    {
        int t = 1;
        while (a[i] != cur)
        {
            t <<= 1;
            cur--;
            if (t > V)
            {
                cur = a[i];
                break;
            }
        }
        if (t > 1)
        {
            for (int k = 0; k <= V / t; k++)
            {
                int tmp = 0;
                for (int j = k * t; j < min((k + 1) * t, V + 1); j++)
                {
                    tmp += f[j];
                    f[j] = 0;
                    tmp %= MOD;
                }
                f[k] += tmp;
                f[k] %= MOD;
            }
            V /= t;
        }
        for (int j = V; j >= 0; j--)
            f[j + 1] += f[j], f[j + 1] %= MOD;
        V++;
    }
    int up = 1, ans = 0;
    while (cur > 1)
    {
        up <<= 1;
        up = min(up, V + 1);
        cur--;
    }
    for (int i = 0; i < up; i++)
        (ans += f[i]) %= MOD;
    ans = -2 * ans;
    ans += qpow(2, n);
    while (ans < 0)
        ans += MOD;
    out(ans);
    putchar('\n');
}
signed main()
{
    T = rd();
    while (T--)
        init(), solve();
    return 0;
}

T4 机房的新生活委员

设 \(f(i,j)\) 表示前 \(i\) 个商店买状态为 \(j\) 花的钱的最小值

则有转移方程 \(f(i,j)=min{f(i-1,j),f(i-1,j)+fee_i+min{f(i,p)+cost_{i,k}}}\)

初始状态 \(f(0,0)=0\) ,其他为 \(inf\)

最终答案为 \(f(n,2^m-1)\) , 时空复杂度为 \(O(nm2^m)\)

#include <cstdio>
#include <cstring>
using namespace std;
#define cmin(_a, _b) (_a > (_b) ? _a = (_b) : 0)
int fee[108], cost[108][18], tmp[108], f[66600], v[66600];
int main()
{
    register int n, m, i, j, S, x, _S, U, newf, newfS;
    scanf("%d %d", &n, &m);
    for (i = 1; i <= n; ++i)
    {
        scanf("%d", &fee[i]);
        for (j = 0; j < m; ++j)
            scanf("%d", &cost[i][j]);
    }

    U = (1 << m) - 1;
    for (S = 1; S <= U; ++S)
    {
        memcpy(tmp, fee, sizeof(tmp) / 108 * (n + 1));
        _S = S;
        for (i = 0; _S; ++i, _S >>= 1)
        {
            if ((_S & 1) == 0)
                continue;
            for (j = 1; j <= n; ++j)
                tmp[j] += cost[j][i];
        }
        v[S] = tmp[1];
        for (i = 2; i <= n; ++i)
            cmin(v[S], tmp[i]);
    }

    memset(f, 63, sizeof(f));
    f[0] = 0;
    for (S = 1; S <= U; ++S)
    {
        newfS = 0x3f3f3f3f;
        for (x = S; x; x = S & (x - 1))
        {
            newf = f[S ^ x] + v[x];
            cmin(newfS, newf);
        }
        f[S] = newfS;
    }
    printf("%d", f[U]);
    return 0;
}

标签:int,28,ret,MAXN,2022.7,include,2k,模拟,MOD
来源: https://www.cnblogs.com/spaceswalker/p/16529276.html