A.换零钞

标题描绘

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

小明去$x$星旅行，他手里只需$2$张$100$元的$x$星币，太不便利，刚好路过$x$星面试技巧和注意事项银行就去换零钱。

小明有点算法的时刻复杂度取决于强迫症，他坚持要求$200$元换出的零钞中$2$元的张数刚好是$1$元的张数的$10$倍，剩面试毛遂自荐3分钟通用余的当然都是$5$元面额的。

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

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

思路

这道标题是数学标题，设一元的张数是$x$，两元的张数为$10x$，五元的张数为(200−二进制转化为十进制x−10x ⋅  2)5frac{left(200-x-1复杂度最高的是0x:cdot ::2rig二进制转化为十进制ht)}{5}5(200−x−10x⋅2)​

能够的到悉数张数的函数表达式f逆向挑选(x) = (2逆向思想的比方00−x−10x ⋅   2)5+11xfleft(xright):=:frac{left(200-x-10x:cdot :::2right)}{5}+11xf(面试毛遂自荐3分钟通用x)=5(复杂度o(1)什么意思200−x−10x⋅2)​+11x

进一步化简能够得：f(x) = 40+34x5fleft(xright):=:40+frac{34x}{5}f(x)=40+534x​

因二进制转化器为标题需求最小张数，且需求为整数，所以$x=5$时，$f\left(x\right)$能够取的最小值$74$

代码

#include<bits/stdc++.h>逆向行驶怎样处分2021
using namespace std;
int main() {
cout << 74 << en二进制核算器dl;
return 0;
}

B.激光款式

标题描绘

$x$星球的盛大节日为添加气氛复杂度怎样核算的，用$30$台机光器一字排开，向太空中打出光柱。

设备调试的时分才发现，不知什么原因，相邻的两台激光器不能一起翻开！

国王很想知道，在现在这种$bug$存在的情况下，总共能打出多少种激光作用？

显着，假定只需$3$台机器，总共能够成555复杂度为nlogn的排序算法种款式，即：

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

开一台，复杂度o(1)什么意思共$3$种

开两台，只$1$种

$30$台就欠好算了，国王只好请你帮助了。

思路

动态规划DP

• 用0标明激光灯灭
• 用1标明激光灯亮

一盏灯的时分能够是$0$，$1$即灭或许亮；
两盏灯的时分能够是逆向思想事例100个$00$，$01$，$10$（并排二进制核算器）
三盏面试常见问题及答复技巧灯的时分能够是$000$，$010$，$100$，$001$，$101$（并排）

因此能够看出三盏灯的款式种数二进制是复杂度o由两部分组成的，

• 榜首部分便是，前面两盏灯不管亮不亮，第三盏灯都不亮
• 第二部分便是，第二盏灯灭的前提下，第三盏灯亮，而第二盏灯灭的款式种数等于只需一盏灯时分的款式种数。

$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&二进制八进制十进制十六进制转化gt;
using namespace s复杂度剖析td;
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] &面试毛遂自荐lt;< 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开始就不行了。

从下一个开始逆向推理 $0101XOR0111=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);
re算法是什么turn 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$ 的时分，假定当时时刻是逆向思想事例100个$0$，连按$2$次 $+k$ 按面试问题大全及答案大全钮，则调为$2$。

输入

两个逆向行驶整数 $n$, $k$ ，含义如题。
0<k<n<=1000000 < k &面试毛遂自荐3分钟通用lt; n <= 1000000&lt面试技巧;k<n<=100000

输出

一行一个整数
标明：按照最优战略按键，从一个时刻调到另一个时刻最多要按多少次。

思路

动态规划DP

标题要求是最优战略，所以必定要求+i的时分，是最少次数的，复杂度每次只能+1或许+k，从一个时刻调整到另一个时刻，需求加上$\left[0,n-1\right]$

$dp[i]$标明$+i$需求的次数，默许只需一个$+1$按钮，所以直接初始化dp[i]=idp[i] = idp[算法工程师和程序员差异i]=i;

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

情况转复杂度o移方程式

dp[i] = min(dp[(i + n − k) % n] + 1, dp[i − 1算法] + 1);dpleft[iright]:=:minleft(dpleft[left(i:+:n:-:kright):%:nright]:+:1,:dpleft[i:-:1right]:+:1right);dp[i]=min(dp算法的五个特性[(i+n−k)%n]+1,dp[i−1]+1);

代码

#include&lt二进制怎样算;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) { // 假定作用是收敛的，则间断循环。复杂度o
int now_sum = 0;
for (in面试t i = 1; i < n; i ++) {
now_sum += dp二进制八进制十进制十六进制转化[i];复杂度符号
// 情况搬运方程式
dp[i] = mi复杂度符号n(d算法的五个特性p[(i + n - k) % n] + 1, dp[i - 1] + 1);
}
if (now_sum == sum) break;
s复杂度o(1)什么意思um = 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$ 块积木作为地基，将他们在桌子上一字排复杂度o(1)什么意思开，中心不留空位，并称其为第0层。

随后，小明能够在上面摆放第$1$层，第$2$层，……，最多摆放至第$n$层。摆放积木有必要遵从三条规矩：

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

规矩$2$：同二进制亡者列车一层中的积木有必要接连摆放，中心不能二进制转十进制核算器留有空位；

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

其间复杂度最高的是，小明不喜欢的方位都被标在了图逆向挑选纸上。图纸共有$n$行，从下至上面试毛遂自荐范文的每一行分别对应积木的第1层至第$n$层。

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

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

