[第七届蓝桥杯省赛C++B组]省赛全题目题解

文章目录

• 快速分支通道

• 煤球数目
• 生日蜡烛
• 凑算式
• 快速排序
• 抽签
• 方格填数
• 剪邮票
• 四平方和
• 交换瓶子
• 最大比例

• 煤球数目

• 题目来源：第七届蓝桥杯省赛C++B组
• 算法标签：递推
• 题目描述：
• 题目答案：
• 题目思路：
• 题目代码

• 生日蜡烛

• 题目来源：第七届蓝桥杯省赛C++B组
• 算法标签：枚举，双指针
• 题目描述：
• 题目答案：
• 题目思路：
• 题目代码：

• 凑算式

• 题目来源：第七届蓝桥杯省赛C++B组
• 算法标签：全排列
• 题目描述：
• 题目答案：
• 题目思路：
• 题目代码：

• 快速排序

• 题目来源：第七届蓝桥杯省赛C++B组
• 算法标签：快速排序
• 题目描述：
• 题目答案：
• 题目思路：

• 抽签

• 题目来源：第七届蓝桥杯省赛C++B组
• 算法标签：DFS
• 题目描述：
• 题目答案：
• 题目思路：

• 注意

• 方格填数

• 题目来源：第七届蓝桥杯省赛C++B组
• 算法标签：全排列
• 题目描述：
• 题目答案：
• 题目思路：
• 题目代码：

• 剪邮票

• 来源：第七届蓝桥杯省赛C++B组
• 算法标签：全排列，连通性，图论
• 题目描述：
• 思路
• 题目代码

• 四平方和

• 来源： 第七届蓝桥杯省赛C++A/B组
• 算法标签：二分，哈希
• 题目描述
• 输入格式
• 输出格式
• 数据范围
• 输入样例：
• 输出样例：
• 思路

• 交换瓶子

• 交换瓶子

• 来源： 第七届蓝桥杯省赛C++B组
• 算法标签 图论 环 置换群 贪心
• 题目描述
• 输入格式
• 输出格式
• 数据范围
• 输入样例1：
• 输出样例1：
• 输入样例2：
• 输出样例2：
• 思路
• 时间复杂度
• C++ 代码

• 最大比例

• 来源：第七届蓝桥杯省赛C++B组
• 算法标签：数论，最大公约数，辗转相减法
• 题目描述：

• 输入格式
• 输出格式
• 数据范围
• 输入样例1：
• 输出样例1：
• 输入样例2：
• 输出样例2：
• 输入样例3：
• 输出样例3：

• 思路
• 题目代码

快速分支通道

煤球数目

生日蜡烛

凑算式

快速排序

抽签

方格填数

剪邮票

四平方和

交换瓶子

最大比例

煤球数目

题目来源：第七届蓝桥杯省赛C++B组

算法标签：递推

题目描述：

有一堆煤球，堆成三角棱锥形。具体： 第一层放1个，
第二层3个（排列成三角形）， 第三层6个（排列成三角形）， 第四层10个（排列成三角形）， …
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。

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

题目答案：

171700

题目思路：

由题目可知！

层 数 1 1 2 3 3 6 4 10

简单推测可知，f[i]=f[i-1]+i,最终累加即可。

题目代码

#include <iostream>

using namespace  std;
int f[101];
int main()
{
	f[1] = 1;
	for (int i = 2; i <= 100; i++)f[i] = f[i - 1] + i;//递推
	for (int i = 2; i <= 100; i++)f[i] = f[i - 1] + f[i];//前缀和

	cout << f[100];
	return 0;
}

生日蜡烛

题目来源：第七届蓝桥杯省赛C++B组

算法标签：枚举，双指针

题目描述：

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。

现在算起来，他一共吹熄了236根蜡烛。

请问，他从多少岁开始过生日party的？

请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

题目答案：

26

题目思路：

