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

1.跑步训练

 

#include<iostream>

using namespace std;

const int SumN = 10000;
const int miniPullN = 600;
const int minipushN = 300;

int main(){
    int tmpSumN = SumN;
    int res=0;
    int resSecond=0;
    while(tmpSumN>=0){
        res++;
        if(res%2==1){
            if(tmpSumN>=miniPullN){
                tmpSumN-=miniPullN;
            }
            else{
                res--;
                resSecond=(tmpSumN/10);
                tmpSumN=-1;
            }
        }
        else {
            tmpSumN+=minipushN;
        }
    }
    
    cout<<res*60+resSecond;
    return 0;
}

2.阶乘约数

#include <cstdio>

int fac[105] = {0};
long long sum = 1;

int main(){
    for(int i=2; i<=100; i++){
        int x = i;
        for(int j=2; j*j<=i; j++){
            while(x % j == 0){
                fac[j]++;
                x /= j;
            }
        }
        if(x != 1){
            fac[x]++;
        }
    }
    for(int i=2; i<=100; i++){
        if(fac[i] != 0){
            sum *= (fac[i]+1);
        }
    }
    printf("%lld", sum);
    
    return 0;
}

3.出栈次序

 

X星球特别讲究秩序，所有道路都是单行线。一个甲壳虫车队，共16辆车，按照编号先后发车，
夹在其它车流中，缓缓前行。

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

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
using namespace std;
 
int main()
{
    int f[17]={0};
    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];
    }
    printf("%d\n",f[16]);
    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;
}

5.图书排练

 

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;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long
int a[]={1,2,3,4,5,6,7,8,9,10};
int main()
{
    int ans=0;
    do
    {
        if(abs(a[0]-a[1])==1) continue;
        if(abs(a[1]-a[2])==1) continue;
        if(abs(a[2]-a[3])==1) continue;
        if(abs(a[3]-a[4])==1) continue;
        if(abs(a[4]-a[5])==1) continue;
        if(abs(a[5]-a[6])==1) continue;
        if(abs(a[6]-a[7])==1) continue;
        if(abs(a[7]-a[8])==1) continue;
        if(abs(a[8]-a[9])==1) continue;
        ans++;

    }while(next_permutation(a,a+10));
    cout<<ans<<endl;
//    cout<<479306<<endl;
    return 0;
}

6.猴子分香蕉

#include<iostream>
using namespace std;
int main(){
    int n=6;//设置 第一只猴子醒来看到的香蕉数量 初始值 至少为6
    while(true){
        if(n%5==1){//满足第一只猴子均分香蕉还剩一个的条件
            int a=(n-1)/5*4;//第二只猴子醒来时看到的香蕉的数量
            if(a%5==2){
                int b=(a-2)/5*4;//第三只猴子醒来时看到的香蕉的数量
                if(b%5==3){
                    int c=(b-3)/5*4;//第四只猴子醒来时看到的香蕉的数量
                    if(c%5==4){
                        int d=(c-4)/5*4;//第五只猴子醒来时看到的香蕉的数量
                
                        if(d%5==0&&d!=0){//判断是否满足第五只猴子均分香蕉刚好分完的条件
                            cout<<n<<endl;
                            break;
                        }
                    }
                }
            }
        }
        n++;
    }
    return n;
}

7.带分数

问题描述
100 可以表示为带分数的形式：100 = 3 + 69258 / 714。还可以表示为：100 = 82 + 3546 / 197。注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。类似这样的带分数，100 有 11 种表示法。
输入格式
从标准输入读入一个正整数N (N<1000*1000)
输出格式
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！
样例输入1
100
样例输出1
11
样例输入2
105
样例输出2
6

