蓝桥杯 — 搜索
方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：
就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
AC思路
图形关于(3,3)点对称,所以我们从(3,3)开始搜索,然后标记走到过的点和对称的点即可;
AC代码
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int book[7][7];
int sum=0;
int to[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
void dfs(int x,int y)
{
if(x==0||y==0||x==6||y==6)
{
sum++;
return;
}
for(int i=0;i<4;i++)
{
int tx=x+to[i][0],ty=y+to[i][1];
if(tx<0||ty<0||tx>6||ty>6||book[tx][ty]==1)
continue;
book[tx][ty]=1;
book[6-tx][6-ty]=1;
dfs(tx,ty);
book[tx][ty]=0;
book[6-tx][6-ty]=0;
}
}
int main()
{
book[3][3]=1;
dfs(3,3);
cout<<sum/4;
return 0;
}
凑算式
这个算式中A— I代表1~9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
AC思路
枚举1 — 9的全排列,然后验证正确性
AC代码
#include <algorithm>
#include <iostream>
#include <cstring>
using namespace std;
double a[10] = {1,2,3,4,5,6,7,8,9};
int ans = 0;
int main(){
while(next_permutation(a,a + 9)){
double sum = a[0] + (a[1] / a[2]) + (a[3] *100 + a[4] * 10 + a[5]) / (a[6] * 100 + a[7] * 10 + a[8]);
if(sum == 10.0){
ans++;
}
}
cout << ans;
return 0;
}
完美平方数
如果整个整数 X 本身是完全平方数，同时它的每一位数字也都是完全平方数，我们就称 X 是完美平方数。
前几个完美平方数是 0、1、4、9、49、100、144……
即第 1 个完美平方数是 0，第 2 个是 1，第 3 个是 4，……
请你计算第 2020 个完美平方数是多少？
AC思路
枚举模拟
AC代码
#include<iostream>
#include<algorithm>
#include<cmath>
#include<string>
using namespace std;
bool hs[11] = { false };
int main() {
int cnt = 0;
hs[0] = 1, hs[1] = 1,hs[4] = 1, hs[9] = 1;
for (int i = 0;i <= 100000000;i++) {
int temp = i * i;
int flag = 1;
string str = to_string(temp);
for (int j = 0;j < str.length();j++) {
if (!hs[str[j] - '0']) {
flag = 0;break;
}
}
if (flag) {
cnt++;
cout << cnt<<endl;
}
if (cnt == 2020) {
cout << temp << endl;
return 0;
}
}
}//i=13786156 ans=1499441040
分配口罩
某市市长获得了若干批口罩，给定每批口罩的数量，市长要把口罩分配给市内的2所医院。
masks = [9090400, 8499400, 5926800, 8547000, 4958200, 4422600, 5751200, 4175600, 6309600, 5865200, 6604400, 4635000, 10663400, 8087200, 4554000]
由于物流限制，每一批口罩只能全部分配给其中一家医院。
市长希望2所医院获得的口罩总数之差越小越好。
请你计算这个差最小是多少？
AC思路
dfs爆搜每一种结果,然后取最小差值
AC代码
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
long int masks[15] = {9090400, 8499400, 5926800, 8547000, 4958200,
4422600, 5751200, 4175600, 6309600,
5865200, 6604400, 4635000, 10663400, 8087200, 4554000};
long ans = 1000000000;
void dfs(int n, long h1, long h2){
if(n==15){
ans = min(ans,abs(h1-h2));
return;
}
dfs(n+1, h1+masks[n], h2 );
dfs(n+1, h1, h2+masks[n] );
}
int main(){
dfs(0, 0, 0);
cout<<ans;
}
搭积木
小明最近喜欢搭数字积木
一共有10块积木，每个积木上有一个数字，0~9。
搭积木规则：
每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。
最后搭成4层的金字塔形，必须用完所有的积木。
下面是两种合格的搭法：
0
1 2
3 4 5
6 7 8 9
0
3 1
7 5 2
9 8 6 4
请你计算这样的搭法一共有多少种？
AC思路
全排列爆搜
AC代码
#include <iostream>
#include <algorithm>
using namespace std;
int a[10] = {0,1,2,3,4,5,6,7,8,9};
int ans=0;
bool vis[10];
int main(){
do{
if (a[0]<a[1] && a[0]<a[2] &&
a[1]<a[3] && a[1]<a[4] && a[2]<a[4] && a[2]<a[5] &&
a[3]<a[6] && a[3]<a[7] && a[4]<a[7] && a[4]<a[8] && a[5]<a[8] && a[5]<a[9])//满足三层
{
ans ++;
}
}while(next_permutation(a,a + 10));
cout<<ans<<endl;
return 0;
}
超级胶水
小明有n颗石子，按顺序摆成一排。他准备用胶水将这些石子粘在一起。每颗石子有自己的重量，如果将两颗石子粘在一起，将合并成一颗新的石子，重量是这两颗石子的重量之和。
为了保证石子粘贴牢固，粘贴两颗石子所需要的胶水与两颗石子的重量乘积成正比，本题不考虑物理单位，认为所需要的胶水在数值上等于两颗石子重量的乘积。
每次合并，小明只能合并位置相邻的两颗石子，并将合并出的新石子放在原来的位置。
现在，小明想用最少的胶水将所有石子粘在一起，请帮助小明计算最少需要多少胶水。
测试样例
输入
3
3 4 5
输出
47
AC思路
AC代码
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e5+10;
int w[N];
int main(){
int n;
scanf("%d",&n);
LL sum=0,ans=0;
for(int i=1;i<=n;i++){
scanf("%d",&w[i]);
ans+=sum*w[i];
sum+=w[i];
}
printf("%lld",ans);
return 0;
}
第39级台阶
小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!
站在台阶前，他突然又想着一个问题：
如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？
请你利用计算机的优势，帮助小明寻找答案。
AC思路
递归保证最后一步是右脚即可
AC代码
#include<stdio.h>
#include<stdlib.h>
int sum = 0;
void count(int n, int m)
{
if (n == 0 && m % 2 == 0)
sum++;
if (n < 0)
return;
count(n - 1, m + 1);
count(n - 2, m + 1);
}
int main()
{
count(39, 0);
printf("%d\n", sum);
system("pause");
return 0;
}
迷宫
问题描述
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。
题目数据
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
AC代码
#include <bits/stdc++.h>
using namespace std;
int n,m;
string mp[500];
int dir[4][2] = {{1,0},{0,-1},{0,1},{-1,0}};
string d = "DLRU";
struct node{
int i,j;
string ans;
};
queue<node>q;
bool check(int x,int y){
if(x < 0 || x >= n || y < 0 || y >= m) return false;
else return true;
}
void bfs(){
node s,b;
s.i = 0,s.j = 0,s.ans = "";
mp[0][0] = '1'; //标记已经走过
q.push(s);
while(!q.empty()){
node a = q.front();
q.pop();
if(a.i == n-1 && a.j == m-1){
cout << a.ans.length() << endl;
cout << a.ans << endl;
break;
}
for(int i = 0;i < 4;i ++){
int fx = a.i + dir[i][0];
int fy = a.j + dir[i][1];
if(check(fx,fy) && mp[fx][fy] == '0'){
b.i = fx,b.j = fy,b.ans = a.ans + d[i];
mp[fx][fy] = '1';
q.push(b);
}
}
}
}
int main()
{
// cin >> n >> m;
// for(int i = 0;i < n;i ++) cin >> mp[i];
// bfs();
cout << "DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR";
return 0;
}
李白打酒
话说大诗人李白，一生好饮。幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：
无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。
请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
AC思路
爆搜每一种可能
AC代码
#include <iostream>
using namespace std;
int x = 5,y = 10,c = 2;
int ans ;
void dfs(int x,int y,int c){
if(x < 0 || y < 0) return;
if(x == 0 && y == 1 && c == 1){
ans ++;
return;
}
if(x > 0)
dfs(x - 1,y,c * 2);
if(y > 0)
dfs(x,y - 1,c - 1);
}
int main(){
dfs(x,y,c);
cout << ans << endl;
return 0;
}
字串排序
问题描述
小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。
在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。
例如，对于字符串 lan 排序，只需要 1 次交换。对于字符串 qiao 排序，总共需要 4 次交换。
小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 V 次交换，可是他忘了把这个字符串记下来，现在找不到了。
请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对该串的字符排序，正好需要 V 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。请注意字符串中可以包含相同的字符。
输入格式
输入的第一行包含一个整数V，小蓝的幸运数字。
输出格式
题面要求的一行字符串。
样例输入
4
样例输出
bbaa
样例输入
100
样例输出
jihgfeeddccbbaa
评测用例规模与约定
对于 30% 的评测用例， 1 ≤ V ≤ 20。
对于 50% 的评测用例， 1 ≤ V ≤ 100。
对于所有评测用例， 1 ≤ V ≤ 10000。
网络分析
问题描述
小明正在做一个网络实验。他设置了 n 台电脑，称为节点，用于收发和存储数据。初始时，所有节点都是独立的，不存在任何连接。小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。一条信息只存储一次。给出小明连接和测试的过程，请计算出每个节点存储信息的大小。
输入格式
输入的第一行包含两个整数 n, m，分别表示节点数量和操作数量。节点从1 至 n 编号。
接下来 m 行，每行三个整数，表示一个操作。
如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b时，表示连接了一个自环，对网络没有实质影响。
如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。
输出格式
输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行
完上述操作后节点 1 至节点 n 上存储信息的大小。
样例输入
4 8
1 1 2
2 1 10
2 3 5
1 4 1
2 2 2
1 1 2
1 2 4
2 2 1
样例输出
13 13 5 3
思路：bfs，bfs属于常考知识点！！！
测试数据
对于 30% 的评测用例，1 ≤ n ≤ 20，1 ≤ m ≤ 100。
对于 50% 的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 1000。
对于 70% 的评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 10000。
对于所有评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ t ≤ 100。
code：
#include<stdio.h>
#include<string.h>
#define INF 10000
int n,m;//设全局变量
int list[INF]={0};//list存放所求值
int M[INF][INF];//使用邻接矩阵放
void bfs(int node,int t){//广度优先遍历，将广度优先遍历结果存放在数组（队列中），最后再依次加t
int head=1,tail=1;
int queue[INF]={0};//队列，存放广度优先遍历序列
int book[INF]={0};//book用于标记是否入队，1为入队，0为没有入队
queue[tail]=node;
book[node]=1;
tail++;
while(head<tail&&tail<=n){
int now=queue[head];
for(int i=1;i<=n;i++){
if(M[now][i]==1&&book[i]==0&&now!=i){
book[i]=1;
queue[tail]=i;
tail++;
}
if(tail>n)break;
}
head++;
}
for(int i=1;i<=head;i++){//依次加t
list[queue[i]]+=t;
}
}
int main(){
scanf("%d %d",&n,&m);
memset(M,0,sizeof M);
for(int i=0;i<m;i++){
int op,n1,n2;
scanf("%d %d %d",&op,&n1,&n2);//op是操作数
if(op==1){//op为1时，连线即可
M[n1][n2]=1;
M[n2][n1]=1;
}
if(op==2){//op为2时，bfs
bfs(n1,n2);
}
}
for(int i=1;i<=n;i++){//最后输出list就行
printf("%d",list[i]);
if(i<n)printf(" ");
}
return 0;
}
波动数列
问题描述
观察这个数列：
1 3 0 2 -1 1 -2 …
这个数列中后一项总是比前一项增加2或者减少3。
栋栋对这种数列很好奇，他想知道长度为 n 和为 s 而且后一项总是比前一项增加a或者减少b的整数数列可能有多少种呢？
输入格式
输入的第一行包含四个整数 n s a b，含义如前面说述。
输出格式
输出一行，包含一个整数，表示满足条件的方案数。由于这个数很大，请输出方案数除以100000007的余数。
样例输入
4 10 2 3
样例输出
2
样例说明
这两个数列分别是2 4 1 3和7 4 1 -2。
数据规模和约定
对于10%的数据，1<=n<=5，0<=s<=5，1<=a,b<=5；
对于30%的数据，1<=n<=30，0<=s<=30，1<=a,b<=30；
对于50%的数据，1<=n<=50，0<=s<=50，1<=a,b<=50；
对于70%的数据，1<=n<=100，0<=s<=500，1<=a, b<=50；
对于100%的数据，1<=n<=1000，-1,000,000,000<=s<=1,000,000,000，1<=a, b<=1,000,000。
跳蚱蜢
如图所示： 有9只盘子，排成1个圆圈。其中8只盘子内装着8只蚱蜢，有一个是空盘。
我们把这些蚱蜢顺时针编号为 1~8。每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？
输出
输出一个整数表示答案
【总结】
1.一看就知道是深搜的题目，但是一开始不知道要怎么记录已经访问过的状态。解决方法是，把序列当成一个 long long型的数。开一个bool型的数组，1e9的大小是开的下的。
2.关于环形的数组，前移动和后移动可能会溢出下标。解决方法是，转移后的坐标公式为
（原坐标+改变量+数组长度）%数组长度
ps:有一点要注意的是，这个数组必须是从0开始的数组。
3.关于bfs。队列里面放什么呢，放一个pair型的，前一个放数组状态，后面放走的步骤。
4.在移动的时候，swap之后得到改变的数组状态之后，要再换回去，开始另一种情况
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int> state;
bool vis[1000000000];//bool型的数组可以开到这么大，int不行
int a[12];//记录数组
int dx[5]={-2,-1,1,2};//四种移动方向
ll res=987654321;//结果状态
ll getsum()//得到数组状态的数字
{
ll tem=0;
for(int i=0;i<9;i++)
{
tem=tem*10+a[i];
}
return tem;
}
int bfs()
{
queue<state> qu;
qu.push(make_pair(getsum(),0));
while(!qu.empty())
{
state tem=qu.front();
qu.pop();
ll hh=tem.first;
//cout<<hh<<endl;
if(hh==res)
{
return tem.second;
}
vis[hh]=true;
int nowkg=0;
int k=8;
while(hh)
{
a[k]=hh%10;
hh/=10;
if(a[k]==9)
{
nowkg=k;
// cout<<k<<endl;
}
k--;
}
for(int i=0;i<4;i++)
{
int newkg=((nowkg+dx[i]+9)%9);
swap(a[nowkg],a[newkg]);
ll nowll=getsum();
swap(a[nowkg],a[newkg]);
if(vis[nowll]==false)
{
qu.push(make_pair(nowll,tem.second+1));
}
}
}
}
int main()
{
a[0]=9;
for(int i=1;i<9;i++)
{
a[i]=i;
}
memset(vis,false,sizeof(vis));
cout<<bfs()<<endl;
}
大臣的路费
很久以前，T王国空前繁荣。
为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。
为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。
同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。
J是T国重要大臣，他巡查于各大城市之间，体察民情。
所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。
他有一个钱袋，用于存放往来城市间的路费。
聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第 x 千米到第 x+1 千米这一千米中（x是整数），他花费的路费是 x+10 这么多。也就是说走 1 千米花费 11，走 2 千米要花费 23。
J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？
【输入格式】
输入的第一行包含一个整数 n，表示包括首都在内的T王国的城市数。
城市从 1 开始依次编号，1 号城市为首都。
接下来 n−1 行，描述T国的高速路（T国的高速路一定是 n−1 条）。
每行三个整数 Pi, Qi, Di，表示城市 Pi 和城市 Qi 之间有一条双向高速路，长度为 Di 千米。
【输出格式】
输出一个整数，表示大臣J最多花费的路费是多少。
【输入样例】
5
1 2 2
1 3 1
2 4 5
2 5 4
【输出样例】
135
【数据范围】
1 ≤ n ≤ 105,
1 ≤ Pi, Qi ≤ n,
1 ≤ Di ≤ 1000
解题思路：
路费越多说明走的越远，并且城市之间的路径唯一，说明没有环存在，这样的无环连通图符合树的定义，所以最远的距离就是树的直径。
那么如何求树的直径呢？
1、第一遍dfs任选一点x，求出距离它最远的点y，
2、第二遍dfs从点y出发，求出距离它最远的点z，
3、那么这棵树的直径就是y到z，也就是其中的最长路径。
题解
树的直径 & DFS：
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 100010;
struct node
{
int id;
int w;
};
int dis[N];
vector<node> h[N]; // 二维数组
void dfs(int u, int dad, int distance) // 分别表示当前节点，父节点，走过的距离
{
dis[u] = distance;
for (int i = 0; i < h[u].size(); i ++)
{
if(h[u][i].id != dad) // 防止往回遍历
{
dfs(h[u][i].id, u, distance + h[u][i].w);
}
}
}
int main()
{
int n;
cin >> n;
for (int i = 0; i < n - 1; i ++) // 建立邻接表
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
h[a].push_back({b, c}); // 因为是双向的，a 与 b 相连
h[b].push_back({a, c}); // b 也与 a 相连
}
dfs(1, -1, 0); // 以第一个点为起点
int u = 1;
for (int i = 1; i <= n; i ++)
{
if(dis[i] > dis[u]) u = i; // 寻找离起点最远的点
}
dfs(u, -1, 0); // 以离起点最远的点为新起点
for (int i = 1; i <= n; i ++)
{
if(dis[i] > dis[u]) u = i; // 寻找离新起点最远的点
}
long long int s = dis[u];
cout << s * 10 + s * (s + 1) / 2 << endl; // 将距离转换成路费
return 0;
}
1452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
