【LeetCode 75】Level 1 5-8天

买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0

public class Solution121 {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        for (int i = 0; i < n; i++) {
            if(i == 0){
                dp[i][0] = 0;
                dp[i][1] = -prices[0];
                continue;

            }
            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] +prices[i]);
            dp[i][1] = Math.max(dp[i-1][1], - prices[i]);
        }
        return dp[n-1][0];
    }
}

每一次有两种选择，如果是买的情况 要么保持上次一次不动继续保持买的状态，要么就是再当前时刻卖掉
如果是卖的情况 一种是持有上次状态不动，一种是此刻买入准备卖掉

最长回文串
给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。

在构造过程中，请注意 区分大小写 。比如 “Aa” 不能当做一个回文字符串。
示例 1:
输入:s = “abccccdd”
输出:7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。
示例 2:
输入:s = “a”
输出:1
示例 3：
输入:s = “aaaaaccc”
输出:7

public class Solution409 {
    public int longestPalindrome(String s) {
        int[] count = new int[128];
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i)-'A']++;
        }
        int res = 0;
        for(int num : count){
            res += num/2*2;
            if(res %2 == 0 && num%2 == 1 ){
                res++;
            }
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println('A'-'a');
    }
}

‘A’-'a’为负数，在减的时候要减A,如果位数为奇数可以添加，在res里面进行判断，如果加过了1那么res就为奇数，不需要在加了，如果没加，有多余的则可以加入一位。

N 叉树的前序遍历
给定一个 n 叉树的根节点 root ，返回 其节点值的 前序遍历 。

n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

public class Solution589 {
    List<Integer> res = new ArrayList<>();
    public List<Integer> preorder(Node root) {
        traverse(root);
        return res;
    }

    private void traverse(Node root) {
        if(root == null){
            return;
        }
        res.add(root.val);
        for(Node child : root.children){
            traverse(child);
        }
    }
}

简单前序遍历

二叉树的层序遍历
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]

public class Solution102 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while (!q.isEmpty()){
            int sz = q.size();
            List<Integer> temp = new ArrayList<>();
            for(int i = 0; i < sz; i++){
                TreeNode cur = q.poll();
                temp.add(cur.val);
                if(cur.left != null){
                    q.offer(cur.left);
                }
                if(cur.right != null){
                    q.offer(cur.right);
                }
            }
            res.add(temp);
        }
        return res;

    }
}

BFS层序遍历

二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

public class Solution704 {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while (left <= right){
            int mid = left +(right-left)/2;
            if(nums[mid] > target){
                right = mid-1;
            }else if(nums[mid] < target){
                left = mid+1;
            } else if (nums[mid] == target) {
                return mid;
            }
        }
        return - 1;
    }
}

二分查找 注意边界收缩

第一个错误的版本
二分查找

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
         int left = 0;
        int right = n;
        while (left <= right){
            int mid = left +(right-left)/2;
            if(!isBadVersion(mid)){
                left = mid+1;
            } else if (isBadVersion(mid)) {
                right = mid-1;
            }
        }
        return left;
    }
}

验证二叉搜索树

public class Solution98 {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root,null,null);
    }

    public boolean isValidBST(TreeNode root,TreeNode min, TreeNode max) {
        if(root == null){
            return true;
        }
        if( min != null && root.val <= min.val ){
            return false;
        }
        if(max != null&& root.val >= max.val){
            return false;
        }
        return isValidBST(root.left, min, root)&&
                isValidBST(root.right, root, max);
//        return isValidBST(root.left, null, root)&&
//                isValidBST(root.right, root, null);
    }
}

注意最小最大值都随着验证判断，不能只判断一侧大小

二叉搜索树的最近公共祖先

public class Solution235 {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        return find(root,p.val,q.val);
    }

    private TreeNode find(TreeNode root, int val1, int val2) {
        if(root == null){
            return null;
        }
        if(root.val == val1 || root.val == val2){
            return root;
        }
        TreeNode left = find(root.left,val1,val2);
        TreeNode right = find(root.right,val1,val2);
        if(left != null && right != null){
            return root;
        }
        return left != null ? left:right;
    }
}