第十一届蓝桥杯省赛模拟赛C/C++题解

问题一

给定一个单词，请使用凯撒密码将这个单词加密。
凯撒密码是一种替换加密的技术，单词中的所有字母都在字母表上向后偏移3位后被替换成密文。即a变为d，b变为e，…，w变为z，x变为a，y变为b，z变为c。
例如：lanqiao会变成odqtldr。
输入格式：
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式：
输出一行，表示加密后的密文。
样例输入：
lanqiao
样例输出：
odqtldr
评测用例规模与约定
对于所有评测用例，单词中的字母个数不超过100。

题解：注意x,y,z加密后分别变成a,b,c

#include
using namespace std;
int main()
{
    string s;
    cin>>s;
    int len=s.size();
    for(int i=0;i<len;i++){
        if(s[i]=='x')      s[i]='a';
        else if(s[i]=='y') s[i]='b';
        else if(s[i]=='z') s[i]='c';
        else s[i]=s[i]+3;
    }
    cout<<s<<endl;
	return 0;

问题二

给定三个整数 a, b, c，如果一个整数既不是 a 的整数倍也不是 b 的整数倍还不是 c 的整数倍，则这个数称为反倍数。 　　
请问在 1至 n 中有多少个反倍数。
输入格式
输入的第一行包含一个整数 n。 　　第二行包含三个整数 a, b, c，相邻两个数之间用一个空格分隔。
输出格式
输出一行包含一个整数，表示答案。
样例输入：
30 2 3 6
样例输出：
10
样例说明
以下这些数满足要求：1, 5, 7, 11, 13, 17, 19, 23, 25, 29。
评测用例规模与约定
对于 40% 的评测用例，1 <= n <= 10000。 　　对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000，1 <= a <= n，1 <= b <= n，1 <= c <= n。
题解：水题，直接模拟判断即可

#include
using namespace std;
int n,a,b,c;
bool fun(int x){
    if(x%a!=0&&x%b!=0&&x%c!=0) return true;
    else return false;
}
int main()
{
    int ans=0;
    cin>>n>>a>>b>>c;
    for(int i=1;i<=n;i++){
        if(fun(i)) ans++;
    }
    cout<<ans<<endl;
	return 0;
}

问题三 螺旋矩阵

对于一个 n 行 m 列的表格，我们可以使用螺旋的方式给表格依次填上正整数，我们称填好的表格为一个螺旋矩阵。
　　例如，一个 4 行 5 列的螺旋矩阵如下：
　　1 2 3 4 5
　　14 15 16 17 6
　　13 20 19 18 7
　　12 11 10 9 8
输入格式：
输入的第一行包含两个整数 n, m，分别表示螺旋矩阵的行数和列数。
　　第二行包含两个整数 r, c，表示要求的行号和列号。
输出格式：
输出一个整数，表示螺旋矩阵中第 r 行第 c 列的元素的值。
样例输入：
4 5
2 2
样例输出：
15
评测用例规模与约定
对于 30% 的评测用例，2 <= n, m <= 20。
　　对于 70% 的评测用例，2 <= n, m <= 100。
　　对于所有评测用例，2 <= n, m <= 1000，1 <= r <= n，1 <= c <= m。

#include
#include
#include
using namespace std;
int vis[1005][1005]={0};
int main()
{
    int n,m,r,c;
    cin>>n>>m>>r>>c;
    memset(vis,0,sizeof(vis));
    int s=n*m;
    int row=0,col=0,cnt=1;
    vis[row][col]=1;
    //行走顺序：右-->下-->左-->上
    while(cnt<s){
        //移动过程中如果元素已经访问过，说明已到达上一层螺旋的边界，需改变行走方向
        //向左走，行不变，列增加。
        while(col+1<m&&!vis[row][col+1]){
            vis[row][++col]=++cnt;
        }
        //向下走，列不变，行增加。
        while(row+1<n&&!vis[row+1][col]){
            vis[++row][col]=++cnt;
        }
        //向左走，行不变，列减小。
        while(col-1>=0&&!vis[row][col-1]){
            vis[row][--col]=++cnt;
        }
        //向上走，列不变，行减小。
        while(row-1>=0&&!vis[row-1][col]){
            vis[--row][col]=++cnt;
        }
    }
    cout<<vis[r-1][c-1]<<endl;
	return 0;
}

问题四 摆动序列

如果一个序列的奇数项都比前一项大，偶数项都比前一项小，则称为一个摆动序列。即 a[2i]a[2i]。小明想知道，长度为 m，每个数都是 1 到 n 之间的正整数的摆动序列一共有多少个。
输入格式
输入一行包含两个整数 m，n。
输出格式
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
样例输入
3 4
样例输出
14
样例说明
以下是符合要求的摆动序列： 　　
2 1 2
2 1 3 　　
2 1 4 　　
3 1 2 　　
3 1 3 　　
3 1 4 　　
3 2 3
3 2 4 　　
4 1 2 　　
4 1 3 　　
4 1 4 　　
4 2 3 　　
4 2 4 　　
4 3 4
评测用例规模与约定
对于 20% 的评测用例，1 <= n, m <= 5；对于 50% 的评测用例，1 <= n, m <= 10；对于 80%的评测用例，1 <= n, m <= 100；对于所有评测用例，1 <= n, m <= 1000。
题解：
直接使用dfs暴力搜索会超时，大概能得一半的分数，模拟赛时用的dfs，想不出来如何用动态规划来表示，赛后参考了 https://qiguanjie.blog.csdn.net/article/details/105622530 这篇文章。我来具体分析下动态规划的思路。

题中条件：奇数项都比前一项大，偶数项都比前一项小。
定义dp[i][j]表达式 ：
i为奇数位：dp[i][j]表示第i个数选择大于等于j的数时的方案总数。
i为偶数位：dp[i][j]表示第i个数选择小于等于j的数时的方案总数。

1. 1i为奇数位 : 由dp[i][j]定义知第i位选择的数大于等于j。（1）第i位可以选数字j,因为奇数项都比前一项大。当选择j时前面的偶数位（第i-1位）选择的数不能大于j,即有dp[i-1][j-1]种选择。（2）第i位选择大于等于j+1的数，有dp[i][j+1]种选择。因此 dp[i][j]=dp[i-1][j-1]+dp[i][j+1]
2. i为偶数位： 由dp[i][j]定义知第i位选择的数小于等于j。（1）第i位可以选数字j，因为偶数项都比前一项小。当选择j时，前面一项选择的数必须大于j,即有dp[i-1][j+1]中选择。（2）第i位选择小于等于i-1的数，即有dp[i][j-1]种选择。因此dp[i][j]=dp[i-1][j+1]+dp[i][j-1]

if(i&1==1)  dp[i][j]=dp[i-1][j-1]+dp[i][j+1]; //i为奇数位
if(i&1==0)  dp[i][j]=dp[i-1][j+1]+dp[i][j-1]; //i为偶数位

初始化dp表示式子边界：
当只有一位数字时，挑选大于等于j的数字有n-j+1种选择。dp[1][j]=n-j+1;

if(i&1)dp[i][n+1]=0;//i为奇数,第i位选择大于等于n+1的方案为0。（最多有n个数）
else dp[i][0]=0;    //i为偶数,第i位选择小于等于0的方案为0;

有序编写状态转移方程
在递推表达式中dp[i][j]用到上一层dp[i-1][k]的结果。i从1…2…n顺序递推。
i为奇数位时，dp[i][j]需要dp[i][j+1]的结果，因此j需要从大到小逆序递推。
i为偶数位时，dp[i][j]需要dp[i][j-1]的结果， 因此j需要从校到大顺序递推。
输出结果ans：当最后一位第m位是奇数时，ans=dp[m][n]。当最后一位第m位是奇数时，ans=dp[m][1] ,这样保证了最后一位可取到1到n的任意一个数。根据题意要求每次计算的过程中进行取余。

#include
using namespace std;
int dp[1005][1005]={0};
int main()
{
    int m,n;
	cin>>m>>n;
    for(int i=1;i<=n;i++){
        if(i&1)dp[i][n+1]=0;//i为奇数时,第i位选择大于等于n+1的值为0;
        else dp[i][0]=0;    //i为偶数时,第i位选择小于等于0的值为0;
        dp[1][i]=n-i+1;
    }
    for(int i=2;i<=m;i++){
       if(i&1){
         for(int j=n;j>=1;j--){      //dp[i][j]需要dp[i][j+1]的值，所有应该倒序输出
            dp[i][j]=(dp[i-1][j-1]+dp[i][j+1])%1000; 
         }
       }else{
          for(int j=1;j<=n;j++){    //dp[i][j]需要dp[i][j-1]的值，所有应该正序输出
            dp[i][j]=(dp[i-1][j+1]+dp[i][j-1])%1000;
          }
       }
    }
    int ans=(m&1?dp[m][1]:dp[m][n]);
    cout<<ans<<endl;
	return 0;
}

问题五

小明和朋友们一起去郊外植树，他们带了一些在自己实验室精心研究出的小树苗。
　　小明和朋友们一共有 n 个人，他们经过精心挑选，在一块空地上每个人挑选了一个适合植树的位置，总共 n 个。他们准备把自己带的树苗都植下去。
　　然而，他们遇到了一个困难：有的树苗比较大，而有的位置挨太近，导致两棵树植下去后会撞在一起。
　　他们将树看成一个圆，圆心在他们找的位置上。如果两棵树对应的圆相交，这两棵树就不适合同时植下（相切不受影响），称为两棵树冲突。
　　小明和朋友们决定先合计合计，只将其中的一部分树植下去，保证没有互冲突的树。他们同时希望这些树所能覆盖的面积和（圆面积和）最大。
输入格式：
输入的第一行包含一个整数 n ，表示人数，即准备植树的位置数。
　　接下来 n 行，每行三个整数 x, y, r，表示一棵树在空地上的横、纵坐标和半径。
输出格式：
输出一行包含一个整数，表示在不冲突下可以植树的面积和。由于每棵树的面积都是圆周率的整数倍，请输出答案除以圆周率后的值（应当是一个整数）。
样例输入：
6
1 1 2
1 4 2
1 7 2
4 1 2
4 4 2
4 7 2
样例输出：
12
评测用例规模与约定
对于 30% 的评测用例，1 <= n <= 10；
　　对于 60% 的评测用例，1 <= n <= 20；
　　对于所有评测用例，1 <= n <= 30，0 <= x, y <= 1000，1 <= r <= 1000
题解：
dfs暴力搜索：对应每一棵树，都有两种选择（可以说是两种状态）：种植或者不种植。1.设置vis数组，表示已经种植的树的集合。vis[i]=1,表示编号为i的树已经种植。2.对搜索过的树进行标记，依次搜索下一棵树并计算能否种植（注意比较时不能和自己比较否则会出错），一趟搜索结束得到一个种植面积的解，然后回溯进行下一趟搜索。所有情况搜索结束后得到最优解。
因为每个树有两种选择，所有时间复杂度为指数级：2^n 。

#include
using namespace std;
int n;
int x[35],y[35],r[35];
bool vis[35]={0};
int ans=0;
bool fun(int i){
    for(int j=0;j<n;j++){
        //!!!注意不能i!=j，与其他访问过的点比较
        if(vis[j]&&i!=j){
            int dis=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
            if(dis<(r[i]+r[j])*(r[i]+r[j])) return false;
        }
    }
    return true;
}
void dfs(int cnt,int sum){
    if(cnt==n){
        ans=max(ans,sum);
        return;
    }
    for(int i=0;i<n;i++){
        if(!vis[i]){
            vis[i]=true;
            if(fun(i)==false) dfs(cnt+1,sum);
            else dfs(cnt+1,sum+r[i]*r[i]);
            vis[i]=false;
        }
    }
}
//每个点都有两种选择，选或者不选
int main()
{
	cin>>n;
	for(int i=0;i<n;i++){
        cin>>x[i]>>y[i]>>r[i];
	}
	dfs(0,0);
	cout<<ans<<endl;
	return 0;
}

问题六

2015年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。
　　这一次，小明要帮助 n 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。
　　现在，这 n 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。
　　小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为 (x_1, y_1) 高度为 h_1 的村庄与坐标为 (x_2, y_2) 高度为 h_2 的村庄之间连接的费用为
　　sqrt((x_1-x_2)(x_1-x_2)+(y_1-y_2)(y_1-y_2))+(h_1-h_2)*(h_1-h_2)。
　　在上式中 sqrt 表示取括号内的平方根。请注意括号的位置，高度的计算方式与横纵坐标的计算方式不同。
　　由于经费有限，请帮助小明计算他至少要花费多少费用才能使这 n 个村庄都通电。
输入格式：
输入的第一行包含一个整数 n ，表示村庄的数量。
　　接下来 n 行，每个三个整数 x, y, h，分别表示一个村庄的横、纵坐标和高度，其中第一个村庄可以建立发电站。
输出格式：
输出一行，包含一个实数，四舍五入保留 2 位小数，表示答案。
样例输入：
4
1 1 3
9 9 7
8 8 6
4 5 4
样例输出：
17.41
评测用例规模与约定
对于 30% 的评测用例，1 <= n <= 10；
　　对于 60% 的评测用例，1 <= n <= 100；
　　对于所有评测用例，1 <= n <= 1000，0 <= x, y, h <= 10000
题解：
不同村庄都可以相互连接，要求所有村庄能通电的最小费用。其实是图论中的最小生成树模型。可以使用Prime算法，不了解的可以先学习下这个算法。直接上模型。

#include
#include
#include
#include
using namespace std;
const int INF=0x3f3f3f3f;
int n,x,y,h;
struct node{
    int x,y,h;
    node(int a,int b,int c):x(a),y(b),h(c){}
};
vector<node>s;
double cost[1005];
bool vis[1005]={0};
int main()
{
    cin>>n;
    fill(cost,cost+1005,INF);
    cost[0]=0;
    for(int i=0;i<n;i++){
        scanf("%d%d%d",&x,&y,&h);
        s.push_back(node(x,y,h));
    }
    double ans=0;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(!vis[j]&&cost[j]<MIN){
                u=j;
                MIN=cost[j];
            }
        }
        vis[u]=true;
        ans+=cost[u];
        for(int v=0;v<s.size();v++){
            double sum=sqrt((s[u].x-s[v].x)*(s[u].x-s[v].x)+(s[u].y-s[v].y)*(s[u].y-s[v].y))+(s[u].h-s[v].h)*(s[u].h-s[v].h);
            if(!vis[v]&&sum<cost[v]){
                cost[v]=sum; //以u为中介点可以使V离集合S更小（即花费更小）
            }
        }
    }
    printf("%.2f\n",ans);
	return 0;
}