121.买卖股票的最佳时机
该题目是只允许买卖一次股票,那么就对于我们买卖的时机需要斟酌。
我们买卖股票肯定不能选择亏本生意,所以说必须买入 <= 卖出,并且买入要晚于卖出。
根据这一特性,我们通过一个 min 的变量标记最低点,如果碰到比最低点还低的值,那么我们就可以选择更换最低点,不然则用以前的 min 计算卖出利润。
//卖股票最佳时机
public int maxProfit(int[] prices) {
int ans = 0;
//标记一个买入资金(卖出要大于买入)
int min = Integer.MAX_VALUE;
for(int price : prices) {
if(price < min) {
//更换买入资金
min = price;
continue;
}
//选择卖出时机
ans = Math.max(ans,price - min);
}
return ans;
}
122.买入股票的最佳时机2
该题目和121的区别在于,该题目可以多次买入卖出。
这个题目更像一道数学题,可以看解析,简单点说就是计算所有的上升部分曲线(连续)。
//卖股票最佳时机(允许多次买入卖出,那就是记录所有上升曲线)
public int maxProfit(int[] prices) {
int ans = 0;
//需要将所有上升曲线累加
int min = Integer.MAX_VALUE;
//记录前一位
int prev = Integer.MAX_VALUE;
for(int price : prices) {
//仍旧处于上升空间(不卖出)
if(price > prev) {
//继续持仓(更新前一位)
prev = price;
}else { //说明处于下降点,不买入,并且更换买入时机
if(prev != Integer.MAX_VALUE) {
ans += prev - min;
}
//更换买入时机
prev = price;
min = price;
}
}
//如果最后一段有上身空间(循环中无法计算)
if(prev != min) {
ans += prev - min;
}
return ans;
}
125.验证回文串
该题目就是使用的双指针法,唯一需要注意的是该题目需要忽略除开字母和数字的字符部分。
//验证回文串
public boolean isPalindrome(String s) {
int left = 0;
int right = s.length() - 1;
//变成小写字母
s = s.toLowerCase();
char[] chars = s.toCharArray();
while(left < right) {
//碰到非字符跳过
if(!Character.isLetter(chars[left]) && !Character.isDigit(chars[left])) {
left++;
continue;
}
if(!Character.isLetter(chars[right]) && !Character.isDigit(chars[right])) {
right--;
continue;
}
if(chars[left] == chars[right]) {
left++;
right--;
}else {
return false;
}
}
return true;
}
127.单词接龙
该题目使用的是一个通配的思想。
例如从hit -> cog
hit 一次变换可以变成 it, ht, hi* 中任意一个
换个方向思考那么 og, cg, co* 可通过一次变换得到 cog
这个题目我是用dfs超时了,所以我们采用bfs进行,即每次对字符进行一次通配处理后,如果没有匹配成功,那么直接将路径 + 1继续入队。
public class Solution {
Map<String,Set<String>> map = new HashMap<>();
//保存访问过的字符
Set<String> set = new HashSet<>();
//单词接龙(每次变换一个字符,并且字符时wordList里面的)
/*
例如从hit -> cog
hit 一次变换可以变成 *it, h*t, hi* 中任意一个
换个方向思考那么 *og, c*g, co* 可通过一次变换得到 cog
*/
public int ladderLength(String beginWord, String endWord, List<String> wordList) {
//生成通配符映射
for(String word : wordList) {
for(int i=0;i<word.length(); i++) {
//选择将第 i 个字符转换成 *
String wildCard = word.substring(0,i) + "*" + word.substring(i + 1,word.length());
if(map.containsKey(wildCard)) {
map.get(wildCard).add(word);
}else {
Set<String> set = new HashSet<>();
set.add(word);
map.put(wildCard,set);
}
}
}
//采用bfs,横向进行遍历,每次找到下一个状态后将路径 + 1
Queue<Pair<String,Integer>> queue = new LinkedList<>();
queue.offer(new Pair<>(beginWord,1));
while(!queue.isEmpty()) {
Pair<String, Integer> poll = queue.poll();
//获得文字
String word = poll.getKey();
//特殊情况
if(word.equals(endWord)) {
return poll.getValue();
}
for(int i=0;i<word.length(); i++) {
//选择将第 i 个字符转换成 *
String wildCard = word.substring(0,i) + "*" + word.substring(i + 1,word.length());
if(map.containsKey(wildCard)) {
//遍历通配字符串可一步到达的字符串
Set<String> strings = map.get(wildCard);
for(String string : strings) {
//说明匹配成功(第一个找到的说明是最短转换路径)
if(string.equals(endWord)) {
return poll.getValue() + 1;
}
//没有匹配成功则尝试进行下一步的转换方向
if(!set.contains(string)) {
queue.offer(new Pair<>(string,poll.getValue() + 1));
//防止重复访问
set.add(string);
}
}
}
}
}
return 0;
}
}
128.最长连续序列
该题目采用的思想是:
将这个离散的数组元素,抽象成多个连续的序列,例如
nums = [100,4,200,1,3,2] 抽象成:
1.【1,2,3,4】
2.【100】
3.【200】
如果将这些数据进行抽象呢?
我们选择找到这些连续序列的最小值,即 num - 1不存在(无前驱值,使用set实现)
当我们找到连续序列的最小值时,那我们在进行 + 1操作,知道加到结尾为止。
//最长连续子序列
public int longestConsecutive(int[] nums) {
Set<Integer> set = new HashSet<>();
for(int num : nums) {
set.add(num);
}
int ans = 0;
for(int num : set) {
//我们需要找到一块连续的最小值(我们可以理解为吧数组划分成几个连续的子序列,针对这几个序列进行长度计算)
if(!set.contains(num - 1)) {
int curr = 1;
while(set.contains(num + 1)) {
num += 1;
curr += 1;
}
ans = Math.max(ans,curr);
}
}
return ans;
}
129.求根到叶子结点的数字之和
该题目需要注意的点,就是我们不能直接进行双边递归求和,碰到叶子结点直接返回。(这样碰到叶子结点会导致计算两次),所以我们需要针对不同的情况进行讨论(叶子结点,单路,双路)
//求根结点到叶子结点的和(存在位数问题)
public int sumNumbers(TreeNode root) {
return dfs(root,0);
}
public int dfs(TreeNode root, int sum) {
if(root == null) {
return sum;
}
//如果碰到叶子结点,则计算后直接返回即可(需要将之前的sum * 10 后再加上 root)
if(root.left == null && root.right == null) {
return sum * 10 + root.val;
}
//如果只有单边,则进行单边递归(防止重复计算)
if(root.right == null) {
return dfs(root.left,sum * 10 + root.val);
}
if(root.left == null) {
return dfs(root.right,sum * 10 + root.val);
}
//如果两边都存在,则两边递归求和
return dfs(root.left,sum * 10 + root.val) + dfs(root.right,sum * 10 + root.val);
}
130.被围绕的区域
该题目就是使用dfs从边界 O 的位置进行深度优先搜索,并且将不需要更改的 O 的位置进行特殊标记(这里我是用的是改成A,等修改时候将A改成O,将O改成X)。A就是被我标记的不需要更改的O。
//被包围的区域
//该题目主要就是从边界 0 进行深度优先搜索
public void solve(char[][] board) {
if(board.length == 0) {
return;
}
int row = board.length;
int col = board[0].length;
//扫描边界 O ,进行dfs搜索,标记与其直接相连的 0
//第一行和最后一行
for(int i=0; i<col; i++) {
if(board[0][i] == 'O') {
dfs(board,0,i);
}
if(board[row - 1][i] == 'O') {
dfs(board,row - 1,i);
}
}
//第一列和最后一列
for(int i=0; i<row; i++) {
if(board[i][0] == 'O') {
dfs(board,i,0);
}
if(board[i][col - 1] == 'O') {
dfs(board,i,col - 1);
}
}
for(int i=0; i<row; i++) {
for(int j=0; j<col; j++) {
if(board[i][j] == 'A') {
board[i][j] = 'O';
}else if(board[i][j] == 'O') {
board[i][j] = 'X';
}
}
}
}
public void dfs(char[][] board, int i, int j) {
//越界
if(i < 0 || i >= board.length || j < 0 || j > board[0].length) {
return;
}
//不符合要求,停止递归
if(board[i][j] != 'O') {
return;
}
// A 为保留的 O
board[i][j] = 'A';
//向上下左右进行判断
dfs(board, i + 1, j);
dfs(board,i - 1,j);
dfs(board,i,j + 1);
dfs(board,i,j - 1);
}