几个经典的算法

一、求2个字符串的编辑距离

描述

编辑距离指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数，包括以下三种操作：
① 将一个字符替换成另一个字符
② 插入一个字符
③ 删除一个字符

输入

两个字符串

输出

字符串的距离

题解

 public static int minEditDistance(String str1, String str2) {
     int[][] dp = new int[str1.length() + 1][str2.length() + 2];
 
     // 从i个字符变成0个字符，需要i步（删除）
     for (int i = 0; i < str1.length() + 1; i++) {
         dp[i][0] = i;
     }
 
     // 当从0个字符变成j个字符，需要j步(增加)
    for (int j = 0; j < str2.length() + 1; j++) {
        dp[0][j] = j;
    }

    for (int i = 1; i < str1.length() + 1; i++) {
        for (int j = 1; j < str2.length() + 1; j++) {
            // 当相同时，dp[i][j] = dp[i - 1][j - 1]
            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                dp[i][j] = dp[i - 1][j - 1];
            } else {
                // 当不同时，求三种操作的最小值
                // dp[i - 1][j - 1]表示的是替换，dp[i - 1][j]表示删除字符，do[i][j - 1]表示的是增加字符
                dp[i][j] = Math.min(dp[i - 1][j - 1] + 1, Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
            }
        }
    }
    return dp[str1.length()][str2.length()];
}

二、质数因子

描述

输入一个正整数，按照从小到大的顺序输出它的所有质因子

输入

一个正整数

输出

按照从小到大的顺序输出它的所有质数的因子，以空格隔开

题解

 public static void primeFactors(Long num) {
     double sqrt = Math.sqrt(num);
     for (int i = 2; i <= sqrt; i++) {
         while (num % i == 0) {
             System.out.print(i + " ");
             num /= i;
         }
     }
     if (num > 1) {
        System.out.println(num + " ");
    }
}

三、斐波那契数列

描述

由0和1开始，之后的斐波那契数由之前的两数相加而得出

输入

一个整数N

输出

N以内的斐波那契数列

题解

public static int fibonacci(int n) {
    if (n == 1 || n == 2) {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

四、放苹果

描述

把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？

输入

输入两个整数，appleNum表示苹果数量，plateNum表示盘子数量

输出

一个整数，表示苹果有多少种分法

题解

 public static Integer putApple(int appleNum, int plateNum) {
     // 盘子只有一个或者苹果只有一个
     if (appleNum == 1 || plateNum == 1) {
         return 1;
     }
     // 没有苹果
     if (appleNum == 0) {
         return 1;
     }
    // 没有盘子
    if (plateNum == 0) {
        return 0;
    }
    // 盘子大于苹果
    if (plateNum > appleNum) {
        return putApple(appleNum, plateNum);
    }
    // 苹果大于盘子
    return putApple(appleNum, plateNum - 1) + putApple(appleNum - plateNum, plateNum);
}

五、最长回文子串

描述

回文串，指左右对称的字符串，给定一个字符串，求最长的回文子串

输入

输入一个仅包含小写字母的字符串

输出

返回最长回文子串的长度

题解

 public static void maxHuiWen(String str) {
     int max = 0;
     // 从左往右遍历
     for (int i = 0; i < str.length(); i++) {
         // 从右往左遍历
         for (int j = str.length(); j > i; j--) {
             // 截取
             String substring = str.substring(i, j);
             // 如果截取的字符串和反转之后的一样，则是回文子串
            if (substring.contentEquals(new StringBuilder(substring).reverse())) {
                // j-i表示回文子串的长度，求最大值
                max = Math.max(max, j - i);
            }
        }
    }
    System.out.println(max);
}

六、最小公倍数

描述

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值

输入

两个正整数A和B

输出

输出A和B的最小公倍数

题解

public static void minCommonMultiple(int a, int b) {
    for (int i = 1; i <= a * b; i++) {
        if (i%a == 0 && i%b == 0) {
            System.out.println(i);
            break;
        }
    }
}

七、打家劫舍

描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

输入

[1,2,3,1]

输出

4

题解

 public static int rob(int[] nums) {
     int n = nums.length;
     if (n == 1) return nums[0];
     if (n == 2) return Math.max(nums[0], nums[1]);
     int[] dp = new int[n];
     dp[0] = nums[0];
     dp[1] = Math.max(nums[0], nums[1]);
 
     for (int i = 2; i < n; i++) {
        dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
    }
    return dp[n-1];
}