NOIP2024集训 Day32 总结

合集 - NOIP2024(12)

1.『NOIP2024』花落，你却身处花海；花开，你却归于人间2024-12-07

2.NOIP2024集训 Day32 总结2024-09-18

3.NOIP2024集训 Day33 总结2024-09-194.NOIP2024模拟赛9 赛后总结2024-09-295.CF EDU 138 略解2024-09-286.CF EDU 139 略解2024-09-287.NOIP2024集训 Day37 总结2024-09-248.NOIP2024集训 Day51 略解2024-10-149.CF EDU 136 总结2024-10-1010.NOIP2024集训 Day47 总结2024-10-0811.CF EDU 137 总结2024-10-0812.NOIP2024集训 Day44-45 略解2024-10-06

收起

前言

当坚冰还盖着北海的时候，我看到了怒放的梅花。

停课了，对于每天的题也是终于有时间写总结了。

我不会告诉你，以前没空写是因为颓废。

今天是，愉快的，数位DP专题~

淘金

乍一看，这个 $n^2$ 怎么感觉跟数位 $\mathtt{\text{DP}}$ 没啥关联呢。

手玩一下小数据，我们可以发现，对于每个变动到的坐标 $(x,y)$，要使其合法，即 $x,y\in [1,n]$，$x,y$ 质因数分解之后必然为：$x,y=2^{p_1}\times 3^{p_2}\times 5^{p_3}\times 7^{p_4}$。观察到合法的 $x,y$ 均 $\in [1,{10}^{12}]$，故 $p_{1,2,3,4}$ 都不是很大，经过计算，$p_1\times p_2\times p_3\times p_4$ 大概在 $2\times {10}^5$ 级别。

由于 $x,y$ 本质上的变动情况是相同的，故我们可以先只考虑一维然后在进行两维的合并。

考虑对于一维，有我们刚刚的推导可以得到，每一维变动之后最终的合法状态在 $2\times {10}^5$ 级别。于是我们可以直接枚举最终状态的 $p_{1,2,3,4}$，通过数位 $\mathtt{\text{DP}}$ 计算每种状态的点上有多少个点。

这个应该是不难的，所以先直接放代码。

//num1,2,3,4是分别对应的2,3,5,7的次数，如6,num1=1,num2=1
long long dfs(int x, bool limit, int num1, int num2, int num3, int num4, bool flg)
{
    if(num1 < 0 || num2 < 0 || num3 < 0 || num4 < 0) return 0;
    if(x == 0) return (num1 + num2 + num3 + num4) == 0 && flg;
    if(~dp[x][num1][num2][num3][num4][limit][flg]) return dp[x][num1][num2][num3][num4][limit][flg];
    int up = limit ? a[x] : 9;
    long long now = 0;
    for (int i = ((!flg) ? 0 : 1); i <= up; ++i) 
    now += dfs(x - 1, limit & (i == a[x]), num1 - ::num1[i], num2 - ::num2[i], num3 - ::num3[i], num4 - ::num4[i], (flg | bool(i)));
    return dp[x][num1][num2][num3][num4][limit][flg] = now;
}

然后样我们就可以得到每个最终状态上有多少个点。

问题就转化成了：有 $n$ 个数 $a_i$，每次可以选一个数对 $(i,j)$，每次选的不能相同，选择一个数对的代价是 $a_i\times a_j$，要求选择 $k$ 个数对的最大代价之和。

一个简单的堆就解决了，先对于每一个 $i$，将 $a_i\times \underset{j=1}{\overset{n}{max}}{a}_j$ 放入堆中，每次取出一个，就将 $a_j$ 变为次大再放进去，一直取直到限制即可。

代码写的非常难评，是时间正常人的 $10$ 倍，还是别看了（（（

