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

        1.跑步训练

问题描述

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

如果小明跑步，每分钟损耗 600 的体力。如果小明休息，每分钟增加 300 的体力。

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

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

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

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

代码提交：

public class 跑步训练 {

    public static void main(String[] args) {
        //count用于计算时间 target用于更新实时的体力值
        int count=0;
        int target=10000;
        boolean flag=true;//判断是否需要跑步
        while (true) {
            //如果小于600体力并且需要跑步，证明这一分钟跑不完
            if(target<600&&flag) {
                break;
            }
            if(flag) {
                target=target-600;
                flag=false;
            }else {
                target=target+300;
                flag=true;
            }
            count++;
        }
        //输出最后需要花费的秒数
        int time=count*60+target/10;
        System.out.println(time);
    }
}

输出结果：

        2.阶乘约数

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

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

代码提交：
 

public class 阶乘约数 {
    public static void main(String[] args) {
        // 100 的阶乘有多少约数
        int[] arr=new int[102];
        //利用唯一分解定理分解100的阶乘
        // 必须要从2开始
        for (int i=2;i<=100;i++){
            int n=i;
            for (int j=2;j*j<=n;j++ ){
                while (n%j==0){// 当能够整除 的时候，对应余数的幂次加一
                    arr[j]++;
                    n/=j;
                }
            }
            //整除完了后如果剩下的n不为1，则当前的n为因子
            if (n>1){
                arr[n]++;
            }
        }
        long ans=1;
        for (int i=2;i<=100;i++){
            if (arr[i]>0){
                ans*=(arr[i]+1);
            }
        }
        System.out.println(ans);

    }

}

 

输出结果：

 

        3.出栈次序

问题描述

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

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

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

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

如果车辆进入检查站和离开的次序可以任意交错。那么，该车队再次上路后，可能的次序有多少种？

为了方便起见，假设检查站可容纳任意数量的汽车。显然，如果车队只有1辆车，可能次序1种；2辆车可能次序2种；3辆车可能次序5种。

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

代码提交：

public class three {
    public static int count = 1;
    
    public void dfs(int step, int num, int car) {
        if(step == num)  //当所有排队的汽车均已进栈后
            return;
        dfs(step + 1, num, car + 1);
        if(car > 0) {   //当栈不为空时，可以选择出栈
            count++;
            dfs(step, num, car - 1);
        }
    }
        
    public static void main(String[] args) {
        three test = new three();
        test.dfs(0, 16, 0);
        System.out.println("DFS: "+count);
        int r = 1;
        for(int i = 2;i <= 16;i++) {
            r = r * (4 * i - 2) / (i + 1);  //借鉴网上网友思想：利用卡特兰数
        }
        System.out.println(r);
    }
}

 输出结果：

        4.哥德巴赫分解

问题描述

哥德巴赫猜想认为:不小于4的偶数都可以表示为两个素数的和。
你不需要去证明这个定理，但可以通过计算机对有限数量的偶数进行分解，验证是否可行。实际上，一般一个偶数会有多种不同的分解方案，我们关心包含较小素数的那个方案。对于给定数值范围，我们想知道这些包含较小素数方案中最大的素数是多少。比如，100以内，这个数是19，它由98的分解贡献。你需要求的是10000以内，这个数是多少?

代码提交：

public class TestGoldbach {
   static int ans=0;
   static int n=0;
   static int[] arr=new int[10005];
    static boolean[] arr2=new boolean[10005];
    public static void main(String[] args) {
        find();
        for(int i=2;i<=10000;i=i+2)
        {
            for(int j=0;j<n;j++)
            {
                boolean flag=false;
                for(int k=j+1;k<n;k++)
                {
                    if(arr[j]+arr[k]==i)
                    {
                        ans=Math.max(ans,arr[j]);
                        flag=true;
                    }
                }
                if(flag)break;
            }
        }
        System.out.println(ans);

    }

    private static void find() {
        for(int i=2;i<=10000;i++)
        {
            if(!arr2[i])
            {
                int j=2;
                while(i*j<=10000) {
                    arr2[i*j]=true;
                    j++;
                }
            }
        }
        for(int i=2;i<=10000;i++)
            if(!arr2[i]) arr[n++]=i;
    }

    public static boolean isprime(int n) {
        if(n == 1 || n == 0) return false;
        for (int j = 2; j <= Math.sqrt(n); j++)
        {
            if (n % j == 0)
            {
                return false;
            }
        }
        return true;

    }
}

输出结果：