专栏首页章鱼的慢慢技术路计蒜客2018 蓝桥杯省赛 B 组模拟赛(一)

计蒜客2018 蓝桥杯省赛 B 组模拟赛(一)

1,结果填空:年龄

今天蒜头君带着花椰妹和朋友们一起聚会,当朋友们问起年龄的时候,蒜头君打了一个哑谜(毕竟年龄是女孩子的隐私)说:“我的年龄是花椰妹年龄个位数和十位数之和的二倍”。

花椰妹看大家一脸懵逼,就知道大家也不知道蒜头君的年龄,便连忙补充道:“我的年龄是蒜头君个位数和十位数之和的三倍”。

请你计算:蒜头君和花椰妹年龄一共有多少种可能情况?

提醒:两位的年龄都是在 [10,100)[10,100) 这个区间内。

分析:

暴力枚举每一个人可能的年龄,然后判断是否符合条件。

#include<stdio.h>
int main()
{
    int ans = 0;
    for(int i = 10;i < 100;++i){
        for(int j = 10;j < 100;++j){
            int a = i / 10;
            int b = i % 10;
            int c = j / 10;
            int d = j % 10;
            if(((a+b)*3 == c*10 + d)&&((c+d)*2 == 10*a + b)){
                ans++;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
 } 

答案为:1。

2,结果填空:开关灯

蒜头君今天回到了老家的大宅院,老家的灯还是那中拉线的灯(拉一次为亮,再拉一次就灭),蒜头君觉得无聊。把 1000 盏灯 33 的倍数拉了一次,55 的倍数拉了一次,7的倍数拉了一次(灯得的编号从 1-10001−1000,灯的初始状态都是亮的)。这个时候蒜头君在想还剩下几盏灯还在亮着?

提示:请不要输出多余的符号。

#include<stdio.h>
bool f[1010];
int main()
{
    int ans = 0;
    for(int i = 3;i <= 1000;i += 3){
        f[i] = !f[i];
    }
    for(int i = 5;i <= 1000;i += 5){
        f[i] = !f[i];
    }
    for(int i = 7;i <= 1000;i += 7){
        f[i] = !f[i];
    }
    for(int i = 1;i <= 1000;++i){
        if(!f[i]){
            ++ans;
        }
    }
    printf("%d\n",ans);
    return 0;
 } 

答案:571。

3,结果填空:U型数字

最近蒜头君喜欢上了U型数字,所谓U型数字,就是这个数字的每一位先严格单调递减,后严格单调递增。比如 212212 就是一个U型数字,但是 333333, 9898, 567567, 3131331313,就是不是U型数字。

现在蒜头君问你,[1,100000][1,100000] 有多少U型数字?

提示:请不要输出多余的符号。

分析:

  1. 从1到100000枚举每一个数字,然后查看每一个数字,是否符合条件。
  2. 从前往后找到一个不递减的位置,然后检查这个位置是否递增到最后。
#include<iostream>
#include<string>
using namespace std;
int main()
{
    int ans = 0;
    for(int i = 1;i <= 100000;i++){
        string s = to_string(i);
        bool down = 0,up = 0;
        int j;
        for(j = 1;j < s.size();j++){
            if(s[j-1] > s[j]){
                down = 1;
            }
            else{
                break;
            }
        }
        if(down && up){
            ans++;
        }
    }
    cout << ans << endl;
    return 0;
}

答案:8193

4,代码填空:LIS

LIS是最长上升子序列。什么是最长上升子序列? 就是给你一个序列,请你在其中求出一段最长严格上升的部分,它不一定要连续。

就像这样:22, 33, 44, 77 和 22, 33, 44, 66 就是序列 22 55 3344 11 77 66 的两个上升子序列,最长的长度是 44。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int f[10000], b[10000];
int max(int a, int b) {
    return a > b ? a : b;
}
int lis(int n) {
    memset(f, 0, sizeof f);
    int res = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < i; ++j) {
            if (b[j] < b[i]) {
                f[i] = max(f[i],f[j]+1); //在此处填空
            }
        }
        res = max(res, f[i]);
    }
    return res+1;
}
int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d", b + i);
    }
    printf("%d\n", lis(n));
    return 0;
}

5,代码填空:全排列

相信大家都知道什么是全排列,但是今天的全排列比你想象中的难一点。我们要找的是全排列中,排列结果互不相同的个数。比如:aab 的全排列就只有三种,那就是aab,baa,aba

代码框中的代码是一种实现,请分析并填写缺失的代码。

分析:

全排列用dfs实现。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 1000

char str[N], buf[N];
int vis[N], total, len;

