algorithm (5/100) day

howeres

已于 2024-08-23 11:02:52 修改

阅读量135

点赞数 1

文章标签： java 算法数据结构

于 2024-03-24 00:11:48 首次发布

本文链接：https://blog.csdn.net/howeres/article/details/136978447

版权

Start at Mar 23 2024
思路正确, 函数名有意义, 变量名有习惯, 重复代码尽量少, 就足够优雅了, 不必过分追求内存占用

Variable

abc/ijk/mn/uv/xyz
p/q
dict/g1/g2/g3
element/o1/o2/o3/q1/q2/q3
forward/backward
prev/next
l/w/h
# 首字母作为前缀 可作为分组使用
user -> u_
# Summary
abc/d/e/f/g/h/ijk/l/mn/o/pq/rs/t/uv/w/xyz

在这里插入图片描述

Structure

Tree

buildTree

public static TreeNode buildTree(Integer[] values) {

    if (values == null || values.length == 0) {
        return null;
    }
    TreeNode        root  = new TreeNode(values[0]);
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    int i = 1;
    while (!queue.isEmpty() && i < values.length) {
        TreeNode node = queue.poll();

        if (values[i] != null) {
            node.left = new TreeNode(values[i]);
            queue.offer(node.left);
        }
        i++;

        if (i < values.length && values[i] != null) {
            node.right = new TreeNode(values[i]);
            queue.offer(node.right);
        }
        i++;
    }

    return root;
}

height, depth, level

       A        <-- Level 0, Depth 0, Height 2
     /   \
    B     C     <-- Level 1, Depth 1, Height 1
   / \   / \
  D   E F   G   <-- Level 2, Depth 2, Height 0 (Leaf nodes)

Traversal 遍历

前序遍历 (Preorder Traversal): 根节点 -> 左子树 -> 右子树
中序遍历 (Inorder Traversal): 左子树 -> 根节点 -> 右子树
后序遍历 (Postorder Traversal): 左子树 -> 右子树 -> 根节点

Queue

FIFO
- offer (!=add with Exception, !=addLast with Exception) 提案
- poll (!=remove with Exception) 现代意思是投票, 但更久远的意思是砍掉树梢的顶部; see: cut off the top of a tree or plant
  - peek (==peekFirst, !=getFirst with Exception) 预览
- clear

Stack

LIFO
- push (==addFirst) 压栈
- pop (==popFirst, !=removeFirst with Exception) 弹出

Bitwise operators

在这里插入图片描述

indent 缩进

java, scala (tab with 2) 一行能放更多内容
cpp (space with 2) 有现成 Google 标准
python (space with 4) PEP 8（Python 的官方风格指南）
all script language: like bash, js, ts, yaml (space with 2) 一行能放更多内容

不要养成格式化代码的习惯, 从合并代码角度和写代码的流畅度方面考虑

Problems

Solution

76. Minimum Window Substring

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> need, window;
        for (char c : t) need[c]++;

        int left = 0, right = 0;
        int valid = 0;
        int start = 0, len = INT_MAX;
        while (right < s.size()) {
            char c = s[right];
            right++;
            if (need.count(c)) {
                window[c]++;
                if (window[c] == need[c]) {
                    valid++;
                }
            }

            while (valid == need.size()) {
                if (right - left < len) {
                    start = left; 
                    len = right - left;
                }
                char d = s[left];
                left++;
                if (need.count(d)) {
                    if (window[d] == need[d]) {
                        valid--;
                    }
                    window[d]--;
                }
            }
        }
        return len == INT_MAX ? "" : s.substr(start, len);
    }
};

567. Permutation in String

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        unordered_map<char, int> need, window;
        for (char c : s1) need[c]++;

        // must initialize variables!
        int left = 0, right = 0;
        int valid = 0;
        while (right < s2.size()) {
            char c = s2[right++];
            if (need.count(c)) {
                window[c]++;
                if (window[c] == need[c]) {
                    valid++;
                }
            }
            while (right - left >= s1.size()) {
                // mistake: s1.size()
                if (valid == need.size()) {
                    return true;
                }
                // mistake s1[left++];
                char d = s2[left++];
                if (need.count(d)) {
                    if (window[d] == need[d]) {
                        valid--;
                    }
                    window[d]--;
                }
            } 
        }
        return false;
    }
};

438. Find All Anagrams in a String

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
         
         unordered_map<char, int> need, window;
         for (char c : p) need[c]++;

         int left = 0, right = 0;
         int valid = 0;
         vector<int> ans;
         while (right < s.size()) {
            // move p.size() first, and move 1 step each loop later.
            char c = s[right++];
            if (need.count(c)) {
                window[c]++;
                if (window[c] == need[c]) {
                    valid++;
                }
            }
            // window: [left, right]
            while (right - left >= p.size()) { 
                // just move 1 step in each loop.
                if (need.size() == valid) {
                    ans.push_back(left);
                }
                char d = s[left++];
                if (need.count(d)) {
                    if (window[d] == need[d]) {
                        valid--;
                    }
                    window[d]--;
                }
            }
         }
         return ans; 
    }
}

3. Longest Substring Without Repeating Characters

class Solution {
public:
    int lengthOfLongestSubstring(string s) {

        unordered_map<char, int> window;
        // sliding window need 2 point.
        int left = 0, right = 0;
        int ans = 0;

        while (right < s.size()) {
            char c = s[right++];
            window[c]++;

            while (window[c] > 1) {
                char d = s[left++];
                if (window.count(d)) {
                    window[d]--;
                }
            }
            // mistake: left - right
            ans = max(right - left, ans);
        }
        return ans;
    }
};

300. Longest Increasing Subsequence

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1);
        int ans = 0;
        for (int i = 0; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            ans = max(dp[i], ans);
        }
        return ans;
    }
};

354. Russian Doll Envelopes

Time Limit Exceeded

class Solution {
public:
    int maxEnvelopes(vector<vector<int>>& envelopes) {

        sort(envelopes.begin(), envelopes.end());
        // sort(envelopes.begin(), envelopes.end(),
        //      [](const vector<int>& a, const vector<int>& b) {
        //          return a[0] == b[0] ? b[1] < a[1] : a[0] < b[0];
        //      });
        vector<int> dp(envelopes.size(), 1);
        int ans = 0;
        for (int i = 0; i < envelopes.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (envelopes[i][1] > envelopes[j][1] &&
                    envelopes[i][0] > envelopes[i][0]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            ans = max(dp[i], ans);
        }
        return ans;
    }
};

2385. Amount of Time for Binary Tree to Be Infected

Solution

class Solution {

    int ans   = 0;  // 最短用时
    int depth = -1; // 起始节点的高度

    public int amountOfTime(TreeNode root, int start) {

        dfs(root, 0, start);
        return ans;
    }

    int dfs(TreeNode root, int level, int start) {

        if (root == null) return 0;
        if (root.val == start) depth = level;                       // 当前节点即起始节点
        int     l      = dfs(root.left, level + 1, start);          // 左子树的树高
        boolean inLeft = depth != -1;                               // 起始节点是否在左子树上
        int     r      = dfs(root.right, level + 1, start);         // 右子树的树高
        if (root.val == start) ans = Math.max(ans, Math.max(l, r)); // 情况1：感染以 start 为根结点的树所需时间
        if (inLeft) ans = Math.max(ans, depth - level + r);         // 情况2：感染以 root 为根结点的树所需时间
        else ans = Math.max(ans, depth - level + l);
        return Math.max(l, r) + 1;                                  // 返回树高
    }

}