leetcode 随笔20

8.18

409. 最长回文串

难度简单

通用的方法就是利用一个map来实现。

class Solution {
    public int longestPalindrome(String s) {
        Map<Character, Integer> map = getMap(s);
        int len = 0;
        Set<Character> set = new HashSet<>();
        for(Map.Entry<Character, Integer> entry : map.entrySet()){
            int val = entry.getValue();
            len += val / 2 * 2;
            if(val % 2 == 0){
                set.add(entry.getKey());
            }
        }

        for(Character c : set){
            map.remove(c);
        }

        if(map.size() > 0){
            len++;
        }

        return len;
    }


    private Map<Character, Integer> getMap(String str){
        Map<Character, Integer> map = new HashMap<>();
        for(char c : str.toCharArray()){
            if(map.containsKey(c)){
                map.put(c, map.get(c) + 1);
            }else{
                map.put(c, 1);
            }
        }
        return map;
    }
}

其中最开始想用以下的方式进行删除。但是在遍历map中删除的时候会有Modify的异常。因为remove(object)会修改内部的mod值，而在之后的遍历时会有预期的mod值，预期与实际不符，就会抛出异常。所以就该用了上面的做法来做。不过如果用数组会更加快速，只是通用性不高。

if(val % 2 == 0){
   map.rempve(entry.getKey());
}

412. Fizz Buzz

难度简单

class Solution {
    public List<String> fizzBuzz(int n) {
        List<String> ans = new ArrayList<>(n);
        for(int i = 1;i <= n;i++){
            if(i % 3 != 0 && i % 5 != 0){
                ans.add(String.valueOf(i));
                continue;
            }
            String temp = "";
            if(i % 3 == 0){
                temp += "Fizz";
            }
            if(i % 5 == 0){
                temp += "Buzz";
            }
            ans.add(temp);
        }
        return ans;
    }
}

414. 第三大的数

难度简单

利用一个列表来维持一个指定长度的序列（或者用栈也可以实现）。总体的复杂度应该是O（N）

class Solution {
    public int thirdMax(int[] nums) {
        if(nums.length == 0){
            return -1;
        }

        List<Integer> list = new ArrayList<>();
        for(int i = 0;i < nums.length;i++){
            if(!list.contains(nums[i])){
                Stack<Integer> stack = new Stack<>();
                while(!list.isEmpty() && nums[i] > list.get(list.size() - 1)){
                    stack.push(list.remove(list.size() - 1));
                }
                if(list.size() == 3 && stack.isEmpty()){
                    continue;
                }
                list.add(nums[i]);
                while(list.size() < 3 && !stack.isEmpty()){
                    list.add(stack.pop());
                }
            }
        }
        
        return list.size() == 3 ? list.get(2) : list.get(0);
    }
}

434. 字符串中的单词数

难度简单

注意特殊情况：多个空格连在一起。

class Solution {
    public int countSegments(String s) {
        String[] arr = s.split(" ");
        int len = 0;
        for(String str : arr){
            if(!str.equals("")){
                len++;
            }
        }
        return len;
    }
}

443. 压缩字符串

难度简单

感觉我的实现略微复杂。

class Solution {
    public int compress(char[] chars) {
        if(chars.length == 0){
            return 0;
        }
        char c = chars[0];
        int length = 0;
        int count = 1;
        for(int i = 1;i < chars.length;i++){
            if(c == chars[i]){
                count++;
            }else{
                chars[length] = c;
                length++;
                if(count > 1){
                    StringBuilder sb = new StringBuilder();

                    while(count != 0){
                        sb.append(count % 10);
                        count /= 10;
                    }
                    String str = sb.reverse().toString();
                    for(char cc : str.toCharArray()){
                        chars[length++] = cc;
                    }    
                }
                count = 1;
                c = chars[i];
            }
        }

        chars[length] = c;
        length++;
        if(count > 1){
            StringBuilder sb = new StringBuilder();
            while(count != 0){
                sb.append(count % 10);
                count /= 10;
            }
            String str = sb.reverse().toString();
            for(char cc : str.toCharArray()){
                chars[length++] = cc;
            }
        }
        return length;
    }
}

448. 找到所有数组中消失的数字

难度简单

如果不能使用额外的空间，并且时间复杂度要为O（n）。我想不到这种做法。看了题解之后发现可以通过修改数组的值，用它的正负表示是否出现过对应的值。好巧妙的方法。

class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> ans = new ArrayList<>();
        for(int i = 0;i < nums.length;i++){
            int index = Math.abs(nums[i]) - 1;
            if(nums[index] > 0){
                nums[index] = -nums[index];
            }
        }

        for(int i = 0;i < nums.length;i++){
            if(nums[i] > 0){
                ans.add(i + 1);
            }
        }
        return ans;
    }
}

455. 分发饼干

难度简单

先排序，双指针实现

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int num = 0;

        int index1 = 0;
        int index2 = 0;
        while(index1 < g.length && index2 < s.length){
            while(index2 < s.length && s[index2] < g[index1]){
                index2++;
            }
            if(index2 < s.length){
                num++;
                index2++;
                index1++;
            }else{
                break;
            }
        }
        return num;
    }
}

8.19

463. 岛屿的周长

难度简单

当是岛屿时，判断它的左边和上边有没有相邻的岛屿，如果有的话，就减去2。这样就能简单快速的得到结果。

class Solution {
        public int islandPerimeter(int[][] grid) {
        int res = 0;
        int m = grid.length, n = grid[0].length;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    res += 4;
                    if (i > 0 && grid[i - 1][j] == 1) 
                        res -= 2;
                    if (j > 0 && grid[i][j - 1] == 1) 
                        res -= 2;
                }
            }
        }
        return res;
    }
}

如果是采用dfs，先加4再减去边的做法，感觉做不出来。

8.20

451. 根据字符出现频率排序

难度中等

本来是打算用treeMap来维持一个有序的结构，但是treeMap只是对键排序，而非对值排序。所以之后就用了另一种方式来进行排序。

class Solution {
    public String frequencySort(String s) {
        Map<Character, Integer> map = new HashMap<>();

        for(char c : s.toCharArray()){
            if(map.containsKey(c)){
                map.put(c, map.get(c) + 1);
            }else{
                map.put(c, 1);
            }
        }
        List<Map.Entry<Character,Integer>> list = new ArrayList<Map.Entry<Character, Integer>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>(){
            public int compare(Map.Entry<Character, Integer> entry1, Map.Entry<Character, Integer> entry2){
                return entry2.getValue() - entry1.getValue();
            } 
        });
        String str = "";
        for(Map.Entry<Character, Integer> entry : list){
            int count = entry.getValue();
            char c = entry.getKey();
            for(int i = 0;i < count;i++){
                str += c;
            }
        }
        return str;
    }
}

452. 用最少数量的箭引爆气球

难度中等

最开始是按照a[0]进行排序，做了一段时间也没做出来，想法一直有错。看了题解发现，实际上是用了另一种思路来实现的。按照a[1]进行排序。

class Solution {
    public int findMinArrowShots(int[][] points) {
        if(points.length <= 1){
            return points.length;
        }
        
        Arrays.sort(points, new Comparator<int[]>(){
            public int compare(int[] a, int[] b){
                return a[1] - b[1];
            }
        });

        int ans = 1;
        int xBegin, xEnd, firstEnd = points[0][1];
        for(int[] p : points){
            xBegin = p[0];
            xEnd = p[1];

            if(firstEnd < xBegin){
                firstEnd = xEnd;
                ans++;
            }
        }   
        return ans;
    }
}