LeetCode自己做的题目记录2

最新推荐文章于 2022-08-09 11:37:40 发布
最新推荐文章于 2022-08-09 11:37:40 发布
阅读量904 收藏
点赞数 2
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35641192/article/details/86552730
版权

421. 数组中两个数的最大异或值

class Solution {
    public int findMaximumXOR(int[] nums) {
        int max = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                max = Math.max(max, nums[i] ^ nums[j]);
            }
        }
        return max;
    }
}

530. 二叉搜索树的最小绝对差

class Solution {
    private List<Integer> result = new ArrayList<>();

    public int getMinimumDifference(TreeNode root) {
        int min = 999;
        setList(root);
        Collections.sort(result);
        for (int i = 1; i < result.size(); i++) {
            min = Math.min(min, result.get(i) - result.get(i - 1));
        }
        return min;
    }

    private void setList(TreeNode node) {
        if (node != null) {
            result.add(node.val);
            setList(node.left);
            setList(node.right);
        }
    }
}

788. 旋转数字

class Solution {
    public int rotatedDigits(int N) {
        List<Integer> l1 = Arrays.asList(2, 5, 6, 9);
        List<Integer> l2 = Arrays.asList(2, 5, 6, 9, 0, 1, 8);
        int count = 0;
        for (int i = 1; i <= N; i++) {
            boolean flag1 = false;
            boolean flag2 = true;
            int num = i;
            while (num != 0) {
                int r = num % 10;
                if (l1.contains(r)) {
                    flag1 = true;
                }
                if (!l2.contains(r)) {
                    flag2 = false;
                    break;
                }
                num /= 10;
            }
            if (flag1 && flag2) {
                count++;
            }
        }
        return count;
    }
}

553. 最优除法

class Solution {
    public String optimalDivision(int[] nums) {
        if (nums.length == 1) {
            return nums[0] + "";
        }
        if (nums.length == 2) {
            return nums[0] + "/" + nums[1];
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < nums.length; i++) {
            if (i == 1) {sb.append("(");}
            sb.append(nums[i]);
            if (i != nums.length - 1) {
                sb.append("/");
            } else {
                sb.append(")");
            }

        }
        return sb.toString();
    }
}

202. 快乐数

class Solution {
    public boolean isHappy(int n) {
        List<Integer> list = Arrays.asList(4, 16, 37, 58, 89, 145, 42, 20);
        n = getNum(n);
        if (n == 1) {
            return true;
        } else if (list.contains(n)) {
            return false;
        } else {
            return isHappy(n);
        }
    }

    private int getNum(int n) {
        int total = 0;
        while (n != 0) {
            int r = n % 10;
            total += r * r;
            n /= 10;
        }
        return total;
    }
}

75. 颜色分类

class Solution {
    public void sortColors(int[] nums) {
        Arrays.sort(nums);
    }
}

520. 检测大写字母

class Solution {
    public boolean detectCapitalUse(String word) {
        String w = word.toLowerCase();
        if (word.equals(word.toUpperCase()) || word.equals(w) || w.substring(1).equals(word.substring(1))) {
            return true;
        }
        return false;
    }
}

122. 买卖股票的最佳时机 II

class Solution {
    public int maxProfit(int[] prices) {
        int buy = -1;
        int total = 0;
        for (int i = 0; i < prices.length - 1; i++) {
            if (buy == -1) {
                if (prices[i] < prices[i + 1]) {
                    buy = prices[i];
                }
            } else {
                if (prices[i] > prices[i + 1]) {
                    total += prices[i] - buy;
                    buy = -1;
                }
            }
        }
        if (buy != -1) {
            total += prices[prices.length - 1] - buy;
        }
        return total;
    }
}

783. 二叉搜索树结点最小距离

class Solution {
    private List<Integer> list = new ArrayList<>();

    public int minDiffInBST(TreeNode root) {
        getMin(root);
        int min = 999;
        Collections.sort(list);
        for (int i = 1; i < list.size(); i++) {
            min = Math.min(min, list.get(i) - list.get(i - 1));
        }
        return min;
    }

    private void getMin(TreeNode node) {
        if (node != null) {
            list.add(node.val);
            getMin(node.left);
            getMin(node.right);
        }
    }
}

382. 链表随机节点

class Solution {
    private int size;
    private List<Integer> list = new ArrayList<>();
    private Random random = new Random();

    /**
     * @param head The linked list's head.
     *             Note that the head is guaranteed to be not null, so it contains at least one node.
     */
    public Solution(ListNode head) {
        getSize(head);
    }

    /**
     * Returns a random node's value.
     */
    public int getRandom() {
        return list.get(random.nextInt(size));
    }

    private void getSize(ListNode node) {
        if (node != null) {
            size++;
            list.add(node.val);
            getSize(node.next);
        }

    }
}

11. 盛最多水的容器

class Solution {
    public int maxArea(int[] height) {
        int max = 0;
        for (int i = 0; i < height.length - 1; i++) {
            for (int j = i + 1; j < height.length; j++) {
                max = Math.max(max, Math.min(height[i], height[j]) * (j - i));
            }
        }
        return max;
    }
}

36. 有效的数独

class Solution {
    private List<Character> list = new ArrayList<>();

    public boolean isValidSudoku(char[][] board) {
        return checkColumn(board) && checkRow(board) && checkBlock(board);
    }

    private boolean checkColumn(char[][] board) {
        for (int i = 0; i < board.length; i++) {
            list.clear();
            for (char[] b : board) {
                char val = b[i];
                if (val != '.' && list.contains(val)) {
                    return false;
                }
                list.add(val);
            }
        }
        return true;
    }

    private boolean checkRow(char[][] board) {
        for (char[] b : board) {
            list.clear();
            for (char c : b) {
                if (c != '.' && list.contains(c)) {
                    return false;
                }
                list.add(c);
            }
        }
        return true;
    }

    private boolean checkBlock(char[][] board) {
        List<Character> l1 = new ArrayList<>();
        List<Character> l2 = new ArrayList<>();
        List<Character> l3 = new ArrayList<>();
        for (int i = 0; i < board.length; i++) {
            if (i % 3 == 0) {
                l1.clear();
                l2.clear();
                l3.clear();
            }
            for (int j = 0; j < board.length; j++) {
                int flag = j / 3;
                char val = board[i][j];
                if (val == '.') {
                    continue;
                }
                if (flag == 0) {
                    if (l1.contains(val)) {
                        return false;
                    }
                    l1.add(val);
                }
                if (flag == 1) {
                    if (l2.contains(val)) {
                        return false;
                    }
                    l2.add(val);
                }
                if (flag == 2) {
                    if (l3.contains(val)) {
                        return false;
                    }
                    l3.add(val);
                }
            }
        }
        return true;
    }
}

113. 路径总和 II

