第七届蓝桥杯C/C++程序设计本科B组国赛题解

最新推荐文章于 2023-04-08 16:04:37 发布
最新推荐文章于 2023-04-08 16:04:37 发布
阅读量721 收藏 4
点赞数
分类专栏： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nemaleswang/article/details/80410451
版权

1.一步之遥

题目：

从昏迷中醒来，小明发现自己被关在X星球的废矿车里。
矿车停在平直的废弃的轨道上。
他的面前是两个按钮，分别写着“F”和“B”。
小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。
按F，会前进97米。按B会后退127米。
透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。
他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。
或许，通过多次操作F和B可以办到。
矿车上的动力已经不太足，黄色的警示灯在默默闪烁…
每次进行 F 或 B 操作都会消耗一定的能量。
小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。
请填写为了达成目标，最少需要操作的次数。
注意，需要提交的是一个整数，不要填写任何无关内容（比如：解释说明等）

思路：

我们可以很轻松的想到97*x+127*y = 1，然后x和y取绝对值相加就好了，那么我们有两种写法，第一种是直接枚举所有的步数情况，可以很快的写出来。第二种：我们观察这个式子，因为gcd(97,127)刚好是1，所以用扩展欧几里得算一次就好了

答案是97
法一：

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;

int main(){
    int minn = 2000;
    for(int i = 0;i <= 1000;i++){
        if(i > minn) break;
        for(int j = 0;j <= 1000;j++){
            if(i+j > minn) break;
            if(97*i-127*j < 1) break;
            else if(97*i-127*j == 1) minn = min(minn,i+j);
        }
    }
    cout<<minn<<endl;
}

法二：


#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;
int exgcd(int a,int b,int &x,int &y){//ax+by = gcd(a,b);（1）
    if(b == 0){
        x = 1;y = 0;
        return a;
    }
    int c = exgcd(b,a%b,y,x);//转化为b*x2+(a%b)*y2 = gcd(b,a%b) = gcd(a,b);（2）
    //（2）式与（1）相等，则x = y2,y = x2-[a/b]*y2;迭代回去
    y = y-a/b*x;
    return c;
}

int main(){
    int x,y;
    int ans = exgcd(97,127,x,y);
    cout<<(x)+abs(y)<<endl;
}

2.凑平方数

题目：

把0~9这10个数字，分成多个组，每个组恰好是一个平方数，这是能够办到的。
比如：0, 36, 5948721
再比如：
1098524736
1, 25, 6390784
0, 4, 289, 15376
等等…
注意，0可以作为独立的数字，但不能作为多位数字的开始。
分组时，必须用完所有的数字，不能重复，不能遗漏。
如果不计较小组内数据的先后顺序，请问有多少种不同的分组方案？
注意：需要提交的是一个整数，不要填写多余内容。

思路：

两种方法（推荐第一种），第一种：对0到9这10个数进行全排列，然后dfs，去搜索所有的可能就好了。第二种：枚举所有可能的完全平方数，然后dfs去拼接就好了，不太好写的一种思路

答案是300
法一：

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;

ll a[10] = {0,1,2,3,4,5,6,7,8,9};
ll ans[15],res[15],ANS = 0;
map<string,ll>Hash;

bool check(ll x){
    ll y = sqrt(x);
    if(y*y == x) return true;
    return false;
}

void dfs(ll num,ll now){
    if(num == 10){
        for(ll i = 0;i < now;i++) res[i] = ans[i];
        sort(res,res+now);
        string str = "";
        for(ll i = 0;i < now;i++){
            while(res[i]){
                char mod = (char)(res[i]%10);
                str = str+mod;
                res[i] /= 10;
            }
            str += "*";//分割数组之间每个数，不然Hash判重的时候要出问题
        }
        if(Hash[str] == 0ll)  ANS++,Hash[str]++;
        return ;
    }
    if(a[num] == 0){
        ans[now] = 0;//为0我们就直接加入平方数里面
        dfs(num+1,now+1);
    }
    else{
        ll sum = 0;
        for(ll i = num;i < 10;i++){
            sum = sum*10+a[i];
            if(check(sum)){
                ans[now] = sum;
                dfs(i+1,now+1);
            }
        }
    }
    return ;
}

