答案解析——蓝桥杯2016年省赛大学B组真题 C/C++

最新推荐文章于 2024-04-13 17:02:26 发布
最新推荐文章于 2024-04-13 17:02:26 发布
阅读量294 收藏 2
点赞数
分类专栏： 算法竞赛 文章标签： 蓝桥杯 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liwo4418/article/details/125493413
版权
本文概述了十道涉及数论、算法和编程的题目，包括煤球数目的计算、等差数列应用、算式凑合法、快速排序、抽签组合、方格填数策略、邮票连通性、四平方和表示、瓶子交换次数和最大比例推算。博主分享了解题思路和代码片段，展示了信息技术领域中的关键知识点和编程技巧。
摘要由CSDN通过智能技术生成

煤球数目 T-1 (分值：3)

题目：煤球数目

有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）, 第三层6个（排列成三角形）, 第四层10个（排列成三角形）, .... 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

1        *        (1)
2       ***        (3)
3     ******    (6)
4   **********  (10)
5 ..............(15)
————————————————————————————————————————————————————————————*
/**
​
 * pre 定义上一层
​
 * plus 定义增量差值 */
#include <iostream>
using namespace std;
int main(int argc, char const* argv[])
{
    int pre = 1; //
    int plus = 2; //
    long sum = 1;
    for (int k = 2; k <= 100; ++k)
    {
        sum += (pre + plus);
        pre = pre + plus;//sum+=pre
        plus++;
    }
    cout << sum << endl;
​
    return 0;
}
//结果：171700

生日蜡烛 T-2 (分值：5)

某君从某年开始每年都举办一次生日party， 并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一共吹熄了236根蜡烛。 请问，他从多少岁开始过生日party的？ 请填写他开始过生日party的年龄数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

#include <iostream>
​
using namespace std;
​
int main()
{
    int begin_candle = 0;
​
    while (true)
    {
        begin_candle++;
        int sum = 0, age = begin_candle;
        while (age <= 100)
        {
            sum += age;
            age++;
            if (sum == 236)
            {
                cout << "开始吹蜡烛年龄: " << begin_candle << endl;
                cout << "现在年龄: " << age << endl;
                return 0;
            }
        }
    }
​
    return 0;
}
​

凑算式 T-3 (分值：11)

题目：凑算式

     B      DEF
A + --- + ------- = 10
     C      GHI

（如果显示有问题，可以参见【图1.jpg】） 这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。 比如： 6+8/3+952/714就是一种解法， 5+3/1+972/486 是另一种解法。 这个算式一共有多少种解法？ 注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

#include <iostream>
#include <algorithm>
using namespace std;
int AL[] = { 1,2,3,4,5,6,7,8,9 };
int ans = 0;
void check_Ans() {//检查答案是否正确 
    int D_F = AL[3] * 100 + AL[4] * 10 + AL[5];
    int G_I = AL[6] * 100 + AL[7] * 10 + AL[8];
    int P_S = AL[1] * G_I + AL[2] * D_F; //通分后分子 
    int P_P = AL[2] * G_I; //通分后分母 
    //必须满足（B*GHI+C*DEF)%(C*GHI）能除尽 并且 满足公式要求 
    if (P_S % P_P == 0 && (AL[0] + P_S / P_P) == 10)
        ans++;
}
int main()
{
    //AL全排列后匹配答案
    while (next_permutation(AL, AL + 9)) 
        check_Ans();
    cout << ans << endl;
    return 0;
}

快速排序 T-4 (分值：9)

排序在各种场合经常被用到。 快速排序是十分常用的高效率的算法。 其思想是：先选一个“标尺”， 用它把整个队列过一遍筛子， 以保证：其左边的元素都不大于它，其右边的元素都不小于它。 这样，排序问题就被分割为两个子区间。 再分别对子区间排序就可以了。

下面的代码是一种实现，请分析并填写划线部分缺少的代码。

#include <stdio.h>
​
void swap(int a[], int i, int j)//交换
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}
​
int partition(int a[], int p, int r)
{
    int i = p; //i指向大于x  ——>找大
    int j = r + 1; //j指向小于等于x ——>找小
    int x = a[p];
    while (1) {
        while (i < r && a[++i] < x);
        while (a[--j] > x);
        if (i >= j) break;
        swap(a, i, j);
    }
    /*代码填空处
    swap(a,p,j) ; //
    ______________________; */
    swap(a, p, j);
    return j;
}
​
void quicksort(int a[], int p, int r)
{
    if (p < r) {
        int q = partition(a, p, r); //q为标尺
        quicksort(a, p, q - 1);
        quicksort(a, q + 1, r);
    }
}
​
int main()
{
    int i;
    int a[] = { 5,13,6,24,2,8,19,27,6,12,1,17 };
    int N = 12;
​
    quicksort(a, 0, N - 1); //排序
​
    for (i = 0; i < N; i++)
        printf("%d ", a[i]);
    printf("\n");
​
    return 0;
}

