解析：10个人站成一排，每班至少要1名，就有9个空然后插入6个板子把他们隔开，从九个里选6个，就是C(9,6)=84

解析：先找两副手套，有1+2+3+4=10种找法;剩下10-22=6只手套有12种取法；1012=120种

#include <cstdlib>
#include <iostream>
using namespace std;

char encoder[26] = {'C', 'S', 'P', 0};
char decoder[26];

string st;

int main() {
    int k = 0;
    for (int i = 0; i < 26; ++i)
        if (encoder[i] != 0) ++k;
    for (char x = 'A'; x <= 'Z'; ++x) {
        bool flag = true;
        for (int i = 0; i < 26; ++i)
            if (encoder[i] == x) {
                flag = false;
                break;
            }
        if (flag) {
            encoder[k] = x;
            ++k;
        }
    }
    for (int i = 0; i < 26; ++i)
        decoder[encoder[i] - 'A'] = i + 'A';
    cin >> st;
    for (int i = 0; i < st.length(); ++i)
        st[i] = decoder[st[i] - 'A'];
    cout << st;
    return 0;
}

解析：程序中将26个大写英文字母进行了编码。第一段for循环统计了encoder[]中字母的个数；第二段for循环将剩余字母依次放入enconder[]数组；第三段for循环将encoder[]中的每一个字母依次映射到A~Z，对应关系如下：
16：输入的字符串应当只由大写字母组成，否则在访问数组时可能越界。
解析：数组大小均为26，如果存在小写字母数组访问会越界。
20：若输出的字符串为“ABCABCABCA”，则下列说法正确的是（ ）
解析：若输出ABCABCABCA，根据映射的对应关系，则输入字符串为CSPCSPCSPC，因此输入的字符串中既有 S 又有 P。

#include <iostream>
using namespace std;

long long n, ans;
int k, len;
long long d[1000000];

int main() {
    cin >> n >> k;
    d[0] = 0;
    len = 1;
    ans = 0;
    for (long long i = 0; i < n; ++i) {
        ++d[0];
        for (int j = 0; j + 1 < len; ++j) {
            if (d[j] == k) {
                d[j] = 0;
                d[j + 1] += 1;
                ++ans;
            }
        }
        if (d[len - 1] == k) {
            d[len - 1] = 0;
            d[len] = 1;
            ++len;
            ++ans;
        }
    }
    cout << ans << endl;
    return 0;

解析：题目中进行了n次循环，每次循环将d[0]增加1；然后检查第0位到第len-2是否为k，如果等于k则进行进位处理；最后判断最高位是否需要向前进位。
因此程序的作用是将n转换为k进制数，len记录转换后的位数，ans记录进位次数。
25：若输入的 n 等于 10的15次方 ，输入的 k 为 1，则输出等于（ ）。
解析：k = 1时，无论n的值为多少，len的值只会在第一次循环最后的if中增加1次，而ans会增加n次，因此输出为10的五次方

#include <algorithm>
#include <iostream>
using namespace std;

int n;
int d[50][2];
int ans;

void dfs(int n, int sum) {
    if (n == 1) {
        ans = max(sum, ans);
        return;
    }
    for (int i = 1; i < n; ++i) {
        int a = d[i - 1][0], b = d[i - 1][1];
        int x = d[i][0], y = d[i][1];
        d[i - 1][0] = a + x;
        d[i - 1][1] = b + y;
        for (int j = i; j < n - 1; ++j)
            d[j][0] = d[j + 1][0], d[j][1] = d[j + 1][1];
        int s = a + x + abs(b - y);
        dfs(n - 1, sum + s);
        for (int j = n - 1; j > i; --j)
            d[j][0] = d[j - 1][0], d[j][1] = d[j - 1][1];
        d[i - 1][0] = a, d[i - 1][1] = b;
        d[i][0] = x, d[i][1] = y;
    }
}

int main() {
    cin >> n;
    for (int i = 0; i < n; ++i)
        cin >> d[i][0];
    for (int i = 0; i < n; ++i)
        cin >> d[i][1];
    ans = 0;
    dfs(n, 0);
    cout << ans << endl;
    return 0;
}

29：若输入的 n 为 20，接下来的输入全为 0，则输出为 0。（正确 ）
解析：当两个序列同时为0，dfs中sum也始终为0，则输出为0。

#include <iostream>

using namespace std;

const int MAXN = 5000;
int n, m;
struct segment { int a, b; } A[MAXN];

void sort() // 排序
{
    for (int i = 0; i < n; i++)
        for (int j = 1; j < n; j++)
            if (①)
            {
                segment t = A[j];
                ②
            }
}

int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        cin >> A[i].a >> A[i].b;
    sort();
    int p = 1;
    for (int i = 1; i < n; i++)
        if (③)
            A[p++] = A[i];
    n = p;
    int ans = 0, r = 0;
    int q = 0;
    while (r < m)
    {
        while (④)
            q++;
        ⑤;
        ans++;
    }
    cout << ans << endl;
    return 0;
}

算法思想如下：
首先使用了冒泡排序的思想，将所有区间按照左端点从小到大排序。
去除所有被包含的区间，例如[3,10]、[4,9]，后面的区间被前面的区间包含了，不需要进行判断。
为覆盖区间[0,m]，将r设为 0，在区间数组中找到离r最近的、并且左端点<=r的区间q，使用区间q的右端点更新r，重复这个过程直到r>=m。
空②，交换A[j]和A[j-1]，答案为A[j]=A[j-1];A[j-1]=t;
空④，找到r左边第一个区间q，答案为q + 1 < p && A[q + 1].a <= r
空⑤，用区间q的右端点更新r，答案为r = max(r, A[q].b)

在线祈求打赏，制作不易