A.换零钞

题目描述

$x$星球的钞票的面额只有：$100$元，$5$元，$2$元，$1$元，共$4$种。

小明去$x$星旅游，他手里只有$2$张$100$元的$x$星币，太不方便，恰好路过$x$星银行就去换零钱。

小明有点强迫症，他坚持要求$200$元换出的零钞中$2$元的张数刚好是$1$元的张数的$10$倍，剩下的当然都是$5$元面额的。

银行的工作人员有点为难，你能帮助算出：在满足小明要求的前提下，最少要换给他多少张钞票吗？

（$5$元，$2$元，$1$元面额的必须都有，不能是$0$）

思路

这道题目是数学题目，设一元的张数是$x$，两元的张数为$10x$，五元的张数为$\frac{\left(200-x-10x\:\cdot \:\:2\right)}{5}$

可以的到所有张数的函数表达式$f\left(x\right)\:=\:\frac{\left(200-x-10x\:\cdot \:\:\:2\right)}{5}+11x$

进一步化简可以得：$f\left(x\right)\:=\:40+\frac{34x}{5}$

由于题目需要最小张数，且需要为整数，所以$x=5$时，$f\left(x\right)$可以取的最小值$74$

代码

#include<bits/stdc++.h>
using namespace std;

int main() {
    cout << 74 << endl;
    return 0;
}

B.激光样式

题目描述

$x$星球的盛大节日为增加气氛，用$30$台机光器一字排开，向太空中打出光柱。

安装调试的时候才发现，不知什么原因，相邻的两台激光器不能同时打开！

国王很想知道，在目前这种$bug$存在的情况下，一共能打出多少种激光效果？

显然，如果只有$3$台机器，一共可以成$5$种样式，即：

全都关上（$sorry$, 此时无声胜有声，这也算一种）

开一台，共$3$种

开两台，只$1$种

$30$台就不好算了，国王只好请你帮忙了。

思路

动态规划DP

• 用0表示激光灯灭
• 用1表示激光灯亮

一盏灯的时候可以是$0$，$1$即灭或者亮； 两盏灯的时候可以是$00$，$01$，$10$（并排） 三盏灯的时候可以是$000$，$010$，$100$，$001$，$101$（并排）

因此可以看出三盏灯的样式种数是由两部分组成的，

• 第一部分就是，前面两盏灯不管亮不亮，第三盏灯都不亮
• 第二部分就是，第二盏灯灭的前提下，第三盏灯亮，而第二盏灯灭的样式种数等于只有一盏灯时候的样式种数。

$dp[i]$表示一共有$i$盏灯时候的样式种类

可以得到DP初始条件: $dp\left[1\right]\:=\:2,\:dp\left[2\right]\:=\:3$

状态转移方程：$dp\left[i\right]\:=\:dp\left[i\:-\:1\right]\:+\:dp\left[i\:-\:2\right]\:\left(i\:\ge \:3\right)$

代码

#include<bits/stdc++.h>
using namespace std;
int main() {
    int dp[31];
    dp[1] = 2;
    dp[2] = 3;
    for (int i = 3; i <= 30; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }   
    cout << dp[30] << endl;
    return 0;
}

C.格雷码

题目描述

格雷码是以n位的二进制来表示数。

与普通的二进制表示不同的是，它要求相邻两个数字只能有1个数位不同。

首尾两个数字也要求只有1位之差。

有很多算法来生成格雷码。以下是较常见的一种：

从编码全0开始生成。

当产生第奇数个数时，只把当前数字最末位改变（0变1，1变0）

当产生第偶数个数时，先找到最右边的一个1，把它左边的数字改变。

用这个规则产生的4位格雷码序列如下：

0000
0001
0011
0010
0110
0111
0101
0100
1100
1101
1111
1110
1010
1011
1001
1000

思路

答案：a = a ^ ((a & (-a)) << 1); //填空

从前面的很明显可以看出，(a << 1) ^ a就可以了，但是后面从0111开始就不行了。

从下一个开始逆向推理 $0101\:XOR\:0111\:=\:0010$ 因此需要想办法把0111 变成 0010 0111 取其负数 1001 再 $XOR$ 即可得到 0010 带入其他奇数验证，成立。

