「思特奇杯-云上蓝桥-算法集训营」第一周

1.跑步训练

问题描述

小明要做一个跑步训练，初始时，小明充满体力，体力值计为 10000。

如果小明跑步，每分钟损耗 600 的体力。

如果小明休息，每分钟增加 300 的体力。

体力的损耗和增加都是 均匀变化的。

小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。

如果某个时刻小明的体力到达 0，他就停止锻炼， 请问小明在多久后停止锻炼。

为了使答案为整数，请以秒为单位输出答案，答案中只填写数，不填写单位。

#include <iostream>
using namespace std;
int main()
{
	int power = 10000;
	int time = 0;
	int key = 1;
	while(power > 0)
	{
		if(key % 2 != 0)
		{
			power -= 600;
			time++;
		}
		else if(key % 2 == 0)
		{
			power += 300;
			time++;
		}
		key++;
	}
	cout << time * 60 <<endl;
	return 0;
 } 

2.阶乘约数

问题描述
定义阶乘 n! = 1 × 2 × 3 × ··· × n。

请问 100! （100 的阶乘）有多少个约数。

#include <iostream>
using namespace std;
int a[100];
int main()
{
	for (int i = 2; i <= 100; i ++)
	{
		int n = i;
		for (int j = 2; j <= n / j; j ++)
			while(n % j == 0)
			{
				a[j] ++;
				n /= j;
			}
		if(n > 1) a[n] ++;	
	}
	
	long long ans = 1;
	for (int i = 2; i <= 100; i ++)
		if(a[i]) ans *= (a[i] + 1);

	cout << ans << endl;
	return 0;	
}

3.出栈次序

问题描述

X星球特别讲究秩序，所有道路都是单行线。

一个甲壳虫车队，共16辆车，按照编号先后发车，夹在其它车流中，缓缓前行。

路边有个死胡同，只能容一辆车通过，是临时的检查站，如图所示。

X星球太死板，要求每辆路过的车必须进入检查站，也可能不检查就放行，也可能仔细检查。

如果车辆进入检查站和离开的次序可以任意交错。

那么，该车队再次上路后，可能的次序有多少种？

为了方便起见，假设检查站可容纳任意数量的汽车。

显然，如果车队只有1辆车，可能次序1种；2辆车可能次序2种；3辆车可能次序5种。

现在足足有16辆车啊，亲！需要你计算出可能次序的数目。

Catalan数：C(2n,n)/(n+1) （C(2n,n)表示2n里取n）

#include <iostream>
#include <string.h>
using namespace std;
int main()
{
    int f[20];
    memset(f,0,sizeof(f));
    f[0]=1;
    f[1]=1;
    f[2]=2;
    f[3]=5;
    for(int i=4; i<=16; i++)
    {
        for(int j=0; j<=i-1; j++)
            f[i]+=f[j]*f[i-1-j];
    }
    cout<<f[16]<<endl;
    return 0;
}

4.哥德巴赫分解
哥德巴赫猜想认为：不小于4的偶数都可以表示为两个素数的和。

你不需要去证明这个定理，但可以通过计算机对有限数量的偶数进行分解，验证是否可行。

实际上，一般一个偶数会有多种不同的分解方案，我们关心包含较小素数的那个方案。
对于给定数值范围，我们想知道这些包含较小素数方案中最大的素数是多少。

比如，100以内，这个数是19，它由98的分解贡献。

你需要求的是10000以内，这个数是多少？
 

#include <iostream>
using namespace std;
bool is_prime(int num) {
    if (num == 1) return false;
    for (int i = 2; i*i < 1+num; i++)
        if (num % i == 0) return false;
    return true;
}

int main() {
    int n;
    cin >> n;
    int m = 0;
    for (int i = n; i > 3; i -= 2) {
        for (int j = 1; 2 * j < i+1; j+=2) {
            if (is_prime(j) && is_prime(i - j)) {
                m = max(m, j);
                break;
            }
        }
    }
    cout << m << endl;
    return 0;
}

5.图书排序

题目描述

将编号为1~10的10本书排放在书架上，要求编号相邻的书不能放在相邻的位置。