#include <bits/stdc++.h>
using namespace std;
#define maxn 1000005
const int mod = 1e9 + 7;
long long n;
int k;
int a[20], cnt;
long long dp[15][42][30][20][15][2][2];
map<long long, int> ans;
int num1[10], num2[10], num3[10], num4[10];
long long dfs(int x, bool limit, int num1, int num2, int num3, int num4, bool flg)
{
    if(num1 < 0 || num2 < 0 || num3 < 0 || num4 < 0) return 0;
    if(x == 0) return (num1 + num2 + num3 + num4) == 0 && flg;
    if(~dp[x][num1][num2][num3][num4][limit][flg]) return dp[x][num1][num2][num3][num4][limit][flg];
    int up = limit ? a[x] : 9;
    long long now = 0;
    for (int i = ((!flg) ? 0 : 1); i <= up; ++i) 
    now += dfs(x - 1, limit & (i == a[x]), num1 - ::num1[i], num2 - ::num2[i], num3 - ::num3[i], num4 - ::num4[i], (flg | bool(i)));
    return dp[x][num1][num2][num3][num4][limit][flg] = now;
}
void solve(long long x)
{
    while(x) a[++cnt] = x % 10, x /= 10;
    memset(dp, -1, sizeof(dp));
    for (int i = 0; i <= 40; ++i)
    {
        for (int j = 0; j < 30; ++j)
        {
            for (int k = 0; k < 20; ++k)
            {
                for (int l = 0; l < 15; ++l)
                ans[dfs(cnt, true, i, j, k, l, 0)]++;
            }
        }
    }
}
unordered_map<long long, int> now, nxt;
int main()
{
    num1[2] = 1, num2[3] = 1, num3[5] = 1, num4[7] = 1;
    num1[4] = 2;
    num1[6] = 1, num2[6] = 1;
    num1[8] = 3;
    num2[9] = 2;
    cin >> n >> k;
    solve(n);
    long long maxx = (*(--ans.end())).first;
    priority_queue<pair<long long, int> > p;
    for (auto i = ans.begin(); i != ans.end(); ++i) now[(*i).first] = maxx;
    for (auto i = ans.begin(); i != ans.end(); ++i) if(i != ans.begin())
    {
        long long now = (*i).first;
        --i;
        nxt[now] = (*i).first;
        ++i;
    }
    for (auto i = ans.begin(); i != ans.end(); ++i) p.push(make_pair((*i).first * maxx, (*i).first));
    int sum = 0;
    while(!p.empty())
    {
        int x = p.top().second;
        long long y = p.top().first;
        p.pop();
        if(ans[x] * ans[now[x]] >= k)
        {
            sum += 1ll * y % mod * k % mod, sum %= mod;
            break;
        }
        sum += 1ll * y % mod * ans[x] % mod * ans[now[x]] % mod, sum %= mod;
        k -= ans[x] * ans[now[x]];
        if(nxt[now[x]])
        {
            now[x] = nxt[now[x]];
            p.push(make_pair(x * 1ll * now[x], x));
        }
    }
    cout << sum << endl;
    return 0;
}

数数

有一说一，这个题还是很难的，至少我一开始就走上了错误的思路。

首先把这个题转化为 $[0,r]-[0,l-1]$ 是基本思路。

看到这种子串的问题，我们先明确一个中心思路。就是说，我们可以考虑去枚举处于 $[l,r]$ 之间每个字符串的前缀的长度，然后通过对于每个字符串的前缀的后缀的答案计算来得到最终答案。注意，我们的长度对应的贡献计算 都默认表示的是在含有数位 DP 的字典序即首位限制的情况下所对应的贡献，当然这一位也就对应的是长度，不是指的字串长度！！！

其实也就是变相的对字串转化了一下，使其更贴近于数位 $\mathtt{\text{DP}}$ 字典序，方便我们统计答案。这两句话还是有点抽象的，只是我自己总结出来的，可以考虑先看后面的比较直白的解法。

我们定义 ${\text{num}}_i$ 表示的是从首位开始进行到第 $i$ 位时，有多少种不会被 $\text{lim}$ 所影响的字符串。

显然有 ${\text{num}}_i={\text{num}}_{i-1}\times b+a_i+(b-1)$

首先可以直接在上一位之后乱填，也可以在前面全部首位都被顶到的情况下填写 $[0,a_i-1]$，也可以前面全部是前导 $0$，这一位填 $[1,b-1]$。