代码

#include <stdio.h>
void show(int a,int n)
{
	int i;
	int msk = 1;
	for(i=0; i<n-1; i++) msk = msk << 1;
	for(i=0; i<n; i++){
		printf((a & msk)? "1" : "0");
		msk = msk >> 1;
	}
	printf("\n");
} 

void f(int n)
{
	int i;
	int num = 1;
	for(i=0; i<n; i++) num = num<<1;
	
	int a = 0;
	for(i=0; i<num; i++){
		show(a,n);
		
		if(i%2==0){
			a = a ^ 1;
		}
		else{
			a = a ^ ((a & (-a)) << 1) ; //填空
		}
	}
}

int main()
{
	f(4);
	return 0;
}

D.调手表

题目描述

小明买了块高端大气上档次的电子手表，他正准备调时间呢。

在 M78 星云，时间的计量单位和地球上不同，M78 星云的一个小时有 $n$ 分钟。

大家都知道，手表只有一个按钮可以把当前的数加一。在调分钟的时候，如果当前显示的数是 $0$ ，那么按一下按钮就会变成 $1$，再按一次变成 $2$ 。如果当前的数是 $n - 1$，按一次后会变成 $0$。

作为强迫症患者，小明一定要把手表的时间调对。如果手表上的时间比当前时间多$1$，则要按 $n - 1$ 次加一按钮才能调回正确时间。

小明想，如果手表可以再添加一个按钮，表示把当前的数加 $k$ 该多好啊……

他想知道，如果有了这个 $+k$ 按钮，按照最优策略按键，从任意一个分钟数调到另外任意一个分钟数最多要按多少次。

注意，按 $+k$ 按钮时，如果加$k$后数字超过$n-1$,则会对$n$取模。

比如，$n=10$, $k=6$ 的时候，假设当前时间是$0$，连按$2$次 $+k$ 按钮，则调为$2$。

输入

两个整数 $n$, $k$ ，意义如题。 $0 < k < n <= 100000$

输出

一行一个整数 表示：按照最优策略按键，从一个时间调到另一个时间最多要按多少次。

思路

动态规划DP

题目要求是最优策略，所以一定要求+i的时候，是最少次数的，每次只能+1或者+k，从一个时刻调整到另一个时刻，需要加上$\left[0,\:n\:-\:1\right]$

$dp[i]$表示$+i$需要的次数，默认只有一个$+1$按钮，所以直接初始化$dp[i] = i$;

其次需要初始化$+k$的次数$dp\left[i\right]\:=\:dp\left[i\:-\:k\right]\:+\:1$

状态转移方程式

$dp\left[i\right]\:=\:min\left(dp\left[\left(i\:+\:n\:-\:k\right)\:\%\:n\right]\:+\:1,\:dp\left[i\:-\:1\right]\:+\:1\right);$

代码

#include<bits/stdc++.h>
using namespace std;
int dp[100005];
int main() {
    int n, k;
    cin >> n >> k;
    // 初始化dp初始状态
    for (int i = 0; i < n; i++) {
        dp[i] = i; // 初始化为多少分钟需要调整多少次，默认为一分钟调整一次；
    }
    for (int i = k; i < n; i += k) {
        dp[i] = dp[i - k] + 1; // 从0开始，每过k步 就+1
    }
    int sum = -1;
    while (1) { // 如果结果是收敛的，则停止循环。
        int now_sum = 0;
        for (int i = 1; i < n; i ++) {
            now_sum += dp[i];
            // 状态转移方程式
            dp[i] = min(dp[(i + n - k) % n] + 1, dp[i - 1] + 1);
        }
        if (now_sum == sum) break;
        sum = now_sum;
    }
    int ans = dp[0];
    for (int i = 0; i < n; i++) {
        ans = max(ans, dp[i]);
    }
    cout << ans << endl;
    return 0;
}

E.搭积木

题目描述

小明对搭积木非常感兴趣。他的积木都是同样大小的正立方体。

在搭积木时，小明选取 $m$ 块积木作为地基，将他们在桌子上一字排开，中间不留空隙，并称其为第0层。