void arrange(int num) {
    int i, j;
    if (num == len) {
        printf("%s\n", buf);
        total++;
        return;
    }
    for (i = 0; i < len; ++i) {
        if (!vis[i]) {
            for (j = i + 1; j < len; ++j) {
                if (str[i] == str[j] && vis[j]/*在这里填写必要的代码*/) {
                    break;
                }
            }
            if (j == len) {
                vis[i] = 1;
                buf[num] = str[i];
                arrange(num + 1);
                vis[i] = 0;
            }
        }
    }
}
int main() {
    while (~scanf("%s", str)) {
        len = strlen(str);
        int i, j;
        for (i = 0; i < len; ++i) {
            for (j = i + 1; j < len; ++j) {
                if (str[i] > str[j]) {
                    char tmp = str[i];
                    str[i] = str[j];
                    str[j] = tmp;
                }
            }
        }
        total = 0;
        buf[len] = '\0';
        arrange(0);
        printf("Total %d\n", total);
    }
    return 0;
}

6,数独

蒜头君今天突然开始还念童年了,想回忆回忆童年。他记得自己小时候,有一个很火的游戏叫做数独。便开始来了一局紧张而又刺激的高阶数独。蒜头君做完发现没有正解,不知道对不对? 不知道聪明的你能否给出一个标准答案?

标准数独是由一个给与了提示数字的 9×9 网格组成,我们只需将其空格填上数字,使得每一行,每一列以及每一个 3×3 宫都没有重复的数字出现。

输出这个数独得正解,输出格式如下:

把上面的 * 替换成 1−9 就可以了

提醒:两个数字之间要有一个空格,其他地方不要输出多余的符号。

本题答案不唯一,符合要求的答案均正确

分析:

数独问题可以用dfs、暴力搜索解决,标记每行、每列、和每个小方格用过的元素。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 107;
const int inf = 0x3f3f3f3f;
struct node{
    int x,y;
}g[90];
int f[11][11];
int flag,num;
bool check(int a,int b,int n){
    for(int i=0;i<9;++i){
        if(f[a][i] == n || f[i][b] == n){
            return false;
        }
    }
    for(int i = a / 3 * 3;i < a / 3 * 3 + 3;++i){
        for(int j = b / 3 * 3;i < b / 3 * 3 + 3;++j){
            if(f[i][j] == n){
                return false;
            }
        }
    }
    return true;
} 
void dfs(int cnt){
    if(flag){
        return;
    }
    if(cnt == num){
        flag = 1;
        return;
    }
    for(int k = 1;k <= 9;++k){
        if(check(g[cnt].x,g[cnt].y)){
            f[g[cnt].x,g[cnt].y,k] = k;
            dfs(cnt + 1);
            if(flag == 1) return;
            f[g[cnt].x][g[cnt].y] = 0;
        }
    }
}
int main()
{
    int i,j,k,n,m,t,tt = 0,xx;
    char ch;
    while(cin >> ch){
        memset(f,0,sizeof f);
        flag = 0,num = 0;
        if(ch != '*'){
            f[0][0] = ch - '0';
        }
        else{
            g[num].x = 0;
            g[num++].y = 0;
        }
        for(i = 0;i < 9;++i){
            for(j = 0;j < 9;++j){
                if(i == 0 && j == 0){
                    continue;
                }
                cin >> ch;
                if(ch != '*'){
                    f[i][j] = ch - '0';
                }
                else{
                    g[num].x = i;
                    g[num++].y = j; 
                }
            }
        }
        dfs(0);
        if(tt++){
            count << endl;
        }
        for(i = 0;i < 9;i++){
            for(j = 0;j < 9;j++){
                cout << f[i][j] << " "; 
            }
            cout << f[i][8] << endl;
        }
    }
    return 0;
}

7,数列求值

样例输入1

1
50.50 25.50
10.15

样例输出1

27.85

样例输入2

2
-756.89 52.52
172.22 67.17

样例输出2

-761.49

分析:

数学题,搞懂公式含义,适当进行变形。

#include<stdio.h>
double x[1010];
double C[1010];
int main()
{
    int n;
    scanf("%d",&n);
    double sum = 0,A0,An1;
    scanf("%lf %lf",&A0,&An1);
    x[0] = A0;
    x[1] = 0;
    for(int i = 1;i <= n;++i){
        scanf("%d",&C[i]);
        x[i+1] = 2.0 * x[i] - x[i-1] + 2.0 * C[i];
    }
    double ans = (An1 - x[n+1])/(n+1);
    printf("%.2lf\n",ans);
    return 0;
}