接下来我们定义 ${\text{len}}_{i,0/1}$ 表示前 $i$ 位，$0$ 表示被首位所限制，$1$ 表示没有限制的满足条件的所有字符串的长度之和。

显然有 ${\text{len}}_{i,0}=le{n}_{i-1,0}+1$，毕竟你都被限制了显然只有一种。

${\text{len}}_{i,1}={\text{len}}_{i-1,1}\times b+{\text{len}}_{i-1,0}\times a_i+{\text{num}}_{i-1}\times b$

其实挺显然的，没限制就是 $b$ 种情况，有限制就只能填 $[0,a_i-1]$，还是好理解的。

然后我们定义 ${\text{now}}_{i,0/1}$ 表示前 $i$ 位，$0/1$ 含义相同，其对应合法的所有字符串的后缀的拼起来的数值之和。

简单的 ${\text{now}}_{i,0}={\text{now}}_{i-1,0}\times b+{\text{len}}_{i,0}\times a_i$

显然这一位只能填 $a_i$，而之前的答案总和要进位，故乘 $b$，$len$ 本质上就是所有字符串的后缀个数之和，和所有字符串的长度相同，很合理。

那么有了 $0$ 的铺垫，$1$ 应该也是相对好理解的，这里就不写了，可以看后面代码。

然后我们考虑定义一个 $\text{dp}$ 来统计答案，由于我们只关心了前面 $i$ 位的贡献，而后面的位仍存在乱填导致的方案数对答案的贡献，也需要通过这个 $\text{dp}$ 加上，这里也不写了。

更多细节参见代码：

//牛的，看题解硬控我2h
#include <bits/stdc++.h>
using namespace std;
#define maxn 100005
const int mod = 20130427;
int n, b;
int dp[maxn][2], num[maxn], now[maxn][2], len[maxn][2];
int get(int x) {return 1ll * x * (x + 1) / 2 % mod;}
int solve(int n, int a[])
{
    for (int i = 1; i <= n; ++i)
    {
        int j = (i > 1) * b - 1;
        num[i] = (1ll * num[i - 1] * b % mod + a[i] + j) % mod;
        len[i][0] = len[i - 1][0] + 1;
        len[i][1] = (len[i][0] * 1ll * a[i] % mod + (num[i - 1] + len[i - 1][1]) * 1ll * b % mod + j) % mod;
        now[i][0] = (now[i - 1][0] * 1ll * b % mod + len[i][0] * 1ll * a[i] % mod) % mod;
        now[i][1] = (get(j) + now[i - 1][0] * 1ll * b % mod * a[i] % mod + len[i][0] * 1ll * get(a[i] - 1) % mod) % mod;
        now[i][1] += (now[i - 1][1] * 1ll * b % mod * b % mod + (len[i - 1][1] + num[i - 1]) * 1ll * get(b - 1) % mod) % mod;
        now[i][1] %= mod;
        dp[i][0] = (dp[i - 1][0] + now[i][0]) % mod;
        dp[i][1] = (dp[i - 1][0] * 1ll * a[i] % mod + dp[i - 1][1] * 1ll * b % mod + now[i][1]) % mod;
    }
    return (dp[n][0] + dp[n][1]) % mod;
}
int l, r;
int a[maxn], c[maxn];
int main()
{
    scanf("%d", &b);
    scanf("%d", &l);
    for (int i = 1; i <= l; ++i) scanf("%d", &a[i]);
    scanf("%d", &r);
    for (int i = 1; i <= r; ++i) scanf("%d", &c[i]);
    a[l]--;
    for (int i = l; a[i] < 0; --i) a[i] += b, a[i - 1]--;
    if(!a[1])
    {
        for (int i = 2; i <= l; ++i) a[i - 1] = a[i];
        --l;
    }
    cout << (solve(r, c) - solve(l, a) + mod) % mod << endl;
    return 0;
}

Beautiful numbers

前面两个题写的太认真了，这个题也没什么水平，所以写的稍微水一点。

由于所有我们需要考虑的因子都是个位数。观察到 $\text{lcm}(1,2,3,4,5,6,7,8,9)=2520$