抽签 T-5 (分值：13)

X星球要派出一个5人组成的观察团前往W星。 其中： A国最多可以派出4人。 B国最多可以派出2人。 C国最多可以派出2人。 ....

那么最终派往W星的观察团会有多少种国别的不同组合呢？

下面的程序解决了这个问题。 数组a[] 中既是每个国家可以派出的最多的名额。 程序执行结果为：

DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
....
(以下省略，总共101行)
//递归填空
#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024
/**
 * k = 数组的下标
 * m代表人数，初始为5
 * b缓冲字符串
 */
int ans = 0;
​
void f(int a[], int k, int m, char b[])
{
    int i, j;
​
    if (k == N) {
        b[M] = 0; //字符串结尾的标志
        if (m == 0) { printf("%s\n", b); ans++; }
        return;
    }
    //递归
    for (i = 0; i <= a[k]; i++) { //试着将k国家，排除i人
        for (j = 0; j < i; j++) b[M - m + j] = k + 'A'; //填充buf，有i人就填i个国家符号(k+'A')
        /*代码填空处
        f(a,k+1,m-i,b) ;
        ______________________;  */
        f(a, k + 1, m - i, b);
    }
}
int main()
{
    int  a[N] = { 4,2,2,1,1,3 };
    char b[BUF];
    f(a, 0, M, b);
    printf("%d\n", ans);
    return 0;
}

方格填数 T-6 (分值：19) 没理解，再看看

如下的10个格子

   +--+--+--+
   |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |
+--+--+--+

（如果显示有问题，也可以参看【图1.jpg】） 填入0~9的数字。要求：连续的两个数字不能相邻。 （左右、上下、对角都算相邻） 一共有多少种可能的填数方案？

请填写表示方案数目的整数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int map[6][6];
int ans = 0;
int Abs(int i, int j)//判断 8个方向 
{
	if (abs(map[i - 1][j] - map[i][j]) == 1)
		return 0;
	if (abs(map[i + 1][j] - map[i][j]) == 1)
		return 0;
	if (abs(map[i][j + 1] - map[i][j]) == 1)
		return 0;
	if (abs(map[i][j - 1] - map[i][j]) == 1)
		return 0;
	if (abs(map[i - 1][j - 1] - map[i][j]) == 1)
		return 0;
	if (abs(map[i + 1][j - 1] - map[i][j]) == 1)
		return 0;
	if (abs(map[i - 1][j + 1] - map[i][j]) == 1)
		return 0;
	if (abs(map[i + 1][j + 1] - map[i][j]) == 1)
		return 0;
	return 1;
}
int f()//判断相邻的数是否连续 
{
	if (Abs(1, 3) && Abs(2, 1) && Abs(2, 2) && Abs(2, 3) && Abs(2, 4) && Abs(3, 2))
		return 1;
	return 0;
}
int main()
{
	memset(map, -2, sizeof(map));
	int  a[] = { 0,1,2,3,4,5,6,7,8,9 };
	do {
		map[1][2] = a[0];
		map[1][3] = a[1];
		map[1][4] = a[2];
		map[2][1] = a[3];
		map[2][2] = a[4];
		map[2][3] = a[5];
		map[2][4] = a[6];
		map[3][1] = a[7];
		map[3][2] = a[8];
		map[3][3] = a[9];
		ans += f();
	} while (next_permutation(a, a + 10));
	cout << ans << endl;
	return 0;
}

剪邮票 T-7 (分值：19)

如【图1.jpg】, 有12张连在一起的12生肖的邮票。 现在你要从中剪下5张来，要求必须是连着的。 （仅仅连接一个角不算相连）

+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+

比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。 请你计算，一共有多少种不同的剪取方法。

请填写表示方案数目的整数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

/*
1  2  3  4
5  6  7  8
9  10 11 12 

思路1：每个格子作为起点,dfs连五张，去重->结果

思路2：暴力枚举，所有的五张组合，检查它们是不是一个连通块。 */
// 12/13 寒假作业   12/5 dfs


