Leetcode 121-130刷题笔记(非困难题目)

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);
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值