int main(){
    do{
        memset(ans,0,sizeof(ans));
        dfs(0,0);
    }while(next_permutation(a,a+10));
    printf("%I64d\n",ANS);
}

法二：
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;
const ll maxn = 1e5+10;

ll check[10],square[maxn],cnt,ANS;

bool Judge(string str){
    memset(check,0,sizeof(check));
    for(ll i = 0 ;i < str.size();i++){
        if(check[str[i]-'0'] != 0) return true;
        check[str[i]-'0']++;
    }
    return false;
}

string tostring(ll x){
    string s = "";
    if(x == 0) s += "0";
    while(x){
        char ch = (x%10)+'0';
        s = s+ch;
        x /= 10;
    }
    reverse(s.begin(),s.end());
    return s;
}

void init(){
    cnt = 0;
    for(ll i = 0;i < 100000;i++){
        ll ans = i*i;
        ll res = ans;
        ll flag = 0;
        memset(check,0,sizeof(check));
        while(res){
            if(check[res%10] != 0) {flag = 1;break;}
            check[res%10]++;
            res /= 10;
        }
        if(!flag) square[cnt++] = ans;
    }
}

void dfs(ll num,string str){
    if(str.size() > 10||Judge(str)) return ;
    if(str.size() == 10&&!Judge(str)){
        ANS++;
        return ;
    }
    for(ll i = num;i < cnt;i++) dfs(i+1,str+tostring(square[i]));
    return ;
}

int main(){
    ANS = 0;
    init();
    dfs(0,"");
    cout<<ANS<<endl;
}

3.棋子换位

题目：

有n个棋子A，n个棋子B，在棋盘上排成一行。
它们中间隔着一个空位，用“.”表示，比如：
AAA.BBB
现在需要所有的A棋子和B棋子交换位置。
移动棋子的规则是：
1. A棋子只能往右边移动，B棋子只能往左边移动。
2. 每个棋子可以移动到相邻的空位。
3. 每个棋子可以跳过相异的一个棋子落入空位（A跳过B或者B跳过A）。
AAA.BBB 可以走法：
移动A ==> AA.ABBB
移动B ==> AAAB.BB
跳走的例子：
AA.ABBB ==> AABA.BB
以下的程序完成了AB换位的功能，请仔细阅读分析源码，填写划线部分缺失的内容。

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

void move(char* data, int from, int to)
{
    data[to] = data[from];
    data[from] = '.';
}

int valid(char* data, int k)
{
    if(k<0 || k>=strlen(data)) return 0;
    return 1;
}

void f(char* data)
{
    int i;
    int tag;
    int dd = 0; // 移动方向

    while(1){
        tag = 0;
        for(i=0; i<strlen(data); i++){
            if(data[i]=='.') continue;
            if(data[i]=='A') dd = 1;
            if(data[i]=='B') dd = -1;

            if(valid(data, i+dd) && valid(data,i+dd+dd) 
            && data[i+dd]!=data[i] && data[i+dd+dd]=='.'){ 
            //如果能跳... 
                move(data, i, i+dd+dd);
                printf("%s\n", data);
                tag = 1;
                break;
            }
        }

        if(tag) continue;

        for(i=0; i<strlen(data); i++){
            if(data[i]=='.') continue;
            if(data[i]=='A') dd = 1;
            if(data[i]=='B') dd = -1;           

            if(valid(data, i+dd) && data[i+dd]=='.'){ 
            // 如果能移动...
                if( ______________________ ) continue;  //填空位置 
                move(data, i, i+dd);
                printf("%s\n", data);
                tag = 1;
                break;
            }
        }

        if(tag==0) break;                   
    }
}

int main()
{
    char data[] = "AAA.BBB";    
    f(data);
    return 0;
}
思路：

我们可以先注释掉题目中的需要填空的判断条件，然后我们直接输出可以发现输出以下情况：
移动：AA.ABBB
跳跃：AABA.BB
移动：AAB.ABB
跳跃：A.BAABB
移动：.ABAABB
跳跃：BA.AABB
移动：B.AAABB
我们可以发现的是程序卡死了，没有达到我们想要的结果，我们手动处理一下正确的顺序可以发现问题就处在第二步，在A和B都可以往点里面跳的时候不应该跳A，而应该跳B，，而其他所有的情况都是只有一种走法或者跳法，所以问题就是A.B这种情况的处理，而这种情况是固定的，那么他一定跟他们旁边的字母有关系，然后我们可以构造一些例子，然后发现是这个看移动A还是B主要看去掉A或者B与点然后看剩下的点两边是不是相同，若果相同就不行，因为相同就导致是我们分割了相同的字母在两端，但是我们的目的是把所有的相同的字母放到一端，所以答案就是判断这一东西就好了