双指针枚举开始与终止年龄，判断合法情况输出即可。

题目代码：

#include <iostream>

using namespace  std;
int main()
{
	for (int i=1;i<=100;i++)//起始年龄
	{
		int sum = 0;
		for (int j = i; j <= 100; j++)//终止年龄
		{
			sum += j;
			if (sum == 236)cout << i;
		}
	}
	return 0;
}

凑算式

题目来源：第七届蓝桥杯省赛C++B组

算法标签：全排列

题目描述：

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

（如果显示有问题，可以参见【图1.jpg】）

这个算式中A_I代表19的数字，不同的字母代表不同的数字。

比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？

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

题目答案：

29

题目思路：

枚举全排列进行判断。

题目代码：

#include <iostream>
#include<algorithm>

using namespace std;
int cnt;
int a[9]={1,2,3,4,5,6,7,8,9};

int main()
{
    do{
        int DEF=a[3]*100+a[4]*10+a[5];
        int GHI=a[6]*100+a[7]*10+a[8];
        if(a[0]*a[2]*GHI+a[1]*GHI+a[2]*DEF==10*a[2]*GHI)cnt++;
    }while(next_permutation(a,a+9));
    cout<<cnt;
    return 0;
}

#include <iostream>

using namespace std;
int cnt;
int a[9]={1,2,3,4,5,6,7,8,9};

void swap(int &a,int &b){int t;t=a;a=b;b=t;}

bool check()
{
    int DEF=a[3]*100+a[4]*10+a[5];
            int GHI=a[6]*100+a[7]*10+a[8];
            if(a[0]*a[2]*GHI+a[1]*GHI+a[2]*DEF==10*a[2]*GHI)return true;
    else return false;
}
void dfs(int u)
{
    if(u==9)
        {
            if(check())cnt++;
            return ;
        }
    else 
        {
            for(int i=u;i<9;i++)
                {
                    swap(a[u],a[i]);
                    dfs(u+1);
                    swap(a[u],a[i]);
                }
        }
    
}
int main()
{
    dfs(0);
    cout<<cnt;
    return 0;
}

快速排序

题目来源：第七届蓝桥杯省赛C++B组

算法标签：快速排序

题目描述：

排序在各种场合经常被用到。

快速排序是十分常用的高效率的算法。
其思想是：先选一个“标尺”，

用它把整个队列过一遍筛子，

以保证：其左边的元素都不大于它，其右边的元素都不小于它。
这样，排序问题就被分割为两个子区间。

再分别对子区间排序就可以了。
下面的代码是一种实现，请分析并填写划线部分缺少的代码。

#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;
    int j = r + 1;
    int x = a[p];
    while(1){
        while(i<r && a[++i]<x);
        while(a[--j]>x);
        if(i>=j) break;
        swap(a,i,j);
    }
	______________________;
    return j;
}
 
void quicksort(int a[], int p, int r)
{
    if(p<r){
        int q = partition(a,p,r);
        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;
}

注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。

题目答案：

swap(a,p,j);

题目思路：

我们只要依据快速排序的整体思路分析相关代码即可：
while(i<r && a[++i]<x);表明左指针找到比目标值大的数字，
while(a[--j]>x);表明右指针找到比目标值小的数字，
f(i>=j) break;表明形成小标i>=j就终止
swap(a,i,j);交换a[i],a[j]即使得逆序对复原，符合左小右大的整体区间。

经过以上的步骤，我们可以确定一次逆序对被复原，则现在程序进行到了标准值P更换的步骤。
我们将交换swap(a,p,j)因为p是标准值，a[j]则是小于标准值的值,而程序中P为a[0],则我们应该将P更换为最小值，所以更换为a[j].

抽签

题目来源：第七届蓝桥杯省赛C++B组

算法标签：DFS

题目描述：

X星球要派出一个5人组成的观察团前往W星。

其中：

A国最多可以派出4人。

B国最多可以派出2人。

C国最多可以派出2人。

…
那么最终派往W星的观察团会有多少种国别的不同组合呢？
下面的程序解决了这个问题。

数组a[] 中既是每个国家可以派出的最多的名额。

程序执行结果为：

DEFFFCEFFF 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
 
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);
		return;
	}
	
	for(i=0; i<=a[k]; i++){
		for(j=0; j<i; j++) b[M-m+j] = k+'A';
		______________________;  //填空位置
	}
}
int main()
{	
	int  a[N] = {4,2,2,1,1,3};
	char b[BUF];
	f(a,0,M,b);
	return 0;
}