解法思路：从分母的取值范围入手
从题目中可以理解，分母的位数不会超过四位,(总共九个数字，整数至少有一位，则剩余的八个数字交给分子和分母，又要保证分子与分母的商为整数，则分子要大于分母，所以分母不会超过五位)，当分母为四位数时，分子也为四位数，分子最大为9876，要保证分子与分母的商为整数，则分母最大为9876/2=4938，显然分母不能超过4938；
带分数的整数取值范围不会超过n(被求的数)，通过枚举整数和分母，可以求出分子：分子=（n-整数）*分母；如果分子、分母、和整数，所有数字都不重复，则是满足条件的答案

#include<iostream>
#include<string.h>
using namespace std;
int a[10]={0};
Division(int m)//将数字分割 
{
    int t;    
    while(m)
    {
        t=m%10;
        if(t==0)//不会为零，不符合题意 
        {
            return 0;
        } 
        a[t]++;
        m=m/10; 
    }    
    return 1;
} 
int main()
{
    int i,k,j;//整数，分子，分母
    int number,ans=0,flag;
    cin>>number;
    for(i=1;i<number;i++)
    {
        for(j=1;j<=4938;j++)
        {
            memset(a,0,sizeof(a));//每次都应更新
            k=(number-i)*j; 
            if(Division(i)&&Division(j)&&Division(k))
            {
                flag=1;//每次都应更新
                for(int x=1;x<10;x++)//判断数字是否有重复的 
                {
                    if(a[x]!=1)
                    {
                        flag=0;
                        break;
                     } 
                }
                if(flag==1) ans++;
            }
        }
    }
    cout<<ans;
    return 0;
} 

8.Excel地址

Excel单元格的地址表示很有趣，它使用字母来表示列号。
比如，
A表示第1列，
B表示第2列，
Z表示第26列，
AA表示第27列，
AB表示第28列，
BA表示第53列，
....

当然Excel的最大列号是有限度的，所以转换起来不难。
如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？

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

#include<iostream>

using namespace std;

#define SUB 50
int sign[SUB] = {0};
int get_digits(int data);
void init_data(int data);
void view(int data[]);
void jud(int data);

int info;

int main(int argc,char** argv){
 
 while(1){
 
 printf("\n");
 cin >> info;
 init_data(info);
 jud(info);
 }

}

void jud(int data){
 
 bool state = true;
 
 for(int i = 0;i < get_digits(data);i++){
 
 if(sign[i] == 0){
 
 state = false;
 }
 }
 
 if(state){
 
 view(sign);
 
 }else{
 
 if(data == 26){
 
 cout << "Z";
 
 }else{
 
 for(int i = get_digits(data) - 1;i >= 0;i--){
 
 if(sign[i] == 0){
 
 sign[i - 1] = sign[i - 1] - 1;
 sign[i] = 26; 
 }
 }
 
 view(sign);
 } 
 }
}

void init_data(int data){
 
 int sub = 0;
 int sub_temp = get_digits(data);
 
 while(data){
 
 sign[sub_temp - 1 - sub] = data % 26;
 data = data / 26;
 sub++;
 }
}

int get_digits(int data){
 
 int order = 1;
 
 while(data / 26){
 
 data = data / 26;
 order++;
 }
 
 return order;
}

void view(int data[]){
 
 for(int i = 0;i < get_digits(info);i++){
 
 switch(data[i]){
 
 case 1:
 cout << "A";
 break;
 case 2:
 cout << "B";
 break;
 case 3:
 cout << "C";
 break;
 case 4:
 cout << "D";
 break;
 case 5:
 cout << "E";
 break;
 case 6:
 cout << "F";
 break;
 case 7:
 cout << "G";
 break;
 case 8:
 cout << "H";
 break;
 case 9:
 cout << "I";
 break;
 case 10:
 cout << "J";
 break;
 case 11:
 cout << "K";
 break;
 case 12:
 cout << "L";
 break;
 case 13:
 cout << "M";
 break;
 case 14:
 cout << "N";
 break;
 case 15:
 cout << "O";
 break;
 case 16:
 cout << "P";
 break;
 case 17:
 cout << "Q";
 break;
 case 18:
 cout << "R";
 break;
 case 19:
 cout << "S";
 break;
 case 20:
 cout << "T";
 break;
 case 21:
 cout << "U";
 break;
 case 22:
 cout << "V";
 break;
 case 23:
 cout << "W";
 break;
 case 24:
 cout << "X";
 break;
 case 25:
 cout << "Y";
 break;
 case 26:
 cout << "Z";
 break;
 case 0:
 cout << "Z";
 default:
 break;
 }
 }
}