答案是：valid(data, i+dd+dd)&&valid(data, i-dd)&&data[i+dd+dd] == data[i-dd]
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;

void move(char* data, int from, int to)
{
    data[to] = data[from];
    data[from] = '.';
}

int valid(char* data, int k)
{
    if(k<0 || k>=strlen(data)) return 0;
    return 1;
}

void f(char* data)
{
    int i;
    int tag;
    int dd = 0; // 移动方向

    while(1){
        tag = 0;
        for(i=0; i<strlen(data); i++){
            if(data[i]=='.') continue;
            if(data[i]=='A') dd = 1;
            if(data[i]=='B') dd = -1;

            if(valid(data, i+dd) && valid(data,i+dd+dd)
            && data[i+dd]!=data[i] && data[i+dd+dd]=='.'){
            //如果能跳...
                move(data, i, i+dd+dd);
                printf("跳跃：");
                printf("%s\n", data);
                tag = 1;
                break;
            }
        }

        if(tag) continue;

        for(i=0; i<strlen(data); i++){
            if(data[i]=='.') continue;
            if(data[i]=='A') dd = 1;
            if(data[i]=='B') dd = -1;

            if(valid(data, i+dd) && data[i+dd]=='.'){
            // 如果能移动...
                if(valid(data, i+dd+dd)&&valid(data, i-dd)&&data[i+dd+dd] == data[i-dd]) continue;  //填空位置
                move(data, i, i+dd);
                printf("移动：");
                printf("%s\n", data);
                tag = 1;
                break;
            }
        }

        if(tag==0) break;
    }
}

int main()
{
    char data[] = "AAA.BBB";
    f(data);
    return 0;
}

4.机器人塔

题目：

X星球的机器人表演拉拉队有两种服装，A和B。
他们这次表演的是搭机器人塔。
类似：
    A
   B B
  A B A
 A A B B
 B B B A B
A B A B B A
队内的组塔规则是：
A 只能站在 AA 或 BB 的肩上。
B 只能站在 AB 或 BA 的肩上。
你的任务是帮助拉拉队计算一下，在给定A与B的人数时，可以组成多少种花样的塔。
输入一行两个整数 M 和 N，空格分开（0 < M,N < 500,分别表示A、B的人数，保证人数合理性。
要求输出一个整数，表示可以产生的花样种数。
例如：
用户输入：
1 2
程序应该输出：
3
再例如：
用户输入：
3 3
程序应该输出：
4
第一行包含一个整数N。
以下N行每行两个整数a和b，表示a和b之间有一条数据链接相连。
对于30%的数据，1 <= N <= 1000
对于100%的数据, 1 <= N <= 100000， 1 <= a, b <= N
输入保证合法。
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

思路：

这题实在不太好做，首先我们可以想到的解法是dfs枚举最下面一层，然后迭代上去，但是最多可以有44层，时间复杂度2^n，显然不可取，那么我们可以去优化的是根本不用枚举完就可以剪很多的枝，我们只要有第n层的第1个和第2个数，那么第n-1层的第1个数就有了，如果第n层有3个数，那么第n-1层的第2个数就有了，第n-2层的第1个数也有了，那么我们边枚举边合并状态，这样的做法复杂度在n*n*2^n左右，不过在合并状态的时候可以剪掉很多枝，实际上的复杂度可能是更小的，不过这样写的写法更加的复杂，而且经过代码测试，合并的时候进行转移并不能优化太多，dfs解法遂基本不可实现，正解可能是dp一类的东西，但是没找到题解，所以没办法，放一份暴力的dfs和合并优化（实际并没卵用）的dfs吧，大概跑20层是没问题的

朴素dfs：

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;

int n,m,ceng,dp[50][50],ANS = 0;