class Solution {
    private List<Integer> temp = new ArrayList<>();
    private List<List<Integer>> result = new ArrayList<>();

    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        getResult(root, 0, sum);
        return result;
    }

    private void getResult(TreeNode node, int level, int sum) {
        if (node != null) {
            temp.add(level, node.val);
            if (node.left == null && node.right == null) {
                int s = 0;
                for (int i = 0; i <= level; i++) {
                    s += temp.get(i);
                }
                //System.out.println(s);
                if (s == sum) {
                    List<Integer> t = new ArrayList<>();
                    for (int i = 0; i <= level; i++) {
                        t.add(temp.get(i));
                    }
                    result.add(t);
                }
            }
            level++;
            getResult(node.left, level, sum);
            getResult(node.right, level, sum);
        }
    }
}

100. 相同的树

class Solution {
    private List<Integer> l1 = new ArrayList<>();
    private List<Integer> l2 = new ArrayList<>();

    public boolean isSameTree(TreeNode p, TreeNode q) {
        setList(p, l1);
        setList(q, l2);
        if (l1.size() != l2.size()) {
            return false;
        }
        for (int i = 0; i < l1.size(); i++) {
            if (!l1.get(i).equals(l2.get(i))) {
                return false;
            }
        }
        return true;
    }

    private void setList(TreeNode node, List<Integer> l) {
        if (node != null) {
            l.add(node.val);
            if (node.left == null && node.right != null) {
                l.add(-1);
            }
            setList(node.left, l);
            setList(node.right, l);
        }
    }
}

976. 三角形的最大周长

class Solution {
    public int largestPerimeter(int[] A) {
        int total = 0;
        Arrays.sort(A);
        for (int i = 0; i < A.length - 2; i++) {
            if (A[i] + A[i + 1] > A[i + 2]) {
                total = Math.max(total, A[i] + A[i + 1] + A[i + 2]);
            }
        }
        return total;
    }
}

961. 重复 N 次的元素

class Solution {
    public int repeatedNTimes(int[] A) {
        List<Integer> l = new ArrayList<>();
        for (int i = 0; i < A.length; i++) {
            if (l.contains(A[i])) {
                return A[i];
            }
            l.add(A[i]);
        }
        return -1;
    }
}

965. 单值二叉树

class Solution {
    private Set<Integer> s = new HashSet<>();

    public boolean isUnivalTree(TreeNode root) {
        setSet(root);
        return s.size() == 1;
    }

    private void setSet(TreeNode node) {
        if (node != null) {
            s.add(node.val);
            setSet(node.left);
            setSet(node.right);
        }
    }
}

973. 最接近原点的 K 个点

class Solution {
    public int[][] kClosest(int[][] points, int K) {
        List<Integer> l1 = new ArrayList<>();
        List<Integer> l2 = new ArrayList<>();
        int[][] result = new int[K][2];
        for (int i = 0; i < points.length; i++) {
            l1.add(points[i][0] * points[i][0] + points[i][1] * points[i][1]);
            l2.add(l1.get(i));
        }
        Collections.sort(l1);
        for (int i = 0; i < K; i++) {
            int flag = l2.indexOf(l1.get(i));
            result[i] = points[flag];
        }
        return result;
    }
}

509. 斐波那契数

class Solution {
    public int fib(int N) {
        if (N == 0) {
            return 0;
        }
        if (N == 1) {
            return 1;
        }
        int total = 0;
        int pre1 = 1;
        int pre2 = 0;
        for (int i = 2; i <= N; i++) {
            total = pre1 + pre2;
            pre2 = pre1;
            pre1 = total;
        }

        return total;
    }
}

538. 把二叉搜索树转换为累加树

class Solution {
    private List<Integer> list = new ArrayList<>();

    public TreeNode convertBST(TreeNode root) {
        setList(root);
        setNode(root);
        return root;
    }

    private void setList(TreeNode node) {
        if (node != null) {
            list.add(node.val);
            setList(node.left);
            setList(node.right);
        }
    }

    private void setNode(TreeNode node) {
        if (node != null) {
            node.val = list.stream().filter(x -> x >= node.val).mapToInt(x -> x).sum();
            setNode(node.left);
            setNode(node.right);
        }
    }
}

303. 区域和检索 - 数组不可变

class NumArray {
    private int[] nums;

    public NumArray(int[] nums) {
        this.nums = nums;
    }

    public int sumRange(int i, int j) {
        int total = 0;
        for (; i <= j; i++) {
            total += nums[i];
        }
        return total;
    }
}

242. 有效的字母异位词

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] c1 = s.toCharArray();
        char[] c2 = t.toCharArray();
        Arrays.sort(c1);
        Arrays.sort(c2);
        return Arrays.toString(c1).equals(Arrays.toString(c2));
    }
}

653. 两数之和 IV - 输入 BST

class Solution {
    private List<Integer> list = new ArrayList<>();

    public boolean findTarget(TreeNode root, int k) {
        setList(root);
        for (int i = 0; i < list.size(); i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i) + list.get(j) == k) {
                    return true;
                }
            }
        }
        return false;
    }

    private void setList(TreeNode node) {
        if (node != null) {
            list.add(node.val);
            setList(node.left);
            setList(node.right);
        }
    }
}

931. 下降路径最小和

class Solution {
    public int minFallingPathSum(int[][] A) {
        int l1 = A.length - 1;
        int l2 = A[0].length - 1;

        for (int i = 0; i < l1; i++) {
            if (l2 > 0) {
                for (int j = 0; j <= l2; j++) {
                    if (j == 0) {
                        A[i + 1][j] = A[i + 1][j] + Math.min(A[i][j], A[i][j + 1]);
                    } else if (j == l2) {
                        A[i + 1][j] = A[i + 1][j] + Math.min(A[i][j], A[i][j - 1]);
                    } else {
                        A[i + 1][j] = A[i + 1][j] + Math.min(A[i][j], Math.min(A[i][j - 1], A[i][j + 1]));
                    }
                }
            }
        }
        Arrays.sort(A[l1]);
        return A[l1][0];
    }
}

462. 最少移动次数使数组元素相等 II

class Solution {
    public int minMoves2(int[] nums) {
        if (nums.length < 2) {
            return 0;
        }
        if (nums.length == 2) {
            return Math.abs(nums[0] - nums[1]);
        }
        Arrays.sort(nums);
        int mid = nums.length / 2;
        long t1 = 0, t2 = 0;
        for (int i = 0; i < nums.length; i++) {
            t1 += Math.abs(nums[i] - nums[mid]);
            t2 += Math.abs(nums[i] - nums[mid + 1]);
        }
        return (int)Math.min(t1, t2);
    }
}

343. 整数拆分

class Solution {
    public int integerBreak(int n) {
        //你可以假设 n 不小于 2 且不大于 58。
        //主要是找规律
        // 1  2  3  4  5  6  7  8  9  10
        // 1  1  2  4  6  9  12 16 27 36
        int[] DP = new int[n + 1];
        DP[0] = 0;
        DP[1] = 1;
        for (int i = 2; i <= n; i++) {
            DP[i] = 0;
            for (int j = 1; j < i; j++) {
                DP[i] = Math.max(DP[i], Math.max(j, DP[j]) * Math.max(i - j, DP[i - j]));
            }
        }
        return DP[n];
    }
}

