算法题存档2020425

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> temp = new ArrayList<>();
        tree(nums, temp, result);
        return result;
    }

    public void tree(int[] nums, List<Integer> temp, List<List<Integer>> result) {
        if(temp.size() == nums.length) {
            result.add(new ArrayList<>(temp));
        }

        for(Integer num : nums) {
            if(!temp.contains(num)) {
                temp.add(num);
                tree(nums, temp, result);
                temp.remove(temp.size() - 1);
            }
        }
    }
}

硬币。给定数量不限的硬币，币值为25分、10分、5分和1分，编写代码计算n分有几种表示法。(结果可能会很大，你需要将结果模上1000000007)

示例1:

 输入: n = 5
 输出：2
 解释: 有两种方式可以凑成总金额:
5=5
5=1+1+1+1+1

示例2:

 输入: n = 10
 输出：4
 解释: 有四种方式可以凑成总金额:
10=10
10=5+5
10=5+1+1+1+1+1
10=1+1+1+1+1+1+1+1+1+1

说明：

注意:

你可以假设：

    0 <= n (总金额) <= 1000000

class Solution {
   int[] coins = {25, 10, 5, 1};

    public int waysToChange(int n) {
        int[] result = new int[n + 1];
        result[0] = 1;

        for(int coin : coins) {
            for(int i = coin; i <= n; i++) {
                result[i] = (result[i] + result[i - coin]) % 1000000007;
            }
        }

        return result[n] % 1000000007;
    }
}

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();

        if(root == null) {
            return result;
        }

        List<TreeNode> stack = new LinkedList<>();
        stack.add(root);

        while(!stack.isEmpty()) {
            Integer size = stack.size();
            result.add(stack.get(stack.size() - 1).val);
            while(size > 0) {
                TreeNode node = stack.get(0);
                stack.remove(0);
                if(node.left != null) {
                    stack.add(node.left);
                }
                if(node.right != null) {
                    stack.add(node.right);
                }
                size--;
            }
        }

        return result;
    }
}

给你一个整数数组 nums 和一个整数 k。

如果某个 连续 子数组中恰好有 k 个奇数数字，我们就认为这个子数组是「优美子数组」。

请返回这个数组中「优美子数组」的数目。

 

示例 1：

输入：nums = [1,1,2,1,1], k = 3
输出：2
解释：包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。

示例 2：

输入：nums = [2,4,6], k = 1
输出：0
解释：数列中不包含任何奇数，所以不存在优美子数组。

示例 3：

输入：nums = [2,2,2,1,2,2,1,2,2,2], k = 2
输出：16

class Solution {
    public int numberOfSubarrays(int[] nums, int k) {
        int count[] = new int[nums.length + 2];
        int cnt = 0;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] % 2 == 1) {
                count[++cnt] = i;
            }
        }
        count[0] = -1;
        count[++cnt] = nums.length;
        int result = 0;
        for(int i = 1; i + k <= cnt; i++) {
            result += (count[i] - count[i - 1]) * (count[i + k] - count[i + k - 1]);
        }
        return result;
    }
}

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

 

示例 1:

输入:
11110
11010
11000
00000
输出: 1

示例 2:

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

class Solution {
    public int numIslands(char[][] grid) {
        int result = 0;

        for(int x = 0; x < grid.length; x++) {
            for(int y = 0; y < grid[0].length; y++) {
                if(grid[x][y] == '1') {
                    result++;
                    infect(grid, x, y);
                }
            }
        }

        return result;
    }

    public void infect(char[][] grid, int x, int y) {
        if(x < 0 ||  x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] != '1') {
            return;
        }
        grid[x][y] = '2';
        infect(grid, x - 1, y);
        infect(grid, x + 1, y);
        infect(grid, x, y - 1);
        infect(grid, x, y + 1);
    }
}