计蒜客2018 蓝桥杯省赛 B 组模拟赛（一）

1，结果填空：年龄

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

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

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

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

分析：

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

#include<stdio.h>

int main()

{

    int ans = ;

    for(int i = ;i < ;++i){

        for(int j = ;j < ;++j){

            int a = i / ;

            int b = i % ;

            int c = j / ;

            int d = j % ;

            if(((a+b)* == c* + d)&&((c+d)* == *a + b)){

                ans++;

            }

        }

    }

    printf("%d\n",ans);

    return ;

 }

第一题C

答案为：1。

2，结果填空：开关灯

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

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

#include<stdio.h>

bool f[];

int main()

{

    int ans = ;

    for(int i = ;i <= ;i += ){

        f[i] = !f[i];

    }

    for(int i = ;i <= ;i += ){

        f[i] = !f[i];

    }

    for(int i = ;i <= ;i += ){

        f[i] = !f[i];

    }

    for(int i = ;i <= ;++i){

        if(!f[i]){

            ++ans;

        }

    }

    printf("%d\n",ans);

    return ;

 }

第二题C

答案：571。

3，结果填空：U型数字

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

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

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

分析：

从1到100000枚举每一个数字，然后查看每一个数字，是否符合条件。
从前往后找到一个不递减的位置，然后检查这个位置是否递增到最后。

#include<iostream>

#include<string>

using namespace std;

int main()

{

    int ans = ;

    for(int i = ;i <= ;i++){

        string s = to_string(i);

        bool down = ,up = ;

        int j;

        for(j = ;j < s.size();j++){

            if(s[j-] > s[j]){

                down = ;

            }

            else{

                break;

            }

        }

        if(down && up){

            ans++;

        }

    }

    cout << ans << endl;

    return ;

}

第三题C++

答案：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[], b[];

int max(int a, int b) {

    return a > b ? a : b;

}

int lis(int n) {

    memset(f, , sizeof f);

    int res = ;

    for (int i = ; i < n; ++i) {

        for (int j = ; j < i; ++j) {

            if (b[j] < b[i]) {

                f[i] = max(f[i],f[j]+); //在此处填空

            }

        }

        res = max(res, f[i]);

    }

    return res+;

}

int main() {

    int n;

    scanf("%d", &n);

    for (int i = ; i < n; ++i) {

        scanf("%d", b + i);

    }

    printf("%d\n", lis(n));

    return ;

}

第四题C

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 = ; i < len; ++i) {

        if (!vis[i]) {

            for (j = i + ; j < len; ++j) {

                if (str[i] == str[j] && vis[j]/*在这里填写必要的代码*/) {

                    break;

                }

            }

            if (j == len) {

                vis[i] = ;

                buf[num] = str[i];

                arrange(num + );

                vis[i] = ;

            }

        }

    }

}

int main() {

    while (~scanf("%s", str)) {

        len = strlen(str);

        int i, j;

        for (i = ; i < len; ++i) {

            for (j = i + ; j < len; ++j) {

                if (str[i] > str[j]) {

                    char tmp = str[i];

                    str[i] = str[j];

                    str[j] = tmp;

                }

            }

        }

        total = ;

        buf[len] = '\0';

        arrange();

        printf("Total %d\n", total);

    }

    return ;

}

第五题C

6，数独

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

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

输出这个数独得正解，输出格式如下：

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

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

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

分析：

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

#include<bits/stdc++.h>

using namespace std;

const int N = 1e6 + ;

const int inf = 0x3f3f3f3f;

struct node{

    int x,y;

}g[];

int f[][];

int flag,num;

bool check(int a,int b,int n){

    for(int i=;i<;++i){

        if(f[a][i] == n || f[i][b] == n){

            return false;

        }

    }

    for(int i = a /  * ;i < a /  *  + ;++i){

        for(int j = b /  * ;i < b /  *  + ;++j){

            if(f[i][j] == n){

                return false;

            }

        }

    }

    return true;

}

void dfs(int cnt){

    if(flag){

        return;

    }

    if(cnt == num){

        flag = ;

        return;

    }

    for(int k = ;k <= ;++k){

        if(check(g[cnt].x,g[cnt].y)){

            f[g[cnt].x,g[cnt].y,k] = k;

            dfs(cnt + );

            if(flag == ) return;

            f[g[cnt].x][g[cnt].y] = ;

        }

    }

}