386. 字典序排数

class Solution {
    public List<Integer> lexicalOrder(int n) {
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            list.add(i);
        }
        return list.stream().sorted(Comparator.comparing(x -> (x + ""))).collect(Collectors.toList());
    }
}

398. 随机数索引

class Solution {
    private Map<Integer, List<Integer>> map;

    public Solution(int[] nums) {
        map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int key = nums[i];
            if (map.containsKey(key)) {
                map.get(key).add(i);
            } else {
                List<Integer> l = new ArrayList<>();
                l.add(i);
                map.put(key, l);
            }
        }
    }

    public int pick(int target) {
        List<Integer> list = map.get(target);
        return list.get((int)(Math.random() * list.size()));
    }
}

178. 分数排名

SELECT Score,(SELECT count(distinct(Score)) + 1 FROM Scores s WHERE s.Score > sc.Score) Rank FROM Scores sc order by Score desc

453. 最小移动次数使数组元素相等

class Solution {
    public int minMoves(int[] nums) {
        int total = 0;
        for (int num : nums) {
            total += num;
        }
        Arrays.sort(nums);
        return total - nums[0] * nums.length;
    }
}

860. 柠檬水找零

class Solution {
    private int[] money = {0, 0};

    public boolean lemonadeChange(int[] bills) {
        for (int bill : bills) {
            if (bill == 5) {
                money[0]++;
            }
            if (bill == 10) {
                if (money[0] < 1) {
                    return false;
                }
                money[0]--;
                money[1]++;
            }
            if (bill == 20) {
                if (money[0] > 2 || (money[1] > 0 && money[0] > 0)) {
                    if (money[1] > 0) {
                        money[1]--;
                        money[0]--;
                    } else {
                        money[0] -= 3;
                    }
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}

897. 递增顺序查找树

class Solution {
    private List<Integer> list = new ArrayList<>();

    public TreeNode increasingBST(TreeNode root) {
        setList(root);
        TreeNode r = new TreeNode(list.get(0));
        getNode(r, 1);
        return r;
    }

    private void setList(TreeNode node) {
        if (node != null) {
            setList(node.left);
            list.add(node.val);
            setList(node.right);
        }
    }

    private TreeNode getNode(TreeNode node, int index) {
        if (index < list.size()) {
            node.right = new TreeNode(list.get(index));
            getNode(node.right, index += 1);
        }
        return node;
    }
}

99. 恢复二叉搜索树

class Solution {
    private List<Integer> list = new ArrayList<>();
    private int index = 0;

    public void recoverTree(TreeNode root) {
        setList(root);
        Collections.sort(list);
        setNode(root);
    }

    private void setList(TreeNode node) {
        if (node != null) {
            list.add(node.val);
            setList(node.left);
            setList(node.right);
        }
    }

    private void setNode(TreeNode node) {
        if (node != null) {
            setNode(node.left);
            node.val = list.get(index++);
            setNode(node.right);
        }
    }
}

404. 左叶子之和

class Solution {
    private int total;

    public int sumOfLeftLeaves(TreeNode root) {
        setTotal(root, false);
        return total;
    }

    private void setTotal(TreeNode node, boolean flag) {
        if (node != null) {
            if (flag && node.left == null && node.right == null) {
                total += node.val;
            }
            setTotal(node.left, true);
            setTotal(node.right, false);
        }
    }
}

690. 员工的重要性

class Solution {
    private int total;
    private List<Employee> employees;

    public int getImportance(List<Employee> employees, int id) {
        this.employees = employees;
        Employee employee = employees.stream().filter(e -> e.id == id).findFirst().orElse(null);
        total += employee.importance;
        getTotal(employee.subordinates);
        return total;
    }

    public void getTotal(List<Integer> ids) {
        for (Employee employee : employees) {
            if (ids.contains(employee.id)) {
                total += employee.importance;
                if (employee.subordinates != null && employee.subordinates.size() != 0) {
                    getTotal(employee.subordinates);
                }
            }

        }

    }
}

121. 买卖股票的最佳时机

class Solution {
    public int maxProfit(int[] prices) {
        int max = 0;
        for (int i = 0; i < prices.length; i++) {
            for (int j = i + 1; j < prices.length; j++) {
                max = Math.max(max, prices[j] - prices[i]);
            }
        }
        return max;
    }
}

495. 提莫攻击

class Solution {
   public int findPoisonedDuration(int[] timeSeries, int duration) {
        if (timeSeries.length == 1) {
            return duration;
        }
        int total = 0;
        for (int i = 1; i < timeSeries.length; i++) {
            if (i == 1) { total += duration; }
            if (timeSeries[i] - timeSeries[i - 1] < duration) {
                total += timeSeries[i] - timeSeries[i - 1];
            } else {
                total += duration;
            }
        }
        return total;
    }
}

228. 汇总区间

class Solution {
    public List<String> summaryRanges(int[] nums) {
        List<String> result = new ArrayList<>();
        if (nums.length < 1) {
            return result;
        }
        int start = -1;
        for (int i = 0; i < nums.length - 1; i++) {
            int val = nums[i + 1] - nums[i];
            if (val == 1 && start == -1) {
                start = nums[i];
            }
            if (val != 1 && start == -1) {
                result.add(nums[i] + "");
            }
            if (val != 1 && start != -1) {
                result.add(start + "->" + nums[i]);
                start = -1;
            }
        }
        if (start != -1) {
            result.add(start + "->" + nums[nums.length - 1]);
        } else {
            result.add(nums[nums.length - 1] + "");
        }
        return result;
    }
}

268. 缺失数字

class Solution {
    public int missingNumber(int[] nums) {
        int t = 0;
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            t = t + i;
            sum += nums[i];
        }
        return t + nums.length - sum;
    }
}

17. 电话号码的字母组合

class Solution {
    private List<List<String>> l = Arrays.asList(Arrays.asList("a", "b", "c"), Arrays.asList("d", "e", "f"),
        Arrays.asList("g", "h", "i"), Arrays.asList("j", "k", "l"), Arrays.asList("m", "n", "o"),
        Arrays.asList("p", "q", "r", "s"), Arrays.asList("t", "u", "v"), Arrays.asList("w", "x", "y", "z"));
    private List<String> result = new ArrayList<>();

    public List<String> letterCombinations(String digits) {
        if (digits.length() == 0) {
            return result;
        }
        int i = Integer.parseInt(digits.charAt(0) + "");

        if (result.size() != 0) {
            List<String> temp = new ArrayList<>();
            for (String s1 : result) {
                for (String s2 : l.get(i - 2)) {
                    temp.add(s1 + s2);
                }
            }
            result = temp;
        } else {
            result.addAll(l.get(i - 2));
        }
        if (digits.length() > 1) {
            letterCombinations(digits.substring(1));
        }
        return result;
    }
}

506. 相对名次

class Solution {
    public String[] findRelativeRanks(int[] nums) {
        String[] result = new String[nums.length];
        int[] temp = new int[nums.length];
        System.arraycopy(nums, 0, temp, 0, nums.length);
        Arrays.sort(temp);
        for (int i = temp.length - 1; i >= 0; i--) {
            for (int j = 0; j < nums.length; j++) {
                if (temp[i] == nums[j]) {
                    if (temp.length - i == 1) {
                        result[j] = "Gold Medal";
                    } else if (temp.length - i == 2) {
                        result[j] = "Silver Medal";
                    } else if (temp.length - i == 3) {
                        result[j] = "Bronze Medal";
                    } else {
                        result[j] = (temp.length - i) + "";
                    }
                    break;
                }
            }
        }
        return result;
    }
}

196. 删除重复的电子邮箱

delete p1 from Person p1 ,Person p2
where p1.Email = p2.Email and p1.Id > p2.Id

164. 最大间距

class Solution {
    public int maximumGap(int[] nums) {
        if (nums.length < 2) { return 0; }
        int max = 0;
        Arrays.sort(nums);
        for (int i = 1; i < nums.length; i++) {
            max = Math.max(max, nums[i] - nums[i - 1]);
        }
        return max;
    }
}

80. 删除排序数组中的重复项 II

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int index = 0;
        int count = 1;
        int num = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] == num) {
                if (count < 2) {
                    index++;
                    count++;
                }
            } else {
                index++;
                count = 1;
                num = nums[i];
            }
            nums[index] = nums[i];
        }
        return index + 1;
    }
}