剩下的就很简单了，我们只在乎这个数模 $2520$ 的值是否被填了的数整除。

所以数位DP的时候，打个取模，打个对于 $[1,9]$ 的状压，也是华丽结束。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 20;
const int mod = 2520;
int T, cur, a[mod + 1];
ll l, r, f[20][mod + 1][50];
vector<int> dim;
int gcd(int x, int y) { return x % y ? gcd(y, x % y) : y; }
int lcm_(int x, int y)
{
    if (!y) return x;
    return x / gcd(x, y) * y;
}
ll dfs(int x, int mode, int lcm, bool op)
{
    if (!x) return mode % lcm == 0 ? 1 : 0;
    if (!op && f[x][mode][a[lcm]]) return f[x][mode][a[lcm]];
    int maxx = op ? dim[x] : 9;
    ll ret = 0;
    for (int i = 0; i <= maxx; i++) ret += dfs(x - 1, (mode * 10 + i) % mod, lcm_(lcm, i), op & (i == maxx));
    if (!op) f[x][mode][a[lcm]] = ret;
    return ret;
}
ll solve(ll x)
{
    dim.clear();
    dim.push_back(-1);
    ll t = x;
    while (t) dim.push_back(t % 10), t /= 10;
    return dfs(dim.size() - 1, 0, 1, 1);
}
main()
{
    for (int i = 1; i <= mod; i++) if (mod % i == 0) a[i] = ++cur;
    scanf("%d", &T);
    while (T--) scanf("%lld%lld", &l, &r), printf("%lld\n", solve(r) - solve(l - 1));
    return 0;
}

New Year and Binary Tree Paths

挺有意思的题目，虽然是黑色，但是我实际做下来还好，至少结论都推出来了。

感觉在草稿纸上认真画一画就有了，只需要注意二进制的低位怎么加都加不到高位的性质。

首先我们先考虑这个路径是一条链的情况。

假设深度最浅的节点为 $x$，路径长度是 $h$。

对于这条路径上的所有右儿子，假设他们在路径上的深度（假设路径最后一个节点的深度为 $1$）分别为 $d_1,d_2...d_m$。

于是我们的路径权值是 $x\times (2^{h+1}-1)+\sum _{i=1}^m{2}^{d_i}-1$

我们发现，在知道最终路径权值的多少的情况下，我们可以通过枚举 $h$，而此时的 $x$ 是一定的。

其实是比较显然的，因为你后面的右儿子无论怎么选，都无法达到 $2^{h+1}$ 级别。感性理解即可。

而在 $x$ 一定的情况下，对于右儿子的分布二进制拆解一下显然也是固定的。

然后我们考虑这条路径是一条分叉的情况，也就是有两条链。

假设最浅的节点为 $x$，左链长度为 $h_1$，右链长度为 $h_2$。

对于左链上的所有右儿子，假设他们在路径上的深度（假设路径最后一个节点的深度为 $1$）分别为 $d_1,d_2...d_n$。

对于右链上的所有右儿子（不算 $x$ 的右儿子），假设他们在路径上的深度（假设路径最后一个节点的深度为 $1$）分别为 $e_1,e_2...e_m$。

显然，这条路径的权值就是 $x\times (2^{h_1+1}+2^{h_2+1}-3)+(2^{h_2}-1)+\sum _{i=1}^n{2}^{d_i}-1+\sum _{i=1}^m{2}^{e_i}-1$

推导一下，发现我们在枚举 $h_1,h_2$ 之后，$x$ 还是唯一的，与上面同理。

问题简化成了：

我们有 $n+m$ 个整数 $2^0-1,2^1-1,...,2^n-1,2^0-1,2^1-1,..{.2}^m-1$，问有多少种选择子集的方案，使得选出来的子集的元素之和为 $S$。

我们发现这个 $-1$ 比较恶心，考虑把他去掉。即我们枚举要选多少个数，然后这个 $-1$ 就被去掉了。

问题转化为：

我们有 $n+m$ 个整数 $2^0,2^1,...,2^n,2^0,2^1,..{.2}^m$，可以从中选择 $k$ 个数，使得选出来的数的元素之和为 $S$。