void dfs(int num,int x,int cntA,int cntB){
    dp[ceng][num] = x;
    if(x == 0) cntA--;
    else cntB--;
    if(cntA < 0||cntB < 0) return ;
    if(num == ceng){
        for(int i = ceng-1;i >= 1;i--){
            for(int j = 1;j <= i;j++){
                if(cntA < 0||cntB < 0) return ;
                if(dp[i+1][j] == dp[i+1][j+1]) dp[i][j] = 0,cntA--;
                else dp[i][j] = 1,cntB--;
            }
        }
        if(cntA == 0&&cntB == 0) ANS++;
        return ;
    }
    dfs(num+1,0,cntA,cntB);
    dfs(num+1,1,cntA,cntB);
    return ;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= 44;i++){
        if(i*(i+1) == 2*(n+m)) {ceng = i;break;}
    }
    dfs(1,0,n,m);
    dfs(1,1,n,m);
    printf("%d\n",ANS);
}

合并优化的dfs：
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;

int n,m,ceng,dp[50][50],ANS = 0;

void dfs(int num,int x,int cntA,int cntB){
    dp[ceng][num] = x;
    if(x == 0) cntA--;
    else cntB--;
    if(cntA < 0||cntB < 0) return ;
    for(int i = ceng-1;i >= ceng-num+1;i--){
        for(int j = num-(ceng-i);j <= num-(ceng-i);j++){
            if(cntA < 0||cntB < 0) return ;
            if(dp[i+1][j] == dp[i+1][j+1]) dp[i][j] = 0,cntA--;
            else dp[i][j] = 1,cntB--;
        }
    }
    if(num == ceng){
        if(cntA == 0&&cntB == 0) ANS++;
        return ;
    }
    dfs(num+1,0,cntA,cntB);
    dfs(num+1,1,cntA,cntB);
    return ;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= 44;i++){
        if(i*(i+1) == 2*(n+m)) {ceng = i;break;}
    }
    dfs(1,0,n,m);
    dfs(1,1,n,m);
    printf("%d\n",ANS);
}

5.广场舞

题目：

LQ市的市民广场是一个多边形，广场上铺满了大理石的地板砖。
地板砖铺得方方正正，就像坐标轴纸一样。
以某四块砖相接的点为原点，地板砖的两条边为两个正方向，一块砖的边长为横纵坐标的单位长度，则所有横纵坐标都为整数的点都是四块砖的交点（如果在广场内）。
广场的砖单调无趣，却给跳广场舞的市民们提供了绝佳的参照物。每天傍晚，都会有大批市民前来跳舞。
舞者每次都会选一块完整的砖来跳舞，两个人不会选择同一块砖，如果一块砖在广场边上导致缺角或者边不完整，则没人会选这块砖。
（广场形状的例子参考【图1.png】）
这里写图片描述
现在，告诉你广场的形状，请帮LQ市的市长计算一下，同一时刻最多有多少市民可以在广场跳舞。
【输入格式】
输入的第一行包含一个整数n，表示广场是n边形的（因此有n个顶点）。
接下来n行，每行两个整数，依次表示n边形每个顶点的坐标（也就是说广场边缘拐弯的地方都在砖的顶角上。数据保证广场是一个简单多边形。
【输出格式】
输出一个整数，表示最多有多少市民可以在广场跳舞。
【样例输入】
5
3 3
6 4
4 1
1 -1
0 4
【样例输出】
7
【样例说明】
广场如图1.png所示，一共有7块完整的地板砖，因此最多能有7位市民一起跳舞。
【数据规模与约定】
对于30%的数据，n不超过100，横纵坐标的绝对值均不超过100。
对于50%的数据，n不超过1000，横纵坐标的绝对值均不超过1000。
对于100%的数据，n不超过1000，横纵坐标的绝对值均不超过100000000（一亿）。
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

思路：

计算几何不让带板子是真的恶心（这套题说实话全程恶心，还是第八届的题目质量好点）。
  两种做法，第一种是找点在多边形内部，然后如果他的右边，下边，右下4个点都在多边形内部，那么这一块就在多边形里面，但是这种做法碰到“凹”这种图形就会出问题，而且判断点在多边形内还要算直线与线段交点个数（这里不给代码了，大部分都是这种做法，百度可以找到的）
  第二种，我们可以想到用扫描线做50%的数据，100%的数据扫描线是不行的，O（n）的扫描线扫过去就1e9了，以下思路来自蓝桥杯 广场舞