896. 单调数列

class Solution {
    public boolean isMonotonic(int[] A) {
        if (A.length < 2) {return true;}
        Boolean flag = null;
        for (int i = 1; i < A.length; i++) {
            int val = A[i] - A[i - 1];
            if (val != 0 && flag == null) {
                flag = val > 0;
            }
            if (flag != null) {
                if (flag && val < 0) {
                    return false;
                }
                if (!flag && val > 0) {
                    return false;
                }
            }
        }
        return true;
    }
}

454. 四数相加 II

class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        /**
        用一个 map 保存 A 和 B 中出现的两数和及次数, 遍历 C 和 D 的两数和
        在 map 内搜索对应的负数出现的次数
        **/
        Map<Integer, Integer> map = new HashMap<>();
        int n = A.length;
        int ret = 0;
        // 统计 A 和 B 中出现的两数和及次数
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < n; ++j) {
                int sum = A[i] + B[j];
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }
        // 遍历 C 和 D 的两数和搜索对应的负数出现的次数
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < n; ++j) {
                int sum = C[i] + D[j];
                ret += map.getOrDefault(-sum, 0);
            }
        }
        
        return ret;
    }
}

307. 区域和检索 - 数组可修改

class NumArray {
    private int[] nums;

    public NumArray(int[] nums) {
        this.nums = nums;
    }

    public void update(int i, int val) {
        nums[i] = val;
    }

    public int sumRange(int i, int j) {
        int total = 0;
        for (; i <= j; i++) {
            total += nums[i];
        }
        return total;
    }
}

551. 学生出勤记录 I

class Solution {
    public boolean checkRecord(String s) {
        return !((s.indexOf("A") != s.lastIndexOf("A")) || s.contains("LLL"));
    }
}

598. 范围求和 II

class Solution {
    public int maxCount(int m, int n, int[][] ops) {
        for (int[] op : ops) {
            if (op[0] < m) {
                m = op[0];
            }
            if (op[1] < n) {
                n = op[1];
            }
        }
        return m * n;
    }
}

455. 分发饼干

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(s);
        int total = 0;
        List<Integer> index = new ArrayList<>();
        for (int i : g) {
            for (int j = 0; j < s.length; j++) {
                if (index.contains(j)) {
                    continue;
                }
                if (s[j] >= i) {
                    total++;
                    index.add(j);
                    break;
                }
            }
        }
        return total;
    }
}

345. 反转字符串中的元音字母

class Solution {
    private String str = "aeiouAEIOU";

    public String reverseVowels(String s) {
        char[] c = s.toCharArray();
        int start = 0, end = c.length - 1;
        boolean flag1 = false, flag2 = false;
        while (start <= end) {
            if (str.contains(c[start] + "")) {
                flag1 = true;
            } else {
                start++;
            }
            if (str.contains(c[end] + "")) {
                flag2 = true;
            } else {
                end--;
            }
            if (flag1 && flag2) {
                flag1 = false;
                flag2 = false;
                char temp = c[start];
                c[start] = c[end];
                c[end] = temp;
                start++;
                end--;
            }
        }
        return new String(c);
    }
}

67. 二进制求和

class Solution {
    public String addBinary(String a, String b) {
        //return new BigInteger(a, 2).add(new BigInteger(b, 2)).toString(2);
        StringBuilder sb = new StringBuilder();
        char[] c1 = a.toCharArray();
        char[] c2 = b.toCharArray();
        int l1 = c1.length - 1;
        int l2 = c2.length - 1;
        boolean flag = false;
        int max = Math.max(c1.length, c2.length);
        for (int i = 0; i < max; i++) {
            int n1 = l1 >= 0 ? Integer.parseInt(c1[l1--] + "") : 0;
            int n2 = l2 >= 0 ? Integer.parseInt(c2[l2--] + "") : 0;
            int n = n1 + n2;
            if (flag) {
                n++;
            }
            if (n == 0) {
                flag = false;
                sb.insert(0, 0);
            }
            if (n == 1) {
                flag = false;
                sb.insert(0, 1);
            }
            if (n == 2) {
                flag = true;
                sb.insert(0, 0);
            }
            if (n == 3) {
                flag = true;
                sb.insert(0, 1);
            }
        }
        if (flag) {
            sb.insert(0, 1);
        }
        return sb.toString();
    }
}

646. 最长数对链

class Solution {
    public int findLongestChain(int[][] pairs) {
        int total = 1;
        Arrays.sort(pairs, Comparator.comparingInt(x -> x[1]));
        int s = pairs[0][1];
        for (int i = 1; i < pairs.length; i++) {
            if (s < pairs[i][0]) {
                total += 1;
                s = pairs[i][1];
            }
        }
        return total;
    }
}

409. 最长回文串

class Solution {
    public int longestPalindrome(String s) {
        int total = 0;
        final Boolean[] flag = {false};
        Map<Character, Integer> map = new HashMap<>(s.length());
        for (char c : s.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        total += map.values().stream().mapToInt(v -> {
            if (v % 2 == 0) {
                return v;
            } else {
                flag[0] = true;
                return v - 1;
            }
        }).sum();
        if (flag[0]) {
            total++;
        }
        return total;
    }
}

671. 二叉树中第二小的节点

class Solution {
    private List<Integer> list = new ArrayList<>();