int main()

{

    int i,j,k,n,m,t,tt = ,xx;

    char ch;

    while(cin >> ch){

        memset(f,,sizeof f);

        flag = ,num = ;

        if(ch != '*'){

            f[][] = ch - '';

        }

        else{

            g[num].x = ;

            g[num++].y = ;

        }

        for(i = ;i < ;++i){

            for(j = ;j < ;++j){

                if(i ==  && j == ){

                    continue;

                }

                cin >> ch;

                if(ch != '*'){

                    f[i][j] = ch - '';

                }

                else{

                    g[num].x = i;

                    g[num++].y = j;

                }

            }

        }

        dfs();

        if(tt++){

            count << endl;

        }

        for(i = ;i < ;i++){

            for(j = ;j < ;j++){

                cout << f[i][j] <<　" ";

            }

            cout << f[i][] << endl;

        }

    }

    return ;

}

第六题C++

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[];

double C[];

int main()

{

    int n;

    scanf("%d",&n);

    double sum = ,A0,An1;

    scanf("%lf %lf",&A0,&An1);

    x[] = A0;

    x[] = ;

    for(int i = ;i <= n;++i){

        scanf("%d",&C[i]);

        x[i+] = 2.0 * x[i] - x[i-] + 2.0 * C[i];

    }

    double ans = (An1 - x[n+])/(n+);

    printf("%.2lf\n",ans);

    return ;

}

第七题C

8，封印之门

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

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

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

输入格式

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

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

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

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

输出格式

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

样例输入

abcd

dddd

3

a b

b c

c d

样例输出

#include<iostream>

#include<string>

using namespace std;

const int inf = 0x3fffffff;

int G[][];

int main()

{

    for(int i = ;i < ;++i){

        for(int j = ;j <;++j){

            if(i == j){

                G[i][j] = ;

            }

            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'] = ;

        }

    }

    for(int k = ;k < ;++k){

        for(int i = ;i < ;++i){

            for(int j = ;j < ;++j){

                G[i][j] = min(G[i][j],G[i][k] + G[k][j]);

            }

        }

    }

    int sum = ;

    for(int i = ;i < s1.size();++i){

        if(G[s1[i] - 'a'][s2[i] - 'a'] >= inf){

            sum = -;

            break;

        }

        else{

            sum += G[s1[i] - 'a'][s2[i] - 'a'];

        }

    }

    cout << sum << endl;

    return ;

}

第八题C++

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。

输出格式

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

样例输入

样例输出

#include<iostream>

using namespace std;

const int mmax = ;

long long sum[mmax][mmax];

int main()

{

    int n;

    cin >> n;

    for(int i = ;i < n;++i){

        int x,y,w;

        ++x,++y;

        cin >> x >> y >> w;

        sum[x][y] += w;

    }

    for(int i = ;i < mmax;++i){

        for(int j = ;i < mmax; ++j){

            sum[i][j] += sum[i-][j] + sum[i][j-] - sum[i-][j-];

        }

    }

    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-][d] - sum[c][b-] + sum[a-][b-];

    }

    return ;

}

第九题C++

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 的人的子弟有多少人超过了他。

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

样例输入

样例输出

0 0 2 0 4 0 1 2 0 0

#include<iostream>

#include<cstring>

using namespace std;

const int mmax = ;

struct node{

    int en,next;

}E[ * mmax];

int p[mmax];

int num;

void init(){

    memset(p,-,sizeof p);

    num = ;

}

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+;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 = ;

    for(int i = x;i > ;i -= (i & -i)){

        res += C[i];

    }

    return res;

}

int main(){

    init();

    for(int i = ;i < n - ;++i){

        int u,v;

        cin >> u >> v;

        add(u,v);

        add(v,u);

    }

    times = ;

    dfs(f,-);

    for(int i = ;i <= n;++i){

        cout << sum(r[i]) - sum(l[i]) << " \n"[i == n];

        up(l[i],);

    }

    return ;

}

第十题C++

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