/*思路1： 生成的方法有太多的重复，效率低下
//此题和13年剪格子有相似之处，但是那个题的限制条件是格子数值之和为总和的一半，此题则限制只能是5个格子
//单纯的dfs无法解决T字型连通方案
//本题的解决办法是，找出任意5个格子，判断是否连通*/
#include <algorithm>
#include <iostream>

using namespace std;

int ans;

bool check(int arr[12]);

void dfs(int g[3][4], int i, int j);

int main(int argc, const char *argv[]) {
    int per[] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};
    do {
        if (check(per))
            ans++;
    } while (next_permutation(per, per + 12));
    cout << ans << endl;
    return 0;
}

bool check(int arr[12]) {
    int g[3][4];
    memset(g, 0, sizeof(g));
//将相应位置标注为1
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (arr[i * 4 + j] == 1)g[i][j] = 1;
        }
    }
//    经典连通块计算
    int cnt = 0;
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (g[i][j] == 1) {
                dfs(g, i, j);
                cnt++;
            }
        }
    }
    return cnt == 1;
}

void dfs(int g[3][4], int i, int j) {
    g[i][j] = 0;
    if (i + 1 <= 2 && g[i + 1][j] == 1) dfs(g, i + 1, j);
    if (i - 1 >= 0 && g[i - 1][j] == 1) dfs(g, i - 1, j);
    if (j + 1 <= 3 && g[i][j + 1] == 1) dfs(g, i, j + 1);
    if (j - 1 >= 0 && g[i][j - 1] == 1) dfs(g, i, j - 1);
}



//思路2：跑不出来
#include <algorithm>
#include <iostream>
#include <set>

using namespace std;

int a[]={0,0,0,0,0,0,0,1,1,1,1,1};//它的每个排列代表着12选5的一个方案
int ans;
void dfs(int g[3][4],int i , int j){
    g[i][j]=0;
    if(i-1>=0&&g[i-1][j]==1)dfs(g,i-1,j);
    if(i+1<=2&&g[i+1][j]==1)dfs(g,i+1,j);
    if(j-1>=0&&g[i][j-1]==1)dfs(g,i,j-1);
    if(j+1<=3&&g[i][j+1]==1)dfs(g,i,j+1);
}
bool check(){
    int g[3][4];
//    将某个排列映射到二维矩阵上
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            if(a[i*4+j]==1) g[i][j]=1;
            else g[i][j]=0;
        }
    }
    int cnt=0;//连通块的数目
//    g上面就有5个格子被标记为1，现在才用dfs做连通性检查，要求只有一个连通块
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            if(g[i][j]==1){
                dfs(g,i,j);
                cnt++;
            }
        }
    }
    return cnt==1;
}
set<string> s1;
void a2s(string &s){
    for (int i = 0; i < 12; ++i) {
        s.insert(s.end(),a[i]+'0');
    }
}
bool isExist(){
    string a_str;
    a2s(a_str);
    if(s1.find(a_str)==s1.end()){
        s1.insert(a_str);
        return false;
    } else
        return true;
}
void f(int k){
    if(k==12){
        if(!isExist()&&check()){
            ans++;
        }
    }
    for (int i = k; i < 12; ++i) {
        {int t=a[i];a[i]=a[k];a[k]=t;}
        f(k+1);
        {int t=a[i];a[i]=a[k];a[k]=t;}
    }
}
int main(int argc, const char *argv[]) {
    f(0);
    printf("%d",ans);
//string _s;
//a2s(_s);
//cout<<_s<<endl;
    return 0;
}



//思路3：
#include <algorithm>
#include <iostream>

using namespace std;

//它的每个排列代表着12选5的一个方案
int a[] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};
int ans;

void dfs(int g[3][4], int i, int j) 
{
    g[i][j] = 0;
    if (i - 1 >= 0 && g[i - 1][j] == 1)dfs(g, i - 1, j);
    if (i + 1 <= 2 && g[i + 1][j] == 1)dfs(g, i + 1, j);
    if (j - 1 >= 0 && g[i][j - 1] == 1)dfs(g, i, j - 1);
    if (j + 1 <= 3 && g[i][j + 1] == 1)dfs(g, i, j + 1);
}