8,封印之门

蒜头君被暗黑军团包围在一座岛上,所有通往近卫军团的路都有暗黑军团把手。幸运的是,小岛上有一扇上古之神打造的封印之门,可以通往近卫军团,传闻至今没有人能解除封印。

封印之门上有一串文字,只包含小写字母,有 k种操作规则,每个规则可以把一个字符变换成另外一个字符。经过任意多次操作以后,最后如果能把封印之门上的文字变换成解开封印之门的文字,封印之门将会开启。

蒜头君战斗力超强,但是不擅计算,请你帮忙蒜头君计算至少需要操作多少次才能解开封印之门。

输入格式

输入第一行一个字符串,长度不大于 1000,只包含小写字母,表示封印之门上的文字。

输入第二行一个字符串,只包含小写字母,保证长度和第一个字符串相等,表示能解开封印之门的文字。

输入第三行一个整数 k(0≤k≤676)。

接下来 kk 行,每行输出两个空格隔开的字符 a, b,表示一次操作能把字符 a 变换成字符 b。

输出格式

如果蒜头君能开启封印之门,输出最少的操作次数。否则输出一行 -1−1。

样例输入

abcd
dddd
3
a b
b c
c d

样例输出

6
#include<iostream>
#include<string>
using namespace std;
const int inf = 0x3fffffff;
int G[30][30];
int main()
{
    for(int i = 0;i < 26;++i){
        for(int j = 0;j <26;++j){
            if(i == j){
                G[i][j] = 0;
            }
            else{
                G[i][j] = inf;
            }
        }
    }
    string s1,s2;
    cin >> s1 >> s2;
    int k;
    cin >> k;
    while(k--){
        char a,b;
        cin >> a >> b;
        if(a != b){
            G[a - 'a'][b - 'a'] = 1;
        }
    }
    for(int k = 0;k < 26;++k){
        for(int i = 0;i < 26;++i){
            for(int j = 0;j < 26;++j){
                G[i][j] = min(G[i][j],G[i][k] + G[k][j]);
            }
        }
    }
    int sum = 0;
    for(int i = 0;i < s1.size();++i){
        if(G[s1[i] - 'a'][s2[i] - 'a'] >= inf){
            sum = -1;
            break;
        }
        else{
            sum += G[s1[i] - 'a'][s2[i] - 'a'];
        }
    }
    cout << sum << endl;
    return 0;
}

9,天上的星星

在一个星光摧残的夜晚,蒜头君一颗一颗的数这天上的星星。

蒜头君给在天上巧妙的画了一个直角坐标系,让所有的星星都分布在第一象。天上有 n 颗星星,他能知道每一颗星星的坐标和亮度。

现在,蒜头君问自己 q 次,每次他问自己每个矩形区域的星星的亮度和是多少(包含边界上的星星)。

输入格式

第一行输入一个整数 n(1≤n≤50000) 表示星星的数量。

接下里 nn 行,每行输入三个整数x,y,w(0≤x,y,w≤2000),表示在坐标 (x,y) 有一颗亮度为 w 的星星。注意一个点可能有多个星星。

接下来一行输入一个整数 q(1≤q≤50000),表示查询的次数。

接下来 q 行,每行输入四个整数 x1​,y1​,x2​,y2​,其中 (x1​,y1​) 表示查询的矩形的左下角的坐标,(x2​,y2​) 表示查询的矩形的右上角的坐标, 20000≤x1​≤x2​≤2000, 20001≤y1​≤y2​≤2000。

输出格式

对于每一次查询,输出一行一个整数,表示查询的矩形区域内的星星的亮度总和。

样例输入

5
5 0 6
7 9 7
8 6 13
9 7 1
3 0 19
4
0 8 7 9
0 0 7 10
2 7 10 9
5 4 7 5

样例输出

7
32
8
0
#include<iostream>
using namespace std;
const int mmax = 2010;
long long sum[mmax][mmax];
int main()
{
    int n;
    cin >> n;
    for(int i = 0;i < n;++i){
        int x,y,w;
        ++x,++y;
        cin >> x >> y >> w;
        sum[x][y] += w;
    }
    for(int i = 1;i < mmax;++i){
        for(int j = 1;i < mmax; ++j){
            sum[i][j] += sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1];
        }
    }
    int q;
    cin >> q;
    while(q--){
        int a,b,c,d;
        cin >> a >> b >> c >> d;
        ++a,++b,++c,++d;
        cout << sum[c][d] - sum[a-1][d] - sum[c][b-1] + sum[a-1][b-1];
    }
    return 0;
}

