第十二届蓝桥杯C/C++ A组省赛 题解（A至I题）

A题：卡片

题面：

思路：

用一个一维数组保存卡片数量，数组的下标对应数字卡片。从1开始遍历，对于当前数字，尝试用剩余卡片组成，如果不能组成，则答案是上一位数字。

实现：

#include <iostream>

using namespace std;

const int N = 10;
int a[N];

int main()
{
    for(int i = 0; i <= 9; i++) a[i] = 2021;

    int cnt = 1;
    while(true)
    {
        int x = cnt;
        while(x)
        {
            if(a[x % 10] > 0) a[x % 10]--;
            else
            {
                cout << cnt - 1 << endl;
                return 0;
            }

            x /= 10;
        }
        
        cnt ++;
    }

    return 0;
}

答案：3181

B题：直线

题面

​

思路

计算两点的斜率和纵截距，两者都相同的记为一条直线（这里没有出现精度损失的问题，可能题目数据要求不高，故不作特殊处理）

实现

#include <iostream>
#include <map>
#include <utility>
#include <vector>

using namespace std;

const int X = 20, Y = 21;

int main()
{
    vector<pair<int, int>> vec;
    for(int i = 0; i < X; i++)
        for(int j = 0; j < Y; j++)
            vec.push_back({i, j});

    map<pair<double, double>, bool> ma;
    for(int i = 0; i < vec.size(); i++)//从这些数中任意两个数，不允许重复
        for(int j = i + 1; j < vec.size(); j++)
        {
            int x1 = vec[i].first, x2 = vec[j].first;
            int y1 = vec[i].second, y2 = vec[j].second;
            if(x1 != x2 && y1 != y2)//排除斜率为0和斜率无穷大的情况
            {
                double k, b;//两点式推导出来的斜率和纵截距计算公式
                k = double(y2 - y1) / (x2 - x1);
                b = double(x1 * y2 - x2 * y1) / (x1 - x2);

                ma[{k, b}] = true;
            }
        }

    //最后结果要加上斜率为0和斜率无穷大的直线
    cout << ma.size() + X + Y  << endl;

    return 0;
}

答案：40257

C题：货物摆放

题面

思路

由题可知，摆放成长方体的长宽高，必须是202104180418的因数，否则无法构成长方体。求出这个数的所有因数，再用三重循环找出可能解

实现

#include <iostream>
#include <vector>

using namespace std;

typedef long long LL;
const LL NUM = 2021041820210418;

int main()
{
    vector<LL> vec;

    for(LL i = 1; i <= NUM / i; i++)
        if(NUM % i == 0)
        {
            vec.push_back(i);
            if(i != NUM / i) vec.push_back(NUM / i);
        }

    LL ans = 0;
    for(LL i = 0; i < vec.size(); i++)
        for(LL j = 0; j < vec.size(); j++)
            for(LL k = 0; k < vec.size(); k++)
                if(vec[i] * vec[j] * vec[k] == NUM) ans++;

    cout << ans << endl;

    return 0;
}

答案：2430

D题：路径

题面

思路

按照题目要求，利用二维的路径矩阵存储边权，由于是无向边，所以要存储 i 到 j 和 j 到 i，然后用dijkstra求最短路径。

实现

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

//辗转相除法求最大公约数
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

//最小公倍数
int stimes(int a, int b) { return a * b / gcd(a, b); }

const int N = 2022, M = 22;
int g[N][N], dist[N];//g是路径矩阵，dist是1到其它点的距离
bool st[N];//表示该点是否使用

