Algorithm Practice Record【6】

「是否连续正整数之和A一递归」

代码案例解析

import java.util.Scanner;

public class 是否连续正整数之和A一递归 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        boolean isYes = checkNum(in.nextInt());
        if (isYes) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
    private static boolean checkNum(int num){
        boolean isYes = false;
        if (num>2){
            if (num%2!=0){
                isYes = true;
            }else {
                return checkNum(num/2);
            }
        }
        return isYes;
    }
}

「是否连续正整数之和B一划窗」

代码案例解析

import java.util.Scanner;

public class 是否连续正整数之和B一划窗 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int left = 1;
        int right = 1;
        int count = 0;
        while (left <= right && right <= n) {
            if (count == n) {
                System.out.println("YES");
                return;
            } else if (count > n) {
                count = count - left;
                left = left + 1;
                continue;
            } else {
                count = count + right;
                right = right + 1;
            }
        }
        /**
         * 1 2 3 4 5  15
         * -1 -2 -3   9
         * 6          15
         * -4         11
         */
        System.out.println("NO");
    }
}

「求幂」

题目描述
涉及计算非常大的量值和精度的精确值的问题很常见。例如，对于许多计算机系统来说，国债的计算是一项繁重的工作。
此问题要求您编写一个程序来计算 R n的精确值，其中 R 是实数 ( 0.0 < R < 99.999 )，n 是 0 < n ≤ 25 的整数。
输入
输入将由一组 R 和 n 值对组成。R 值将占据第 1 至 6 列，n 值将占据第 8 和 9 列。
输出
输出将由一行组成，每一行输入给出 R n的精确值。输出中应抑制前导零。不得打印无意义的尾随零。如果结果是整数，则不打印小数点。
输入样例 1
95.123 12
0.4321 20
5.1234 15
6.7592 9
98.999 10
1.0100 12
输出样例 1
548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

代码案例解析

import java.math.BigDecimal;
import java.util.Scanner;

public class 求幂 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()){
            BigDecimal a = new BigDecimal(in.next());
            int b = in.nextInt();
            String str = a.pow(b).stripTrailingZeros().toPlainString();
            if(str.startsWith("0."))
                System.out.println(str.substring(1));
            else
                System.out.println(str);
        }
    }
}

「矩阵连词」

题目描述
Word Maze 是一个网络小游戏，你需要找到以字母标注的食物，但要求以给定单词字母的顺序吃掉。假设给定单词if，你必须先吃掉i然后才能吃掉f。
但现在你的任务可没有这么简单，你现在处于一个迷宫Maze（n×m的矩阵）当中，里面到处都是以字母标注的食物，但你只能吃掉能连成给定单词W的食物。
注意区分英文字母大小写,并且你只能上下左右行走。
输入
输入第一行包含两个整数n、m(0<n,m<21)分别表示n行m列的矩阵，第二行是长度不超过100的单词W，从第3行到第n+2行是只包含大小写英文字母的长度为m的字符串。
输出
如果能在地图中连成给定的单词，则输出“YES”，否则输出“NO”。注意：每个字母只能用一次。
输入样例 1
5 5
SOLO
CPUCY
EKLQH
CRSOL
EKLQO
PGRBC
输出样例 1
YES

代码案例解析

import java.util.Scanner;

public class 矩阵连词 {
  