9.日期问题

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

struct date
{

    int year,month,day;

    bool operator<(date &d)
    {

        if(this->year<d.year)
        {
            return true;
        }
        else if(this->year==d.year&&this->month<d.month)
        {
            return true;
        }
        else if(this->year==d.year&&this->month==d.month&&this->day<d.day)
        {
            return true;
        }
        else return false;
    }

    bool operator=(date &d)
    {
        this->day=d.day;
        this->year=d.year;
        this->month=d.month;
    }
} dates[3];
int transa(int a)
{
    if(a>59)
    {
        a=1900+a;
    }
    else a=2000+a;
    return a;

}
bool checkdates(int year,int month,int day)
{
    year=transa(year);
    int leap;
    int monday[12]= {31,28,31,30,31,30,31,31,30,31,30,31};
    if(month<1||month>12)return false;

    if(year%400==0||(year%4==0&&year%100!=0))leap=1;
    else leap=0;

    monday[1]+=leap;
    if(day<1||day>monday[month-1])return false;
    return true;

}

void innidates(int a,int b,int c,int i)
{
    a=transa(a);
    dates[i].year=a;
    dates[i].month=b;
    dates[i].day=c;

}
int main()
{
    string str;
    int a,b,c;
    scanf("%d/%d/%d",&a,&b,&c);

    int num=0;

    if(checkdates(a,b,c))
    {
        innidates(a,b,c,num);
        num++;
        // cout<<a<<" "<<b<<" "<<c<<endl;
    }
    if(checkdates(c,a,b))
    {

        innidates(c,a,b,num);
        num++;

        // cout<<c<<" "<<a<<" "<<b<<endl;
    }
    if(checkdates(c,b,a))
    {

        innidates(c,b,a,num);
        num++;

        //cout<<c<<" "<<b<<" "<<a<<endl;
    }
    //cout<<num<<endl;
    for(int i=1; i<num; i++)
    {

        if(dates[i] < dates[i-1])         //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入
        {
            int j= i-1;
            date x = dates[i];    //复制为哨兵，即存储待排序元素

            dates[i]= dates[i-1];      //先后移一个元素

            while(x < dates[j])  //查找在有序表的插入位置
            {
                dates[j+1] = dates[j];
                j--;     //元素后移
            }
            dates[j+1] = x;   //插入到正确位置
        }
    }

    for(int i=0; i<num; i++)
    {
        if(dates[i].year==dates[i+1].year&&dates[i].month==dates[i+1].month&&dates[i].day==dates[i+1].day)
        {

            continue;
        }
        if(dates[i].month>9&&dates[i].day>9)
        {
            printf("%d-%d-%d\n",dates[i].year,dates[i].month,dates[i].day);
        }
        else if(dates[i].month>9&&dates[i].day<10)
        {
            printf("%d-%d-0%d\n",dates[i].year,dates[i].month,dates[i].day);
        }
        else if(dates[i].month<10&&dates[i].day<10)
        {
            printf("%d-0%d-0%d\n",dates[i].year,dates[i].month,dates[i].day);
        }
        else if(dates[i].month<10&&dates[i].day>9)
        {
            printf("%d-0%d-%d\n",dates[i].year,dates[i].month,dates[i].day);
        }

    }
    return 0;
}

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<stdio.h>
 
int resolve(int a,int max)//一般想来会觉得这个函数只需要一个参数就够了，这里却用了两个。
//因为如果只是一个简单的递归如if(a == 1)return 1;else return resolve(a-1);那么会发现只有
//一个结果，因此加入一个变量作为比较，能够把更多的情况表示出来进而方便处理
{
    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;
}

11.一步之遥