其实是一个简单的 $\text{dp}$。

定义 $d{p}_{i,j,k}$ 表示前 $i$ 位选择了 $j$ 个数，$k$ 表示进不进位。

这个转移是真心简单，注意一下要等于 $S$ 的细节就行了，具体可以看代码。

复杂度比较显然，即 $(\log n{)}^5$，可过。

感觉细节还是很多的，不知道为什么 $\mathtt{\text{PYT}}$ 会觉得很好写。

#include <bits/stdc++.h>
using namespace std;
long long n;
long long dp[65][120][2], qpow[65];
long long solve(long long x, int l, int r, int m)
{
    long long lim = __lg(x);
    memset(dp, 0, sizeof(dp));
    dp[1][0][0] = 1;
    for (int i = 1; i <= lim + 1; ++i)
    {
        for (int j = 0; j <= 2 * i - 2; ++j)
        {
            for (int k = 0; k <= 1; ++k)
            {
                if(!dp[i][j][k]) continue;
                for (int a = 0; a <= 1; ++a)
                {
                    if(a && i >= l) continue;
                    for (int b = 0; b <= 1; ++b)
                    {
                        if(b && i >= r) continue;
                        if((k + a + b & 1) == bool(x & (1ll << i)))
                        dp[i + 1][j + a + b][(a + b + k) / 2] += dp[i][j][k];
                    }
                }
            }
        }
    }
    return dp[lim + 2][m][0];
}
int main()
{
    long long ans = 0;
    cin >> n;
    qpow[0] = 1;
    for (int i = 1; i <= 60; ++i) qpow[i] = qpow[i - 1] * 2;
    for (int i = 1; i <= 60; ++i)
    {
        if(qpow[i] > n) break;
        long long now = n / (qpow[i] - 1);
        if(now == 0) continue;
        long long x = n - 1ll * now * (qpow[i] - 1);
        for (int j = i - 1; j >= 0; --j) if(x >= qpow[j] - 1) x -= qpow[j] - 1;
        if(!x) ++ans;
    }
    for (int i = 1; i <= 60; ++i)
    {
        if(qpow[i] > n) break;
        for (int j = 1; j <= 60; ++j)
        {
            if(qpow[j] > n) continue;
            long long now = (n - qpow[j] + 1) / (qpow[i + 1] + qpow[j + 1] - 3);
            if(now <= 0) continue;
            long long x = (n - qpow[j] + 1) - now * 1ll * (qpow[i + 1] + qpow[j + 1] - 3);
            if(!x)
            {
                ++ans;
                continue;
            }
            if(i == 1 && j == 1)
            {
                ans += (x == 5ll * now + 1);
                continue;
            }
            for (int k = 1; k <= i + j; ++k)
            {
                if(~(x + k) & 1)
                ans += solve(x + k, i, j, k);
            }
        }
    }
    cout << ans << endl;
    return 0;
}

方伯伯的商场之旅

还是比较有意思的一道题目。

我们发现对于合并石子中的终点，从最高位到最低位一定是单峰的。

故我们考虑去枚举这个终点，从高到低，如果在数位 DP 转移的过程中他优于之前的状态，那就更新，否则不更新。

具体来说，考虑先求出在最高位的答案，然后我们依次向最低位走，每次计算要减少的量。

感觉还是挺简单的（？

#include <bits/stdc++.h>
#define int long long
using namespace std;
int l, r, k;
int a[100], f[105][10005];
int dfs(int now, int sum, int p, int lim)
{
    if (!now) return max(sum, 0LL);
    if (!lim && ~f[now][sum]) return f[now][sum];
    int ans = 0;
    int num = lim ? a[now] : k - 1;
    for (int i = 0; i <= num; i++) ans += dfs(now - 1, sum + (p == 1 ? i * (now - 1) : (now < p ? -i : i)), p, lim && (i == num));
    if (!lim) f[now][sum] = ans;
    return ans;
}
int solve(int x)
{
    int n = 0;
    while (x)
    {
        a[++n] = x % k;
        x /= k;
    }
    int ans = 0;
    for (int i = 1; i <= n; i++)
    {
        memset(f, -1, sizeof(f));
        ans += (i == 1 ? 1 : -1) * dfs(n, 0, i, 1);
    }
    return ans;
}
signed main()
{
    cin >> l >> r >> k;
    cout << solve(r) - solve(l - 1) << endl;
    return 0;
}

