剑指（五题）

 

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s.length() == 0) return 0;
        int len = s.length();
        int max = 1;
        for (int i = 0; i < len; i++) {
            char ch = s.charAt(i);
            //把遍历到的字符存起来
            Map<Character, Integer> map = new HashMap<>();
            map.put(ch, i);
            for (int j = i + 1; j < len; j++) {
                char ch1 = s.charAt(j);
                if (map.get(ch1) == null) {
                    map.put(ch1, j);
                    max = Math.max(max, j - i + 1);
                } else {
                    break;
                }
            }
        }
        return max;
    }
}

 

class Solution {
    public int maxValue(int[][] grid) {
        if (grid.length == 0) return 0;
        if (grid.length == 1 && grid[0].length == 1) return grid[0][0];
        int[][] dp = new int[grid.length][grid[0].length];
        //dp[i][j]代表到达这个位置能拿到的最大值
        //初始化
        dp[0][0] = grid[0][0];
        for (int i = 1; i < dp[0].length; i++) {
            dp[0][i] = grid[0][i] + dp[0][i - 1];
        }
        for (int i = 1; i < dp.length; i++) {
            dp[i][0] = grid[i][0] + dp[i - 1][0];
        }
        for (int i = 1; i < dp.length; i++) {
            for (int j = 1; j < dp[0].length; j++) {
                dp[i][j] = grid[i][j] + Math.max(dp[i][j - 1], dp[i - 1][j]);
            }
        }
        return dp[dp.length - 1][dp[0].length - 1];
    }
}

 

class Solution {
    public String reverseWords(String s1) {
        if (s1.length() == 0) return "";
        // int left = 0;
        // int right = s.length() - 1;
        // while (left < right) {
        //     if (s.charAt(left) == ' ') {
        //         left++; 
        //     } else {
        //         break;
        //     }
        // }
        // while (left < right) {
        //     if (s.charAt(right) == ' ') {
        //         right--;
        //     } else {
        //         break;
        //     }
        // }
        //使用trim得返回个新的，对原数组没改动
        String s = s1.trim();
        //if (left == r) return "";
        StringBuilder sb = new StringBuilder();
        Deque<String> stack = new LinkedList<>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) != ' ') {
                sb.append(s.charAt(i));
            } else {
                //先判断后面是否在不在下标内
                if (i + 1 < s.length() && s.charAt(i + 1) == ' ') {
                    continue;
                }
                stack.push(sb.toString());
                sb.setLength(0);
            }
        }
        //sb.toString()后才是String
        stack.push(sb.toString());
        List<String> list = new ArrayList<>();
        while (!stack.isEmpty()) {
            list.add(stack.pop());
        }
        String[] res = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        //字符串数组转为字符串，字符串转为字符串数组是spilt
        return String.join(" ", res);
    }
}

//直接用最简单的方式写
//连续空格的还是不好处理啊，用api也没弄成。
// class Solution {
//     public String reverseWords(String s) {
//         String[] strings = s.trim().split(" ");
//         //StringBuilder sb = new StringBuilder();
//         int left = 0;
//         int right = strings.length - 1;
//         while (left < right) {
//             if (strings[left] == " " && strings[right] == " ") {
//                 left++;
//                 right--;
                
//             } else if (strings[left] == " ") {
//                 left++;
                
//             } else if (strings[right] == " ") {
//                 right--;
                
//             } else {
//                 String temp = strings[left];
//                 strings[left] = strings[right];
//                 strings[right] = temp;
//                 left++;
//                 right--;
//             }
            
//         }
//         return String.join(" ", strings);
//     }

// }

 

class Solution {
    public int nthUglyNumber(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 1;
        int p2 = 1, p3 = 1, p5 = 1;
        for (int i = 2; i <= n; i++) {
            int num2 = dp[p2] * 2, num3 = dp[p3] * 3, num5 = dp[p5] * 5;
            dp[i] = Math.min(Math.min(num2, num3), num5);
            //去重问题考虑到了呀，又不是用得if else
            if (dp[i] == num2) {
                p2++;
            }
            if (dp[i] == num3) {
                p3++;
            }
            if (dp[i] == num5) {
                p5++;
            }
        }
        return dp[n];
    }
}

 

class Solution {
    public int maxSubArray(int[] nums) {
        //int left = 0;
        
        int right = 0;
        int sum = 0;
        int res = Integer.MIN_VALUE;
        int falg = 0;
        while (right < nums.length) {
            sum += nums[right];
            if (sum < 0) {
                sum = 0;
            } 
            right++;
            if (sum > 0) {
                falg++;
                res = Math.max(res, sum);
            }
        }
        sum = 0;
        right = 0;
        int res1 = Integer.MIN_VALUE;
        while (right < nums.length) {
            res1 = Math.max(res1, nums[right]);
            right++;
        }
        
        if (falg != 0) {
            return res;
        } else {
            return res1;
        }
    }
}