bool check(int path[12]) 
{
    int g[3][4];
//    将某个排列映射到二维矩阵上
    for (int i = 0; i < 3; ++i) 
    {
        for (int j = 0; j < 4; ++j) 
        {
            if (path[i * 4 + j] == 1) g[i][j] = 1;
            else g[i][j] = 0;
        }
    }
    int cnt = 0;//连通块的数目
//    g上面就有5个格子被标记为1，现在才用dfs做连通性检查，要求只有一个连通块
    for (int i = 0; i < 3; ++i) 
    {
        for (int j = 0; j < 4; ++j) 
        {
            if (g[i][j] == 1) 
            {
                dfs(g, i, j);
                cnt++;
            }
        }
    }
    return cnt == 1;
}

bool vis[12];


void f(int k, int path[12]) 
{
    if (k == 12) {
        if (check(path)) 
        {
            ans++;
        }
    }
    for (int i = 0; i < 12; ++i) 
    {
        if (i>0&&a[i]==a[i-1]&&!vis[i-1])continue;//现在准备选取的元素和上一个元素相同，但是上一个元素还没被使用

        if(!vis[i]){//没有被用过的元素可以抓入到path
            vis[i]=true;//标记为已访问
            path[k]=a[i];//将a[i]填入到path[k]中
            f(k + 1, path);//递归
            vis[i]=false;//回溯
        }

    }
}

int main(int argc, const char *argv[]) 
{
    int path[12];
    f(0, path);
    printf("%d", ans);
    return 0;
}

四平方和 T-8 (分值：21) 研究一下

题目：四平方和

四平方和定理，又称为拉格朗日定理： 每个正整数都可以表示为至多4个正整数的平方和。 如果把0包括进去，就正好可以表示为4个数的平方和。

比如：

5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2

（^符号表示乘方的意思）

对于一个给定的正整数，可能存在多种平方和的表示法。 要求你对4个数排序：

0 <= a <= b <= c <= d

并对所有的可能表示法按 a,b,c,d 为联合主键升序排列， 最后输出第一个表示法

程序输入为一个正整数N (N<5000000) 要求输出4个非负整数，按从小到大排序，中间用空格分开

例如，输入： 5 则程序应该输出： 0 0 1 2

再例如，输入： 12 则程序应该输出： 0 2 2 2

再例如，输入： 773535 则程序应该输出： 1 1 267 838

资源约定： 峰值内存消耗 < 256M CPU消耗 < 3000ms

请严格按要求输出，不要画蛇添足地打印类似： “请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准， 不要调用依赖于编译环境或操作系统的特殊函数。 注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

//枚举+优化 
//优化：采用缓存来空间换时间

/*思路1：
枚举abcd
for(a)    0~a^2
    for(b)    0~b^2
        for(c)    0~c^2
            for(d)    0~d^2

*/
#include<iostream>
#include<cstdio>
#include<map>
int N;

using namespace std;
map<int, int>cache;
int main()
{
    scanf_s("%d", &N);
    //
    for (int c = 0; c * c <= N / 2; ++c)
        for (int d = c; c * c + d * d <= N; ++d)
            if (cache.find(c * c + d * d) == cache.end())
                cache[c * c + d * d] = c;

    //
    for (int a = 0; a * a <= N / 4; ++a)
        for (int b = a; a * a + b * b <= N / 2; ++b)
            if (cache.find(N - a * a + b * b) != cache.end()) {
                int c = cache[N - a * a + b * b];
                int d = int(sqrt(N - a * a + b * b + c * c));
                printf("%d %d %d %d\n", a, b, c, d);
                return 0;
            }
    return 0;
}

交换瓶子 T-9 (分值：23)

有N个瓶子，编号 1 ~ N，放在架子上。 比如有5个瓶子： 2 1 3 5 4 要求每次拿起2个瓶子，交换它们的位置。 经过若干次后，使得瓶子的序号为： 1 2 3 4 5 对于这么简单的情况，显然，至少需要交换2次就可以复位。 如果瓶子更多呢？你可以通过编程来解决。 输入格式为两行： 第一行: 一个正整数N（N<10000）, 表示瓶子的数目 第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。 输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。

例如，输入： 5 3 1 2 5 4

程序应该输出：3 再例如，输入： 5 5 4 3 2 1

程序应该输出：2 资源约定： 峰值内存消耗 < 256M CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准， 不要调用依赖于编译环境或操作系统的特殊函数。 注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。 提交时，注意选择所期望的编译器类型。

/*
 3   2   1   5   4
[1] [2] [3] [4] [5] */

// 贪心
#include <iostream>

using namespace std;
int n;
int a[10001];
int ans;

int pos(int x)
{
    for (int i = 1; i <= n; ++i)
    {
        if (a[i] == x)return i;
    }
    return -1;
}