    public int findSecondMinimumValue(TreeNode root) {
        setList(root);
        Collections.sort(list);
        int min = list.get(0);
        for (Integer i : list) {
            if (i > min) {
                return i;
            }
        }
        return -1;
    }

    private void setList(TreeNode node) {
        if (node != null) {
            list.add(node.val);
            setList(node.left);
            setList(node.right);
        }
    }
}

844. 比较含退格的字符串

class Solution {
    public boolean backspaceCompare(String S, String T) {
        String s1 = getString(S);
        String s2 = getString(T);
        return s1.equals(s2);
    }

    private String getString(String s) {
        int i = s.indexOf("#");
        if (i == 0) {
            return getString(s.substring(1));
        }
        if (i > 0) {
            return getString(s.substring(0, i - 1) + s.substring(i + 1));
        }
        return s;
    }
}

191. 位1的个数

public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        return Integer.toBinaryString(n).replace("0", "").length();
    }
}

445. 两数相加 II

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        setNum(l1, list1);
        setNum(l2, list2);
        Collections.reverse(list1);
        Collections.reverse(list2);
        char[] chars = getResultChars(list1, list2);
        ListNode l = new ListNode(Integer.parseInt(chars[0] + ""));
        setNode(l, 1, chars);
        return l;
    }

    private char[] getResultChars(List<Integer> l1, List<Integer> l2) {
        StringBuilder sb = new StringBuilder();
        boolean flag = false;
        int max = Math.max(l1.size(), l2.size());
        for (int i = 0; i < max; i++) {
            int r1 = l1.size() > i ? l1.get(i) : 0;
            int r2 = l2.size() > i ? l2.get(i) : 0;
            int r = r1 + r2;
            if (flag) {
                r++;
                flag = false;
            }
            if (r > 9) {
                flag = true;
                r -= 10;
            }
            sb.append(r);
        }
        if (flag) {
            sb.append(1);
        }
        return sb.reverse().toString().toCharArray();
    }

    private void setNum(ListNode l, List<Integer> list) {
        if (l != null) {
            list.add(l.val);
            setNum(l.next, list);
        }

    }

    private void setNode(ListNode l, int index, char[] chars) {
        if (index < chars.length) {
            l.next = new ListNode(Integer.parseInt(chars[index] + ""));
            setNode(l.next, index += 1, chars);
        }
    }
}

217. 存在重复元素

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int num : nums) {
            set.add(num);
        }
        return !(set.size() == nums.length);
    }
}

167. 两数之和 II - 输入有序数组

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for (int i = 0; i < numbers.length; i++) {
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[i] + numbers[j] == target) {
                    return new int[] {i + 1, j + 1};
                }
            }
        }
        return null;
    }
}

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

class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        Set<Integer> s1 = new HashSet<>();
        Set<Integer> s2 = new HashSet<>();
        for (int i = 1; i <= nums.length; i++) {
            s1.add(i);
            s2.add(nums[i - 1]);
        }
        s1.removeAll(s2);
        return new ArrayList<>(s1);
    }
}

888. 公平的糖果交换

class Solution {
    public int[] fairCandySwap(int[] A, int[] B) {
        int totalA = 0, totalB = 0;
        for (int i : A) {
            totalA += i;
        }
        for (int i : B) {
            totalB += i;
        }
        int diff = (totalA - totalB) / 2;
        for (int i : A) {
            for (int j : B) {
                if (i == j + diff) {
                    return new int[] {i, j};
                }
            }
        }
        return null;
    }
}

392. 判断子序列

class Solution {
    public boolean isSubsequence(String s, String t) {
        if (s == null || s.equals("")) {
            return true;
        }
        char[] c1 = s.toCharArray();
        int index = 0;
        for (char c : t.toCharArray()) {
            if (c == c1[index]) {
                index++;
            }
            if (index == c1.length) {
                return true;
            }
        }
        return false;
    }
}

383. 赎金信

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character, Integer> map = new HashMap<>(magazine.length());
        for (char c : magazine.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        for (char c : ransomNote.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) - 1);
        }
        return map.values().stream().filter(x -> x < 0).count() <= 0;
    }
}

796. 旋转字符串

class Solution {
    public boolean rotateString(String A, String B) {
        if (A.length() < 2) {
            return A.equals(B);
        }
        for (int i = 0; i < B.length() - 1; i++) {
            A = A.substring(1) + A.charAt(0);
            if (A.equals(B)) {
                return true;
            }
        }
        return false;
    }
}

263. 丑数

class Solution {
    public boolean isUgly(int num) {
        if (num <= 0) {
            return false;
        }
        while (num % 2 == 0) {
            num >>= 1;
        }

        while (num % 3 == 0) {
            num /= 3;
        }

        while (num % 5 == 0) {
            num /= 5;
        }
        return num == 1;
    }
}

112. 路径总和

class Solution {
    private List<Integer> list = new ArrayList<>();
    private boolean flag = false;

    public boolean hasPathSum(TreeNode root, int sum) {
        setList(root, sum, 0);
        return flag;
    }

    private void setList(TreeNode node, int sum, int index) {
        if (node != null) {
            list.add(index, node.val);
            index++;
            if (node.left == null && node.right == null) {
                int t = 0;
                for (int i = 0; i < index; i++) {
                    t += list.get(i);
                }
                if (t == sum) {
                    flag = true;
                }
            }
            setList(node.left, sum, index);
            setList(node.right, sum, index);
        }
    }
}

342. 4的幂

class Solution {
    public boolean isPowerOfFour(int num) {
        if (num <= 0) {
            return false;
        }
        while (num % 4 == 0) {
            num >>= 2;
        }
        return num == 1;
    }
}

611. 有效三角形的个数

class Solution {
    public int triangleNumber(int[] nums) {
        int total = 0;
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                for (int k = j + 1; k < nums.length; k++) {
                    if (nums[i] + nums[j] > nums[k]) {
                        total++;
                    } else {
                        break;
                    }
                }
            }
        }
        return total;
    }
}

134. 加油站

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int length = gas.length;
        for (int i = 0; i < length; i++) {
            if (gas[i] >= cost[i]) {
                int index = i;
                int total = 0;
                for (int j = 0; j < length; j++) {
                    if (index >= length) {
                        index = 0;
                    }
                    total += gas[index] - cost[index];
                    if (total < 0) {
                        break;
                    }
                    index++;
                }
                if (total >= 0) {
                    return i;
                }
            }
        }
        return -1;
    }
}

231. 2的幂

class Solution {
    public boolean isPowerOfTwo(int n) {
        if (n <= 0) {
            return false;
        }
        while (n % 2 == 0) {
            n >>= 1;
        }
        return n == 1;
    }
}

405. 数字转换为十六进制数

class Solution {
    public String toHex(int num) {
        return Integer.toHexString(num);
    }
}

541. 反转字符串 II

class Solution {
    private StringBuilder sb = new StringBuilder();