    static String target = "";

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String nAndM = in.nextLine();
        String[] rangeArrays = nAndM.split(" ");
        int n = Integer.parseInt(rangeArrays[0]); // 行
        int m = Integer.parseInt(rangeArrays[1]); // 列
        target = in.nextLine();
        String[][] maze = new String[n][m];
        for (int i=0;i<n;i++){ // 构建矩阵
            String row = in.nextLine();
            String[] rowArrays = row.split("");
            for (int j=0;j<m;j++){
                maze[i][j] = rowArrays[j];
            }
        }
//        int n = 4;
//        int m = 5;
//        target = "solot";
//        // a a a a a
//        // s o l o l
//        // a a a s o
//        // a a a a t
//        String[][] maze = new String[n][m];
//        for (int i=0;i<n;i++){ // 构建矩阵
//            String row = "";
//            if (i==0){ row = "aaaaa";}
//            if (i==1){ row = "solol";}
//            if (i==2){ row = "aaaso";}
//            if (i==3){ row = "aaaat";}
//            String[] rowArrays = row.split("");
//            for (int j=0;j<m;j++){
//                maze[i][j] = rowArrays[j];
//            }
//        }
        // 遍历矩阵，找到首位坐标后，递归匹配下一个字符
        for (int i=0;i<n;i++){
            for (int j=0;j<m;j++){
                if (findNext(maze,i,j,0)){
                    System.out.println("YES");
                    return;
                }
            }
        }
        System.out.println("NO");
    }

    /**
     * 递归判断是否能找到下一位,四个方向分别是n+1,n-1,m+1,m-1
     * @param maze 迷宫矩阵
     * @param n 当前行坐标
     * @param m 当前纵坐标
     * @param index 需要匹配的字符串索引
     * @return
     */
    static boolean findNext(String[][] maze,int n,int m,int index){
        // 终止条件1：target字符串全部比对完
        if (index>=target.length()){
            return true;
        }

        // 终止条件2：查找的索引越界
        if (n<0 || m<0 || n>=maze.length || m>=maze[n].length){
            return false;
        }

        // 找到目标字符后，向四个方向继续匹配
        if (maze[n][m].equals(target.substring(index,index+1))){
            // 当前位置置空，防止重复“吃”
            String temp = maze[n][m];
            maze[n][m] = "";
            // 四个方向
            if (findNext(maze,n+1,m,index+1)){
                return true;
            }else if (findNext(maze,n-1,m,index+1)){
                return true;
            }else if (findNext(maze,n,m+1,index+1)){
                return true;
            }else if (findNext(maze,n,m-1,index+1)){
                return true;
            }else { // 说明当前位已匹配，下一位匹配不到,还原当前位字符
                maze[n][m] = temp;
                return false;
            }
        }else {
            return false;
        }
    }
}

「连续n个整数的最小公倍数」

题目描述
为什么1小时有60分钟，而不是100分钟呢？这是历史上的习惯导致。但也并非纯粹的偶然：60是个优秀的数字，它的因子比较多。事实上，它是1至6的每个数字的倍数。即1,2,3,4,5,6都是可以除尽60。
我们希望寻找到能除尽1至n的的每个数字的最小整数。
输入
输入一个整数n,(1<n<=100），测试包含组样例，读到文件末尾结束。
输出
输出求1至n的最小公倍数。
输入样例 1
6
10
100
输出样例 1
60
2520
69720375229712477164533808935312303556800

代码案例解析

import java.math.BigInteger;
import java.util.Scanner;

public class 连续n个整数的最小公倍数 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()){
            int intN = in.nextInt();
            int intNum = intN*(intN-1);
            BigInteger num = new BigInteger(intNum+"");
            for (int i = intN; i >0; i--) {
                if ("0".equals(yuShu(num,i))){
                    continue;
                }else {
                    // 求最两个数小公倍数
                    num = getMinBei(num,i);
                }
            }
            System.out.println(num);
        }
    }
    static BigInteger getMinBei(BigInteger num,int intNn){
        BigInteger n = new BigInteger(intNn+"");
        BigInteger maxYue = new BigInteger("1");
        for (int i = (num.compareTo(n)>0?n.intValue():num.intValue()); i > 0; i--) {
            if ("0".equals(yuShu(num,i)) && "0".equals(yuShu(n,i))){
                maxYue = new BigInteger(i+"");
                break;
            }
        }
        return num.multiply(n).divide(maxYue);
    }

    static String yuShu(BigInteger a, int c){
        BigInteger b = new BigInteger(c+"");
        BigInteger[] bigIntegers = a.divideAndRemainder(b);
        return bigIntegers[1].toString();
    }
}

「超过32位的乘法运算」

题目描述
我有一个非常简单的问题要问你。给定两个整数 A 和 B，您的任务是将 A × B 的乘积相乘。
输入
每行将包含两个整数 A 和 B。处理到文件末尾。请注意，整数非常大，这意味着您不应该使用 32 位整数来处理它们。
您可以假设每个整数的长度不会超过 1000。
输出
对于每种情况，在一行中输出 A × B 的乘积。
输入样例 1
1 2
3 11
14512451451245124512 15125125124512451245
输出样例 1
2
33
219502644063494817653152060344354417440