Number with Bachelors

这个题我是真不想评价啊，什么时候 $\mathtt{\text{ICPC}}$ 的题也能这么烂了啊，真的 $\mathtt{\text{QOJ}}$ 上的评分都要负了。

题意即求在 $[l,r]$ 满足条件的数的个数和第 $k$ 小的满足条件的数。

满足条件即每个数位上的数不重复出现。

额，第 $k$ 大直接转化为二分。至于不重复出现，随便打一个 $2^{10}$ 的状压不就有了吗。

这不是最关键的，关键是你的那一坨输入输出一会十六进制一会十进制又是什么鬼。。。。

不想写这个题了，直接奉上代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 16) + 10;
typedef unsigned long long ull;
ull dp[2][22][maxn];
int typ, a[100];
ull dfs(int x, int sta, int limit)
{
    if (x == -1) return 1;
    int ty = (typ == 10) ? 0 : 1;
    if (dp[ty][x][sta] != -1 && !limit) return dp[ty][x][sta];
    int up = limit ? a[x] : typ - 1;
    ull ans = 0;
    for (int i = 0; i <= up; i++)
    {
        if ((sta >> i) & 1) continue;
        if (sta == 0 && i == 0) ans += dfs(x - 1, sta, limit && i == up);
        else ans += dfs(x - 1, sta | (1 << i), limit && i == up);
    }
    if (!limit) dp[ty][x][sta] = ans;
    return ans;
}
ull solve(ull x)
{
    int num = 0;
    while (x)
    {
        a[num++] = x % typ;
        x /= typ;
    }
    return dfs(num - 1, 0, true);
}
void input(ull &x)
{
    x = 0;
    char s[22];
    scanf("%s", s + 1);
    int len = strlen(s + 1);
    for (int i = 1; i <= len; i++)
    {
        if (s[i] <= '9' && s[i] >= '0')  x = x * typ + s[i] - '0';
        else x = x * typ + s[i] - 'a' + 10;
    }
}
void print(ull x)
{
    if (x == 0)
    {
        printf("0\n");
        return;
    }
    if (typ == 10) printf("%llu\n", x);
    else
    {
        vector<int> ans;
        while (x)
        {
            int p = x % typ;
            x /= typ;
            ans.push_back(p);
        }
        for (int i = ans.size() - 1; i >= 0; i--)
        {
            if (ans[i] >= 10) printf("%c", ans[i] - 10 + 'a');
            else printf("%c", ans[i] + '0');
        }
        printf("\n");
    }
}
void test()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int x;
        scanf("%d%d", &x, &typ);
        printf("%llu", solve(x));
    }
}
int main()
{
    memset(dp, -1, sizeof(dp));
    int T;
    scanf("%d", &T);
    while (T--)
    {
        char op[10];
        scanf("%s", op);
        if (op[0] == 'd') typ = 10;
        else typ = 16;
        int flg;
        scanf("%d", &flg);
        if (!flg)
        {
            ull a, b;
            input(a), input(b);
            ull ans = solve(b);
            if (a > 0) ans -= solve(a - 1);
            print(ans);
        }
        else
        {
            ull x;
            input(x);
            if (x < 10)
            {
                printf("%llu\n", x - 1);
                continue;
            }
            ull l = 0, r = 0, ans = 0;
            r--;
            if (solve(r) < x)
            {
                printf("-\n");
                continue;
            }
            while (l <= r)
            {
                ull mid = l + (r - l) / 2;
                if (solve(mid) >= x) r = mid - 1, ans = mid;
                else l = mid + 1;
            }
            print(ans);
        }
    }
    return 0;
}

后记

写完了，今天也要结束了。

$\text{All tragedy erased. I see only wonders.}$