请计算一共有多少种不同的排列方案。

#include <bits/stdc++.h>
using namespace std;
int main() {
	int a[]={1,2,3,4,5,6,7,8,9,10},i,count=0;
	while(next_permutation(a,a+10)) {
		for(i=0;i<9;i++) 
			if(abs(a[i]-a[i+1])==1) break;
		if(i==9) count++;						
	}
	cout<<count<<endl;
   return 0;
}

6.猴子分香蕉

5 只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。

第 11 只猴子醒来，把香蕉均分成 55 堆，还剩下 11 个，就吃掉并把自己的一份藏起来继续睡觉。

第 22 只猴子醒来，把香蕉均分成 55 堆，还剩下 22 个，就吃掉并把自己的一份藏起来继续睡觉。

第 33 只猴子醒来，把香蕉均分成 55 堆，还剩下 33 个，就吃掉并把自己的一份藏起来继续睡觉。

第 44 只猴子醒来，把香蕉均分成 55 堆，还剩下 44 个，就吃掉并把自己的一份藏起来继续睡觉。

第 55 猴子醒来，重新把香蕉均分成 55 堆，哈哈，正好不剩！

请计算一开始最少有多少个香蕉。
暴力求解

#include <iostream>
using namespace std;
int check(int s_banana) {//当函数满足所有条件的时候返回True
    int temp = s_banana % 5;//定义每只猴子平分后剩下的香蕉
    if (temp == 1) {
        s_banana = s_banana - temp - (s_banana - temp) / 5;
        temp = s_banana % 5;
        if (temp == 2) {
            s_banana = s_banana - temp - (s_banana - temp) / 5;
            temp = s_banana % 5;
            if (temp == 3) {
                s_banana = s_banana - temp - (s_banana - temp) / 5;
                temp = s_banana % 5;
                if (temp == 4) {
                    s_banana = s_banana - temp - (s_banana - temp) / 5;
                    temp = s_banana % 5;
                    if (temp == 0&&s_banana!=0) {
                        return 1;//满足所有条件；返回True;
                    }
                }return 0;
            }return 0;
        }return 0;
    }return 0;//如果不满足任意条件则返回False
}
 
int  main()
{
    for (int s_banana= 0; s_banana <= 4000; s_banana++)//暴力求解50到4000满足条件的香蕉数目
    {
        if (check(s_banana)) {//调用函数看是否满足所有条件
            cout << s_banana << endl;
            break;
        }
    }
    return  0;
}         
 

7.

稍小分数

回到小学----
真分数：分子小于分母的分数
既约分数：分子分母互质，也就是说最大公约数是1

x星球数学城的入口验证方式是：
屏幕上显示一个真分数，需要你快速地找到一个比它小的既约分数，要求这个分数越大越好。
同时限定你的这个分数的分母不能超过100。

int gcd(int a, int b)
{
    if(b==0) return a;
    return gcd(b,a%b);    
}
int main()
{
    // 这是屏幕上显示的那个分数 a/b
    int a = 7;
    int b = 13;
    
    int m,n;
    int max_a = 0;
    int max_b = 1; 
    
    for(n=100; n>1; n--){
        for(m=n-1; m>=1; m--){
            if(m*b<a*n && gcd(m,n)==1){
                if( max_a*n<max_b*m){  //填空
                    max_a = m;
                    max_b = n;
                    break;
                }
            }
        }
    }
    
    printf("%d/%d\n", max_a, max_b);    
    return 0;
}

8.Excel地址

时间限制：1.0s   内存限制：256.0MB

问题描述

Excel单元格的地址表示很有趣，它使用字母来表示列号。

　　比如，

A表示第1列，

B表示第2列，

Z表示第26列，

AA表示第27列，

AB表示第28列，

BA表示第53列，

....

　　当然Excel的最大列号是有限度的，所以转换起来不难。

　　如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？

　　本题目即是要求对输入的数字, 输出其对应的Excel地址表示方式。

#include<iostream>
#include<string.h>
using namespace std;
long long n;
string tos(char a){
	string b;
	b += a;
	return b;
}
string res(long long x){
	if(x<26)return tos(char('A'+x%26));
	return res(x/26-1)+char('A'+x%26);
}
int main(){
	cin>>n;
	cout<<res(n-1);
	return 0;
}

