【思特奇杯·云上蓝桥-算法集训营】 第1周

跑步训练

问题描述

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

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

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

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

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

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

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

//由题意得，跑步每秒消耗10， 休息每秒增加5 ,且最后一定为跑步  
//10000 / (600-300) == 33.33
//33*(600-300) = 9900
//10000 - 9900 + 300 = 400 < 600
//所以时间为32*2*60 + 400/10 = 3880

int main()
{
    long int t=10000;
	int i=0,j=0;//计数 
	int time=0;
	int a;
	
	while(t>=0)
	{
		t-=600;
		i++;
		
		if(t<=0)//当体力小于0时，这一分钟无法跑完，应另行计算 
		{
		t+=600;
		i--;
		break;}
		
		t+=300;
		j++;
		
	 } 
	 
	time=(i+j)*60+(t/10);
	printf("%d,%d,%d\n",i,j,a);
	printf("%d",time);
	
    return 0;
}

 2阶乘约数

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

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

错解：未解出

int f(int n);//n有几个约数 

int main()
{
	long long a=1;
	int i,j;
	
	for(i=1;i<=100;i++)
	{
		if(f(i)!=0)
		a=f(i)*a;
	}
	
	printf("%lld",a);
	return 0;
 } 
 
int f(n) 
{
	int i,j;
	for(i=1;i<=n;i++)
	{
		if(n%i==0)j++;
	}
	return j;
}
 

出栈次序

问题描述

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

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

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

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

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

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

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

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

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

#include <stdio.h>

int f(int n,int m) //n为未入检车站，m为在检车站
{
	if(n==0) //如果左边没有车返回1
		return 1;

	if(m==0) //如果检车站没车就入栈
		return f(n-1,1);

	if(m>0)//如果检车站有车
		//分两种情况，车辆入站和出站
		return f(n-1,m+1)+f(n,m-1);
	return 0;
}

int main() 
{
	printf("%d",f(16,0));
	return 0;
}

哥德巴赫分解

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

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

实际上，一般一个偶数会有多种不同的分解方案，我们关心包含较小素数的那个方案。

对于给定数值范围，我们想知道这些包含较小素数方案中最大的素数是多少。

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

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

注意，需要提交的是一个整数，不要填写任何多余的内容（比如，说明性的文字）

图书排列

题目描述

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

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

注意，需要提交的是一个整数，不要填写任何多余的内容。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
int s[15];
void init()
{
	for(int i=1;i<=10;i++)
		s[i]=i;
}
int cmp()
{
	int k=1;
	while(fabs(s[k]-s[k+1])!=1&&k<=9)
	{
		k++;
	}
	if(k==10)
	return 1;
	else
	return 0;
}
int main()
{
	int ans=0;
	init();
	do{
		if(cmp())
		{
			ans+=1;
		}
	
	}while(next_permutation(s+1,s+11));
	printf("%d\n",ans);
 	return 0;
}

 

题目描述：

5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。
第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。
第2只猴子醒来，重新把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。
第3只猴子醒来，重新把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。
第4只猴子醒来，重新把香蕉均分成5堆，还剩下4个，就吃掉并把自己的一份藏起来继续睡觉。
第5只猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！

请计算一开始最少有多少个香蕉。
 

#include <stdio.h>
int main()
{
    int i=6;//要分5次所以从6开始计算
    while(true)
    {
        if(i%5==1)//第一次分会多出一个
        {
            int x1=i-(i-1)/5;//第一次均分后 都会少一份被拿走
            x1=x1-1;//对了，不能忘记每次多出来的香蕉也被醒过来的猴子偷吃了
            if(x1%5==2)
            {
                int x2=x1-(x1-2)/5;
                x2=x2-2;
                if(x2%5==3)
                {
                    int x3=x2-(x2-3)/5;
                    x3=x3-3;
                    if(x3%5==4)
                    {
                        int x4=x3-(x3-4)/5;
                        x4=x4-4;
                        if(x4%5==0 && x4!=0)//要确保到最后一个猴子醒过来的时候还有香蕉！且正好可以被均分
                        {
                            printf("%d \n",i);
                            break;
                        }
                    }
                }
            }
        }
        i++;
    }
    return 0;
}

 

1. 整数划分

对于一个正整数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

#include<stdio.h>
 
int resolve(int a,int max)
{
	if(a == 1||max ==1)
		return 1;
	if(a == max)
		return resolve(a,max-1)+1;
	if(a > max)
		return resolve(a,max-1)+resolve(a-max,max);
	if(a < max)
		return resolve(a,a);
	else return 0;
}
 
int main()
{
	int n;
	int sum;
	scanf("%d",&n);
	sum = resolve(n,n);
	printf("%d",sum);
	return 0;
}