    public String reverseStr(String s, int k) {
        if (s.length() <= k) {
            sb.append(new StringBuilder(s).reverse());
        } else if (s.length() <= 2 * k) {
            sb.append(new StringBuilder(s.substring(0, k)).reverse());
            sb.append(s.substring(k));
        } else {
            sb.append(new StringBuilder(s.substring(0, k)).reverse());
            sb.append(s, k, 2 * k);
            s = s.substring(2 * k);
            reverseStr(s, k);
        }
        return sb.toString();
    }
}

70. 爬楼梯

class Solution {
   public int climbStairs(int n) {
        if (n <= 3) {
            return n;
        } else {
            return climbStairs(n - 1) + climbStairs(n - 2);
        }
    }
}

其实就是斐波那契数列
83. 删除排序链表中的重复元素

class Solution {
    private List<Integer> list = new ArrayList<>();

    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return null;
        }
        getList(head);
        ListNode l = new ListNode(list.get(0));
        setList(l, 1);
        return l;
    }

    private void setList(ListNode node, int index) {
        if (index < list.size()) {
            node.next = new ListNode(list.get(index));
            setList(node.next, index += 1);
        }
    }

    private void getList(ListNode node) {
        if (node != null) {
            if (!list.contains(node.val)) {
                list.add(node.val);
            }
            getList(node.next);
        }
    }
}

599. 两个列表的最小索引总和

class Solution {
    public String[] findRestaurant(String[] list1, String[] list2) {
        Map<String, Integer> map = new HashMap<>();

        for (int i = 0; i < list1.length; i++) {
            for (int j = 0; j < list2.length; j++) {
                if (list1[i].equals(list2[j])) {
                    map.put(list1[i], i + j);
                }
            }
        }

        Integer i = map.values().stream().sorted().findFirst().get();
        List<String> collect = map.entrySet().stream().filter(e -> e.getValue().equals(i))
                .map(e -> e.getKey()).collect(Collectors.toList());
        String[] strs = new String[collect.size()];
        collect.toArray(strs);
        return strs;
    }
}

492. 构造矩形

class Solution {
    public int[] constructRectangle(int area) {
        int n = (int)Math.sqrt(area);
        while(area % n > 0 && n-- > 0);
        return new int[]{area/n,n};
    }
}
第一个能取模为0的是最大的

223. 矩形面积

class Solution {
    public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
        int total = (C - A) * (D - B) + (G - E) * (H - F);
        int subTotal;
        //不相交的情况
        if (B >= H || F >= D || E >= C || A >= G) {
            subTotal = 0;
        } else {
            subTotal = (Math.min(C, G) - Math.max(E, A)) * (Math.min(D, H) - Math.max(B, F));
        }
        return total - subTotal;
    }
}

543. 二叉树的直径

class Solution {
    private int max;

    public int diameterOfBinaryTree(TreeNode root) {
        getMax(root);
        return max;
    }

    private int getMax(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int leftVal = getMax(node.left);
        int rightVal = getMax(node.right);
        if (max < leftVal + rightVal) {
            max = leftVal + rightVal;
        }
        return Math.max(leftVal, rightVal) + 1;
    }
}

23. 合并K个排序链表

class Solution {
    private List<Integer> list = new ArrayList<>();

    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length < 1) {
            return null;
        }
        for (ListNode listNode : lists) {
            setList(listNode);
        }
        if (list.size() == 0) {
            return null;
        }
        Collections.sort(list);
        ListNode root = new ListNode(list.get(0));
        setNode(root, 1);
        return root;
    }

    private void setNode(ListNode root, int index) {
        if (index < list.size()) {
            root.next = new ListNode(list.get(index));
            setNode(root.next, index += 1);
        }
    }

    private void setList(ListNode node) {
        if (node != null) {
            list.add(node.val);
            setList(node.next);
        }
    }
}

917. 仅仅反转字母

class Solution {
    public String reverseOnlyLetters(String S) {
        char[] cs = S.toCharArray();
        int l = S.length() - 1;
        int index = 0;
        while (l >= index) {
            char c1 = cs[index];
            char c2 = cs[l];
            if (!((c1 > 64 && c1 < 91) || (c1 > 96 && c1 < 123))) {
                index++;
                continue;
            }
            if (!((c2 > 64 && c2 < 91) || (c2 > 96 && c2 < 123))) {
                l--;
                continue;
            }
            if (c1 == c2) {
                index++;
                l--;
                continue;
            }
            cs[index] = c2;
            cs[l] = c1;
            index++;
            l--;
        }
        return new String(cs);
    }
}

415. 字符串相加

class Solution {
    public String addStrings(String num1, String num2) {
        StringBuilder sb = new StringBuilder();
        char[] chars1 = num1.toCharArray();
        char[] chars2 = num2.toCharArray();
        int l1 = num1.length() - 1;
        int l2 = num2.length() - 1;
        boolean flag = false;
        for (; Math.max(l1, l2) >= 0; l1--, l2--) {
            int i1, i2;
            if (l1 < 0) {
                i1 = 0;
            } else {
                i1 = Integer.parseInt(chars1[l1] + "");
            }
            if (l2 < 0) {
                i2 = 0;
            } else {
                i2 = Integer.parseInt(chars2[l2] + "");
            }
            int total = i1 + i2;
            if (flag) {
                total++;
                flag = false;
            }
            if (total > 9) {
                total -= 10;
                flag = true;
            }
            sb.insert(0, total);
        }
        if (flag) {
            sb.insert(0, 1);
        }
        return sb.toString();
    }
}

205. 同构字符串

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, Character> sMap = new HashMap<>();
        Map<Character, Character> tMap = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char sE = s.charAt(i);
            char tE = t.charAt(i);
            Character sVal = sMap.get(sE);
            if (sVal == null) {
                if (tMap.containsKey(tE)) {
                    return false;
                }
                sMap.put(sE, tE);
                tMap.put(tE, sE);
                continue;
            }
            if (sVal != tE) {
                return false;
            }
        }
        return true;
    }
}

35. 搜索插入位置

class Solution {
    public int searchInsert(int[] nums, int target) {
        if (target <= nums[0]) {
            return 0;
        }
        if (target > nums[nums.length - 1]) {
            return nums.length;
        }
        for (int i = 1; i < nums.length; i++) {
            if (target == nums[i]) {
                return i;
            }
            if (target > nums[i - 1] && target < nums[i]) {
                return i;
            }
        }
        return -1;
    }
}

26. 删除排序数组中的重复项

class Solution {
    public int removeDuplicates(int[] nums) {
        int index = nums.length - 1;
        for (int i = 0; i < index; i++) {
            if (nums[i] == nums[i + 1]) {
                for (int j = i + 1; j < index; j++) {
                    nums[j] = nums[j + 1];
                }
                i--;
                index--;
            }
        }
        return index + 1;
    }
}

326. 3的幂

class Solution {
    public boolean isPowerOfThree(int n) {
        return n > 0 && 1162261467 % n == 0;
    }
}