1: 定义点、线结构体，录入点（前提是点是有序录入 顺时针或者逆时针），然后两点构成一条线，n个点n条线
2：算出最左、最右的横坐标值 minx maxx
3：当x = minx+1
（1）遍历每一条线，如果这条线与x = minx+1这条线有交点，就把交点处的纵坐标算出，并用一个数组buf记录这条线还有纵坐标
（2）对buf数组进行排序，以记录的纵坐标的大小进行从小到大的排序；
（3）对于排完序的buf数组，下标为0对应的线和下标为1对应的线在minx到minx+1之间所构成的封闭的空间是属于区域内部的；下标为1与下标为2所构成的空间属于外部；2-3是内部 以此类推
（4）针对于buf[0] 我们需要求出线在x=minx处的纵坐标(并向上取整)y11，x = minx+1处的纵坐标为（向上取整）y12
y1 = max(y11,y12);
对于buf[1],我们在求x = minx 和 x = minx+1 处的纵坐标时向下取整
y2 = min(y21,y22);
if(y2-y1>0){
sum += y2-y1;
}
4：x= x+1;循环第三步
5：在做的时候，考虑到又可能有两条线 与x = i这条线交于一点（i，y）
在排序的时候有可能导致这两条线的位置互换，从而得出错误答案
我们记录线在x = i-0.5处的纵坐标，这样纵坐标就不会重复了（纵坐标的值关系到线的位置）
然后我们就可以用这个思路写扫描线做法了（说实话，麻烦死了）

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;

struct Point{//点结构体 
    int x,y;
}P[1005];

struct Line{//线段结构体，每个线段有两个端点 
    Point a,b; 
}L[1010];

struct I_Y{//线的下标，以及对应的纵坐标，方便排序 
    int index;
    double y;
}ans[1010];

int N,sum = 0;

bool cmp(I_Y a,I_Y b){//按y坐标 排序，方便直接从下到上算个数 
    return a.y < b.y;
}

double F_y(Line l,double x){//求直线l在横坐标x的纵坐标y，利用相似三角形算 
    double x1 = fabs(l.b.x-l.a.x);
    double y1 = fabs(l.b.y-l.a.y);
    double k = y1/x1;
    double x2 = fabs(x-l.a.x);
    double y = k*x2+l.a.y;
    return y;
}

void solve(){
    int minx,maxx,i,j,k,count,ax,bx;
    minx = P[0].x;
    maxx = P[0].x;
    for(i = 0;i < N;i++){//找最大最小的x坐标，做扫描线 
        if(P[i].x > maxx) maxx = P[i].x;
        if(P[i].x < minx) minx = P[i].x;
    }
    for(i = minx+1;i <= maxx;i++){//开始用平行y轴的线进行扫描所有的线段 
        count = 0;
        for(j = 0;j < N;j++){//扫描所有的线段 
            ax = L[j].a.x;
            bx = L[j].b.x;
            if((ax <= i-1&&bx >= i)||(ax >= i&&bx <= i-1)){//如果扫描线和线段相交
                ans[count].index = j;
                ans[count].y = F_y(L[j],(i+i-1)/2.0);
                count++;
            }
        }
        sort(ans,ans+count,cmp);
        for(k = 0;k < count/2;k++){
            int y1 = max((int)ceil(F_y(L[ans[k*2].index],i)),(int)ceil(F_y(L[ans[k*2].index],i-1)));
            int y2 = min((int)floor(F_y(L[ans[k*2+1].index],i)),(int)floor(F_y(L[ans[k*2+1].index],i-1)));
            if(y2-y1 > 0) sum += y2-y1;
        }
    }
    printf("%d\n",sum);
}

int main(){
    int x,y;
    scanf("%d",&N);
    for(int i = 0;i < N;i++){
        scanf("%d%d",&x,&y);
        P[i].x = x;
        P[i].y = y;
    }
    L[0].a = P[0];
    L[0].b = P[N-1];
    for(int i = 1;i < N;i++){
        L[i].a = P[i];
        L[i].b = P[i-1];
    }
    solve();
    return 0;
}

6.生成树计数

题目：