随后，小明可以在上面摆放第$1$层，第$2$层，……，最多摆放至第$n$层。摆放积木必须遵循三条规则：

规则$1$：每块积木必须紧挨着放置在某一块积木的正上方，与其下一层的积木对齐；

规则$2$：同一层中的积木必须连续摆放，中间不能留有空隙；

规则$3$：小明不喜欢的位置不能放置积木。

其中，小明不喜欢的位置都被标在了图纸上。图纸共有$n$行，从下至上的每一行分别对应积木的第1层至第$n$层。

每一行都有$m$个字符，字符可能是‘.’或‘X’，其中‘X’表示这个位置是小明不喜欢的。

现在，小明想要知道，共有多少种放置积木的方案。他找到了参加蓝桥杯的你来帮他计算这个答案。

由于这个答案可能很大，你只需要回答这个答案对$1000000007$(十亿零七)取模后的结果。

注意：地基上什么都不放，也算作是方案之一种。

输入

输入数据的第一行有两个正整数n和m，表示图纸的大小。$n<=100$，$m<=100$

随后n行，每行有$m$个字符，用来描述图纸 。每个字符只可能是‘.’或‘X’。

输出

输出一个整数，表示答案对$1000000007$取模后的结果。

样例输入

2 3

..X

.X.

样例输出

4

样例解释

成功的摆放有（其中O表示放置积木）：

(1)
..X
.X.
(2)
..X
OX.
(3)
O.X
OX.
(4)
..X
.XO

思路

动态规划

$check[i][j]$:表示第$i$层前$j$个中有多少个‘X’

$dp[l][r] = v$：表示当前层中的$[l,r]$的方法数是$v$

$check$其实就是前缀和操作，对每一层进行前缀和运算

我们规定积木从下到上分别是第$n$层，第$n-1$层，最上面是第一层

我们首先用$check$来更新最低层$dp$的值

然后从最低层开始向上传递，即从大区间枚举到小区间后得出的方法数

转移方程是：$dp[l][r]+=dp[l-1][r]+dp[l][r+1]-dp[l-1][r+1]$

因为我们的l和r分别是从两端开始向内走，所以我们更新区间时也是由外向内更新，当更新区间$[l,r]$时，我们已知的值区间$[l-1][r]$和区间$[l][r+1]$区间$[l-1][r+1]$，因为$dp[l-1][r]$和dp$[l][r+1]$中包括的是$[l-1,r+1]+[l,r]$所以要减去

代码

#include<bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
typedef long long ll;
const int maxn = 110;
ll dp[maxn][maxn];
int check[maxn][maxn];
int main() {
    int m, n;
    char str[maxn];
    cin >> n >> m;
    // 读入数据
    for (int i = 1; i <= n; i++) {
        scanf("%s", str + 1);
        for (int j = 1; j <= m; j++) {
            // check 预处理 第i层 中前j个 有多少个X
            check[i][j] = check[i][j - 1];
            if (str[j] == 'X') check[i][j]++;
        }
    }
    // 默认也算一种结果
    ll ans = 1;
    // 初始化，最底层的数据，采用两边向中间靠拢
    for (int i = 1; i <= m; i++) {
        for (int j = m; j >= i; j--) {
            // check[n][j] - check[n][i - 1] == 0相当于没有X可以算一种
            if (check[n][j] - check[n][i - 1] == 0) {
                ans ++;
                // l=i r=j 这个区间可以的种数 = [l=i][r=j + 1] + [l=i - 1][j] - [l=i - 1][r=j + 1] + 1
                dp[i][j] = dp[i][j + 1] + dp[i - 1][j] - dp[i - 1][j + 1] + 1;
            }
        }
    }

    // 开始状态转移，循环层数
    for (int t = n - 1; t > 0; t--) {
        // 像初始化底层数据一样有相同的状态转移表达式
        // 枚举每一层的所有情况
        for (int i = 1; i <= m; i++) {
            for (int j = m; j >= i; j--) {
                // [i,j]没有X 向上递推
                // [i,j]含有X 上面则不能堆放积木
                if (check[t][j] - check[t][i - 1] == 0) {
                    ans = (ans + dp[i][j]) % mod;
                    dp[i][j] = (dp[i][j] + dp[i - 1][j] + dp[i][j + 1] - dp[i - 1][j + 1]) % mod;
                } else dp[i][j] = 0;
            }
        }
    }
    cout << ans << endl;
    return 0;
}