9.日期问题

小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。

比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。

给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？

输入

一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)

输出

输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。

样例输入

02/03/04

样例输出

2002-03-04

2004-02-03

2004-03-02

1 把输入的字符串切割为三个整数。

2.日、月合法性检验，不合法返回空字符串 

3.月，日如果少零，则补全 ( 首先把整数化为字符串 i2s()，用字符串的长度判断是否少0 ) 

4.用集合 set<string> 对三种 case( 年/月/日，日/月/年，月/日/年 )进行排序和去掉重复

#include<cstdio>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
bool isLeapYear(int year)
{
	if(year%4==0&&year%100!=0 || year%400==0)  return true;
	else return false;
}
void i2s(int i, string &s) //&s 传引用 
{
	stringstream ss;
	ss<<i;
	ss>>s;
}
string f(int a, int b, int c) //a年  b月  c日  
{
	//剔除不合法年月日，return "" 
	if(a>=60 && a<=99) a+=1900;
	if(a>=0 && a<=59)  a+=2000;
	if(b<1 || b>12) return "";
	if(c<1 || c>31)  return "";
	
	switch(b){
		case 2 : 
			if(isLeapYear(a) && c>29) return "";
			if(!isLeapYear(a) && c>28) return "";
		    break;
		case 4 :
			if(c>30) return "";
			break;
		case 6 :
			if(c>30) return "";
			break;
		case 9 :
			if(c>30) return "";
			break;
		case 11 :
			if(c>30) return "";
			break;
		default :
			break;
		
	}
	//月，日如果少零，则补全(首先把整数化为字符串，用字符串的长度判断是否少0) 
	string _a, _b, _c; 
	i2s(a, _a);
	i2s(b, _b);
	i2s(c, _c); 
	if(_b.length()==1) _b = "0" + _b;
	if(_c.length()==1) _c = "0" + _c;
	
	return _a+"-"+_b+"-"+_c;
	
	
}
 
int main(int argc, const char *argv[])
{
	// 输入的字符串切割为三个整数(年月日)
	string in;
	cin>>in;
	int a=0, b=0, c=0;
	a = (in[0]-'0')*10 + (in[1]-'0');
	b = (in[3]-'0')*10 + (in[4]-'0');
	c = (in[6]-'0')*10 + (in[7]-'0');
	string case1 = f(a, b, c);
	string case2 = f(c, a, b);
	string case3 = f(c, b, a);
	
	//对元素排序(日期从小到大)，去重——set 
	set<string> ans;
	if(case1!="") ans.insert(case1);
	if(case2!="") ans.insert(case2);
	if(case3!="") ans.insert(case3);
	for(set<string>::iterator iter = ans.begin(); iter != ans.end(); iter++)
	{
		cout<<*iter<<endl;//* 指针 
	}
	
} 

10.整数划分

对于一个正整数n的划分，就是把n变成一系列正整数之和的表达式。注意，分划与顺序无关，例如6=5+1.跟6=1+5是同一种分划，另外，这个整数本身也是一种分划。

例如：对于正整数n=5，可以划分为：

1+1+1+1+1

1+1+1+2

1+1+3

1+2+2

2+3

1+4

5

输入描述

输入一个正整数n

输出描述

输出n整数划分的总数k

输入样例

5

输出样例

7

#include<iostream>
using namespace std;
const int A = 10005;
int min(int x,int y){return x<y?x:y;}

int dp(int n,int m){
	if(m<=1)return 1;
	int sum=0;
	for(int i=1;i<m;i++){
		sum += dp(n-i,min(n-1,i));
	}
	return sum;
}
int main(){
	int n;
	cin>>n;
	cout<<dp(n,n);
	return 0;
}

11.一步之遥

从昏迷中醒来，小明发现自己被关在X星球的废矿车里。

矿车停在平直的废弃的轨道上。

他的面前是两个按钮，分别写着“F”和“B”。

小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。

按F，会前进97米。按B会后退127米。

透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。

他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。