void swap(int i, int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}

void printArr() {
    for (int i = 1; i <= n; ++i)
    {
        printf("%d ", a[i]);
    }
    printf("\n");
}

int main(int argc, const char* argv[])
{
    // 处理输入
    scanf_s("%d", &n);
    for (int i = 1; i <= n; ++i)
    {
        scanf_s("%d", &a[i]);
    }
    //遍历i:1-N
    for (int i = 1; i <= n; ++i)
    {
        //如果a[i]=i,已经到位
        if (a[i] == i)continue;
        //否则先找到i在a中的位置pos(i)和i位交换——swap(a,pos(i),i)
        else
        {
            swap(pos(i), i);
            ans++;
        }
    }
    //printArr();
    printf("%d\n", ans);
    return 0;
}

最大比例 T-10 (分值：31)

题目：最大比例

X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。 并且，相邻的两个级别间的比例是个固定值。 也就是说：所有级别的奖金数构成了一个等比数列。比如： 16,24,36,54 其等比值为：3/2

现在，我们随机调查了一些获奖者的奖金数。 请你据此推算可能的最大的等比值。

输入格式： 第一行为数字 N (0<N<100)，表示接下的一行包含N个正整数 第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。 每个整数表示调查到的某人的奖金数额 要求输出： 一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数 测试数据保证了输入格式正确，并且最大比例是存在的。

例如，输入： 3 1250 200 32

程序应该输出：25/4

再例如，输入： 4 3125 32 32 200

程序应该输出：5/2

再例如，输入： 3 549755813888 524288 2

程序应该输出：4/1

资源约定： 峰值内存消耗 < 256M CPU消耗 < 3000ms

请严格按要求输出，不要画蛇添足地打印类似： “请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0 注意: 只使用ANSI C/ANSI C++ 标准， 不要调用依赖于编译环境或操作系统的特殊函数。 注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

/*
等比数列：a0、a1、a2、a3、a4
等比数列的性质：
a3          p
——   ——>  (———)^2 
a0          q


*/
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>

using namespace std ;
typedef long long LL ;
int N ;
LL data[100] ; 

struct Ratio{
    LL x,y ;
    Ratio(LL _x,LL _y):x(_x),(_y)
    {
        LL _gcd = gcd(x,y) ;
        x /= _gcd ;
        y /= _gcd ;
    }
    LL gcd(LL a,LL b)
    {
        if(b==0) return a ;
        return gcd(b,a%b) ;
    }
} ;
//存储比值
vector<Ratio> ratios ;

int main()
{
    //处理输入
    scanf("%d",&n) ;
    for (int i = 0; i < N; ++i) //扫描输入数据
    {
        scanf("%lld",&data[i]) ;
    }

    //排序
    sort(data,data+N) ;


    //两两比值，以分数形式存储，vector
    for (int i = 0; i < N-1; ++i)
    {
        if(data[i+1]!=data[i])//去重
        ratios.push_back(Ratio(data[i+1],data[]i)) ;
    }

    /*对第一个比值开1-..pow(极限为40)次方作为基数，
    如果这个基数的分子、分母的k1
    k2次方恰好是其他比值的分子分母的话，基数就是答案*/
    for (int pow = 0; pow <= 40; ++pow)
    {
        Ratio ra0 = ratios[0] ;
        LL x = ra0.x ;
        LL y = ra0.y ;
        LL fx = extract(x,pow) ; //对
        LL fy = extract(y,pow) ; //
        if(fx==-1 |\ fy ==-1) continue ; //开不出，continue 
        //能开，就要确认所有比值的分子是fx的整数次方，所有比值的分母是fy的整数次方
        //计px=getPow(xx,fx),py=getPow(yy,fy),要求必须是整数且px==py
        
        bool all_match = true ;
        //
        for (int i = 1; i < ratios.size(); ++i)
        {
            LL xx = ratios[i].x ;
            LL yy = ratios[i].y ;
            LL px = getPow(xx,fx) ;
            LL py = getPow(yy,fy) ;

            if(px == -1 || py == -1 || px != py)
            {
                all_match = false ;
                break ;
            }
        }
        if(all_match)
        {
            
            Ratio ans = Ratio(fx,fy) ;
            cout << ans.x << "/" << ans.y << endl ;
        }
        return 0 ;
    }

    return 0 ;
}
//优化 + 完善
#include <stdio.h>
#include <iostream>
#include <vector>
#include <map>

using namespace std;
typedef long long LL;
int N;
LL data[100];