由于这个答案可面试技巧能很大，你只需求答复这个答案逆向行驶怎样处分2021对$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]=vdp[l][r] = vd算法的时刻复杂度是指什么p[l][r]=v：标明当时层中的[l,r][l,r][l,r]逆向思想事例100个的方法数是$v$

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

咱们规则积木从下到上分别是第$n$层，第$n-1$层算法，最上面是榜首层

咱们首先用$check$来更新最面试低层$dp$的值

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

搬运方程是：dp[l][r]+=dp[l−1][r]+dp[l][r+1]−dp[l−1][r+1]dp[l][r]+=dp[l-1][r]+dp[l][r+1]-dp[l-1][r+1]dp[l][r]+=dp[l逆向思想−1][r]+dp[l][r+1]−dp[l−1][r+1]

由于咱们的l和r分别是从两端开始向内走，所以咱们更新区间时也是由外向内更新，当更新区间$[l,r]$时，咱们已知的值区间[l−1][r][l-1][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][l-面试技巧和注意事项1,r+1]+[l,r][l−1,r+1面试毛遂自荐一分钟]+[l,r]所以要减去

代码

#i复杂度英文nclude&面试问题lt;bits/stdc++.h>
using namespace std;
int mo复杂度最优d = 1e9 + 7;
typedef long long ll;
const int maxn = 110;
l算法导论l dp[maxn][maxn];
int check[maxn][maxn];
int main() {
int m面试问题大全及答案大全, n;
char str[maxn];
cin >> n &g面试问题t;> 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;
// 初始化，最底层的数据，选用两面试毛遂自荐3分钟通用头向中心靠近
for (int i = 1; i &l逆向行驶扣几分罚款多少钱t;= m; i++) {面试毛遂自荐3分钟通用
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 这个区间能够的种数逆向思想练习500题 = [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 &面试毛遂自荐范文gt;= 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<=107n <= 10^7n<=逆向思想事例100个107

输出

一行一个数，标明悉数元素的和。由于答案比较大，请输出模 (109+7面试毛遂自荐3分钟通用10^9 + 7109+7)(即：十亿零七) 后的作用

输入

$4$

输出

$48$

思路

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

这道题公式表达式ans =∑i=1n ∑i=1n gcd(i, j)2ans:=sum _{i=1}^n:sum _{i=1逆向思想事例100个}^n:gcdleft(i,:jright)^2ans=∑i=1n​算法的时刻复杂度取决于∑i=1n​gcd(i,j)2

gcd(i, j) = d gcd逆向思想left(i,:jright):=:d:gcd(i,面试j)=d标算法明$\left(i,j\right)$的最大公约数为$d$

$count\left(d\right)$则标明最大公二进制八进制十进制十六进制转化约数为$d$的数对的个数

$count\left(d\right)\cdot d\cdot d$则求解的为最大公约数为$d$的悉数数的和，此时问题的中心则转化为怎样求$count\left(d\right)$。

(, )=, (d, d)=1left(,:right)=,:left复杂度符号(frac{}{d},:逆向思想事例100个frac{}{算法d}right)=1gcd(i,j)=d,gcd(di​,dj​)=1

令 =d, =d。:=frac{}{面试毛遂自荐3分钟通用d},:=frac{}{d}。i=di​,j=dj算法剖析的意图是​。代入则$gcd\left(i,j\right)=1。$

最大公约数的取值规划为 $[1,n]$，$d$ 为 [1,n][1, n][1面试,n] 中的恣意一个数。

$i$, $j$的取面试问题大全及答案大全值在 $[1,n/d]$，求解该区间内悉数互质对的个数， 而该题的数据规划比较大，故选用筛法求欧拉函数（线性筛法）即 $1-n$ 中的欧拉函数，时刻复杂度能控制在 $O(n)$。

[]=∑i = 2n ()2面试问题大全及答案大全+1 left[right]=sum _{i:=:2}^n:left(right)2+1:s[n]=∑逆向行驶怎样处分2021i=2n​Euler(i)2+1

推导到如下：

[]=[−1]+2[]left[right]=left[−1right]+逆向行驶扣几分2left[right]s[i]=s[i−1]+2Eul面试问题er[i]

代码

#include <iostream>
using namespace复杂度最高的是 std;
typedef long面试 long LL;
co复杂度符号nst int N = 1e7 + 10, mod复杂度怎样核算的 = 1e9 + 7;
in逆向行驶扣几分罚款多少钱t 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 为质数 
e面试ulers[i] = i - 1;
}
// 筛非质数 
for (int j = 0; primes[j] <= n / i; ++j) {
int t = primes[j] * i;复杂度o
st[t] = true;
if逆向行驶扣几分罚款多少钱 (i % primes[j] == 0) {
eulers[t] = eulers[i] * pr算法的五个特性imes[j];
break;
}
eulers[t] = eulers[i] * (primes[j] - 1);
}
}
// 开 LL，避免溢出  
s[1] = 1;
// 递推求解 s[i]
for (int i = 2; i <=逆向思想的比方 n; ++i) {逆向行驶怎样处分2021
s[i] = s[i - 1] + 2 * eulers[算法工程师i];
}
}
int main()
{
cin >> n;
get_eulers(n);
int r算法导论es = 0;
for (int d = 1; d <= n; ++d) {
res = (res + (LL) s[n / d] * d % mod * d复杂度为nlogn的排序算法) % mod;
}
cout << res << endl;
r逆向挑选eturn 0;
}