10,青出于蓝胜于蓝

武当派一共有 n 人,门派内 n 人按照武功高低进行排名,武功最高的人排名第 1,次高的人排名第 2,... 武功最低的人排名第 n。现在我们用武功的排名来给每个人标号,除了祖师爷,每个人都有一个师父,每个人可能有多个徒弟。

我们知道,武当派人才辈出,连祖师爷的武功都只能排行到 p。也就是说徒弟的武功是可能超过师父的,所谓的青出于蓝胜于蓝。

请你帮忙计算每个人的所有子弟(包括徒弟的徒弟,徒弟的徒弟的徒弟....)中,有多少人的武功超过了他自己。

输入格式

输入第一行两个整数 n,p(1≤n≤100000,1≤p≤n)。

接下来 n−1 行,每行输入两个整数 u,v(1≤u,v≤n),表示 u 和 v 之间存在师徒关系。

输出格式

输出一行 n 个整数,第 i 个整数表示武功排行为 i 的人的子弟有多少人超过了他。

行末不要输出多余的空格。

样例输入

10 5
5 3
5 8
3 4
3 1
2 1
6 7
8 7
9 8
8 10

样例输出

0 0 2 0 4 0 1 2 0 0
#include<iostream>
#include<cstring>
using namespace std;
const int mmax = 100010;
struct node{
    int en,next;
}E[2 * mmax];
int p[mmax];
int num;
void init(){
    memset(p,-1,sizeof p);
    num = 0;
}
void add(int st,int en){
    E[num].en = en;
    E[num].next = p[st];
    p[st] = num++;
}
int l[mmax],r[mmax];
int times;
void dfs(int u,int fa){
    l[u] = ++times;
    for(int i = p[u];i+1;i = E[i].next){
        int v = E[i].en;
        if(v != fa){
            dfs(v,u);
        }
    }
    r[u] = times;
}
int n,f;
int C[mmax];
void up(int x,int v){
    for(int i = x;i <= n;i += (i & -i)){
        C[i] += v;
    }
}
int sum(int x){
    int res = 0;
    for(int i = x;i > 0;i -= (i & -i)){
        res += C[i];
    }
    return res;
}

int main(){
    init();
    for(int i = 0;i < n - 1;++i){
        int u,v;
        cin >> u >> v;
        add(u,v);
        add(v,u);
    }
    times = 0;
    dfs(f,-1);
    for(int i = 1;i <= n;++i){
        cout << sum(r[i]) - sum(l[i]) << " \n"[i == n];
        up(l[i],1);
    }
    return 0;
}

注:题解和代码仅供参考,非本人原创。如有更好的想法,欢迎评论~~~

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 2013年第四届蓝桥杯C/C++B组省赛题目解析

    Zoctopus
  • 2014年第五届蓝桥杯C/C++B组省赛题目解析

    Zoctopus
  • 2015年第六届蓝桥杯C/C++B组省赛题目解析

    Zoctopus
  • 剑指Offer-构建乘积数组

    package Array; import sun.security.util.Length; /** * 构建乘积数组 * 给定一个数组A[0,1,....

    武培轩
  • 水果Fruit(母函数) - HDU 2152

    转眼到了收获的季节,由于有TT的专业指导,Lele获得了大丰收。特别是水果,Lele一共种了N种水果,有苹果,梨子,香蕉,西瓜……不但味道好吃,样子更是好看。 ...

    ACM算法日常
  • 「CodeForces - 598B」Queries on a String

    字符串s(1 ≤ |s| ≤ 10 000),有m(1 ≤ m ≤ 300)次操作,每次给l,r,k,代表将r位置插入l位置前,执行k(1 ≤ k ≤ 1 00...

    饶文津
  • 15.瀑布流、测量

    六月的雨
  • 1250 Fibonacci数列

    时间限制: 1 s  空间限制: 128000 KB  题目等级 : 钻石 Diamond 题解  查看运行结果 题目描述 Description 定义:f0=...

    attack
  • 初级程序员面试不靠谱指南(三)

    二、指针的好基友的& 1.&的意义。说&是指针的好基友其实不恰当,因为&这个符号在C/C++不止有一种含义,但是因为其经常会和指针一起出现在被问的问题列表上,所...

    一心一怿
  • PTA 7-1 畅通工程之局部最小花费问题(35 分)

    7-1 畅通工程之局部最小花费问题(35 分) 某地区经过对城镇交通状况的调查,得到现有城镇间快速道路的统计数据,并提出“畅通工程”的目标:使整个地区任何两个城...

    Kindear

扫码关注云+社区

领取腾讯云代金券