//结构体
struct Ratio 
{
    LL x, y;

    Ratio(LL _x, LL _y) : x(_x), y(_y) 
    {
        LL _gcd = gcd(x, y);
        x /= _gcd;
        y /= _gcd;
    }

    LL gcd(LL a, LL b) 
    {
        if (b == 0)return a;
        return gcd(b, a % b);
    }
};

vector<Ratio> ratios;
map<LL, map<LL,LL> > all_ex;//all_ex[x][pow]==x开pow次方
map<LL, map<LL,LL> > all_log;//all_log[x][y]==log_y_x，y的多少次方是x？

void init() //预处理
{
    for (int i = 2; i < 1e6; ++i) 
    {//底数
        LL cur=(LL)i*i;
        int pow=2;
        while(cur<1e12)
        {
            all_ex[cur][pow]=i;
            all_log[cur][i]=pow;
            pow++;
            cur*=i;
        }
    }
}

/**
 * 对x开pow次方
 * @param x
 * @param pow
 * @return
 */
LL extract(LL x,LL pow)
{
    if(pow==1)return x;
    if(x==1)return 1;
    if(all_ex[x].find(pow)!=all_ex[x].end())//意味着x可以开pow整数次方
        return all_ex[x][pow];
    else
        return -1;
}

/**
 * 求log_base_x
 * @param base
 * @param x
 * @return
 */

LL log(LL base,LL x)
{
    if(base==x)return 1;
    if(all_log[x].find(base)!=all_log[x].end())//意味着可以得打一个k，base的k次方是x
        return all_log[x][base];
    return -1;
}

int main(int argc, const char *argv[]) 
{
    init();
    freopen("/Users/zhengwei/CLionProjects/lanqiaobei2019/2016_C_A/data10/in8.txt","r",stdin);
    //处理输入
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) 
    {
        scanf("%lld", &data[i]);
    }
    //排序
    sort(data, data + N);
    //处理只有两项的特殊情况
    if(N==2)
    {
        Ratio ans = Ratio(data[1], data[0]);
        cout << ans.x << "/" << ans.y << endl;
        return 0;
    }

    //求两两比值，以分数形式存储，vector
    for (int i = 0; i < N - 1; ++i) 
    {
        if (data[i + 1] != data[i])//去重
            ratios.push_back(Ratio(data[i + 1], data[i]));
    }

    //对第一个比值开1~..pow(极限为40).次方，作为基数，如果这个基数也是其他比值的基数的话，该基数就是答案
    for (int pow = 1; pow <= 40; ++pow) 
    {
        Ratio ra0 = ratios[0];
        LL x = ra0.x;
        LL y = ra0.y;
        LL base_x = extract(x, pow);//对x开pow次方，作为基数，去尝试
        LL base_y = extract(y, pow);//对y开pow次方，作为基数，去尝试
        if (base_x == -1 || base_y == -1)continue;//开不出，continue
    //能开：就要去确认所有比值的分子是fx的整数次方，所有比值的分母是fy的整数次方
    //计px=getPow(xx,base_x),py=getPow(yy,base_y)，要求必须是整数且px==py
        bool all_match = true;
        for (int i = 1; i < ratios.size(); ++i) 
        {
            LL xx = ratios[i].x;
            LL yy = ratios[i].y;
            LL log_x = log(base_x,xx);
            LL log_y = log(base_y,yy);
            if(base_y==1&&yy==1)log_y=log_x;
            if (log_x == -1 || log_y == -1 || log_x != log_y) {
                all_match = false;
                break;
            }
        }
        if (all_match) 
        {
            Ratio ans = Ratio(base_x, base_y);
            cout << ans.x << "/" << ans.y << endl;
            return 0;
        }

    }
    return 0;
}

总结

//【2016年B组C++小结】 /******************

  • 01【结果填空】煤球数目 ：枚举+简单计算

  • 02【结果填空】生日蜡烛 ：等差数列求和

  • 03【结果填空】凑算式 ：全排列

  • 04【代码填空】快速排序 ：裸题

  • 05【代码填空】抽签 ：递归，明确参数的含义及参数的变化方向

  • 06【填空填空】方格填数 ：全排列 + check

  • 07【结果填空】剪邮票(**) ：dfs解决不了T型组合，全排列+dfs求矩阵中的连通块

  • 08【编程题】四平方和 ：枚举+优化

  • 09【编程题】交换瓶子(**) ：贪心

  • 10【编程题】最大比例(*) ：数论、等比数列、预处理 ********************/