仔细阅读代码，填写划线部分缺少的内容。
注意：不要填写任何已有内容或说明性文字。

题目答案：

16

题目思路：

很明显的深搜，不难想到我们需要填的肯定就是递归语句，则现在我们的问题就转换为了弄懂参数起到什么作用。

f(int a[], int k, int m, char b[])

由题目可知一共有四个参数，其中a[N] = {4,2,2,1,1,3}与printf("%s\n",b)表明了a用来存放国家，b用来表示字符串是显而易见的。
那我们现在的目标转换为了弄清看k,m的作用。

因为上文，我们弄清了a,b的作用。

for(i=0; i<=a[k]; i++){//a[k]当前国家最大派出人员数量
		for(j=0; j<i; j++) b[M-m+j] = k+'A';//字符串b拼接国家字符
		______________________;  //填空位置

我们可以明白k的作用即为表达当前选择国家的下标。
现在我们的目标转向弄清m的意思。
阅读b[M-m+j] = k+'A'可以勉强清晰，这里的意思大概是给字符串b赋予国别字符，其中M是队伍人员总数，j是国家派出的人数，所以m大致起到也起到了计数的作用。

阅读退出条件

if(k==N){ //所有国家计数完毕
		b[M] = 0;
		if(m==0) printf("%s\n",b);//如果m==0则输出字符串
		return;

且一开始递归时f(a,0,M,b); m的位置传的参数即为M队伍最大人数，不难想出，m表明的是队伍剩余位子，当所有国家计数完毕且队伍剩余位子为0时输出答案。

则综上我们不难给出答案。

f(a,k+1,m-i,b)

或者

f(a,k+1,m-j,b)

注意

1.a,b作为数组不做变更只做传入。
2.k+1表明递归到下一个国家选择
3.m-i或者m-j表明队伍空位减去一个国家派出的人数
4.i,j的范围实际相同，没有区别。

方格填数

题目来源：第七届蓝桥杯省赛C++B组

算法标签：全排列

题目描述：

如下的10个格子

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

（如果显示有问题，也可以参看【图1.jpg】）

填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）
一共有多少种可能的填数方案？
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

题目答案：

1580

题目思路：

题目是格子填入数，连续两个数字不能相邻。
那么换句话说，我们得到判断条件，一个格子与上下左右对角绝对差值==1则不符合条件。
很明显这道题是全排列判断，每个格子尝试不同的数字，那么我们现在的问题转换为了一个格子怎么做判断。

我们先假设第一个位子

将周边的距离为1的位子全部标记。则第二个位子的标记方式即为下图，不用判断与上一个的关系，因为位于上一个时，已经判断过了。

当我们往下移动一层时，则如下图，上一层的两个与当前位子相邻的位子与前一个位子都在之前的过程中与当前的位子判断过了。

让我们下沉到最后一层，即为下图，上一层，当前层左边都判断过，下一层没有：

则我们很容易得出代码！

题目代码：

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace  std;

int a[10];
int ans;

bool check()
{
	if (abs(a[0] - a[1]) == 1 || abs(a[0] - a[3]) == 1 || abs(a[0] - a[4]) == 1 || abs(a[0] - a[5]) == 1)return false;
	if (abs(a[1] - a[2]) == 1 || abs(a[1] - a[4]) == 1 || abs(a[1] - a[5]) == 1 || abs(a[1] - a[6]) == 1)return false;
	if (abs(a[2] - a[5]) == 1 || abs(a[2] - a[6]) == 1)return false;
	if (abs(a[3] - a[4]) == 1 || abs(a[3] - a[7]) == 1 || abs(a[3] - a[8]) == 1)return false;
	if (abs(a[4] - a[5]) == 1 || abs(a[4] - a[7]) == 1 || abs(a[4] - a[8]) == 1 || abs(a[4] - a[9]) == 1)return false;
	if (abs(a[5] - a[6]) == 1 || abs(a[5] - a[8]) == 1 || abs(a[5] - a[9]) == 1)return false;
	if (abs(a[6] - a[9]) == 1)return false;
	if (abs(a[7] - a[8]) == 1 || abs(a[8] - a[9]) == 1)return false;
	return true;
}
int main()
{
	for (int i = 0; i <= 9; i++)a[i] = i;//初始化

	do
	{
		if (check())ans++;//如果符合条件则答案加1
	} while (next_permutation(a, a + 10));
	cout << ans;
	return 0;
}

剪邮票

来源：第七届蓝桥杯省赛C++B组

算法标签：全排列，连通性，图论

题目描述：

如【图1.jpg】, 有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

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

思路

首先我们有一个3X4的方块，每个方块都有一个数字，我们要检测所有可能排列下的合适的剪法。

1.必须是连通的，所以我们直接可以考虑连通性
2.我们要找所有的状态，直接往全排列上走
3.每种状态都只有5个可剪，也就是说我们可以直接赋值12个中有5个可以用
4.我们考虑几个连通块，如果只有一个，那就成功，如果是一个以上或者没有，那就说明错了
5.可得简单模型

a[]={1,1,1,1,1,0,0,0,0,0,0,0};do( dfs() if(num==1) ans++; ){next_permutation(a,a+12)};

题目代码

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int row=3,col=4;
int a[]={0,0,0,0,0,0,0,1,1,1,1,1};
int map[row][col];
bool st[row][col];
int ans;

int dx[]={-1,0,1,0},dy[]={0,1,0,-1};

//连通 直接走完连通的部分
void dfs(int x,int y)
{
    st[x][y]=true;
    for(int i=0;i<4;i++)
        {
            int tx=x+dx[i],ty=y+dy[i];
            if(tx<0||tx>=row||ty<0||ty>=col)continue;
            if(st[tx][ty]||!map[tx][ty])continue;
            dfs(tx,ty);
        }
}

int main()
{
    do{
        //重置
        memset(map,0,sizeof map),memset(st,false,sizeof st);
        int num=0,cnt=0;
        
        //读入
        for(int i=0;i<row;i++)
            for(int j=0;j<col;j++)
                map[i][j]=a[cnt++];
        
        //连通
        for(int i=0;i<row;i++)
            for(int j=0;j<col;j++)
                if(!st[i][j]&&map[i][j])
                    num++,dfs(i,j);

        //检查 连通块只有一个，正确
        if(num==1)ans++;
    }while(next_permutation(a,a+12));
    
    cout<<ans;
    
    return 0;
}

四平方和

来源： 第七届蓝桥杯省赛C++A/B组

算法标签：二分，哈希

题目描述

四平方和定理，又称为拉格朗日定理：

每个正整数都可以表示为至多 4 个正整数的平方和。

如果把 0 包括进去，就正好可以表示为 4 个数的平方和。

比如：

5=02+02+12+22
7=12+12+12+22
对于一个给定的正整数，可能存在多种平方和的表示法。

要求你对 4 个数排序：

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

输入格式

输入一个正整数 N。

输出格式

输出4个非负整数，按从小到大排序，中间用空格分开。

数据范围

0<N<5∗10E6

输入样例：

5

输出样例：

0 0 1 2

思路

暴力 o(n^3)

#include<iostream>
#include<cmath>
using namespace std;

int main()
{
    int n;
    cin>>n;
     //为什么遍历是到 a*a<= n  b*b+a*a ？
    //因为都是 n==a*a+b*b+c*c+d*d 确定 外层确定之后内层可以减去
    for(int a=0;a*a<=n;a++)
        for(int b=a;b*b+a*a<=n;b++)
            for(int c=b;b*b+a*a+c*c<=n;c++)
                {
                    int t=n-a*a-b*b-c*c;
                    int d=sqrt(t);
                     if(d*d==t)//这样必定是升序最小
                        {
                            cout<<a<<" "<<b<<" "<<c<<" "<<d;
                            return 0;
                        }
                }
}

5*10^6 开方2300 枚举不能过多

二分 O(N2logN)

#include<iostream>
#include<algorithm>

using namespace std;

const int N=5e6+10;
int n,cnt;

struct node{
    int v,c,d;
    bool operator < (const node &t)const    //重载< 因为sort给结构体排序,括号中的const表示参数a对象不会被修改，最后的const表明调用函数对象不会被修改
    {
        if(v!=t.v)return v<t.v;
        if(c!=t.c)return c<t.c;
        if(d!=t.d)return d<t.d;
    }
}node[N];
int main()
{
    cin>>n;
    for(int c=0;c*c<=n;c++)
        for(int d=c;d*d+c*c<=n;d++)
            node[cnt++]={c*c+d*d,c,d};
            
    sort(node,node+cnt);
    
    for(int a=0;a*a<=n;a++)
        for(int b=a;a*a+b*b<=n;b++)
            {
                int l=0,r=cnt-1;
                int t=n-a*a-b*b;
                while(l<r)// a<b,c<d,ab之后二分查找cd的值，所以一定是最小升序
                    {
                        int mid=l+r>>1;
                        if(node[mid].v>=t)r=mid;
                        else l=mid+1;
                    }
                if(node[l].v==t)
                    {
                        cout<<a<<" "<<b<<" "<<node[l].c<<" "<<node[l].d;
                        return 0;
                    }
            }
}

交换瓶子

交换瓶子

来源： 第七届蓝桥杯省赛C++B组

算法标签 图论 环 置换群 贪心

题目描述

有 N 个瓶子，编号 1∼N，放在架子上。

比如有 5 个瓶子：

2 1 3 5 4
要求每次拿起 2 个瓶子，交换它们的位置。

经过若干次后，使得瓶子的序号为：

1 2 3 4 5
对于这么简单的情况，显然，至少需要交换 2 次就可以复位。

如果瓶子更多呢？你可以通过编程来解决。

输入格式

第一行包含一个整数 N，表示瓶子数量。

第二行包含 N 个整数，表示瓶子目前的排列状况。

输出格式

输出一个正整数，表示至少交换多少次，才能完成排序。

数据范围

1≤N≤10000,

输入样例1：

5
3 1 2 5 4

输出样例1：

3

输入样例2：

5
5 4 3 2 1

输出样例2：

2

思路

由样例1
3 1 2 5 4 转为
1 2 3 4 5

对于瓶子顺序而言 则会有
3 对应正确顺序的3的位子 即当前的 2
2 对应正确顺序的2的位子 即当前的 1
1 对应正确顺序的2的位子 即当前的 3
这连接则形成一个闭环
总共有两个闭环

环内两个点的变动可以使得环分裂为2
环外的两个点的变动可以使得两个环合并为1

环最简的情况下是 自指，即存在n个环
这种情况同时也是 该题转换为正确顺序之后的情况
则可以遍历出当前所有环的数量 k
从k变更到n 需要n-k步骤
答案即为 n-k

在实际的操作过程当中，遍历环可以从1(i)出发每次指向i=a[i]即指向指定的目标

时间复杂度

实际从n^2优化到了n

C++ 代码

#include<iostream>
#include<cstdio>

using namespace std;

const int N=1e4+10;
bool st[N];
int a[N],n,k;

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];//瓶子初始序号
    
    for(int i=1;i<=n;i++)//从每个正确序号出发
        if(!st[i])//如果没有走过
            {
                k++;//环数量加一
                for(int j=i;!st[j];j=a[j])//走完这个环 每次变更指向a[j] 即瓶子初始序号的第j个
                    st[j]=true;
            }
    
    cout<<n-k;//环最简情况为自指 则最多有n个环 当前有k个环 从K达到n则需要n-k次
    
    return 0;
}

