百度2022秋招 -研发B卷（9月7日） 后两题解答

第二题

A,B是两个自然数，已知A和B的最大公约数可以表示为GCD(A,B)，最小公倍数可以表示为LCM(A,B)，现给出以下限制：

GCD(A,B)=1

LCM(A,B)=A*B

假设一个自然数N是两个自然数A和B的最小公倍数，给出N的值，满足上述条件的数对A和B有多少对？例如，如果N=30，则有四对可能的自然数:(1, 30), (2, 15), (3, 10), (5, 6)。（注意：此处（2，15）和（15，2）视为同一对情况。）

编写一个程序，给定一个自然数N，输出满足上述条件的情况数有多少。

输出描述：

第一行给出一个自然数T，表示测试用例的数量

接下来T行测试用例，没行给出一个自然数N

$1\le T\le 10^3$

$1\le N\le 10^8$

输出描述：

按顺序输出每个测试用例的答案

解：质因数分解，统计自然数N的质因数个数，设为k，则答案为$2^{k-1}$。

我们只需要考虑质因数个数，而不需要考虑质因数的次数。因为分解的两个质数要互质，所以A，B不能有相同的质因数，只能全部分给A或者B。如果A有质因数2，那么B不能有质因数2了。

设质因数个数为$k$个，如果分出A质因数$i$个，B取剩下的，共有$C(k,i)$种情况。

那么总共有$\frac{1}{2}{\sum }_{i=0}^{k}C(k,i)=\frac{1}{2}{2}^k=2^{k-1}$种情况，这里除以2是考虑到（2，15）和（15，2）视为同一对情况。

// 本题为考试多行输入输出规范示例，无需提交，不计分。
#include <iostream>
#include <cstdio>

using namespace std;

int main(){
    int T;
    scanf("%d", &T);
    while (T--) {
        int n; scanf("%d", &n);
        int k = 0;
        for (int i = 2; i*i <= n; i++) {
            if (n % i == 0) {
                k++;
                while (n % i == 0) n /= i;
            }
        }
        if (n > 1) k++;
        
        long long ans = 1;
        for (int i  = 1; i < k; i++) ans *= 2;
        cout<<ans<<endl;
    }
    return 0;
}

第三题

给出一个只包含大写英文字母A，B，C的字符串，每次可以选择该字符串的一个前缀，然后将其反转，请问至少反转多少次，才能使字符串中较小字母都排在较大的字母的之前，即字母A都在字母B，C之前，字母B都在字母C之前。

输入描述：

第一行给定两个正整数N，Q，代表字符串的长度和字符串的个数

接下来Q行每行给出一个长度为N的字符串

$2\le N\le 13,1\le Q\le 100000$

输出描述：

对于每个字符串在一行中输出一个整数代表最小的反转次数

例一：

输入：

5 1
ABCBA

输出：

3

说明：

ABCBA -> BCBAA -> CBBAA -> AABBC

例二：

输入：

5 1

CCBAB

输出：

2

说明：

CCBAB -> BABCC -> ABBCC

方法1

可能的字符串个数最多是$3^{13}=1594323$，这个值不是很大，我们可以把所有的可能性都存下来。

从给定的字符串开始宽度优先搜索，每次把当前字符串反转可能的情况，并记录。如果字符串第一次被走到就是最少的反转次数，以后走到的都是反转次数相同的或者更多的（因为宽度优先搜索会优先走反转次数少的）。

但是这样需要重复Q次，会超时。

方法2

因为Q个字符串长度都相同，我们考虑预处理：从所有有序的状态向外宽度优先搜索，得到所有状态的最少反转次数。以后每个字符串直接输出即可。

// 本题为考试多行输入输出规范示例，无需提交，不计分。
#include <bits/stdc++.h>

using namespace std;

const int M = 1594323;
const int INF = 1e9 + 10;
int dp[M];


int char2int(char *s, int n) {
    int res = 0;
    for (int i = 0; i < n; i++) {
        res = res * 3 + s[i] - 'A';
    }
    return res;
}

struct Node {
    char str[15];
    Node() {}
    Node (char *s, int n) {
        for (int i = 0; i < n; i++) str[i] = s[i];
    }
};


queue<Node> Q;
void build(char *s, int cur, int n, bool o) {
    if (cur == n) {
        if (o) {
            dp[char2int(s, n)] = 0;
            Q.push(Node(s, n));
        }
        return ;
    }
    for (int i = 0; i < 3; i++) {
        s[cur] = char('A' + i);
        build(s, cur+1, n, o && ((cur == 0) || (s[cur-1]<=s[cur])));
    }
}
void run(int n) {
    for (int i = 0; i < M; i++) dp[i] = INF;
    char s[15];
    build(s, 0, n, true); //得到所有有序状态
    
    while (!Q.empty()) {
        Node temp = Q.front(); Q.pop();
        int cur = char2int(temp.str, n);
        
        for (int i = 1; i <= n; i++) {
            memcpy(s, temp.str, sizeof temp.str);
            reverse(s, s+i);
            int nxt = char2int(s, n);
            if (dp[nxt] > dp[cur] + 1) {
                dp[nxt] = dp[cur] + 1;
                Q.push(Node(s, n));
            }
        }
    }
}
int main(){
    int n, q; scanf("%d%d", &n, &q);
    run(n);
    
    char str[15];
    while (q--) {
        scanf("%s", str);
        printf("%d\n", dp[char2int(str, n)]);
    }
    
    return 0;
}