F.矩阵求和

题目描述

经过重重笔试面试的考验，小明成功进入 $Macrohard$ 公司工作。

今天小明的任务是填满这么一张表：

表有 $n$ 行 $n$ 列，行和列的编号都从$1$算起。

其中第 $i$ 行第 $j$ 个元素的值是 $gcd(i, j)$的平方，

$gcd$ 表示最大公约数，以下是这个表的前四行的前四列：

1  1  1  1
1  4  1  4
1  1  9  1
1  4  1 16

小明突然冒出一个奇怪的想法，他想知道这张表中所有元素的和。

输入

一行一个正整数 $n$ 意义见题。$n <= 10^7$

输出

一行一个数，表示所有元素的和。由于答案比较大，请输出模 ($10^9 + 7$)(即：十亿零七) 后的结果

输入

$4$

输出

$48$

思路

这道题暴力思路必定TLE 搜了一下大佬的思路，需要用到欧拉函数和莫比乌斯反演来做

这道题公式表达式$ans\:=\sum _{i=1}^n\:\sum _{i=1}^n\:gcd\left(i,\:j\right)^2$

$gcd\left(i,\:j\right)\:=\:d\:$表示$\:\left(i,\:j\right)\:$的最大公约数为$\:d$

$\:count\left(d\right)\:$则表示最大公约数为$\:d\:$的数对的个数

$count\left(d\right)\:\cdot \:d\:\cdot \:d\:$则求解的为最大公约数为$\:d\:$的所有数的和，此时问题的核心则转化为如何求$\:count\left(d\right)$。

$𝑔𝑐𝑑\left(𝑖,\:𝑗\right)=𝑑,\:𝑔𝑐𝑑\left(\frac{𝑖}{d},\:\frac{𝑗}{d}\right)=1$

令$\:𝑖=\frac{𝑖}{d},\:𝑗=\frac{𝑗}{d}。$代入则$\:𝑔𝑐𝑑\left(𝑖,𝑗\right)=1。$

最大公约数的取值范围为 $[1, n]$，$d$ 为 $[1, n]$ 中的任意一个数。

$i$, $j$的取值在 $[1, n / d]$，求解该区间内所有互质对的个数， 而该题的数据范围比较大，故采用筛法求欧拉函数（线性筛法）即 $1 - n$ 中的欧拉函数，时间复杂度能控制在 $𝑂(𝑛)$。

$𝑠\left[𝑛\right]=\sum _{i\:=\:2}^n\:𝐸𝑢𝑙𝑒𝑟\left(𝑖\right)×2+1\:$

推导到如下：

$𝑠\left[𝑖\right]=𝑠\left[𝑖−1\right]+2×𝐸𝑢𝑙𝑒𝑟\left[𝑖\right]$

代码

#include <iostream>
using namespace std;

typedef long long LL;
const int N = 1e7 + 10, mod = 1e9 + 7;
int n, cnt;
LL primes[N], eulers[N], s[N];
bool st[N];

// 线性筛法 
void get_eulers(int n)
{ 
    eulers[1] = 1;
    for (int i = 2; i <= n; ++i) {
        if (!st[i]) {
            primes[cnt++] = i;
            // i 为质数 
            eulers[i] = i - 1;
        }
        // 筛非质数 
        for (int j = 0; primes[j] <= n / i; ++j) {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0) {
                eulers[t] = eulers[i] * primes[j];
                break;
            }
            eulers[t] = eulers[i] * (primes[j] - 1);
        }
    }
    // 开 LL，避免溢出  
    s[1] = 1; 
    // 递推求解 s[i]
    for (int i = 2; i <= n; ++i) {
        s[i] = s[i - 1] + 2 * eulers[i];
    } 
}

int main()
{
    cin >> n;
    get_eulers(n);
    int res = 0;
    for (int d = 1; d <= n; ++d) {
        res = (res + (LL) s[n / d] * d % mod * d) % mod;
    }
    cout << res << endl;
    return 0;
}