最大比例

来源：第七届蓝桥杯省赛C++B组

算法标签：数论，最大公约数，辗转相减法

题目描述：

X星球的某个大奖赛设了 M 级奖励。

每个级别的奖金是一个正整数。

并且，相邻的两个级别间的比例是个固定值。

也就是说：所有级别的奖金数构成了一个等比数列。

比如：16,24,36,54，其等比值为：3/2。

现在，我们随机调查了一些获奖者的奖金数。

请你据此推算可能的最大的等比值。

输入格式

第一行为数字 N ，表示接下的一行包含 N 个正整数。

第二行 N 个正整数 Xi，用空格分开，每个整数表示调查到的某人的奖金数额。

输出格式

一个形如 A/B 的分数，要求 A、B 互质，表示可能的最大比例系数。

数据范围

0<N<100
0<Xi<1012
数据保证一定有解。

输入样例1：

3
1250 200 32

输出样例1：

25/4

输入样例2：

4
3125 32 32 200

输出样例2：

5/2

输入样例3：

3
549755813888 524288 2

输出样例3：

4/1

思路

我们要找一个数列的最大的等比值。
这种感觉和等差数列很相似，我们直接往GCD上靠

由于一串数据，排序之后肯定存在等差q

s= s1, s2 , s3 ...sq ... sns= aq^0,aq^1, aq^2 ...a^q^k....aq^n每个位次上都可以转换为[p/q]^w形式，即si=[s/a0,s/ai]^k存在公比形如[p/q]^k 因为[p/q]^k>0,要使得整体最大则公比系数最大，则求K最大 k的限制条件 [p/q]^w是[p/q]^k的次幂 [p/q]^w=（[p/q]^k）^s=[p/q]^k^s 则k是每一个w的约数 k最大就是wi的最大公约数 状如[p/q]^wi 我们现在转向了求每一个wi的最大公约数 [p/q]^k = [p^k/q^k] 我们可以直接求取分子分母 则分别求分子分母指数最大公约数

关于辗转相减求指数最大公约数

题目代码

#include<iostream>
#include<algorithm>


using namespace std;

typedef long long LL;

const int N=110;

int n;
LL x[N],a[N],b[N];

LL gcd(LL a,LL b)//辗转相除
{
    return b?gcd(b,a%b):a;
}

LL gcd_sub(LL a,LL b)//辗转相减
{
    if(b>a)swap(a,b);
    if(b==1)return a;
    return gcd_sub(b,a/b);
}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)cin>>x[i];//读入
    
    sort(x,x+n);
    
    LL dd=0;
    int cnt =0;
    for(int i=1;i<n;i++)
    {
        if(x[i]!=x[i-1])//去重
        {
            dd =gcd(x[i],x[0]);//最大公约数
            a[cnt] = x[i]/dd;
            b[cnt] = x[0]/dd;
            cnt++;
        }
    }
    
    LL up = a[0],down = b[0];//up分子 down分母
    for(int i=1;i<cnt;i++)//分开求分子分母的指数最大公约数
    {
        up = gcd_sub(up,a[i]);
        down = gcd_sub(down,b[i]);
    }
    
    cout<<up<<"/"<<down;
    
    return 0;
}