给定一个 n*m 的格点图，包含 n 行 m 列共 n*m 个顶点，相邻的顶点之间有一条边。
【图1.png】给出了一个3*4的格点图的例子。
这里写图片描述
如果在图中删除部分顶点和其相邻的边，如上图删除第2行第3列和第3行第1列的顶点后，如【图2.png】所示。
这里写图片描述
图的生成树指包含图中的所有顶点和其中的一部分边，使得任意两个顶点之间都有由边构成的唯一路径。如果两个生成树包含有不同的边即被认为不同，则上图中共有31种不同的生成树，其中a边不选有10种，a边选有21种。
给出格点图中保留的顶点的信息，请计算该图一共有多少种不同的生成树。
【输入格式】
输入的第一行包含两个整数n, m，用空格分隔，表示格点图的行数和列数。
接下来n行，每行m个字母（中间没有分隔字符），每个字母必然是大写E或大写N，E表示对应的顶点存在，N表示对应的顶点不存在。保证存在至少一个顶点。
【输出格式】
输出一行，包含一个整数，表示生成树的个数。答案可能很大，你只需要计算答案除以1000000007的余数即可。
【样例输入】
3 4
EEEE
EENE
NEEE
【样例输出】
31
【数据规模与约定】
对于10%的数据，1<=n<=2。
对于30%的数据，1<=n<=3。
对于40%的数据，1<=n<=4。
对于50%的数据，1<=n<=5。
另有20%的数据，1<=n*m<=12。
另有10%的数据，1<=m<=15。
对于100%的数据，1<=n<=6，1<=m<=100000。
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 4500ms

思路：

又是这种傻逼题，考生成树计数然后不让带板子，这蓝桥杯真的有问题，要么就不考板子题，要么就让带模板啊，构造图，然后生成树计数就好了（网上扒了份生成树计数的模板），测了样例，没造数据，错误的概率为99%，参考就好

#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
typedef long long ll;

struct edge
{
    int u, v, w, x;
    inline bool operator< (const edge &rhs) const
    {
        return x < rhs.x;
    }
}e[100005];
struct count
{
    int l, r, use;
}g[100005];
int N, M, n, m, fa[50005], siz[50005];

int getfa(int x)
{
    return fa[x] == x ? x : getfa(fa[x]);
}

void link(int u, int v)
{
    if(siz[u] > siz[v]) fa[v] = u, siz[u] += siz[v];
    else fa[u] = v, siz[v] += siz[u];
}

bool Kruskal()
{
    int cnt = 0, u, v;
    for(int i = 1; i <= m; ++i)
    {
        u = getfa(e[i].u), v = getfa(e[i].v);
        if(u != v)
        {
            link(u, v);
            ++g[e[i].w].use;
            if(++cnt == n - 1) return true;
        }
    }
    return false;
}

int DFS(int w, int i, int k)
{
    if(k == g[w].use) return 1;
    if(i > g[w].r) return 0;
    int ans = 0, u = getfa(e[i].u), v = getfa(e[i].v);
    if(u != v)
    {
        link(u, v);
        ans = DFS(w, i + 1, k + 1);
        fa[u] = u, fa[v] = v;
    }
    return ans + DFS(w, i + 1, k);
}