void dijkstra()
{
    dist[1] = 0;
    for(int i = 1; i < N; i++)
    {
        int t = -1;
        for(int j = 1; j < N; j++)
            if(!st[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        st[t] = true;

        //用选中的点更新其它点
        for(int j = 1; j < N; j++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    }
}

int main()
{
    memset(dist, 0x3f, sizeof dist);
    memset(g, 0x3f, sizeof g);

    //构建无向边
    for(int i = 1; i < N; i++)
        for(int j = i + 1; j < N && j - i < M; j++)
            g[i][j] = g[j][i] = stimes(i, j);

    dijkstra();

    cout << dist[2021] << endl;

    return 0;
}

答案：10266837

E题：回路计数

题面

思路

1.知识点 ： 动态规划，状态压缩，最大公因数
2.先用布尔类型的路径矩阵存储图
3.用二进制数位表示，(M << 22) - 2 的二进制表示为1111111111111111111110，除了最低位，每一位表示一个点，值为1则表示经过该点，否则不经过
4.遍历1 到 (M << 22) - 2 即是遍历每一种路径
5.f[i][j]表示路径为i（二进制下的情况），到达点为j的方案个数
6.因为1和任何数互质，所以最后到达的点，总能回到1。所以最后的答案是1到21这些点的方案个数的累加。

实现

#include <iostream>

using namespace std;

const int N = 22, M = 1 << N;

int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }

bool g[N][N];
long long f[M][N];

int main()
{
    for(int i = 1; i < N; i++)
        for(int j = 1; j < N; j++)
            if(gcd(i, j) == 1)
                g[i][j] = true;

    f[2][1] = 1;
    for(int i = 1; i <= M - 2; i++)//遍历方案
        for(int j = 1; j < N; j++)//对于当下方案到达的j点
            if(i >> j & 1)//如果当下能到达j点
                for(int k = 1; k < N; k++)//当前已到达的点中，不经过j点到达j点的所有方案累加
                    if(g[k][j] && i - (1 << j) >> k & 1)
                        f[i][j] += f[i - (1 << j)][k];
                        //到达j点的方案数是，由所有能到j点的前节点的方案数的累加

    long long ans = 0;
    for(int i = 1; i < N; i++) ans += f[M - 2][i];

    cout << ans << endl;

    return 0;
}
//参考自：https://blog.csdn.net/weixin_46239370/article/details/116805499

答案：881012367360

F题：砝码称重

题面

思路

1.知识点：动态规划，01背包问题
2.用二维布尔数组 f[ i ][ j ] 表示 前 i 个砝码能否构成 重量j。
状态更新（分为三类）：
一、放在同侧 ：因为重量要构成j，所以前 i - 1个砝码 重量构成 j - a[ i ]
二、放在反侧：因为重量要构成j，所以前 i - 1 个砝码 重量要构成 j + a[ i ]
三、不放 ：因为重量要构成j，所以前 i - 1 个砝码 重量要构成 j
由于j的范围为[ -sum, sum ], 所以要加偏移量B保证下标不为负
3.最后统计所有正的砝码重量
特别注意：j 的范围不能设为( 0, sum ]. 例如 -1 + 4 + 6。当前1个砝码时，会得到-1.虽然在结果统计时负数是重复的，但是在动态规划状态更新中必不可少

实现

#include <cstdio>

using namespace std;

const int N = 110, M = 2e5 + 10, B = M / 2;//B表示偏移量，为了让j下标不为负
bool f[N][M];//f[i][j]表示前i个点，j的重量能否构成
int n, sum, a[N];

int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        sum += a[i];
    }

    f[0][B] = true;
    for(int i = 1; i <= n; i++)
        for(int j = -sum; j <= sum; j++)
        {
            //不考虑第i个砝码
            f[i][j + B] = f[i - 1][j + B];
            //第i个砝码放在同侧
            if(j - a[i] >= -sum) f[i][j + B] |= f[i - 1][j - a[i] + B];
            //第i个砝码放在另一侧
            if(j + a[i] <= sum) f[i][j + B] |= f[i - 1][j + a[i] + B];
        }

    //由于对称性，只需统计正数部分，不包括0
    int ans = 0;
    for(int j = 1; j <= sum; j++) ans += f[n][j + B];

    printf("%d\n", ans);

    return 0;
}

//参考自：https://www.acwing.com/activity/content/code/content/1175270/

G题：异或数列

题面

思路

1.想要异或得到的值最大，只需要保证 1 的最高位位数最大

2.假设所有 n 个数中，二进制下，第 i 位是所有数的值为 1 的最高位。分两种情况讨论：
一、第 i 位有偶数个 1，则Alice和Bob足够聪明可以通过互相异或消掉这一位。第 i 位最终对于胜负不构成影响
二、第 i 位有奇数个 1，则这一位无论如何肯定有一方无法消去，对结果起决定性作用

3.根据上一条，只考虑最奇数个 1 的最高位，设为j。又分为两种情况
一、n 为奇数：则第 j 位为 0 的数有偶数个，第一步Alice先选 第 j 位 为 1 的数，则第二步 Bob选 第 j 位 为 0 的 数。双方轮流选择，直到第 j 位为 0 的 数被选择完。双方都不想先选第 j 位 为 1 的数，因为局面上仅剩偶数个这样的数，先选总会导致自己的第 j 位 的 1 被消掉。最后必定会造成Alice再次选择了 第 j 位 为 1 的数。Bob获胜
二、n 为偶数：则第 j 位 为 0 的数有奇数个，Bob先选这样的数，结果bob先选第 j 位 为 1 的数。Alice获胜

4.当第 j 位 为 1 的 数仅有 1 个时，需要特判，这时 Alice必胜。

实现

#include <iostream>
#include <bitset>
#include <vector>
#include <cstring>

using namespace std;

