11.30-12.6

11月30日

767.重构字符串

class Solution {
    public String reorganizeString(String S) {
        char[] s = S.toCharArray();
        int[] count = new int[26];
        int l = S.length();

        //统计每个字符出现的次数
        for (int i = 0; i < l; i++) {
            count[s[i] - 'a']++;
        }
        int max = 0, alphabet = 0;
        //找出出现次数最多的那个字符
        for (int i = 0; i < count.length; i++) {
            if (count[i] > max) {
                max = count[i];
                alphabet = i; 
            }
        }
        //如果出现次数最多的那个字符的数量大于阈值，说明他不能使得两相邻的字符不同
        if (max > ((l + 1) / 2)){
             return "";
        } 
        //res就是返回结果
        char[] res = new char[l];
        int index = 0;
        //先把出现次数最多的字符存储在数组下标为偶数的位置上
        while (count[alphabet]-- > 0) {
            res[index] = (char) (alphabet + 'a');
            index += 2;
        }
        //然后再把剩下的字符存储在其他位置上
        for (int i = 0; i < count.length; i++) {
            while (count[i]-- > 0) {
                if (index >= res.length) {
                    index = 1;
                }
                res[index] = (char) (i + 'a');
                index += 2;
            }
        }
        return new String(res);
    }
}

12月1日

34.在排序数组中查找元素的第一个和最后一个位置

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] ans = new int[2];
        int start = -1, end = -1;
        //从左往右遍历，找到第一个相同的
        for(int i = 0; i < nums.length; i ++) {
            if(nums[i] == target) {
                start = i;
                break;
            }
        }
        //从右往左遍历，找到第一个相同的
        for(int i = nums.length - 1; i >= 0; i --) {
            if(nums[i] == target) {
                end = i;
                break;
            }
        }
        ans[0] = start;
        ans[1] = end;
        return ans;
    }
}

class Solution {
    public int[] searchRange(int[] nums, int target) {
        //寻找 left 即为在数组中寻找第一个大于等于 targett 的下标，寻找 right 即为在数组中寻找第一个大于 target 的下标，然后将下标减一
        int left = binarySearch(nums, target, true);
        int right = binarySearch(nums, target, false) - 1;
        if(left <= right && right < nums.length && nums[left] == target && nums[right] == target) {
            return new int[]{left, right};
        } 
        return new int[]{-1, -1};
    }

    public int binarySearch(int[] nums, int target, boolean lower) {
        int left = 0, right = nums.length - 1, ans = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

12月2日

321.拼接最大数

class Solution {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int m = nums1.length, n = nums2.length;
        int[] res = new int[k];
        //先从nums2中取k个数，若不够，则取n个数，从nums1中取k-n个数，然后依次增减
        for(int i = Math.max(0, k - n); i <= k && i <= m; i ++) {
            //将两个数组组合起来，使其数值最大
            int[] arr = merge(maxArr(nums1, i), maxArr(nums2, k - i), k);
            //比较每种组合的大小，取大的
            if (gt(arr, 0, res, 0)) {
                res = arr;
            }
        }
        return res;
    }

    //从给定数组中按顺序取得k个最大的数，返回值为取得的数组成的数组
    private int[] maxArr(int[] nums, int k) {
        int n = nums.length;
        int[] res = new int[k];
        //i为当前取得了几个数，j为存储最大数的数字的下标
        for(int i = 0, j = 0; i < n; i ++) {
            //n-i为nums中还剩几个数没有判断，n-i+j为当前最多有几个数，如果下一个数比已选取的数大的话，则将其替换
            while (n - i + j > k && j > 0 && nums[i] > res[j-1]){
                j --;
            }  
            if (j < k){
                res[j ++] = nums[i];
            }
        }
        return res;
    }
    //拼接两个数组，得到结果最大的数组
    private int[] merge(int[] nums1, int[] nums2, int k) {
        int[] res = new int[k];
        for(int i = 0, j = 0, r = 0; r < k; r ++) {
            //判断两个数组当前位置的数的大小，取大的，已取得的数组下标+1
            res[r] = gt(nums1, i, nums2, j) ? nums1[i++] : nums2[j++];
        }
        return res;
    }

    //比较两数组相应位置大小,相等就一直跳过,直到不相等就比较
    private boolean gt(int[] nums1, int i, int[] nums2, int j) {
        while(i < nums1.length && j < nums2.length && nums1[i] == nums2[j]) {
            i++;
            j++;
        }
        //如果两数组前面的数一样，则先从nums1中取
        return j == nums2.length || (i < nums1.length && nums1[i] > nums2[j]);
    }
}

12月3日

204.计数质数

//暴力法，遍历每一个数，判断它是否是质数
class Solution {
    public int countPrimes(int n) {
        if(n < 2) {
            return 0;
        }
        int num = 0;
        for(int i = 2; i < n; i ++) {
            boolean t = true;
            for(int j = 2; j*j <= i && t; j ++) {
                if(i % j == 0) {
                    t = false;
                }
            }
            if(t) {
                num ++;
            }
        }
        return num;
    }
}

class Solution {
    public int countPrimes(int n) {
        if(n < 2) {
            return 0;
        }
        int num = 0;
        int[] a = new int[n+1];
        for(int i = 2; i < n; i ++){
            a[i] = 1;
        }
        //从2开始遍历，把每个数的在n以内的倍数除去
        for(int i = 2; i < n; i ++) {
            if(a[i] != 0) {
                num ++;
                for(int j = i*2; j < n; j += i) {
                    a[j] = 0;
                }
            }
        }
        return num;
    }
}

12月5日

621.任务调度器

class Solution {
    public int leastInterval(char[] tasks, int n) {
        int[] map = new int[26];
        //统计每个任务出现的次数，并排序
        for(int i = 0; i < tasks.length; i ++) {
            map[tasks[i] - 'A'] ++;
        }
        int ans = 0;
        Arrays.sort(map);
        /*
        分配任务，每n+1个任务为一组，每组任务各不相同，每次分完任务重新排序
        所以当map[25] == 0时，所有任务都分配完了
        优先分配次数最多的，如果没有其它任务用来间隔冷却时间，那么就添加待命状态
        */
        while(map[25] > 0) {
            int i = 0;
            while(map[25] > 0 && i <= n) {
                if(i < 26 && map[25-i] > 0) {
                    map[25-i] --;
                }
                i ++;
                ans ++;
            }
            Arrays.sort(map);
        }
        return ans;
    }
}

12月6日

118.杨辉三角

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> list = new ArrayList<>();
        int[][] res = new int[numRows][numRows];
        int n = 1;
        for(int i = 0; i < numRows; i ++) {
            List<Integer> l = new ArrayList<>();
            for(int j = 0; j < n; j ++) {
                if(j == 0 || j == n-1) {
                    res[i][j] = 1;
                } else {
                    res[i][j] = res[i-1][j-1] + res[i-1][j];
                }
                l.add(res[i][j]);
            }
            n ++;
            list.add(l);
        }
        return list;
    }
}