LeetCode 刷题 第十天

1. 为算术表达式设计优先级

给你一个由数字和运算符组成的字符串 expression ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以按任意顺序返回答案。

分析：

采用分治+递归的方法。按运算符把算式分成左右两部分，实现一个递归函数可以按照运算符返回算式的解，最后再合并左右两部分的解，返回最终解。

class Solution {
    public List<Integer> diffWaysToCompute(String expression) {
        List<Integer> list = new ArrayList<>();
        int len = expression.length();
        int start;
        for (start = 0; start < len; start++) {
            if (Character.isDigit(expression.charAt(start))) continue;
            else break;
        }
        if (start==len) list.add(Integer.valueOf(expression));

        for (int i = start; i < len; i++) {
            if (Character.isDigit(expression.charAt(i))) continue;
            char op = expression.charAt(i);
            List<Integer> list1 = diffWaysToCompute(expression.substring(0, i));
            List<Integer> list2 = diffWaysToCompute(expression.substring(i + 1, len));
            for (int k : list1) {
                for (int j: list2) {
                    if (op=='*'){
                        list.add(k*j);
                    }
                    else if (op=='+') list.add(k+j);
                    else if (op=='-') list.add(k-j);
                }
            }
        }
        return list;
    }
}

2. 把数字翻译成字符串

       

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

分析：

动态规划问题。令dp[i]为以s中下标为i的结尾的数字可能翻译成字符串的方法数目，初始值dp[0]为1。可以发现dp[i]的取值与dp[i-1]和dp[i-2]有关，当s[i]与s[i-1]组成的数字>=10且<=25时，dp[i]=dp[i-1]+dp[i-2]，否则dp[i]=dp[i-1]。

class Solution {
    public int translateNum(int num) {
        String n = String.valueOf(num);
        if (n.length()<2) return 1;
        int a = 1 ,b = 1;
        for (int i = 2; i <=n.length() ; i++) {
            String tmp = n.substring(i-2, i);
            if (tmp.compareTo("10")>=0&&tmp.compareTo("25")<=0){
                int c = a + b;
                a=b;
                b=c;
            }else {
                int c = b;
                a=b;
                b=c;
            }
        }
        return b;


    }
}

3. 礼物的最大价值

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

分析：

动态规划问题。令dp[i][j]为到矩阵(i,j)的最大值，dp[0][0]=grid[0][0]。因为每次只能向右或向下移动一格，所以当i==0时，一定是从该位置左边移动过来的；当j==0时，一定是从该位置上边移动过来的；都不为0时，dp[i][j]就要取其上方和左侧的最大值与其相加。

class Solution {
    public int maxValue(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i==0 && j==0) continue;
                if (i==0){
                    dp[i][j] = dp[i][j-1]+grid[i][j];
                }
                if (j==0){
                    dp[i][j] = dp[i-1][j]+grid[i][j];
                }
                if (i!=0 && j!=0){
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1])+grid[i][j];
                }
            }
        }
        return dp[m-1][n-1];
    }
}

4. 最长不含重复字符的子字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

分析：

首先用的暴力解法，但效率比较低。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s==null||s.length()==0) return  0;
        int max = 1;
        for (int i = 0; i < s.length(); i++) {
            int len = 1;
            for (int j = i+1; j < s.length(); j++) {
                if (s.substring(i,j).contains(s.substring(j,j+1))) break;
                ++len;
                max = Math.max(max, len);
            }
        }
        return max;
    }
}

另外一种方法时动态规划。令dp[i]为以s[i]结尾的最长不含重复字符的子字符串的长度，使用哈希表记录每个字符最近出现时的索引值j。在哈希表中查询s[i]的值j，如果i-j<dp[i-1]时，说明s[i]存在于dp[i-1]的最长不含重复字符的子字符串中，此时dp[i]=i-j；否则dp[i]=dp[i-1]+1。要注意更新哈希表中的值，并定义一个变量max不断地更新最长的的长度。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> dic = new HashMap<>();
        int res = 0, tmp = 0;
        for(int j = 0; j < s.length(); j++) {
            int i = dic.getOrDefault(s.charAt(j), -1); // 获取索引 i
            dic.put(s.charAt(j), j); // 更新哈希表
            tmp = tmp < j - i ? tmp + 1 : j - i; // dp[j - 1] -> dp[j]
            res = Math.max(res, tmp); // max(dp[j - 1], dp[j])
        }
        return res;
    }
}