或许，通过多次操作F和B可以办到。

矿车上的动力已经不太足，黄色的警示灯在默默闪烁...

每次进行 F 或 B 操作都会消耗一定的能量。

小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。

请填写为了达成目标，最少需要操作的次数。

注意，需要提交的是一个整数，不要填写任何无关内容（比如：解释说明等）

//暴力解法
#include <iostream>
using namespace std;
const int maxn = 1000;
int main(){
    for(int i = 0; i < maxn; ++i){
        for(int j = 0; j < maxn; ++j){
            if(97 * i - 127 * j == 1){
                cout << i <<" "<< j <<endl;
            }
        }
    }   
    return 0;
}

 解法2：扩展欧几里得算法

//不定方程 不定方程的整数解 
//扩展欧几里得定理 Ax + By = gcd(A,B)有解 
#include <iostream>
#include <fstream>

using namespace std;

int ex_gcd(int a, int b, int &x, int &y){
    //该函数求不定方程 a * x + b * y = gcd(a,b) 的整数解x,y 
    //返回最大公约数 
    if(b == 0){
        x = 1;//b == 0时, x * a = gcd(a,0) = a 
        y = 0;
        return a;
    }
    int ans = ex_gcd(b, a % b, x, y);
    int t = x;
    x = y;
    y = t - a / b * x;
    return ans;
}

int main(){
//  97 * x + 127 * y = 1;
    int x,y;
    int a = ex_gcd(127,97,x,y);
    cout<<a<<endl;//a:最大公约数
    cout<<x<<endl;//方程的解x
    cout<<y<<endl;//方程的解y
    return 0;
}

12.

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

先暴力最低层后确定最高层

#include<iostream>
using namespace std;
 int n,m,sum,a[1010],n1,m1;  

 bool judge(int a[]){  
        int i=0;  
            for(int j=1;i+j<n+m;j++){//从第一行开始判断  
                for(int k=0;k<j;k++){//每行的个数  
                    if(a[i]==1){  
                        if(a[i+j]!=a[i+j+1]){  
                            return false;  
                        }  
                    }  
                    if(a[i]==2){  
                        if(a[i+j]==a[i+j+1]){  
                            return false;  
                        }  
                    }  
                    i++;  
                }  
            }  

        return true;      
    }  

  void A(int c[],int k){  
        if(k==n+m){  
            if(n1==n&&m1==m){  
                if(judge(c))  
                    sum++;                
            }  
        }else{  
        for(int i=1;i<=2;i++){  
                if(i==1){  
                    c[k]=i;  
                    n1++;  
                    A(c,k+1);  
                    n1--;  
                }  
                else if(i==2){  
                    c[k]=i;  
                    m1++;  
                    A(c,k+1);  
                    m1--;  
                }  

        }         
        }  
    }  



int main() {  
        cin>>n>>m;
        A(a,0);  
        cout<<sum<<endl;
        return 0;
    }  

13.七星填空

如下图所示。在七角星的 14 个节点上填入 1 ~ 14的数字，不重复，不遗漏。 要求每条直线上的四个数字之和必须相等。

 

图中已经给出了 3 个数字。 请计算其它位置要填充的数字，答案唯一。

填好后，请输出绿色节点的 4 个数字（从左到右，用空格分开）。

全排列

#include<iostream>
#include<algorithm>
using namespace std;
int a[20]={1,2,3,4,5,7,8,9,10,12,13};
int main()
{
	do
	{
		int x1=a[0]+a[1]+a[2]+a[3];
		int x2=a[0]+a[4]+a[6]+a[9];
		int x3=6+a[1]+a[4]+14;
		int x4=6+a[2]+a[5]+11;
		int x5=a[3]+a[5]+a[7]+a[10];
		int x6=14+a[6]+a[8]+a[10];
		int x7=a[9]+a[8]+a[7]+11;
		if(x1==x2 && x1==x3 && x1==x4 && x1==x5 && x1==x6 && x1==x7)
		{
			for(int i=0;i<11;i++)
				cout<<a[i]<<" ";
			cout<<endl;
		}
	}while(next_permutation(a,a+10));
	return 0;
}