牛客题目——最长公共子串、最长回文子串、兑换零钱

---

题目1——最长公共子串

给定两个字符串str1和str2，输出两个字符串的最长公共字串。题目保证str1和str2的最长公共字串存在且唯一。
要求： 空间复杂度 O(n^2)，时间复杂度 O(n^2)。

示例
输入：“1AB2345CD”,“12345EF”
输出：“2345”

解题思路

利用动态规划，定义dp[i][j] 为str1的前 i 个字符和str2的前 j 个字符的最长公共子串长度，因为子串必须连续，所以状态方程应为dp[i][j] = dp[i-1][j-1]+1，为了确定字串的范围，需要定义一个maxlen来记录最长公共字串的最大长度，同时需要定义一个index来记录公共子串的下标；如果找不到子串，返回”-1“。

代码实现

import java.util.*;
public class Solution {
    
    public String LCS (String str1, String str2) {
        if(str1 == null || str2 == null)
            return "-1";
        int m = str1.length();
        int n = str2.length();
        int maxlen = 0; //记录最长公共子串的长度
        int index = 0;
        int[][] dp = new int[m][n];  //记录以i下标结束的字符串和j下标结束的字符串的公共子串的长度     
        //初始化二维矩阵边界
        if(str1.charAt(0) == str2.charAt(0)){
            dp[0][0] = 1;
            maxlen = 1;
        }
        for(int i=1;i<n;i++){
            if(str1.charAt(0) == str2.charAt(i)){
                dp[0][i] = 1;
                maxlen = 1;
            }
        }
        for(int i=1;i<m;i++){
            if(str1.charAt(i) == str2.charAt(0)){
                dp[i][0] = 1;
                maxlen = 1;
            }
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                //当两个字符相同时，更新dp
                if(str1.charAt(i) == str2.charAt(j)){
                    dp[i][j] = dp[i-1][j-1]+1;
                    //若当前长度大于maxlen,则更新maxlen和当前公共字串的下标
                    if(maxlen <= dp[i][j]){
                        maxlen = dp[i][j];
                        index = i;
                    }
                }
            }
        }
        if(maxlen == 0)
            return "-1";
        return str1.substring(index-maxlen+1,index+1);
    }
}

题目2——最长回文子串

对于一个长度为n的一个字符串A(仅包含数字，大小写英文字母)，请设计一个高效算法，计算其中最长回文子串的长度。
要求：空间复杂度O(n)，时间复杂度O(n^2)。

示例
输入：“ababc”
输出：3 (最长的回文子串为"aba")

解题思路

定义一个布尔类型的数组dp，dp[i][j]表示下标i到下标j的子串是否为回文字符串，如果是，则dp[i+1][j-1]也是回文字符串，由此可得，状态转移方程dp[i][j] = true if (dp[i+1][j-1] && str[i] == str[j]。

代码实现

import java.util.*;
public class Solution {
    public int getLongestPalindrome (String A) {
        int n = A.length();
        String ans = "";
        boolean[][] dp = new boolean[n][n];
        for(int k=0;k<n;++k){ //k是i与j之间的间隔
            for(int i=0;i+k<n;++i){
                int j = i+k;
                //k=0,k=1都为边界情况
                if(k==0){
                    dp[i][j]=true;
                }else if(k==1){
                    dp[i][j] = (A.charAt(i) == A.charAt(j));
                }else{
                    dp[i][j] = (A.charAt(i) == A.charAt(j) && dp[i+1][j-1]);
                }
                //如果[i:j]回文字符串，且大与现有回文字符串长度，进行更新
                if(dp[i][j] && k+1>ans.length())
                    ans = A.substring(i,j+1);
            }  
        }
        return ans.length();
    }
}

题目3——兑换零钱

给定数组arr，arr中所有的值都为正整数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个aim，代表要找的钱数，求组成aim的最少货币数。如果无解，请返回-1。
要求：时间复杂度O(n*aim)，空间复杂度O(aim)。

示例
输入：[5,2,3], 20
输出：4

解题思路

重新回顾动态规划算法的基本思想：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并将答案保存起来。

在这个问题中，可以用dp[i]表示要凑出 i 元钱需要的最小货币数，因为货币最小为1元，所以开始可以将每个元素设置为最大值aim+1，使得货币数不会超过aim。凑出 i 元的最小货币数应该为dp[i] = min(dp[i],dp[i-arr[j]]+1).

代码实现

import java.util.*;
public class Solution {
    public int minMoney (int[] arr, int aim) {
        if(aim<1)
            return 0;
        int[] dp = new int[aim+1];
        //填充数组最大值aim+1
        Arrays.fill(dp,aim+1);
        dp[0] = 0;
        for(int i=1;i<=aim;i++){
            //计算每种面值，取最小的货币数
            for(int j=0;j<arr.length;j++){
                if(arr[j]<=i){
                    dp[i] = Math.min(dp[i],dp[i-arr[j]]+1);
                }
            }
        }
        //如果最终答案大于aim，则表示无解
        return dp[aim]>aim?-1:dp[aim];
    }
}