88. 合并两个有序数组

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = m; i < m + n; i++) {
            nums1[i] = nums2[i - m];
        }
        Arrays.sort(nums1);
    }
}

357. 计算各个位数不同的数字个数

class Solution {
    public int countNumbersWithUniqueDigits(int n) {
        int count = 0;
        for (int i = 0; i < (int) Math.pow(10, n); i++) {
            if (isRepeat(i)) {
                count++;
            }
        }
        return count;
    }

    private boolean isRepeat(int n) {
        if (n < 11) {
            return true;
        }
        String s = n + "";
        for (char c : s.toCharArray()) {
            if (s.indexOf(c) != s.lastIndexOf(c)) {
                return false;
            }
        }
        return true;
    }
}

53. 最大子序和

class Solution {
    public int maxSubArray(int[] nums) {
        int total = nums[0];
        int sum = 0;
        for (int num : nums) {
            if (sum > 0) {
                sum += num;
            } else {
                sum = num;
            }
            total = Math.max(total, sum);
        }
        return total;
    }
}

504. 七进制数

class Solution {
    public String convertToBase7(int num) {
        return Integer.toString(num, 7);
    }
}

628. 三个数的最大乘积

class Solution {
    public int maximumProduct(int[] nums) {
        int l = nums.length - 1;
        Arrays.sort(nums);
        if (nums[0] > -1 || nums[l] < 0) {
            return nums[l] * nums[l - 1] * nums[l - 2];
        } else {
            return Math.max(nums[0] * nums[1], nums[l - 1] * nums[l - 2]) * nums[l];
        }
    }
}

744. 寻找比目标字母大的最小字母

class Solution {
    public char nextGreatestLetter(char[] letters, char target) {
        for (char letter : letters) {
            if (letter - target > 0) {
                return letter;
            }
        }
        return letters[0];
    }
}

717. 1比特与2比特字符

class Solution {
    public boolean isOneBitCharacter(int[] bits) {
        int count = 0;
        for (int i = bits.length - 2; i >= 0; i--) {
            if (bits[i] == 1) {
                count++;
            } else {
                break;
            }
        }
        return count % 2 == 0;
    }
}

180. 连续出现的数字

# Write your MySQL query statement below
select distinct l1.num ConsecutiveNums from Logs l1 join Logs l2 on l1.id=l2.id-1 join Logs l3 on l1.id=l3.id-2 where l1.num=l2.num and l2.num=l3.num

830. 较大分组的位置

class Solution {
    public List<List<Integer>> largeGroupPositions(String S) {
        S += "-";
        List<List<Integer>> result = new ArrayList<>();
        int index = 0, start = 0;
        char preChar = ' ';
        for (char c : S.toCharArray()) {
            if (preChar != c) {
                if (index - start > 2) {
                    result.add(Arrays.asList(start, index - 1));
                }
                start = index;
            }
            preChar = c;
            index++;
        }
        return result;
    }
}

197. 上升的温度

# Write your MySQL query statement below
select w2.Id from Weather w1,Weather w2 where DATEDIFF(w2.RecordDate,w1.RecordDate) = 1 and w2.Temperature > w1.Temperature

6. Z 字形变换