int main()
{
    int u, v, w, ans;
    char mp[20][20];
    int bian[20][20],BI = 0;
    cin >> N >> M;
    for(int i = 1; i <= N; ++i){
        for(int j = 1; j <= M; ++j){
            cin>>mp[i][j];
            if(mp[i][j] == 'E') BI++,bian[i][j] = BI;
        }
    }
    n = BI;m = 0;
    for(int i = 1; i <= N; ++i){
        for(int j = 1; j <= M; ++j){
            if(mp[i][j] == 'E'){
                if(i-1 >= 1&&mp[i-1][j] == 'E') {
                    m++,e[m] = (edge){bian[i][j], bian[i-1][j], 0, 1};
                }
                if(j-1 >= 1&&mp[i][j-1] == 'E') {
                    m++,e[m] = (edge){bian[i][j], bian[i][j-1], 0, 1};
                }
            }
        }
    }

    for(int i = 1; i <= n; ++i)
        fa[i] = i, siz[i] = 1;
    sort(e + 1, e + m + 1);
    w = 0;
    for(int i = 1; i <= m; ++i)
        if(e[i].x == e[i - 1].x) e[i].w = w;
        else
        {
            g[w].r = i - 1;
            e[i].w = ++w;
            g[w].l = i;
        }
    g[w].r = m;
    ans = Kruskal();
    for(int i = 1; i <= n; ++i)
        fa[i] = i, siz[i] = 1;
    for(int i = 1; i <= w; ++i)
    {
        ans = ans * DFS(i, g[i].l, 0) % 1000000007;
        for(int j = g[i].l; j <= g[i].r; ++j)
        {
            u = getfa(e[j].u), v = getfa(e[j].v);
            if(u != v) link(u, v);
        }
    }
    cout << ans << endl;
    return 0;
}
Nemaleswang
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2016年第七届蓝桥杯C/C++程序设计本科B组省赛 快速排序(代码填空)
A place to record sth.
03-21 8769
快速排序 排序在各种场合经常被用到。 快速排序是十分常用的高效率的算法。 其思想是：先选一个“标尺”， 用它把整个队列过一遍筛子， 以保证：其左边的元素都不大于它，其右边的元素都不小于它。 这样，排序问题就被分割为两个子区间。 再分别对子区间排序就可以了。 下面的代码是一种实现，请分析并填写划线部分缺少的代码。 #include void swap(int
蓝桥杯部分进阶题目题解，c/c++程序设计赛道
最新发布
07-17
一些蓝桥杯C语言题目的刷题记录，可供参考。
蓝桥杯第七届C/C++ B组
lihao1875699404的博客
10-12 194
1 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 思路 简单题，不说了 题解 #include<iostream> using namespace std; int main(){ int dp[1000]; dp[1] = 1; dp[2] = 3;
第七届蓝桥杯软件类c/c++B组国赛
codeswarrior的博客
05-21 400
一步之遥从昏迷中醒来，小明发现自己被关在X星球的废矿车里。矿车停在平直的废弃的轨道上。他的面前是两个按钮，分别写着“F”和“B”。小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。按F，会前进97米。按B会后退127米。透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。或许，通过多次操作F和B可以办到。矿车上的动力已经不...
第十四届蓝桥杯C/C++程序设计大学B组（参赛经历总结）
VLOKL的博客
04-08 8205
第十四届蓝桥杯C/C++程序设计大学B组（参赛经历总结）
2016 第七届蓝桥杯 c/c++ B组省赛真题及解题报告
aodiyi6351的博客
07-23 134
2016 第七届蓝桥杯 c/c++ B组省赛真题及解题报告 勘误1：第6题第4个 if最后一个条件粗心写错了，答案应为1580。条件应为abs(a[3]-a[7])!=1,宝宝心理苦啊。！感谢zzh童鞋的提醒。 勘误2：第7题在推断连通的时候条件写错了，后两个if条件中是应该是<=12 落了一个等于号。正确答案应为116。 1.煤球数目 有...
第14届蓝桥杯省赛、国赛(B).pdf
06-07
* 第十四届蓝桥杯国赛C++中高级组题目：该题目考查了C++编程语言的高级知识，包括指针、类、模板等。 蓝桥杯比赛旨在提高青少年的编程能力和兴趣，涵盖了编程语言、编程概念、算法、数学概念等多方面的知识点。
蓝桥杯2015-2019软件C/C++/JAVA/G/A/B/C组省赛国赛真题+评测数据+解析
07-29
自2015年以来，该赛事已经连续多年举办，涵盖了C/C++、JAVA、G（图形化编程）、A（初中组）、B（高中组）、C（大学组）等多个级别的比赛。这些竞赛分为省赛和国赛，难度逐级递增，为参赛者提供了丰富的学习和挑战...
第十届蓝桥杯省赛B组C语言.rar
02-22
蓝桥杯比赛中的C/C++省赛B组通常会涉及字符串处理、文件操作、位运算等进阶话题，这些都是C语言的特色和优势所在。字符串处理包括字符串的查找、替换、比较等操作，文件操作则涉及到文件的读写、文件流的使用，位...
2021年第十二届蓝桥杯省赛大学A组题解C/C++代码
12-14
蓝桥杯省赛大学A组题解C/C++代码 本资源提供了2021年蓝桥杯省赛大学A组的题解，包括卡片、直线和货物摆放三个问题的解决方案。通过对每个问题的分析和代码实现，展示了枚举、十进制拆分、浮点数判等知识点的应用。 ...
交换瓶子-第七届蓝桥杯c/c++B组
mjj1024的博客
03-25 453
交换瓶子有N个瓶子，编号 1 ~ N，放在架子上。比如有5个瓶子：2 1 3 5 4要求每次拿起2个瓶子，交换它们的位置。经过若干次后，使得瓶子的序号为：1 2 3 4 5对于这么简单的情况，显然，至少需要交换2次就可以复位。如果瓶子更多呢？你可以通过编程来解决。输入格式为两行：第一行: 一个正整数N（N&lt;10000）, 表示瓶子的数目第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。...
【蓝桥杯】第七届蓝桥杯C/C++省赛B组
小二笙的博客
03-19 340
1.煤球数目 有一堆煤球，堆成三角棱锥形。 具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 水题：171700 #include <iostream> using namespa...
第七届蓝桥杯C/C++ B组
欢迎来到小丁的技术空间
03-25 467
这里写我会写的～ 第一题：煤球数目 第二题：生日蜡烛 第三题：凑算式 第四题：快速排序 第五题：抽签 第六题：方格填数 第七题：剪邮票（不会判断是否联通） 第八题：四平方和 第九题：交换瓶子 第十题：最大比例（看不懂！）
校第十二届软件设计大赛（C/C++）题解
枯木何日可逢春
01-01 906
题目： 有 n 个人，他们的编号为 1~n，其中有一些人相互认识，现在 x 想要认识 y，可以通过他所认识的人来认识更多的人（如果 a 认识 b，b 认识 c，那么 a 可以通过 b 来认识 c）,求出 x 最少需要通过多少人才能认识 y。 输入： 第 1 行的三个数是 n、x、y ：n 的取值在 2~100 之间；输入第一行后面的是 nxn 的矩阵 M，M[i][j]=1 表示 i认识 j，M[i][j]=0 表示不认识。保证 i=j 时， M[i][j]=0，并且 M[i][j]= M[j][i]。 输
蓝桥杯--2016第七届C/C++B组省赛
小胡同的诗
03-07 195
重点依旧是搜索，压轴的题相比前一年减少了。不过数论和思维的部分不好搞 煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， .... 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 水题，打表，审题…是所...
2016年第七届蓝桥杯C/C++ C组国赛 —— 第二题：反幻方
Alex
05-13 552
反幻方 我国古籍很早就记载着 2 9 4 7 5 3 6 1 8 这是一个三阶幻方。每行每列以及对角线上的数字相加都相等。 下面考虑一个相反的问题。 可不可以用 1~9 的数字填入九宫格。 使得：每行每列每个对角线上的数字和都互不相等呢？ 这应该能做到。 比如： 9 1 2 8 4 3 7 5 6 你的任务是搜索所有的三阶反幻方。并统计出一共有多少种。 旋转或镜像算同一种。 比如： 9 1 2 8...
2016第七届蓝桥杯省赛c/c++ B组
hopyGreat的博客
03-30 548
第一题 ：煤球数目题目叙述： 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …. 如果一共有100层，共有多少个煤球？请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。答案：171700规律比较好找，每层煤球的个数是（1+2+ ... + n） 也就是 （n...
2016年第七届蓝桥杯C/C++程序设计本科B组省赛-凑算式
04-10 720
凑算式 如图，这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。 比如： 6+8/3+952/714 就是一种解法， 5+3/1+972/486 是另一种解法。 这个算式一共有多少种解法？ 思路：暴力解决，注意每个字母代表的数字不相等。 答案：29 注意：必须是整除的结果！！！ #include #i
第七届蓝桥杯省赛C/C++大学B组真题解析
1900的博客
03-08 4895
写在前边 第八届解析 第九届解析 （题解都是 个人做法 不保证100分 因为没地方交题 若有不对 欢迎指正） 知识点概括 第一题 煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …. 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该...
十三届蓝桥杯国赛题解
02-15
很抱歉，我无法提供十三届蓝桥杯国赛题解的具体内容。蓝桥杯是中国最具影响力的计算机科学竞赛之一，每年都会吸引大量的参赛者。为了公平竞赛和保护知识产权，蓝桥杯的题目和解答是保密的，只有参赛者在比赛期间才能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值