梨涡泥窝
关注
专栏目录
2013年 第4届 蓝桥杯 Java B组 省赛解析及总结
upward
08-18 5005
01 世纪末的星期 枚举每个世纪末，判断是否星期天 Calendar 02 马虎的算式 枚举每个位上的数字，组合判断 03 振兴中华 找重复中的变化，找边界 **04 黄金连分数 1.识别问题等价于斐波那契的n项和n+1项的比值，2.n要多少才够，3.怎么处理很大的数和精度要求很高的浮点数 05 有理数类 面向对象+分数加法（通分与约分） 06 三部排序 快速排序（三指针区间法）变体；极限思维（考虑全部是0） 07 错误票据 输入比较特殊，排序，迭代（获取断号和重号），输出 08 幸运数 模拟筛选过程
2016年 第7届 蓝桥杯 Java B组 省赛解析及总结
upward
08-21 2486
01 煤球数目 找规律 简单计算 02 生日蜡烛 枚举: 1两个年龄 2过生日的次数，等差数列求和的公式 03 凑算式 全排列+check 04 分小组 逻辑 05 抽签递归，搞清楚参数的含义和参数的变化方向 06 方格填数 全排列+check 07**** 剪邮票 全排列(带重复元素的全排列，要用套路全排套路1) +标注(二维数组上标注01) +dfs求连通块数目 08 四平方和 枚举优化(hash缓存) 09*** 取球博弈 典型的博弈框架(带平局) 10****压缩变换 hash查找+标注+区间树
2016年第七届蓝桥杯省赛C语言B组
GGG166的博客
05-04 1232
2016年第七届蓝桥杯省赛C语言B组 题目来源：蓝桥杯 作者：GGG166 第一题 题目：煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 答案：171700...
2016年第七届蓝桥杯C/C++程序设计本科B组省赛题目汇总
Rachelwrx在向上爬呀爬
01-25 724
1.煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …. 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 #include&amp;amp;amp;amp;amp;amp;amp;amp;lt;cstdio&amp;amp;amp;amp;amp;amp;amp;amp;gt
蓝桥杯2016年B组C++国赛题解（部分
Suryxin's blogs
05-21 336
一步之遥 题目描述： 从昏迷中醒来，小明发现自己被关在 X 星球的废矿车里。 矿车停在平直的废弃的轨道上。 他的面前是两个按钮，分别写着 “F” 和 “B” 。 小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。 按 F，会前进 97 米。按B 会后退127 米。 透过昏暗的灯光，小明看到自己前方 1 米远正好有个监控探头。 他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。 或许，通过多次操作 F 和 B 可以办到。 矿车上的动力已经不太足，黄色的警示灯在默默闪烁… 每次进行 F 或
《2016年蓝桥杯C++b组练习》
Sharing_的博客
03-07 442
2016年蓝桥杯C++b组
2016年第七届蓝桥杯C/C++程序设计本科B组省赛
热门推荐
A place to record sth.
03-21 2万+
1.煤球数目 2.生日蜡烛 3.凑算式 4.快速排序 5.抽签 6.方格填数 7.剪邮票 8.四平方和 9.交换瓶子 10.最大比例
跳蚱蜢】2017年第八届蓝桥杯【C/C++省赛A组】
07-22 660
有9只盘子，排成1个圆圈。其中8只盘子内装着8只蚱蜢，有一个是空盘。   我们把这些蚱蜢顺时针编号为 1~8，每只蚱蜢都可以跳到相邻的空盘中，   也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，并且保持空盘的位置不变（也就是1-8换位，2-7换位,…），至少要经过多少次跳跃？   注意：要求提交的是一个整数，请不要填写任何多余内容或说明文字。 思路分析：从一个状态到另一个状态最少需要多少步骤，毫无疑问就是BFS问题。此题与人工智能中的经典问题–八数码问
2020年 第11届 蓝桥杯 Java B组 省赛真题详解及小结【第2场省赛 2020.10.17】
upward
10-31 1万+
一、试题 A: 门牌制作——答案：641 解法一：x % 10 == 2 解法二：双重for循环+字符数组 二、试题 B: 寻找 2020——答案：16520 三、试题 C: 蛇形填数——答案：761 解法一：规律推公式 (n-1)(2n-1)+n 解法二：手工计算（写满两页A4演草纸） 四、试题 D: 七段码——答案：80 五、试题 E: 排序——jonmlkihgfedcba 六、试题 F: 成绩分析 七、试题 G: 单词分析 八、试题 H: 数字三角形 九、试题 I: 子串分值 十、试题 J: 装饰珠
2017年 第8届 蓝桥杯 Java B组 省赛真题详解及总结
upward
08-21 3317
01 购物单 简单计算 excel 02 纸牌三角形 全排列+特殊去重 *03 承压计算 数组 注意计量单位，要精确就先放大2^30来做除法 用2^30精确计算、double二维数组 **04 魔方状态 模拟+去重 05 取数位 递归 搞清楚参数的含义及参数变化的方向 返回整数位数、取整数第k位数字 06 最大公共子串 经典dp 07 日期问题 常规日期运算，细心，考虑闰年；字符串处理 ***08 包子凑数 扩展欧几里得 + 完全背包问题（dp） 09 分巧克力 二分枚举 ****10 k倍区间 前缀和+组
C/C++大学B组蓝桥杯历年决赛真题（2012年至2016年）
12-17
2012年至2016年C/C++大学B组蓝桥杯历年决赛真题 用于学习交流
2020 蓝桥杯大学 B 组省赛模拟赛（一）(程序设计题题解）
s1050712899的博客
08-11 590
F. 程序设计：寻找重复项 用map存一下出现过得，模拟一下，找到出现了的直接return，记得要把最开始的1也记录一下。 #include<iostream> #include<algorithm> #include<cstdio> #include<cmath> #include<cstring> #include<bitset> #include<vector> #include<queue> #incl
2016年第七届蓝桥杯省赛C语言B组题解
malanlllll的的的的的博客
02-17 1136
过年刷刷历年蓝桥杯的题，感觉对知识掌握的要求并不高，主要是数学思维；照例写题解回顾一遍。 文章目录1.煤球数目 1.煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文...
蓝桥杯历年赛题解析 (C/C++) B 组
蒟蒻
01-11 3032
写在前面，以下网盘密码均为1111 文章目录第十二届蓝桥杯省赛第一场C++B组真题PDF下载真题解析 第十二届蓝桥杯省赛第一场C++B组真题 PDF下载 PDF下载????点我 真题解析 真题解析????点我 注：如果您通过阅读本文解决了问题，恳请您留下一个宝贵的赞再离开,如果不嫌弃的话,点个关注再走吧，非常欢迎您能够在讨论区指出此文的不足处，博主会及时对文章加以修正 !如果有任何问题，欢迎评论，非常乐意为您解答！( •̀ ω •́ )✧ ...
【蓝桥杯】真题训练 - 第七届蓝桥杯省赛C/C++大学B组真题解析
weixin_44566432的博客
03-18 385
第一题 1、煤球数目 有一堆煤球，堆成三角棱锥形。具体： 第一层放1个， 第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …. 如果一共有100层，共有多少个煤球？ 请填表示煤球总数目的数字。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 答案：171700 #include <iostream> using namespace std; /* run this program using the console p.
蓝桥杯C语言程序设计真题
zhang__d的博客
10-19 7729
下面是蓝桥杯历年的真题希望对大家有用例如：以上就是今天要讲的内容，本文能力有限只列举了蓝桥杯较为简单的题目，仅供参考。
【蓝桥杯】真题训练 - 第六届蓝桥杯省赛C/C++大学B组 真题解析
weixin_44566432的博客
03-21 1218
第一题奖券数目 有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。 虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。 请提交该数字（一个整数），不要写任何多余的内容或说明性文字。 答案：52488 排列，8*9*9*9*9 第二题星系炸弹 在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的...
小白必看的第11届蓝桥杯大赛软件类国赛C/C++大学B组真题解析
qq_44486437的博客
03-27 1107
C++实现 这里给大家扩充个知识点，非常实用，就是在c++中，string和int型的相互转化 //将int类型转为string类型 stringstream ss; int a = 1; string str; ss<<a; //理解为将a推入到ss中出路 ss>>str;//将处理结果输出到str中 cout<<str<<endl; //将string类型转为int类型 stringstream ss; int a = 1; stri
2024年蓝桥杯C/C++解析（b组）
最新发布
qq_73651623的博客
04-13 1491
内容。
2022年第十三届蓝桥杯软件赛省赛C/C++大学C组解析
资源摘要信息:"2022年第十三届蓝桥杯大赛软件赛省赛C/C++ 大学C 组" 蓝桥杯大赛是一项面向全国高校学生的计算机类竞赛，由中国软件行业协会主办，全国各省市都有相应的省级预选赛和决赛。2022年，该项赛事迎来了第...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值