8.
给你两个 m x n 的二进制矩阵 grid1 和 grid2 ,它们只包含 0 (表示水域)和 1 (表示陆地)。一个 岛屿 是由 四个方向 (水平或者竖直)上相邻的 1 组成的区域。任何矩阵以外的区域都视为水域。
如果 grid2 的一个岛屿,被 grid1 的一个岛屿 完全 包含,也就是说 grid2 中该岛屿的每一个格子都被 grid1 中同一个岛屿完全包含,那么我们称 grid2 中的这个岛屿为 子岛屿 。
请你返回 grid2 中 子岛屿 的 数目 。
class Solution {
int n, m;
public int countSubIslands(int[][] grid1, int[][] grid2) {
n = grid1.length;
m = grid1[0].length;
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid2[i][j] == 1) {
grid2[i][j] += grid1[i][j];
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid2[i][j] == 2 && find(grid2, i, j)) {
res++;
}
}
}
return res;
}
public boolean find(int[][] arr, int i, int j) {
if (i < 0 || j < 0 || i >= n || j >= m) {
return true;
}
if (arr[i][j] != 2) {
return arr[i][j] == 0;
}
arr[i][j] = 0;
boolean up = find(arr, i - 1, j);
boolean down = find(arr, i + 1, j);
boolean left = find(arr, i, j - 1);
boolean right = find(arr, i, j + 1);
return up && down && left && right;
}
}
7.
给你一个有 n 个节点的 有向无环图(DAG),请你找出所有从节点 0 到节点 n-1 的路径并输出(不要求按特定顺序)
graph[i] 是一个从节点 i 可以访问的所有节点的列表(即从节点 i 到节点 graph[i][j]存在一条有向边)。
class Solution {
public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> list = new ArrayList<>();
list.add(0);
dfs(res, list, graph, 0);
return res;
}
public void dfs(List<List<Integer>> res, List<Integer> list, int[][] graph, int x) {
if (x == graph.length - 1) {
res.add(new ArrayList<>(list));
return;
}
for (int i = 0; i < graph[x].length; i++) {
list.add(graph[x][i]);
dfs(res, list, graph, graph[x][i]);
list.remove(list.size() - 1);
}
}
}
6.
给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target,返回 [-1, -1]。
进阶:
你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗?
示例 1:
输入:nums = [5,7,7,8,8,10], target = 8
输出:[3,4]
示例 2:
输入:nums = [5,7,7,8,8,10], target = 6
输出:[-1,-1]
class Solution {
public int[] searchRange(int[] nums, int target) {
int left = surch(nums, target - 1);
int right = surch(nums, target) - 1;
if (left <= right && nums[left] == target)
return new int[]{left, right};
return new int[]{-1, -1};
}
public int surch(int[] nums, int target) {
int left = 0, right = nums.length - 1, ans = nums.length;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > target) {
ans = mid;
right = mid - 1;
}else
left = mid + 1;
}
return ans;
}
}
5.
给定一个区间的集合 intervals ,其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量,使剩余区间互不重叠 。
示例 1:
输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后,剩下的区间没有重叠。
示例 2:
输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
int n = intervals.length;
if (n == 1) return 0;
int res = 0;
Arrays.sort(intervals, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o1[1] - o2[1];
}
});
int ans = 1;
int right = intervals[0][1];
for (int i = 1; i < n; i++) {
if (intervals[i][0] >= right) {
ans++;
right = intervals[i][1];
}
}
return n - ans;
}
}
class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
int n = intervals.length;
if (n == 1) return 0;
int res = 0;
Arrays.sort(intervals, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o1[1] - o2[1];
}
});
int ans = 1;
int right = intervals[0][1];
for (int i = 1; i < n; i++) {
if (intervals[i][0] >= right) {
ans++;
right = intervals[i][1];
}
}
return n - ans;
}
}
4.
给你一个整数数组 prices ,其中 prices[i] 表示某支股票第 i 天的价格。
在每一天,你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买,然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1:
输入:prices = [7,1,5,3,6,4]
输出:7
解释:在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。
class Solution {
public int maxProfit(int[] prices) {
int n = prices.length;
if (n == 1) return 0;
int[][] dp = new int[n][2];
dp[0][0] = 0;
dp[0][1] = -prices[0];
for (int i = 1; i < n; i++) {
dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
}
return dp[n - 1][0];
}
}
3.
给定一个未排序的整数数组 nums , 返回最长递增子序列的个数 。
注意 这个数列必须是 严格 递增的。
示例 1:
输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列,分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。
示例 2:
输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1,并且存在5个子序列的长度为1,因此输出5。
class Solution {
public int findNumberOfLIS(int[] nums) {
int n = nums.length;
if (n == 1) return 1;
int[] dp = new int[n];
int[] res = new int[n];
Arrays.fill(dp, 1);
Arrays.fill(res, 1);
int max = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (nums[j] < nums[i]) {
if (dp[i] < dp[j] + 1) {
dp[i] = dp[j] + 1;
res[i] = res[j];
} else if (dp[i] == dp[j] + 1) {
res[i] += res[j];
}
}
}
max = Math.max(max, dp[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (dp[i] == max) {
ans += res[i];
}
}
return ans;
}
}
2.
给你一个整数数组 nums ,判断这个数组中是否存在长度为 3 的递增子序列。
如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ,使得 nums[i] < nums[j] < nums[k] ,返回 true ;否则,返回 false 。
示例 1:
输入:nums = [1,2,3,4,5]
输出:true
解释:任何 i < j < k 的三元组都满足题意
示例 2:
输入:nums = [5,4,3,2,1]
输出:false
解释:不存在满足题意的三元组
class Solution {
public boolean increasingTriplet(int[] nums) {
int n = nums.length;
if (n < 3) return false;
int first = nums[0], second = Integer.MAX_VALUE;
for (int i = 1; i < n; i++) {
if (nums[i] > second) {
return true;
}else if (nums[i] > first) {
second = nums[i];
}else {
first = nums[i];
}
}
return false;
}
}
1.
给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。
子序列 是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
示例 1:
输入:nums = [10,9,2,5,3,7,101,18]
输出:4
解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。
示例 2:
输入:nums = [0,1,0,3,2,3]
输出:4
示例 3:
输入:nums = [7,7,7,7,7,7,7]
输出:1
class Solution {
public int lengthOfLIS(int[] nums) {
int n = nums.length;
if (n == 1) return 1;
int[] dp = new int[n];
dp[0] = 1;
int res = 0;
for (int i = 1;i < n;i++) {
dp[i] = 1;
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = Math.max(dp[i], dp[j] + 1);
}
}
res = Math.max(res, dp[i]);
}
return res;
}
}