剑指 Offer 第九天

剑指 Offer 46. 把数字翻译成字符串

加了条件的青蛙跳格子

public int translateNum(int num){
    String s = String.valueOf(num);
    int a = 1,b = 1;
    for(int i = 2;i<=s.lengh();i++){
        String tmp = s.substring(i-2,i);
        int c=tmp.compareTo("10")>=0 && tmp.compareTo("25")<=0?a+b:a;
        b = a;
        a = c;
    }
    return a
}

剑指 Offer 47. 礼物的最大价值

    public int maxValue(int[][] grid) {
        //边界判断
        if(grid==null||grid.length==0)
            return 0;
        int m=grid.length;
        int n=grid[0].length;
        //初始化dp的最上面一行，从左到右累加
        for(int i=1;i<n;i++){
            grid[0][i] = grid[0][i]+grid[0][i-1];
        }
        //初始化dp的最左边一列，从上到下累加
        for(int i=1;i<m;i++){
            grid[i][0] = grid[i][0]+grid[i-1][0];
        }
        //递推公式
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                grid[i][j] = grid[i][j] + Math.max(grid[i][j-1],grid[i-1][j]);
            }    
        }
        return grid[m-1][n-1];
    }

剑指 Offer 48. 最长不含重复字符的子字符串

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);
        dic.put(s.charAt(j),j);
        tmp = tmp<j-i?tmp+1:j-i;
        res = Math.max(res,tmp);
    }
    return res;
}

    public int lengthOfLongestSubstring(String s) {
        if (s.length() == 0)
            return 0;
        HashMap<Character, Integer> map = new HashMap<>();
        int max = 0;
        for (int i = 0, j = 0; i < s.length(); ++i) {
            if (map.containsKey(s.charAt(i))) {
                j = Math.max(j, map.get(s.charAt(i)) + 1);
            }
            map.put(s.charAt(i), i);
            max = Math.max(max, i - j + 1);
        }
        return max;
    }

剑指 Offer 49. 丑数

class Solution {
    public int nthUglyNumber(int n) {
        int[] dp = new int[n];  // 使用dp数组来存储丑数序列
        dp[0] = 1;  // dp[0]已知为1
        int a = 0, b = 0, c = 0;    // 下个应该通过乘2来获得新丑数的数据是第a个， 同理b, c

        for(int i = 1; i < n; i++){
            // 第a丑数个数需要通过乘2来得到下个丑数，第b丑数个数需要通过乘2来得到下个丑数，同理第c个数
            int n2 = dp[a] * 2, n3 = dp[b] * 3, n5 = dp[c] * 5;
            dp[i] = Math.min(Math.min(n2, n3), n5);
            if(dp[i] == n2){
                a++; // 第a个数已经通过乘2得到了一个新的丑数，那下个需要通过乘2得到一个新的丑数的数应该是第(a+1)个数
            }
            if(dp[i] == n3){
                b++; // 第 b个数已经通过乘3得到了一个新的丑数，那下个需要通过乘3得到一个新的丑数的数应该是第(b+1)个数
            }
            if(dp[i] == n5){
                c++; // 第 c个数已经通过乘5得到了一个新的丑数，那下个需要通过乘5得到一个新的丑数的数应该是第(c+1)个数
            }
        }
        return dp[n-1];
    }
}

剑指 Offer 50. 第一个只出现一次的字符

class Solution {
    public char firstUniqChar(String s) {
        HashMap<Character, Boolean> dic = new HashMap<>();
        char[] sc = s.toCharArray();
        for(char c : sc)
            dic.put(c, !dic.containsKey(c));//如果 hashMap 中是否存在指定的 key 对应的映射关系返回 true，否则返回 false。
        for(char c : sc)
            if(dic.get(c)) return c;
        return ' ';
    }
}