#include<bits/stdc++.h>
using namespace std;

int main()
{
    int x, y;
    int ans = 99999;
    for(x = 1; x <= 330; x++)
    {
        for(y = 1; y <= 330; y++)
        {
            if(x * 97 - 127 * y == 1)
            {
                ans = min(ans, x + y);
            } 
        }
    }
    cout << ans<< endl;
    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
1
2
3
4
5
6
队内的组塔规则是：

A 只能站在 AA 或 BB 的肩上。
B 只能站在 AB 或 BA 的肩上。

你的任务是帮助拉拉队计算一下，在给定A与B的人数时，可以组成多少种花样的塔。

输入一行两个整数 M 和 N，空格分开（0<M,N<500）,分别表示A、B的人数，保证人数合理性。

要求输出一个整数，表示可以产生的花样种数。

#include<iostream>

using namespace std;

int v[500][500];
int a[500][500];
int f[2];//记录剩余A,B的个数
int counts,maxmax,s;
int num=0;
void pd(int r, int c)//判断是否是符合要求的机器人塔
{
    if(r!=maxmax-1)
    {
        if(a[r][c]+a[r+1][c-1]+a[r+1][c+1]==3||a[r][c]+a[r+1][c-1]+a[r+1][c+1]==1)
        {
            counts++;
            pd(r+1,c-1);
            pd(r+1,c+1);
        }
    }
}

void dfs(int r, int c, int flag)//暴力遍历出所有可能的情况
{
    int i;
    if(r>=0&&r<maxmax&&c>=0&&c<maxmax*2-1)
    {
        if(v[r][c]==0)
        {
            for(i=0;i<2;i++)
            {
                if(f[i]>0)
                {
                    v[r][c]=1;
                    a[r][c]=i;
                    f[i]--;
                    if(r==maxmax-1&&c==maxmax*2-2)//当遍历至右下角时，判断该种情况是否是符合要求的机器人搭
                    {
                        counts=0;
                        pd(0,maxmax-1);
                        if(counts==s-maxmax)
                            num++;
                    }
                        
                    if(r<maxmax-1)//按斜线（左下）进行遍历
                        dfs(r+1,c-1,flag);
                    else if(r==maxmax-1)//当到达最底层后，遍历下一个斜线
                        dfs(flag,maxmax-1+flag,flag+1);
                    v[r][c]=0;
                    a[r][c]=0;
                    f[i]++;
                }
            }
        }
    }
}
    
int main()
{
    int m,n,i;
    cin>>m>>n;
    f[1]=m;
    f[0]=n;
    int sum=m+n;
    s=0;
    for(i=1;i<1000;i++)
    {
        s=s+i;
        if(s==sum)
            break;
    }
    maxmax=i;
    dfs(0,maxmax-1,1);
    cout<<num;
    return 0;
}

13.七星填空

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

图片描述

 

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

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

//2016g 七星填数
#include <iostream>   //vxgzh：xtsn
using namespace std;
#include <algorithm>
#include <set>
 
bool abc(int *a)  //用来判断是否满足题目要求
{
    int sum;
    set <int> s;
    sum=a[0]+a[1]+a[2]+a[3]; s.insert(sum);
    sum=a[3]+a[4]+a[5]+a[6];s.insert(sum);
    sum=a[6]+a[7]+a[8]+14;s.insert(sum);
    sum=14+a[10]+a[1]+6;s.insert(sum);
    sum=6+a[2]+a[4]+11;s.insert(sum);
    sum=11+a[5]+a[7]+a[9];s.insert(sum);
    sum=a[9]+a[8]+a[10]+a[0];s.insert(sum);
    if(s.size()==1)
        return true;
    else
        return false;    
}
int main()
{
    int i,a[11]={1,2,3,4,5,7,8,9,10,12,13};  //初始化其余元素
    do
    {
        if(abc(a))
            break;
    }while(next_permutation(a,a+11));   //全排列模拟所有情况
    cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<" "<<a[3]<<endl;
    return 0;
}