第十二届蓝桥杯大赛软件赛决赛（C/C++ 大学C组）

---

  蓝桥杯个人赛软件类历届真题及其解析

  省流，十道签到题。

---

试题 A: 整数范围

本题总分：$5$ 分

---

【问题描述】

  用 $8$ 位二进制（一个字节）来表示一个非负整数，表示的最小值是 $0$，则一般能表示的最大值是多少？

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

255

---

#include <stdio.h>

int main() {
    printf("%d", 0xff);
}

  $¿$

---

试题 B: 带宽

本题总分：$5$ 分

---

【问题描述】

  小蓝家的网络带宽是 $200$ $\mathrm{M}\mathrm{b}\mathrm{p}\mathrm{s}$，请问，使用小蓝家的网络理论上每秒钟最多可以从网上下载多少 $\mathrm{M}\mathrm{B}$ 的内容。

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

25

---

#include <stdio.h>

int main() {
    printf("%d", 200 / 8);
}

  $\mathrm{p}\mathrm{s}$ 意为 $\mathrm{p}\mathrm{e}\mathrm{r}\mathrm{s}\mathrm{e}\mathrm{c}\mathrm{o}\mathrm{n}\mathrm{d}$，$1\mathrm{B}=8\mathrm{b}$。

---

试题 C: 纯质数

本题总分：$10$ 分

---

【问题描述】

  如果一个正整数只有 $1$ 和它本身两个约数，则称为一个质数（又称素数）。

  前几个质数是$：$$2,3,5,7,11,13,17,19,23,29,31,37,\cdots$。

  如果一个质数的所有十进制数位都是质数，我们称它为纯质数。例如$：$$2,3,5,7,23,37$ 都是纯质数，而 $11,13,17,19,29,31$ 不是纯质数。当然 $1,4,35$ 也不是纯质数。

  请问，在 $1$ 到 $20210605$ 中，有多少个纯质数？

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

1903

---

#include <stdio.h>

const int N = 20210605;

int ans, composite[N + 1];

int check(int n) {
    if (n < 10) return n == 2 || n == 3 || n == 5 || n == 7;
    do
        if (!check(n % 10)) return 0;
    while (n /= 10);
    return 1;
}

int main() {
    for (int i = 2; i <= N; ++i)
        if (!composite[i]) {
            for (int j = i + i; j <= N; j += i) composite[j] = 1;
            if (check(i)) ++ans;
        }
    printf("%d", ans);
}

  埃拉托色尼筛选法。

---

试题 D: 完全日期

本题总分：$10$ 分

---

【问题描述】

  如果一个日期中年月日的各位数字之和是完全平方数，则称为一个完全日期。

  例如$：$$2021$ 年 $6$ 月 $5$ 日的各位数字之和为 $2+0+2+1+6+5=16$，而 $16$ 是一个完全平方数，它是 $4$ 的平方。所以 $2021$ 年 $6$ 月 $5$ 日是一个完全日期。

  例如$：$$2021$ 年 $6$ 月 $23$ 日的各位数字之和为 $2+0+2+1+6+2+3=16$，是一个完全平方数。所以 $2021$ 年 $6$ 月 $23$ 日也是一个完全日期。

  请问，从 $2001$ 年 $1$ 月 $1$ 日到 $2021$ 年 $12$ 月 $31$ 日中，一共有多少个完全日期？

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

977

---

#include <stdio.h>