代码案例解析

import java.math.BigInteger;
import java.util.Scanner;

public class 超过32位的乘法运算 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextBigInteger()){
            BigInteger a = sc.nextBigInteger();
            BigInteger b = sc.nextBigInteger();
            BigInteger sum = a.multiply(b);
            System.out.println(sum);
        }
    }
}

「超过32位的减法运算」

题目描述
我又给你一个非常简单的问题。给定两个整数 A 和 B，您的任务是计算 A - B 的结果。
输入
输入的第一行包含一个整数 T(1<=T<=20)，表示测试用例的数量。
接下来是 T 行，每行由两个正整数 A 和 B 组成。请注意，这些整数非常大，这意味着您不应该使用 32 位整数来处理它们。
您可以假设每个整数的长度不会超过 1000。
输出
对于每个测试用例，您应该输出两行。第一行是“Case #:”，#表示测试用例的编号。第二行是方程“A - B = ?”, ? 表示 A - B 的结果。注意方程中有一些空格。在两个测试用例之间输出一个空行。
输入样例 1
3
9 8
12 8
123456789 987654321
输出样例 1
情况1：
9 - 8 = 1
案例2：
12 - 8 = 4
案例3：
123456789 - 987654321 = -864197532

代码案例解析

import java.math.BigInteger;
import java.util.Scanner;

public class 超过32位的减法运算 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        StringBuffer sb = new StringBuffer();
        for (int i = 1; i <= T; i++) {
            BigInteger a = sc.nextBigInteger();
            BigInteger b = sc.nextBigInteger();
            BigInteger sum = a.subtract(b);
            sb.append("Case " + i + ":\r\n");
            sb.append(a + " - " + b + " = " + sum+"\r\n");
            sb.append("\r\n");
        }
        System.out.println(sb);
    }
}

「超过32位的加法运算」

题目描述
我有一个非常简单的问题要问你。给定两个整数 A 和 B，您的任务是计算 A + B 的总和。
输入
输入的第一行包含一个整数T(1≤T≤20)，表示测试用例的数量。
接下来是 T 行，每行由两个正整数 A 和 B 组成。请注意，这些整数非常大，这意味着您不应该使用 32 位整数来处理它们。您可以假设每个整数的长度不会超过1000。
输出
对于每个测试用例，您应该输出两行。第一行是“Case #:”，#表示测试用例的编号。第二行是一个方程“A + B = Sum”，Sum表示A + B的结果。注意方程中有一些空格。在两个测试用例之间输出一个空行。
输入样例 1
2
1 2
112233445566778899 998877665544332211
输出样例 1
1 + 2 = 3
112233445566778899 + 998877665544332211 = 1111111111111111110

代码案例解析

import java.math.BigInteger;
import java.util.Scanner;

public class 超过32位的加法运算 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        StringBuffer sb = new StringBuffer();
        for (int i = 1; i <= T; i++) {
            BigInteger a = sc.nextBigInteger();
            BigInteger b = sc.nextBigInteger();
            BigInteger sum = a.add(b);
            sb.append("Case " + i + ":\r\n");
            sb.append(a + " + " + b + " = " + sum+"\r\n");
            sb.append("\r\n");
        }
        System.out.println(sb);
    }
}

「阶乘BigInteger版本」

题目描述
给定一个整数 N(0 ≤ N ≤ 10000)，你的任务是计算 N!
输入样例 1
3
输出样例 1
6

代码案例解析

import java.math.BigInteger;
import java.util.Scanner;

public class 阶乘 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println(jc(in.nextBigInteger()));
    }
    static BigInteger jc(BigInteger num){
        BigInteger bi0 = new BigInteger("0");
        BigInteger bi1 = new BigInteger("1");
        if (num.compareTo(bi1)==0 || num.compareTo(bi0)==0){
            return bi1;
        }
        return num.multiply(jc(num.subtract(bi1)));
    }
}

「」

代码案例解析

阶乘a
在这里插入代码片