class Solution {
   public String convert(String s, int numRows) {
       if (numRows == 1) {
            return s;
        }
        List<List<Character>> lists = new ArrayList<>();
        for (int i = 0; i < numRows; i++) {
            lists.add(new ArrayList<>());
        }
        boolean flag = true;
        int index = 1;
        for (char c : s.toCharArray()) {
            if (flag) {
                lists.get(index - 1).add(c);
                if (index == numRows) {
                    flag = false;
                    index--;
                } else {
                    index++;
                }
            } else {
                lists.get(index - 1).add(c);
                if (index == 1) {
                    flag = true;
                    index++;
                } else {
                    index--;
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        for (List<Character> list : lists) {
            for (Character c : list) {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

367. 有效的完全平方数

class Solution {
    public boolean isPerfectSquare(int num) {
        long i = 0;
        while (true) {
            i++;
            if (i * i == num) {
                return true;
            }
            if (i * i > num) {
                return false;
            }
        }
    }
}

925. 长按键入

class Solution {
    public boolean isLongPressedName(String name, String typed) {
        int index = 0;
        char[] chars = typed.toCharArray();
        for (char c : name.toCharArray()) {
            if (index == chars.length) {
                return false;
            }
            for (int i = index; i < chars.length; i++) {
                index++;
                if (c == chars[i]) {
                    break;
                }
            }
        }
        return name.charAt(name.length() - 1) == chars[chars.length - 1];
    }
}

229. 求众数 II

class Solution {
   public List<Integer> majorityElement(int[] nums) {
        if (nums.length < 1) {
            return new ArrayList<>();
        }
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        int max = nums.length / 3 + 1;
        return map.entrySet().stream().filter(m -> m.getValue() >= max).map(x -> x.getKey()).collect(Collectors.toList());
    }
}

240. 搜索二维矩阵 II

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int length = matrix.length;
        int y = length == 0 ? -1 : matrix[0].length - 1;
        if (y < 0) {
            return false;
        }
        for (int[] row : matrix) {
            for (; y >= 0; --y) {
                int cur = row[y];
                if (cur == target) {
                    return true;
                } else if (cur > target) {
                } else {
                    break;
                }
            }
        }
        return false;
    }
}

162. 寻找峰值

class Solution {
    public int findPeakElement(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            int preNum = i == 0 ? Integer.MIN_VALUE : nums[i - 1];
            int nextNum = i == nums.length - 1 ? Integer.MIN_VALUE : nums[i + 1];
            if (nums[i] > preNum && nums[i] > nextNum) {
                return i;
            }
        }
        return 0;
    }
}

203. 移除链表元素

class Solution{
    private List<Integer> list = new ArrayList<>();
    
    public ListNode removeElements(ListNode head, int val) {
        getList(head, val);
        if (list.isEmpty()) {
            return null;
        }
        ListNode listNode = new ListNode(list.get(0));
        getNode(listNode, 1);
        return listNode;
    }

    private void getList(ListNode node, int val) {
        if (node != null) {
            if (node.val != val) {
                list.add(node.val);
            }
            getList(node.next, val);
        }
    }

    private void getNode(ListNode node, int index) {
        if (index < list.size()) {
            node.next = new ListNode(list.get(index));
            getNode(node.next, index + 1);
        }
    }
}

747. 至少是其他数字两倍的最大数

class Solution {
    public int dominantIndex(int[] nums) {
        if (nums.length == 1) {
            return 0;
        }
        int max1, max2, index;
        if (nums[0] > nums[1]) {
            index = 0;
            max1 = nums[0];
            max2 = nums[1];
        } else {
            index = 1;
            max1 = nums[1];
            max2 = nums[0];
        }
        for (int i = 2; i < nums.length; i++) {
            if (nums[i] > max1) {
                max2 = max1;
                max1 = nums[i];
                index = i;
                continue;
            }
            if (nums[i] > max2) {
                max2 = nums[i];
            }
        }
        if (max1 >= max2 * 2) {
            return index;
        }
        return -1;
    }
}
JokerDa
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode2305. 公平分发饼干（中等，周赛，状压dp）
zhangjiaji111的博客
07-01 288
思路一：暴力dfs，时间复杂度为O(n^n)，时间复杂度有些高。思路二：子集划分+子集个数有限制->状压dp 时间复杂度O(n * 3^n)是固定的 状压dp相关知识： 具体思路： dp[i][j]表示消耗的集合个数为i，选择的饼干为j所获得饼干最大总数的最小值。 i的取值为1->k j的取值为1->(1......
求两个整数中的最大值
weixin_73230994的博客
08-21 7959
求两个整数中的最大值
[LeetCode]5289. 公平分发饼干
wat1r的博客
06-12 321
5289. 公平分发饼干 给你一个整数数组 cookies ，其中 cookies[i] 表示在第 i 个零食包中的饼干数量。另给你一个整数 k 表示等待分发零食包的孩子数量，所有 零食包都需要分发。在同一个零食包中的所有饼干都必须分发给同一个孩子，不能分开。 分发的 不公平程度 定义为单个孩子在分发过程中能够获得饼干的最大总数。 返回所有分发的最小不公平程度。 示例 1： 输入：cookies = [8,15,10,20,8], k = 2 输出：31 解释：一种最优方案是 [8,15,8]
Unity3d 获得两GameObject间距
12-22
获取Unity场景内两个GameObject物体的实际距离
【java】973. 最接近原点的 K 个点------使用Java8新特性让你两行代码解决问题！
惠菁
11-09 233
我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。 （这里，平面上两点之间的距离是欧几里德距离。） 你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。 示例 1： 输入：points = [[1,3],[-2,2]], K = 1 输出：[[-2,2]] 解释： (1, 3) 和原点之间的距离为 sqrt(10)， (-2, 2) 和原点之间的距离为 sqrt(8)， 由于 sqrt(8) < sqrt(10)，(-2, 2) 离原点
LeetCode:LeetCode做题记录
03-09
通过熟做LeetCode的500道题目，即使是编程基础相对较弱的“差生”，也有机会大幅提高自己的编程能力和解决问题的技巧，从而增加进入知名科技公司（即所谓的“大厂”）的机会。这是因为LeetCode的题目往往与实际工作...
leetcode提交记录怎么看-LeetCodeSoving:LeetCode做过的值得记录思考的题目
06-30
LeetCode做过的，值得记录思考的题目，所以不是每道题目都会记录。 但每道题目都会自己先思考一下，写，然后提交，因此有一些没通过的也会记录，记录当时自己是怎么想的。 一般想题目肯定都是先简单的想，所以一般...
leetcode题库-LeetCode:做题记录
06-29
leetcode题库 LeetCode 此存储库主要是用于存储平时做过的算法题目 LeetCode 个人主页 LeetCode 周赛的代码 LeetCode 题目的代码 笔试题的代码 数据结构与算法相关的代码 其他来源的一些题目
linxid#Leetcode_Python#题目记录1
07-25
面试题22. 链表中倒数第k个节点|Easy|$O(n)$|链表|Done|双指针，第一个指针先遍历k步，另一个再开始面试题24. 反转链表|Easy|$O(n
Leetcode所有题目和解答（多语言实现）.rar
最新发布
06-24
此外，LeetCode社区的讨论和提交记录也是学习的好资源，可以借鉴他人的解决方案，了解不同的实现技巧。 总之，“Leetcode所有题目和解答（多语言实现）.rar”这个压缩包是一份全方位的编程学习资料，无论是初学者...
(C语言)写一个函数insert,用来向一个动态链表插入节点
爱上小公举
05-11 9600
写一个函数insert,用来向一个动态链表插入节点
Leetcode刷题笔记 973. 最接近原点的 K 个点
cjl的博客
11-09 133
973. 最接近原点的 K 个点 时间：2020年11月9日 知识点：排序、优先队列 题目链接：https://leetcode-cn.com/problems/k-closest-points-to-origin/ 题目 我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。 （这里，平面上两点之间的距离是欧几里德距离。） 你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。 示例 1： 输入： points = [[1,3],[-2,2]],
455. 分发饼干(分配问题)
m0_46646835的博客
06-05 1375
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 示例 1: 输入: g = [1,2,3], s = [1,1] 输出: 1 解释: 你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1
Python描述 LeetCode15. 三数之和
亓官劼的博客
06-06 238
给你一个包含 个整数的数组 ，判断 中是否存在三个元素 *a，b，c ，*使得 a + b + c = 0 ？请你找出所有和为 且不重复的三元组。**注意：**答案中不可以包含重复的三元组。示例 1： 示例 2： 示例 3： 提示：遍历两个数，剩下一个数使用字典进行验证。...
华为上机题汇总----java
weixin_30909575的博客
03-10 500
以下华为上机题目都是网上整理得到的，代码都是自己调试过的，由于网上java答案较少，欢迎大家批评指正，也希望对准备华为上机的童鞋们有一点点帮助。在练习的过程中成长，加油！~~ 第1题：输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。从后向前比较，以最短字符串为标准， 输出不同的元素的个数。 例如...
算法题汇总
qq_24095055的博客
08-09 1627
算法
Leetcode——最接近原点的 K 个点（快排）
Yawn
08-21 136
1. 最接近原点的 K 个点 （1）API class Solution { public int[][] kClosest(int[][] points, int K) { //将原数组 以距离原点大小 从小到大 排序 Arrays.sort(points, Comparator.comparingInt((int[] point) -> (point[0] * point[0] + point[1] * point[1])
LeetCode详细题解-Java版
热门推荐
听雪楼
12-12 5万+
LeetCode 1- 100 **1. 两数之和 : ** https://blog.csdn.net/love905661433/article/details/84779586 **2. 两数相加 : **https://blog.csdn.net/love905661433/article/details/84842140 **3. 无重复字符的最长子串 : **https://blog....
LeetCode第973题最接近原点的 K 个点
qq_41967623的博客
11-09 321
973. 最接近原点的 K 个点 题目： 我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。 （这里，平面上两点之间的距离是欧几里德距离。） 你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。 示例 1： 输入：points = [[1,3],[-2,2]], K = 1 输出：[[-2,2]] 解释： (1, 3) 和原点之间的距离为 sqrt(10)， (-2, 2) 和原点之间的距离为 sqrt(8)， 由于 sqrt(8) <
leetcode sql会员题目汇总
03-16
leetcode sql会员题目汇总包括以下题目： 1. 第N高的薪水 2. 从不订购的客户 3. 超过经理收入的员工 4. 员工奖金 5. 第二高的薪水 6. 分数排名 7. 连续出现的数字 8. 部门工资最高的员工 9. 交换工资 10. 员工考勤...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值