int ans, days[]{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

int is_leap(int year) { return !(year % 100 ? year % 4 : year % 400); }

int calc(int n) {
    int res = 0;
    do
        res += n % 10;
    while (n /= 10);
    return res;
}

int check(int n) {
    switch (n) {
        case 1:
        case 4:
        case 9:
        case 16:
        case 25:
        case 36: return 1;
    }
    return 0;
}

int main() {
    for (int year = 2001; year <= 2021; ++year)
        for (int month = 1; month <= 12; ++month) {
            if (is_leap(year)) days[2] = 29;
            for (int day = 1; day <= days[month]; ++day)
                if (check(calc(year) + calc(month) + calc(day))) ++ans;
            days[2] = 28;
        }
    printf("%d", ans);
}

  签到 $\times 4$。

---

试题 E: 最小权值

本题总分：$15$ 分

---

【问题描述】

  对于一棵有根二叉树 $T$，小蓝定义这棵树中结点的权值 $W(T)$ 如下$：$

  空子树的权值为 $0$。

  如果一个结点 $v$ 有左子树 $L$，右子树 $R$，分别有 $C(L)$ 和 $C(R)$ 个结点，则 $W(v)=1+2W(L)+3W(R)+(C(L){)}^{2}C(R)$。

  树的权值定义为树的根结点的权值。

  小蓝想知道，对于一棵有 $2021$ 个结点的二叉树，树的权值最小可能是多少？

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

2653631372

---

动态规划

---

#include <stdio.h>

#define min(a, b) (a < b ? a : b)

const int N = 2021;

long long dp[N + 1];

int main() {
    for (int i = 1; i <= N; ++i) {
        dp[i] = 0x3f3f3f3f3f3f3f3f;
        for (int l = 0; l < i; ++l)
            dp[i] = min(dp[i], 1 + 2 * dp[l] + 3 * dp[i - l - 1] + l * l * (i - l - 1));
    }
    printf("%lld", dp[N]);
}

  设 $f_i$ 为 $C(T)=i$ 的有根二叉树 $T$ 的最小权值，显然 $f_i$ 无后效性，故考虑动态规划，有转移方程$：$$$f_i=\min (1+2f_l+3f_r+l^{2}r),i=l+r+1,l,r\in \mathbb{N}$$  初始时 $f_0=0$，答案为 $f_{2021}$。

---

试题 F: 大写

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{M}\mathrm{B}$ 本题总分：$15$ 分

---

【问题描述】

  给定一个只包含大写字母和小写字母的字符串，请将其中所有的小写字母转换成大写字母后将字符串输出。

【输入格式】

  输入一行包含一个字符串。

【输出格式】

  输出转换成大写后的字符串。

【样例输入】

LanQiao

【样例输出】

LANQIAO

【评测用例规模与约定】

  对于所有评测用例，字符串的长度不超过 $100$。

---

#include <stdio.h>

#define upper(a) a >= 'a' && a <= 'z' ? a - 0x20 : a

int main() {
    for (int a; ~(a = getchar());) putchar(upper(a));
}

  签到 $\times 6$，几个常用的 $\mathrm{A}\mathrm{S}\mathrm{C}\mathrm{I}\mathrm{I}$ 码 需要记住，

  像 $0$ 对应 $0\mathrm{x}30$；$\mathrm{A}$ 对应 $0\mathrm{x}41$；$\mathrm{a}$ 对应 $0\mathrm{x}61$，

  且数字字母字符在 $\mathrm{A}\mathrm{S}\mathrm{C}\mathrm{I}\mathrm{I}$ 码 表中是自然连续的。

---

试题 G: 123

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{M}\mathrm{B}$ 本题总分：$20$ 分

---

【问题描述】

  小蓝发现了一个有趣的数列，这个数列的前几项如下$：$

  $1,1,2,1,2,3,1,2,3,4,\cdots$

  小蓝发现，这个数列前 $1$ 项是整数 $1$，接下来 $2$ 项是整数 $1$ 至 $2$，接下来 $3$ 项是整数 $1$ 至 $3$，接下来 $4$ 项是整数 $1$ 至 $4$，依次类推。

  小蓝想知道，这个数列中，连续一段的和是多少。

【输入格式】

  输入的第一行包含一个整数 $T$，表示询问的个数。

  接下来 $T$ 行，每行包含一组询问，其中第 $i$ 行包含两个整数 $l_i$ 和 $r_i$，表示询问数列中第 $l_i$ 个数到第 $r_i$ 个数的和。

【输出格式】

  输出 $T$ 行，每行包含一个整数表示对应询问的答案。

【样例输入】

3
1 1
1 3
5 8

【样例输出】

1
4
8

【评测用例规模与约定】

  对于 $10\%$ 的评测用例，$1\le T\le 30,1\le l_i\le r_i\le 100$。
  对于 $20\%$ 的评测用例，$1\le T\le 100,1\le l_i\le r_i\le 1000$。
  对于 $40\%$ 的评测用例，$1\le T\le 1000,1\le l_i\le r_i\le 10^6$。
  对于 $70\%$ 的评测用例，$1\le T\le 10000,1\le l_i\le r_i\le 10^9$。
  对于 $80\%$ 的评测用例，$1\le T\le 1000,1\le l_i\le r_i\le 10^{12}$。
  对于 $90\%$ 的评测用例，$1\le T\le 10000,1\le l_i\le r_i\le 10^{12}$。
  对于所有评测用例，$1\le T\le 100000,1\le l_i\le r_i\le 10^{12}$。

---

容斥原理

---

  令该数列为 $A$，显然对于每个回答 ${\sum }_{i=l}^r{a}_i$ 可变化为 ${\sum }_{i=1}^r{a}_i-{\sum }_{i=1}^{l-1}{a}_i$，同时构造数列 $S$，${\sum }_{i=1}^k{s}_i={\sum }_{i=1}^{k(k+1)/2}{a}_i$，并定义 $l^{\prime }$ 满足 $l=l^{\prime }(l^{\prime }+1)/2$，容易将回答再变化为 ${\sum }_{i=1}^{r^{\prime }}{s}_i-{\sum }_{i=1}^{l^{\prime }-\xi }{s}_i$，不过 $l^{\prime }、r^{\prime }$ 都可能不为正整数，但容易发现 $s_k=a_{k(k-1)/2+1}+a_{k(k-1)/2+2}+\cdots +a_{k(k+1)/2}$，因此在此基础上添加一点点细节，将 $A$ 的前缀和变化为$：$$${\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{c}}_i=\sum _{j=1}^i{a}_j=\sum _{j=1}^{\lfloor i^{\prime }\rfloor }{s}_i+\sum _{j=1}^{i-\lfloor i^{\prime }\rfloor }{a}_j,$$  最终，答案为$：$$${\mathrm{a}\mathrm{n}\mathrm{s}}_{l,r}={\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{c}}_r-{\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{c}}_{l-1}.$$

#include <stdio.h>
#include <algorithm>
#include <math.h>

const int N = sqrt(2e12) + 9;

typedef long long ll;

ll A[N], S[N], l, r;

ll calc(ll n) {
    ll *K = std::upper_bound(A, A + N, n) - 1;
    return S[K - A] + A[n - *K];
}

int T;

int main() {
    for (int i = 0; i < N; ++i)
        A[i] = A[i - 1] + i,
        S[i] = S[i - 1] + A[i];
    for (scanf("%d", &T); T--;) {
        scanf("%lld %lld", &l, &r);
        printf("%lld\n", calc(r) - calc(l - 1));
    }
}

---

试题 H: 异或变换

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{M}\mathrm{B}$ 本题总分：$20$ 分

---

【问题描述】

  小蓝有一个 $01$ 串 $s=s_1{s}_2{s}_3\cdot \cdot \cdot s_n$。

  以后每个时刻，小蓝要对这个 $01$ 串进行一次变换。每次变换的规则相同。

  对于 $01$ 串 $s=s_1{s}_2{s}_3\cdot \cdot \cdot s_n$，变换后的 $01$ 串 $s^{\prime }=s_1^{\prime }{s}_2^{\prime }{s}_3^{\prime }\cdots s_n^{\prime }$ 为$：$

  $s_1^{\prime }=s_1$;
  $s_i^{\prime }=s_{i-1}\oplus s_i$。

  其中 $a\oplus b$ 表示两个二进制的异或，当 $a$ 和 $b$ 相同时结果为 $0$，当 a 和 b不同时结果为 $1$。

  请问，经过 $t$ 次变换后的 $01$ 串是什么？

【输入格式】

  输入的第一行包含两个整数 $n,t$，分别表示 $01$ 串的长度和变换的次数。

  第二行包含一个长度为 $n$ 的 $01$ 串。

【输出格式】

  输出一行包含一个 $01$ 串，为变换后的串。

【样例输入】

5 3
10110

【样例输出】

11010

【样例说明】
  初始时为 $10110$，变换 $1$ 次后变为 $11101$，变换 $2$ 次后变为 $10011$，变换 $3$ 次后变为 $11010$。

【评测用例规模与约定】

  对于 $40\%$ 的评测用例，$1\le n\le 100,1\le t\le 1000$。
  对于 $80\%$ 的评测用例，$1\le n\le 1000,1\le t\le 10^9$。
  对于所有评测用例，$1\le n\le 10000,1\le t\le 10^{18}$。

---

二项式定理

---

  我们将 $01$ 串 $s$ 视为 $n$ 维向量，第 $i$ 个分量为 $s_i$，容易想到通过模 $2$ 矩阵乘法，对 $s$ 进行 $t$ 次变化，更具体地说$：$

  $s=(s_1,s_2,\cdots ,s_n{)}^T,$

  则变换后的 $01$ 串 $s^{\prime }$ 可以表示为$：$

  $s^{\prime }=s{A}_{n\times n},A_{n\times n}=\left(\begin{array}{cccccc}1& 1& 0& \cdots & 0& 0\\ 0& 1& 1& \cdots & 0& 0\\ 0& 0& 1& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 1& 1\\ 0& 0& 0& \cdots & 0& 1\end{array}\right)(\mathrm{m}\mathrm{o}\mathrm{d}2)$

  最终答案为 $s{A}^t$，不过 $n$ 最大为 $1e4$，即使是在快速幂加速的情况下，$O(n^3\log t)$ 的复杂度显然无法通过所有测试用例，不过矩阵 $A$ 很“工整”，我们将 $A$ 拆分为 $E$ 与 $B$ 之和，即$：$

  $A=E+B=\left(\begin{array}{cccccc}1& 0& 0& \cdots & 0& 0\\ 0& 1& 0& \cdots & 0& 0\\ 0& 0& 1& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 1& 0\\ 0& 0& 0& \cdots & 0& 1\end{array}\right)+\left(\begin{array}{cccccc}0& 1& 0& \cdots & 0& 0\\ 0& 0& 1& \cdots & 0& 0\\ 0& 0& 0& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 0& 1\\ 0& 0& 0& \cdots & 0& 0\end{array}\right)$

  $E$、$B$ 可交换，即 $EB=BE$，对二项式 $A^t=(E+B{)}^t$ 展开有 $A^t=\sum _{i=0}^n{C}_n^i{E}^{n-i}{B}^i=\sum _{i=0}^n{C}_n^i{B}^i$，

  而 $B_{n\times n}=(b_{ij}{)}_{n\times n}$，$b_{ij}=\{\begin{array}{ll}1& i=j-1\\ 0& otherwise\end{array},$

  根据矩阵乘法的定义，$(c_{ij}{)}_{n\times m}=(a_{ij}{)}_{n\times k}(b_{ij}{)}_{k\times m}$，$c_{ij}={\sum }_{g=1}^k{a}_{ig}{b}_{gj}$，则 $g$ 确定时，$(d_{ij})=B^2$，$i=j-2$ 时 $d_{ij}$ 才非零，类似的我们可以得到结论$：$$$B^n=(b_{ij}),b_{ij}=\{\begin{array}{ll}1& i=j-n\\ 0& otherwise\end{array},$$  容易找到 $A^n$ 的通项公式$：$$$A^n=(a_{ij}),a_{ij}\{\begin{array}{ll}0& i<j\\ C_n^{j-i}& otherwise\end{array}$$  再根据组合数性质：有组合数 $C_n^m$，定义 $n\&m$ 为二进制表示下，$n$、$m$ 按位相与，则若 $n\&m=m$，$C_n^m$ 为奇数，否则则为偶数，即可在 $O(n^2)$ 复杂度下完成 $s{A}^t(\mathrm{m}\mathrm{o}\mathrm{d}2)$ 的计算。

---

  证明$：$

  首先 $[C_n^m=$ 偶数$]\iff [2\mid C_n^m]$，

  而 $C_n^m=\frac{n!}{m!(n-m)!}$，令 $a、b、c$ 分别为 $n!、m!、(n-m)!$ 中因子 $2$ 的个数，则 $[C_n^m=$ 偶数$]\iff [a>b+c]$，

  笔者在 十三届省赛 求阶乘 中给出过一种计算某个阶乘给定因子个数的公式，即有 $a=\sum _{i=1}^{\lfloor {\log }_{2}n\rfloor }\lfloor \frac{n}{2^i}\rfloor$，

  若 $n\&m=m$ 成立，则 $\lfloor \frac{n}{2^k}\rfloor =\lfloor \frac{m}{2^k}\rfloor +\lfloor \frac{n-m}{2^k}\rfloor$ 恒成立，同时 $a=b+c$ 成立，$C_n^m$ 为奇数。

  若 $n\&m=m$ 不成立，则 $m+(n-m)$ 在某一二进制位上会出现进位，设该数位为 $k$，则有 $n\mathrm{m}\mathrm{o}\mathrm{d}{2}^k<m\mathrm{m}\mathrm{o}\mathrm{d}{2}^k+(n-m)\mathrm{m}\mathrm{o}\mathrm{d}{2}^k$；$\lfloor \frac{n}{2^k}\rfloor >\lfloor \frac{m}{2^k}\rfloor +\lfloor \frac{n-m}{2^k}\rfloor$，故而 $a>b+c$ 成立，$C_n^m$ 为偶数。

---

#include <stdio.h>

#define min(a, b) (a < b ? a : b)

char buf[10009];

long long t;

int n;

int main() {
    scanf("%d %lld %s", &n, &t, buf);
    for (int i = n - 1; i; --i)
        for (int j = min(i, t); j; --j)
            if ((t & j) == j && buf[i - j] == '1') buf[i] ^= 1;
    printf("%s", buf);
}

---

试题  I: 巧克力

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{M}\mathrm{B}$ 本题总分：$25$ 分

---

【问题描述】

  小蓝很喜欢吃巧克力，他每天都要吃一块巧克力。

  一天小蓝到超市想买一些巧克力。超市的货架上有很多种巧克力，每种巧克力有自己的价格、数量和剩余的保质期天数，小蓝只吃没过保质期的巧克力，请问小蓝最少花多少钱能买到让自己吃 x 天的巧克力。

【输入格式】

  输入的第一行包含两个整数 $x,n$，分别表示需要吃巧克力的天数和巧克力的种类数。

  接下来 $n$ 行描述货架上的巧克力，其中第 $i$ 行包含三个整数 $a_i,b_i,c_i$，表示第 $i$ 种巧克力的单价为 $a_i$，保质期还剩 $b_i$ 天（从现在开始的 $b_i$ 可以吃），数量为 $c_i$。

【输出格式】

  输出一个整数表示小蓝的最小花费。如果不存在让小蓝吃 $x$ 天的购买方案，输出 $-1$。

【样例输入】

10 3
1 6 5
2 7 3
3 10 10

【样例输出】

18

【样例说明】
  一种最佳的方案是第 $1$ 种买 $5$ 块，第 $2$ 种买 $2$ 块，第 $3$ 种买 $3$ 块。前 $5$ 天吃第 $1$ 种，第 $6、7$ 天吃第 $2$ 种，第 $8$ 至 $10$ 天吃第 $3$ 种。

【评测用例规模与约定】

  对于 $30\%$ 的评测用例，$n,x\le 1000$。
  对于所有评测用例，$1\le n,x\le 100000，1\le a_i,b_i,c_i\le 10^9$。

---

贪心 + 并查集

---

  最佳的方案总是可以描述为：尽可能多的选择尽可能便宜的巧克力。

  为此，我们按巧克力价值升序重排，并建立一个数组，标记某天是否有安排巧克力，对于每 $1$ 种巧克力，我们至剩余保质期向前寻找第 $1$ 个未被安排的日期，直至该种巧克力用尽或保质期内的日子都被排满。

  易知每 $1$ 种巧克力可能的安排只会被另一种更优的安排占用，故最终方案最优。

  同时使用查并集去寻找某个时间前第 $1$ 个未被安排的日期，设 $x$ 与 $n$ 同阶，最终复杂度为 $O(x\log x)$。

#include <stdio.h>
#include <algorithm>

#define min(a, b) (a < b ? a : b)

const int N = 100001;

int n, x, buf, linked[N];

long long ans;

struct node {
    int a, b, c;
} choco[N];

inline bool cmp(node &n1, node &n2) { return n1.a < n2.a; }

int find(int x) { return x == linked[x] ? x : (linked[x] = find(linked[x])); }

int main() {
    scanf("%d %d", &x, &n);
    for (int i = 0; i < n; ++i)
        scanf("%d %d %d", &choco[i].a, &choco[i].b, &choco[i].c);
    for (int i = 1; i <= x; ++i) linked[i] = i;
    std::sort(choco, choco + n, cmp);
    for (int i = 0; i < n; ++i) {
        if (choco[i].b > x) choco[i].b = x;
        while (buf = find(choco[i].b)) {
            if (!choco[i].c--) break;
            linked[buf] = buf - 1;
            ans += choco[i].a;
        }
    }
    for (int i = 1; i <= x; ++i)
        if (i == linked[x]) ans = -1;
    printf("%lld", ans);
}

---

贪心 + 大根堆

---

  除了以价值大小为起点外，还可以某个时间范围内为起点考量最佳方案，更具体地说$：$

  将巧克力以剩余保质期升序重排，遍历并维护当前巧克力保质期内的最优方案，为此我们建立一个以巧克力价值为关键字大根堆 $H$，对于第 $i$ 种巧克力，若 $c_i+|H|>b_i$，尝试从 $H$ 中弹出 $c_i+|H|-b_i$ 个巧克力，因为当前巧克力的加入会使堆中方案更优，然后往 $H$ 中压入当前巧克力，直至 $|H|=b_i$ 或当前巧克力用空。

  使用大根堆使得程序可以方便的以种为单位组织巧克力，最终复杂度为 $O(n\log n)$。

#include <stdio.h>
#include <algorithm>
#include <queue>

struct node {
    int a, b;
    mutable int c;
    inline bool operator<(const node &n) const { return a < n.a; }
} choco[100000];

inline bool cmp(node &n1, node &n2) { return n1.b < n2.b; }

std::priority_queue<node> heap;

int n, x, cnt, buf;

long long ans;

int main() {
    scanf("%d %d", &x, &n);
    for (int i = 0; i < n; ++i)
        scanf("%d %d %d", &choco[i].a, &choco[i].b, &choco[i].c);
    std::sort(choco, choco + n, cmp);
    for (int i = 0; i < n; ++i) {
        if (choco[i].b > x) choco[i].b = x;
        while (heap.size() &&
            heap.top().a > choco[i].a &&
            cnt + choco[i].c > choco[i].b) {
            buf = cnt + choco[i].c - choco[i].b;
            if (heap.top().c <= buf)
                cnt -= heap.top().c, heap.pop();
            else {
                if (buf > 0) heap.top().c -= buf, cnt -= buf;
                break;
            }
        }
        if (choco[i].c + cnt > choco[i].b)
            choco[i].c = choco[i].b - cnt;
        if (choco[i].c > 0)
            heap.push(choco[i]), cnt += choco[i].c;
    }
    if (cnt < x) puts("-1");
    else {
        for (; heap.size(); heap.pop())
            ans += (long long)heap.top().a * heap.top().c;
        printf("%lld", ans);
    }
}

  以普遍理性而论，$n\le x$ 在多数测试点上应当是成立的，不过考虑到数据范围和常数等因素，大根堆实现的贪心性能上应该不优于并查集。

---

试题 J: 二进制问题

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{M}\mathrm{B}$ 本题总分：$25$ 分

---

【问题描述】

  小蓝最近在学习二进制。他想知道 $1$ 到 $N$ 中有多少个数满足其二进制表示中恰好有 $K$ 个 $1$。你能帮助他吗？

【输入格式】

  输入一行包含两个整数 $N$ 和 $K$。

【输出格式】

  输出一个整数表示答案。

【样例输入】

7 2

【样例输出】

3

【评测用例规模与约定】

  对于 $30\%$ 的评测用例，$1\le N\le 10^6,1\le K\le 10$。
  对于 $60\%$ 的评测用例，$1\le N\le 2\times 10^9,1\le K\le 30$。
  对于所有评测用例，$1\le N\le 10^{18},1\le K\le 50$。

---

数位 dp

---

  设函数 $f_{N,K}$ 表示 $1$ 到 $N$ 中满足其二进制表示中恰好有 $K$ 个 $1$ 的数的个数，容易得知当 ${\log }_{2}N\in \mathbb{Z}$ 成立时，$f_n=C_{{\log }_{2}N}^K$，

  因此，我们可以将 $N$ 看作 $1\sim 2^{\lfloor {\log }_{2}N\rfloor }$ 和 $2^{\lfloor {\log }_{2}N\rfloor }+1\sim N$ 两部分，从第二部分提出常数项 $2^{\lfloor {\log }_{2}N\rfloor }$，整理可得 $f_{N,K}=C_{\lfloor {\log }_{2}N\rfloor }^K+f_{N-\lfloor {\log }_{2}N\rfloor ,K-1}$。

  可以 数位 $\mathrm{d}\mathrm{p}$，但没必要。

#include <stdio.h>

long long C(int n, int m) {
    if (m > n) return 0;
    long long C = 1;
    for (int i = 0; i < m; ++i)
        C = C * (n - i) / (i + 1);
    return C;
}

long long n, k, ans;

int main() {
    scanf("%lld %d", &n, &k);
    for (int i = 63; ~i; --i)
        if (n >> i & 1) ans += C(i, k--);
    printf("%lld", ans + !k);
}

  定义 $\mathrm{countBit}(x)$，其意义为统计 $x$ 在二进制表示下 $1$ 的个数，即 $\mathrm{g}\mathrm{c}\mathrm{c}$ 中的__builtin_popcount，当 $\mathrm{countBit}(N)=K$ 时，笔者给出的程序会陷入“无法累加 $C_{-1}^0$” 的困境中，即无法统计到 $N$ 这个符合要求的数，为此最后需要特判一下。