const int N = 2e5 + 10, M = 22;
int bit[M];

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        memset(bit, 0, sizeof bit);
        int n;
        cin >> n;

        vector< bitset<M> > bins;
        bins.resize(n);
        for(int i = 0; i < n; i++)
        {
            int x;
            cin >> x;
            bins[i] = x;
            //统计第i位1的个数
            for(int j = 0; j < M; j++)  bit[j] += bins[i][j];
        }        
        
        int t = -1;
        for(int i = M - 1; i >= 0; i--)
            if(bit[i] & 1)//如果第i位1的个数是奇数
            {
                t = i;
                break;
            }

        if(~t)
        {
            //需要特判，当最高位1只有一个时，alice赢
            if(bit[t] == 1) cout << 1 << endl;
            else
            {
                if(n & 1) cout << 1 << endl;
                else cout << -1 << endl;
            }
        }
        else cout << 0 << endl;
    }
    
    return 0;
}

H题：左孩子右兄弟

题面

思路

1.知识点：树的遍历，递归，邻接表
2.考虑一个常规的多叉树root。若想通过左孩子右兄弟表示法得到高度最大的二叉树，只需要选择高度最大的子树作为root的左子树，其余为右子树。这样构成的树的高度为，左子树的高度，加上root的子树个数。
3.但是root下的这棵左子树，可能又会通过左子树右兄弟表示法进行转化，导致高度改变。所以需要递归，自叶子至根计算高度。
4.用邻接表存储边

实现

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1e5 + 10;
int h[N], ne[N], e[N], idx, res[N];

//邻接表存储
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int height(int v)
{
    //如果该点计算过，直接返回值, 保证不会重复计算
    if(~res[v]) return res[v];
    if(h[v] == -1) return res[v] = 0;//叶节点高度为0

    int cnt = 0, hei = 0;//子树个数和最高子树高度
    for(int i = h[v]; ~i; i = ne[i])
    {
        int u = e[i];
        hei = max(hei, height(u));
        cnt++;
    }

    return res[v] = hei + cnt;
}

int main()
{
    memset(h, -1, sizeof h);
    memset(res, -1, sizeof res);

    int n;
    scanf("%d", &n);
    for(int i = 2; i <= n; i++)
    {
        int a;
        scanf("%d", &a);
        add(a, i);
    }

    printf("%d\n", height(1));

    return 0;
}

I 题：括号序列

思路

1.知识点：动态规划
2.合法括号两条性质：
一、左括号数等于右括号数
二、任意前缀，左括号数总是大于或等于右括号数
3.由于括号插入总是在括号之间，或者首尾，对于每一个可能插入的位置，左右括号排列都有且仅有一种可能[ 只能 ： )(，不能() ]，所以可以独立考虑插入左右括号，最终的结果就等于左括号可能方案数 * 右括号可能方案数
4.f[i][j]表示前i个字符中，左括号领先右括号j个的方案数
状态更新：
一、当遇到左括号时：前i个字符领先j个，因为第i个也是左括号，所以等同于前i - 1个字符领先j - 1个
二、当遇到右括号时：
j自0遍历到n，假设插入j个左括号
插入0个的方案数 f[i - 1][ j + 1]
插入1个的方案数f[i - 1][j]
插入 j + 1个的方案数f[i - 1][0]
所以f[i][j] = f[i - 1][j + 1] + f[i - 1][j] + … + f[i - 1][0]， 结合类似完全背包的更新方式
f[i][j - 1] = f[i - 1][j] + f[i - 1][j - 1] + … + f[i - 1][0]
所以f[i][j] = f[i - 1][j + 1] + f[i][j - 1]

实现

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 5010, MOD = 1e9 + 7;
typedef long long LL;
LL f[N][N];
char str[N];
int n;

LL calc()
{
    memset(f, 0, sizeof f);
    
    f[0][0] = 1;
    for(int i = 1; i <= n; i++)
        if(str[i] == '(')
           for(int j = 1; j <= n; j++) f[i][j] = f[i - 1][j - 1];
        else
        {
            f[i][0] = (f[i - 1][0] + f[i - 1][1]) % MOD;
            for(int j = 1; j <= n; j++)
                f[i][j] = (f[i - 1][ j + 1] + f[i][j - 1]) % MOD;
        }
    
    for(int j = 0; j <= n; j++)
        if(f[n][j])
            return f[n][j];
            
    return -1;
}

int main()
{
    scanf("%s", str + 1);
    n = strlen(str + 1);
    
    LL l = calc();
    
    //由于对称性，将符号替换并反转，复用函数
    reverse(str + 1, str + 1 + n);
    for(int i = 1; i <= n; i++)
        if(str[i] == '(') str[i] = ')';
        else str[i] = '(';
    
    LL r = calc();
    
    printf("%lld\n", l * r % MOD);
    
    return 0;
}
//转载自：https://www.acwing.com/activity/content/code/content/1175584/