算法题整理

1.最长回文子串

class Solution {
public:
    string isPalindrome(string& s, int left, int right) {
        while (left >= 0 && right <= s.length() - 1 && s[left] == s[right]) {
            left --;
            right ++;
        }
        return s.substr(left+1, right-left-1);
    }
    
    string longestPalindrome(string s) {
        if (s.empty()) return s;
        int left = 0,  right = 0;
        string longestpld = "";
        for (int start = 0; start < s.length(); start ++) {
            string str = isPalindrome (s, start,start);
            if (longestpld.length() < str.length()) longestpld = str;
            str = isPalindrome (s, start,start + 1);
            if (longestpld.length() < str.length()) longestpld = str;
        }
        return longestpld;
    }
};

 2. 快速排序

void quicksort(int *a, int start, int end) {
    if (start >= end) {
        return;
    }
    int right = end;
    int left = start;
    int middle = a[(right+left)/2];
    while (left <= right) {
        while (left <= right && a[left] < middle) 
            left++;
        while (left <= right && a[right] > middle) 
            right--;
        if (left <= right) {
            int temp = a[left];
            a[left] = a[right];
            a[right]   = temp;
            left++;
            right--;
        }
    }
    quicksort (a, start, right);
    quicksort (a, left, end);
}

3. 归并排序

#include <iostream>
using namespace std;


void merge(int *a, int start, int end, int *temp) {
    int middle = (start +  end)/2;
    int left = start;
    int right = middle +1;
    int index = left;
    while(left <= middle && right <= end) {
        if (a[left] <= a[right]){
            temp[index++] = a[left++];
        }
        else {
            temp[index++] = a[right++];
        }
    }
    while (left <= middle) {
        temp[index++] = a[left++];
    }
    while (right <= end) {
        temp[index++] = a[right++];
    }
    for ( int i = start; i<= end; i++){
        a[i] = temp[i];
    }
}

void mergesort(int *a, int start, int end, int *temp) {
    if (start >= end) {
        return;
    }
    mergesort(a, start, (start+end)/2, temp);
    mergesort(a, (start+end)/2 + 1, end, temp);
    merge(a, start, end, temp);
}

int main(int argc, char* argv[]){
    int a[] = {2,8,4,10,3,5,7,9};
    const int num = sizeof(a)/sizeof(a[0]);
    int b[num];
    mergesort(a, 0, num - 1, b);
    for (int i = 0; i< sizeof(a)/sizeof(a[0]); i++){
        cout << a[i] <<endl;
    }
}

 4. 快速选择排序

#include <iostream>
using namespace std;

int quickselect(int *a, int start, int end, int k) {
    if (start >= end) {
        return a[start];
    }
    int left = start;
    int right = end;
    int middle = a[(start+end)/2];
    while (left <= right) {
        while (left <= right && a[left] > middle)
            left++;
        while (left <= right && middle > a[right])
            right--;
        if (left <= right) {
            int temp = a[left];
            a[left] = a[right];
            a[right] = temp;
            left++;
            right--;
        }
    }
    if ( start +k -1 <= right) {
        return quickselect (a, start, right, k);
    }
    else if(start +k -1 >= left) {
        return quickselect (a, left, end, k - (left - start)) ;
    }
    return a[right+1];
}

int main(int argc, char* argv[]){
    int a[] = {2,8,4,10,3,5,7,9};
    const int num = sizeof(a)/sizeof(a[0]);
    int k = 3;
    int n = quickselect(a, 0, num - 1, k);
    cout << n << endl;
}

5.二分法

int binarySearch(int *nums, int start, int end, int target) {
　　if (!nums) {
　　　　return -1;
　　}
　　while (start + 1 < end) {
　　　　int middle = start + (end - start) / 2;
　　　　if (nums[middle] <= target) {
　　　　　　start = middle;
　　　　}
　　　　else {
　　　　　　end = middle;
　　　　}
　　}
　　if (nums[end] == target) 
　　　　return end;
　　if (nums[start] == target)
　　　　return start;
　　return -1;
}

 

 6. 三数之和 15. 三数之和 - 力扣（LeetCode）

class Solution {
public:
    void towsum (vector<int>& nums, int index, vector<vector<int>>& results) {
        int start = index + 1;
        int end = nums.size()-1;
        int target = -nums[index];
        while(start < end) {
            if (nums[start] + nums[end] > target) {
                end--;
            }
            else if (nums[start] + nums[end] < target) {
                start++;
            }
            else {
                results.push_back(vector<int>{-target, nums[start],nums[end]});
                start++;
                end--;
                while (start < end && nums[start] == nums[start-1]){
                    start++;
                }
            }
        }
    }
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> results;
        if (nums.size()<3){
            return results;
        }
        sort(nums.begin(), nums.end());
        for (int i = 0; i<nums.size()-2; i++){
            if (i!=0 && nums[i] == nums[i-1]) 
                continue;
            towsum(nums, i, results);
        }
        return results;
    }
};

7. 三角形个数 LintCode - LintCode

class Solution {
public:
    /**
     * @param s: A list of integers
     * @return: An integer
     */
    int getnum(vector<int> &s, int index){
        int left = 0;
        int right = index-1;
        int ans = 0;
        while (left < right){
            if (s[left] + s[right] > s[index]) {
                ans += right - left;
                right--;
            }
            else {
                left++;
            }
        }
        return ans;
    }

    int triangleCount(vector<int> &s) {
        if (s.size()<3) {
            return 0;
        }
        sort(s.begin(), s.end());
        int ans = 0;
        for (int i = 2; i<s.size(); i++) {
            ans += getnum(s, i);
        }
        return ans;
    }
};

8. 四数之和 18. 四数之和 - 力扣（LeetCode）

class Solution {
public:
    /**
     * @param numbers: Give an array
     * @param target: An integer
     * @return: Find all unique quadruplets in the array which gives the sum of zero
     *          we will sort your return value in output
     */
    void twosum (vector<int> &numbers, int index1, int index2, long target, vector<vector<int>>& res) {
        int left = index2 + 1;
        int right = numbers.size() - 1;
        while(left < right) {
            if (numbers[left] + numbers[right] > target) {
                right--;
            }    
            else if (numbers[left] + numbers[right] < target) {
                left++;
            }
            else {
                res.push_back(vector<int> {numbers[index1], numbers[index2], numbers[left], numbers[right]});
                left++;
                right--;
                while (left < right && numbers[left] == numbers[left-1]){
                    left++;
                }
            }
        }
    }
    vector<vector<int>> fourSum(vector<int> &numbers, int target) {
        vector<vector<int>> res;
        if (numbers.size()<4){
            return res;
        }
        sort (numbers.begin(), numbers.end());
        for (int i = 0; i<numbers.size()-3; i++){
            if (i != 0 && numbers[i] == numbers[i-1])
                continue;
            for (int j = i+1; j<numbers.size()-2; j++){
                if (j != i+1 && numbers[j] == numbers[j-1])
                    continue;
                twosum(numbers, i, j, (long)target-(numbers[i] + numbers[j]), res);
            }
        }
        return res;
    }
};

9. 四数组的四数之和 976 · 4数和 II - LintCode

class Solution {
public:
    /**
     * @param a: a list
     * @param b: a list
     * @param c: a list
     * @param d: a list
     * @return: how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero
     */
    int fourSumCount(vector<int> &a, vector<int> &b, vector<int> &c, vector<int> &d) {
        if (!a.size() || !b.size() || !c.size() || !d.size()){
            return 0;
        }
        unordered_map <int, int> hashTable;
        int res = 0;
        for (int i = 0; i < a.size(); i++){
            for (int j = 0; j < b.size(); j++){
                hashTable[a[i]+b[j]]++;
            }
        }
        for (int p = 0; p < c.size(); p++){
            for (int q = 0; q < d.size(); q++){
                int num = c[p] + d[q];
                if (hashTable.find(-num) != hashTable.end()){
                    res += hashTable[-num];
                }
            }
        }
        return res;
    }
};

 10.数组划分 2161. 根据给定数字划分数组 - 力扣（LeetCode）

class Solution {
public:
    vector<int> pivotArray(vector<int>& nums, int pivot) {
        if (nums.size() <= 1){
            return nums;
        }
        int left = 0;
        int right = nums.size() - 1;
        vector<int> ans(nums.size(), pivot);
        for (int i = 0;i < nums.size(); i++){
            if (nums[i] < pivot) {
                ans[left++] = nums[i];
            }
            else if(nums[i] > pivot){
                ans[right--] = nums[i];
            }
        }
        reverse(ans.begin()+right+1, ans.end());
        return ans;
    }
};

11.颜色分类143 · 颜色分类 II - LintCode

class Solution {
public:
    /**
     * @param colors: A list of integer
     * @param k: An integer
     * @return: nothing
     */
    void sortColor (vector<int> &colors, int color_begin, int color_end, int start, int end) {
        if (color_begin == color_end) return;
        int left = start, right = end;
        int middle = (color_begin + color_end) / 2;
        while (left <= right) {
            while (left <= right && colors[left] <= middle)
                left++;
            while (left <= right && colors[right] > middle)
                right--;
            if (left <= right) {
                int temp = colors[left];
                colors[left] = colors[right];
                colors[right] = temp;
                left++;
                right--;
            }
        }
        sortColor(colors, color_begin, middle, start, right);
        sortColor(colors, middle + 1, color_end, left, end);
    }

    void sortColors2(vector<int> &colors, int k) {
        sortColor(colors, 1, k, 0, colors.size() - 1);
    }
};

12.层序遍历102. 二叉树的层序遍历 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return vector<vector<int>>();
        vector<vector<int>> res;
        queue <TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int len = que.size();
            vector<int> vec;
            for (int i= 0; i<len; i++) {
                TreeNode* temp = que.front();
                if (temp->left)  que.push(temp->left);
                if (temp->right) que.push(temp->right);
                vec.push_back(temp->val);
                que.pop();
            }
            res.push_back(vec);
        }
        return res;
    }
};

 13. 二叉树的所有路径 480 · 二叉树的所有路径 - LintCode

class Solution {
public:
    /**
     * @param root: the root of the binary tree
     * @return: all root-to-leaf paths
     *          we will sort your return value in output
     */
    void findpaths(TreeNode *node, string& path, vector<string>& res) {
        if (node == nullptr) return;
        int size = path.size();
        if (node->left == nullptr && node->right == nullptr) {
            path += to_string(node->val);
            res.push_back(path);
        }
        else {
            path += to_string(node->val) + "->";
            findpaths(node->left, path, res);
            findpaths(node->right, path, res);
        }
        path.erase(size);
    }

    vector<string> binaryTreePaths(TreeNode *root) {
        vector<string> res;
        string path;
        findpaths(root, path, res);
        return res;
    }
};

14.93 · 平衡二叉树 - LintCode

class Result {
 public:
     Result (int a, bool b): height(a), isbalance(b) {}
    int height;
    bool isbalance;
 };

class Solution {
public:
    /**
     * @param root: The root of binary tree.
     * @return: True if this Binary tree is Balanced, or false.
     */
    Result banlance (TreeNode *node) {
        if (node == nullptr) return Result(0, true);

        Result res1 = banlance(node->left);
        Result res2 = banlance (node->right);
        int height = max(res1.height, res2.height) + 1;
        if (!res1.isbalance || !res2.isbalance) {
            return Result(height, false);
        }
        if (abs(res1.height - res2.height) > 1) {
            return Result(height, false);
        }
        return Result(height, true);
    }
    bool isBalanced(TreeNode *root) {
        Result res = banlance(root);
        return res.isbalance;
    }
};

 15.二叉查找树迭代器  中序遍历 86 · 二叉查找树迭代器 - LintCode

class BSTIterator {
public:
    /*
    * @param root: The root of binary tree.
    */BSTIterator(TreeNode * root) {
        if (root == nullptr) return;
        vec.clear();
        for (TreeNode *temp = root; temp != nullptr; temp = temp->left) {
            vec.push_back(temp);
        }
    }

    /*
     * @return: True if there has next node, or false
     */
    bool hasNext() {
        return !vec.empty();
    }

    /*
     * @return: return next node
     */
    TreeNode * next() {
        if (!hasNext()) return nullptr;
        TreeNode* temp = vec.back();
        vec.pop_back();
        if (temp->right != nullptr) {
            for (TreeNode *node = temp->right; node != nullptr; node = node->left ){
                vec.push_back(node);
            }
        }
        return temp;
    }
private:
    vector<TreeNode *> vec;
};

 16 . 651 · 二叉树垂直遍历 - LintCode

 

class Solution {
public:
    /**
     * @param root: the root of tree
     * @return: the vertical order traversal
     */
    vector<vector<int>> verticalOrder(TreeNode *root) {
        vector<vector<int>> res;
        if (root == nullptr) return res;
        map <int, vector<int>> mp;
        queue<TreeNode *> nodeque;
        queue<int> numque;
        nodeque.push(root);
        numque.push(0);
        while (!nodeque.empty()) {
            TreeNode *tempnode = nodeque.front();
            int tempnum = numque.front();
            nodeque.pop();
            numque.pop();
            mp[tempnum].push_back(tempnode->val);
            if (tempnode->left != nullptr) {
                nodeque.push(tempnode->left);
                numque.push(tempnum-1);
            }
            if (tempnode->right != nullptr) {
                nodeque.push(tempnode->right);
                numque.push(tempnum+1);
            }
        }
        for (auto &vec : mp) {
            res.emplace_back(vec.second);
        }
        return res;
    }
};

17.433 · 岛屿的个数 - LintCode

class Solution {
public:
    /**
     * @param grid: a boolean 2D matrix
     * @return: an integer
     */
    int deltaX[4] = {-1, 0, 0, 1};
    int deltaY[4] = {0, 1, -1, 0};

    bool isvalid(vector<vector<bool>> &grid, int i, int j, vector<vector<bool>> &visited) {
        if (i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size() || visited[i][j]) return false;
        if (grid[i][j])
            return true;
        return false;
    }

    void bfs (vector<vector<bool>> &grid, int i, int j, vector<vector<bool>> &visited) {
        queue <pair<int, int>> que;
        que.push({i, j});
        visited[i][j] = true; 
        while (!que.empty()) {
            int nx = que.front().first;
            int ny = que.front().second;
            que.pop();
            for (int ii = 0; ii < 4; ii++){
                int x = nx + deltaX[ii];
                int y = ny + deltaY[ii];
                if (!isvalid (grid, x , y, visited))
                    continue;
                que.push({x, y});
                visited[x][y] = true; 
            }
        }
    }

    int numIslands(vector<vector<bool>> &grid) {
        if (grid.size() == 0 || grid[0].size() == 0) return 0;
        int rowsize = grid.size();
        int colsize = grid[0].size();
        vector<vector<bool>> visited(rowsize, vector<bool> (colsize, false));
        int res = 0;
        for (int i = 0; i < rowsize; i++) {
            for (int j = 0; j < colsize; j++) {
                if ( grid[i][j] && !visited[i][j]) {
                    res++;
                    bfs (grid, i, j, visited);
                }
            }
        }
        return res;
    }
};

18.墙和门 663 · 墙和门 - LintCode

class Solution {
public:
    /**
     * @param rooms: m x n 2D grid
     * @return: nothing
     */
    int delX[4] = {0, 0, 1, -1};
    int delY[4] = {1, -1, 0, 0};
    void wallsAndGates(vector<vector<int>> &rooms) {
        int row = rooms.size();
        int col = rooms[0].size();
        if (row == 0 || col == 0) return;
        queue<pair<int, int>> que;
        for (int i = 0; i < row; i++){
            for (int j = 0; j <col; j++) {
                if (rooms[i][j] == 0) {
                    que.push({i,j});
                }
            }
        }
        while (!que.empty()) {
            int nx = que.front().first;
            int ny = que.front().second;
            que.pop();
            for (int i = 0; i<4; i++){
                int x = nx + delX[i];
                int y = ny + delY[i];
                if (x < 0 || x >= row || y <0 || y >= col || rooms[x][y] <= 0) continue;
                if (rooms[x][y] > rooms[nx][ny]+1) {
                    que.push({x,y});
                    rooms[x][y] = rooms[nx][ny] + 1;
                }
            }
        }
    }
};

19.

class Solution {
public:
    /**
     * @param numCourses: a total of n courses
     * @param prerequisites: a list of prerequisite pairs
     * @return: true if can finish all courses or false
     */
    bool canFinish(int numCourses, vector<vector<int>> &prerequisites) {
        if (numCourses <= 0) return true;
        vector<vector<int>> mp(numCourses);
        int indegree[numCourses] = {0};
        queue<int> que;
        int coursetoken = 0;
        for (auto &temp : prerequisites){
            mp[temp[1]].push_back(temp[0]);
            indegree[temp[0]]++;
        }
        for (int i = 0; i< numCourses; i++){
            if (indegree[i] == 0) {
                que.push(i);
                coursetoken++;
            }
        }
        while (!que.empty()){
            int temp = que.front();
            que.pop();
            for (int i = 0; i < mp[temp].size(); i++){
                indegree[mp[temp][i]]--;
                if (indegree[mp[temp][i]] == 0){
                    que.push(mp[temp][i]);
                    coursetoken++;
                }
            }
        }
        return coursetoken == numCourses;
    }
};

20 616 · 课程表 II - LintCode

class Solution {
public:
    /**
     * @param numCourses: a total of n courses
     * @param prerequisites: a list of prerequisite pairs
     * @return: the course order
     */
    vector<int> findOrder(int numCourses, vector<vector<int>> &prerequisites) {
        vector<int> res;
        if (numCourses <= 0) return res;
        vector<vector<int>> mp(numCourses);
        int indegree[numCourses] = {0};
        queue<int> que;
        for (auto &temp : prerequisites){
            mp[temp[1]].push_back(temp[0]);
            indegree[temp[0]]++;
        }
        for (int i = 0; i< numCourses; i++){
            if (indegree[i] == 0) {
                que.push(i);
                res.push_back(i);
            }
        }
        while (!que.empty()){
            int temp = que.front();
            que.pop();
            for (int i = 0; i < mp[temp].size(); i++){
                indegree[mp[temp][i]]--;
                if (indegree[mp[temp][i]] == 0){
                    que.push(mp[temp][i]);
                    res.push_back(mp[temp][i]);
                }
            }
        }
        return res.size() == numCourses ? res : vector<int>();
    }
};

 21 最小子树 596 · 最小子树 - LintCode

class Solution {
public:
    /**
     * @param root: the root of binary tree
     * @return: the root of the minimum subtree
     */
    TreeNode* temp = nullptr;
    int minnum = INT_MAX;
    int findtree (TreeNode* root) {
        if (root == nullptr) return 0;
        int num = root->val + findtree(root->left) + findtree(root->right);
        if (num < minnum) {
            minnum = num;
            temp = root;
        } 
        return num;
    }
    TreeNode* findSubtree(TreeNode *root) {
        if(root == nullptr) return nullptr;
        findtree(root);
        return temp;

    }
};

22. 474 · 最近公共祖先 II - LintCode

class Solution {
public:
    /*
     * @param root: The root of the tree
     * @param A: node in the tree
     * @param B: node in the tree
     * @return: The lowest common ancestor of A and B
     */
    ParentTreeNode * lowestCommonAncestorII(ParentTreeNode * root, ParentTreeNode * A, ParentTreeNode * B) {
        if (root == nullptr) return nullptr;
        ParentTreeNode *temp = A;
        unordered_set<ParentTreeNode*> st;
        while(A != nullptr) {
            st.insert(A);
            A = A->parent;
        }
        temp = B;
        while (temp != nullptr) {
            if (st.find(temp) != st.end()) {
                return temp;
            }
            temp = temp->parent;
        }
        return nullptr;
    }
};

23.88 · 最近公共祖先 - LintCode

TreeNode * lowestCommonAncestor(TreeNode * root, TreeNode * A, TreeNode * B) {
        if (root == nullptr) return nullptr;
        if (root == A || root == B) return root;
        TreeNode *leftnode = lowestCommonAncestor(root->left, A, B);
        TreeNode *rightnode = lowestCommonAncestor(root->right, A, B);
        if (leftnode != nullptr && rightnode != nullptr) return root;
        if (leftnode != nullptr) return leftnode;
        if (rightnode != nullptr) return rightnode;
        return nullptr;
    }

24 614 · 二叉树的最长连续子序列 II - LintCode

class block {
public:
    block(int i, int j, int k) : decr(i), incr(j), max_length(k){}
    int decr;
    int incr;
    int max_length;
};

block get_maxlenth(TreeNode *root) {
    if (root == nullptr) return block(0,0,0);
    block val_left = get_maxlenth (root->left);
    block val_right = get_maxlenth (root->right);

    int root_decr = 0, root_incr = 0;
    if (root->left != nullptr && root->left->val + 1 == root->val) {
        root_decr = val_left.decr + 1;
    }
    if (root->left != nullptr && root->left->val-1 == root->val) {
        root_incr = val_left.incr +1;
    }
    if (root->right != nullptr && root->right->val +1 == root->val) {
        root_decr = max(val_right.decr +1, root_decr);
    }
    if (root->right != nullptr && root->right->val - 1 == root->val) {
        root_incr = max(val_right.incr + 1, root_incr);
    }
    int max_lenth = max(root_decr + root_incr +1, max(val_left.max_length, val_right.max_length));
    return block(root_decr, root_incr, max_lenth);
}



class Solution {
public:
    /**
     * @param root: the root of binary tree
     * @return: the length of the longest consecutive sequence path
     */
    int longestConsecutive2(TreeNode *root) {
        if (root == nullptr) return 0;
        block val = get_maxlenth(root);
        return val.max_length;
    }
};

 25 453 · 将二叉树拆成链表 - LintCode

class Solution {
public:
    /**
     * @param root: a TreeNode, the root of the binary tree
     * @return: nothing
     */
    TreeNode *getlastnode(TreeNode *root) {
        if (root == nullptr) return nullptr;
        TreeNode *leftnode = getlastnode(root->left);
        TreeNode *rightnode = getlastnode(root->right);

        if (leftnode != nullptr) {
            leftnode->right = root->right;
            root->right = root->left;
            root->left = nullptr;
        }
        if (rightnode != nullptr) {
            return rightnode;
        }
        else if (leftnode != nullptr)
            return leftnode;
        return root;
    }

    void flatten(TreeNode *root) {
        getlastnode(root);
    }
};

26 902 · BST中第K小的元素 - LintCode

class Solution {
public:
    /**
     * @param root: the given BST
     * @param k: the given k
     * @return: the kth smallest element in BST
     */
    void medisort(TreeNode *root, vector <int> &res) {
        if (root == nullptr) return;

        medisort(root->left, res);
        res.push_back(root->val);
        medisort(root->right,res);

    } 
    int kthSmallest(TreeNode *root, int k) {
        vector <int> res;
        medisort(root, res);
        return res[k-1];
    }
};

非递归

class Solution {
public:
    /**
     * @param root: the given BST
     * @param k: the given k
     * @return: the kth smallest element in BST
     */
    int kthSmallest(TreeNode *root, int k) {
        vector<TreeNode *> st;
        while (root != nullptr) {
            st.push_back(root);
            root = root->left;
        }
        for (int i = 0; i < k-1; i++) {
            TreeNode * temp = st.back();
            st.pop_back();
            if(temp->right != nullptr) {
                temp = temp->right;
                while (temp != nullptr) {
                    st.push_back(temp);
                    temp = temp->left;
                }
            }
        }
        return st.back()->val;
    }
};

 

27 900 · 二叉搜索树中最接近的值 - LintCode

class Solution {
public:
    /**
     * @param root: the given BST
     * @param target: the given target
     * @return: the value in the BST that is closest to the target
     */
    TreeNode *getlowernode(TreeNode *root, double target) {
        if (root == nullptr) return nullptr;
        if (root->val > target) {
            return getlowernode(root->left, target);
        }
        TreeNode *temp = getlowernode(root->right,target);
        if (temp == nullptr){
            return root;
        }
        return temp;
    }

    TreeNode *getuppernode(TreeNode *root, double target) {
        if (root == nullptr) return nullptr;
        if (root->val < target) {
            return getuppernode(root->right, target);
        }
        TreeNode *temp = getuppernode(root->left,target);
        if (temp == nullptr){
            return root;
        }
        return temp;
    }

    int closestValue(TreeNode *root, double target) {
        TreeNode *lownode = getlowernode(root, target);
        TreeNode *uppernode = getuppernode(root, target);
        if (lownode == nullptr) return uppernode->val;
        if (uppernode == nullptr) return lownode->val;
        return ((target-lownode->val) > (uppernode->val-target)) ? uppernode->val : lownode->val;
    }
};

非递归

class Solution {
public:
    /**
     * @param root: the given BST
     * @param target: the given target
     * @return: the value in the BST that is closest to the target
     */

    int closestValue(TreeNode *root, double target) {
        TreeNode *low = root;
        TreeNode *upper = root;
        while (root != nullptr) {
            if (root->val > target) {
                upper = root;
                root = root->left;
            }
            else if (root->val < target) {
                low = root;
                root = root->right;
            }
            else
                return root->val;
        }
        return (abs(upper->val-target) > abs(target-low->val)) ? low->val : upper->val;

    }
};

 28 90 · k数和（二） - LintCode

void dfs(vector<int> &a, int index, int k, int target, vector<int> &temp, vector<vector<int>> &res) {
        if (k == 0 && target == 0) {
            res.emplace_back(temp);
            return;
        }
        if (k == 0 || target < 0) {
            return;
        }
        for (int i = index; i < a.size(); i++) {
            temp.push_back(a[i]);
            dfs(a, i+1, k-1, target - a[i], temp, res);
            temp.pop_back();
        }
    }

    vector<vector<int>> kSumII(vector<int> &a, int k, int target) {
        vector<vector<int>> res;
        if (a.size() == 0 || k == 0 || target == 0) return res;
        vector<int> temp;

        dfs (a, 0, k, target, temp, res);
        return res;
    }

29 425 · 电话号码的字母组合 - LintCode

vector<string> keyboard = {
        "",
        "",
        "abc",
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz"
    };
    void dfs(string &digits, int index, string temp, vector<string> &res) {
        if (index == digits.length()) {
            res.emplace_back(temp);
            return;
        }
        int num = digits[index] - '0';
        for (int i = 0; i < keyboard[num].length(); i++) {
            dfs (digits, index+1, temp+keyboard[num][i], res);
        }
    }

    vector<string> letterCombinations(string &digits) {
        vector<string> res;
        if (digits.size() == 0) return res;
        dfs(digits, 0, "", res);
        return res;
    }

 30 46. 全排列 - 力扣（LeetCode）

class Solution {
public:
    void dfs(vector<int> &nums, vector<bool> &used, vector<int> &path, vector<vector<int>> &res) {
        if (nums.size() == path.size()){
            res.emplace_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i]) continue;
            path.push_back(nums[i]);
            used[i] = true;
            dfs(nums, used, path, res);
            used[i] = false;
            path.pop_back();
        }
    }

    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        if (nums.size() == 0) return res;
        vector<bool> used(nums.size(), false);
        vector<int> path;
        dfs (nums, used, path, res);
        return res;
    }
};

31 剑指 Offer 38. 字符串的排列 - 力扣（LeetCode）

class Solution {
public:

    void dfs(string s, string &path, vector<bool> &used, vector<string>& res) {
        if (path.length() == s.length()) {
            res.emplace_back(path);
            return;
        }
        for (int i = 0; i < s.length(); i++){
            if (used[i]) continue;
            if (i > 0 && s[i] == s[i-1] && !used[i-1]) continue;
            path += s[i];
            used[i] = true;
            dfs(s, path, used, res);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<string> permutation(string s) {
        vector<string> vec;
        if (s.length() == 0) return vec;
        string path;
        sort(s.begin(),s.end());
        vector<bool> used(s.length(), false);
        dfs(s, path, used, vec);
        return vec;
    }
};

32212. 单词搜索 II - 力扣（LeetCode） 超时了

class Solution {
public:
    int dx[4] = {0, -1, 1, 0};
    int dy[4] = {-1, 0, 0, 1};

    bool isvalid(vector<vector<char>> &board, int x, int y, vector<vector<bool>> &visited) {
        if (x < 0 || y < 0 || x >= board.size() || y >= board[0].size() || visited[x][y]) return false; 
        return true;
    }

    void dfs(vector<vector<char>>& board, int x, int y, vector<vector<bool>> &visited, string path, unordered_set<string> &partset, 
        unordered_set<string> &wordset, set<string> &temp) {
            if (partset.find(path) == partset.end()) return;
            if (wordset.find(path) != wordset.end()) {
                temp.insert(path);
            }
            for (int i = 0; i < 4; i++){
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (!isvalid(board, nx, ny, visited)) continue;
                visited[nx][ny] = true;
                dfs(board, nx, ny, visited, path+board[nx][ny], partset, wordset, temp);
                visited[nx][ny] = false;
            }
        }

    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
        vector<string> res;
        set<string> temp;
        if (board.size() == 0 || board[0].size() == 0) return res;
        unordered_set<string> partset;
        unordered_set<string> wordset;
        for (auto &v : words) {
            for (int i = 0; i < v.size(); i++) {
                partset.insert(v.substr(0, i+1));
            }
            wordset.insert(v);
        }
        vector<vector<bool>> visited (board.size(), vector<bool>(board[0].size(), false));
        for (int i = 0; i < board.size(); i++){
            for (int j = 0; j < board[i].size(); j++) {
                visited[i][j] = true;
                string path = "";
                dfs(board, i, j, visited, path+board[i][j], partset, wordset, temp);
                visited[i][j] = false;
            }
        }
        for (auto &v : temp){
            res.emplace_back(v);
        }
        return res;
    }
};

 33 685 · 数据流中第一个唯一的数字 - LintCode

class Solution {
public:
    /**
     * @param nums: a continuous stream of numbers
     * @param number: a number
     * @return: returns the first unique number
     */
    int firstUniqueNumber(vector<int> &nums, int number) {
        if (nums.size() == 0) return -1;
        unordered_map <int, bool> mp;
        for (auto & v : nums) {
            if (mp.find(v) != mp.end()) {
                mp[v] = false;
            }
            else {
                mp[v] = true;
            }
            if (v == number) break;
        }
        if (mp.find(number) == mp.end()) return -1;
        for (auto &v:nums) {
            if (mp[v]){
                return v;
            }
        }
        return -1;
    }
};

34.链表内指定区间反转_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        ListNode *dummnode = new ListNode(0);
        ListNode *pre = dummnode;
        pre->next = head;
        for (int i = 0; i < m - 1; i++) {
            pre = pre->next;
        }
        ListNode* node = pre->next, *nodenext;
        for (int i = 0; i < n-m; i++) {
            nodenext = node->next;
            node->next = nodenext->next;;
            nodenext->next = pre->next;
            pre->next = nodenext;
        }
        return dummnode->next;
    }
};

35.反转链表_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if (pHead == nullptr) return pHead;
        ListNode* cur = pHead, *q = nullptr, *t;
        while (cur) {
            t = cur->next;
            cur->next = q;
            q = cur;
            cur = t;
        }
        return q;
    }
};

36.链表中的节点每k个一组翻转_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* tail = head;
        for (int i = 0; i < k; i++) {
            if (!tail) return head;
            tail = tail->next;
        }
        ListNode* pre = NULL, *cur = head;
        while (cur != tail) {
            ListNode * temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        head->next = reverseKGroup(tail, k);
        return pre;
    }
};

37.合并k个已排序的链表_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        int num = lists.size();
        vector<int> vec;
        for (int i = 0; i < num; i++) {
            while (lists[i]) {
                vec.push_back(lists[i]->val);
                lists[i] = lists[i]->next;
            }
        }
        sort(vec.begin(),vec.end());
        ListNode *head = new ListNode(0);
        ListNode *node = head;
        for (auto &v : vec){
            node->next = new ListNode(v);
            node = node->next;
        }
        return head->next;
    }
};

38.判断链表中是否有环_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *fast = head, *slow = head;
        while(fast) {
            if (fast->next) {
                fast = fast->next->next;
                slow = slow->next;
            }
            else {
                return false;
            }
            if (fast == slow) return true;
        }
        return false;
    }
};

39.链表中环的入口结点_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        ListNode *fast = pHead, *slow = pHead;
        while(fast) {
            if (fast->next) {
                fast = fast->next->next;
                slow = slow->next;
            }
            else {
                return NULL;
            }
            if (fast == slow) break;
        }
        if (!fast) return NULL;
        fast = pHead;
        while (fast != slow) {
            fast = fast->next;
            slow = slow->next;
        }
        return fast;
    }
};

 40. 合并两个排序的链表_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        ListNode *Node = new ListNode(0);
        ListNode *node = Node;
        while(pHead1 && pHead2) {
            if (pHead1->val < pHead2->val) {
                node->next = pHead1;
                pHead1 = pHead1->next;
                node = node->next;
            }
            else {
                node->next = pHead2;
                pHead2 = pHead2->next;
                node = node->next;
            }
        }
        if (pHead1) {
            node->next = pHead1;
        }
        else{
            node->next = pHead2;
        }
        return Node->next;
    }
};

41. 链表中倒数最后k个结点_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        ListNode *fast = pHead;
        ListNode *slow = pHead;
        for (int i = 0; i < k; i++){
            if (!fast) return fast;
            fast = fast->next;
        }
        while(fast){
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

42.删除链表的倒数第n个节点_牛客题霸_牛客网 (nowcoder.com)

ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *node = new ListNode(0);
        node->next = head;
        ListNode *fast = node, *slow = node;

        for (int i = 0; i <= n; i++) {
            if (!fast) return node->next;
            fast = fast->next;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode *temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        return node->next;
    }

43. 两个链表的第一个公共结点_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        unordered_set<ListNode* > st;
        while(pHead1){
            st.insert(pHead1);
            pHead1 = pHead1->next;
        }
        while (pHead2) {
            if (st.find(pHead2) != st.end()) {
                return pHead2;
            }
            pHead2 = pHead2->next;
        }
        return pHead2;
    }
};

class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode *l1 = pHead1, *l2 = pHead2;
        while(l1 != l2) {
            l1 = (l1 == NULL) ? pHead2 : l1->next;
            l2 = (l2 == NULL) ? pHead1 : l2->next;
        }
        return l1;
    }
};

44.链表相加(二)_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* reverse(ListNode* head) {
        if (!head) return head;
        ListNode *pre = NULL, *cur = head;
        while (cur) {
            ListNode *temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        if (!head1) return head2;
        if (!head2) return head1;
        ListNode* l1 = reverse (head1);
        ListNode* l2 = reverse (head2);
        int temp = 0;
        ListNode* node = new ListNode(0);
        ListNode* head = node;
        while (l1 != NULL || l2 != NULL) {
            int val = temp;
            if (l1) {
                val += l1->val;
                l1 = l1->next;
            }
            if (l2) {
                val += l2->val;
                l2 = l2->next;
            }
            temp = val/10;
            head->next = new ListNode(val%10);
            head = head->next;
        }
        if (temp) head->next = new ListNode(temp);
        return reverse (node->next);
    }
};

45. 单链表的排序_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    ListNode* sortInList(ListNode* head) {
        if (!head) return head;
        vector<int> vec;
        while (head) {
            vec.push_back(head->val);
            head = head->next;
        }
        sort(vec.begin(), vec.end());
        ListNode *node = new ListNode(0);
        ListNode *p = node;
        for (auto& v : vec) {
            p->next = new ListNode(v);
            p = p->next;
        }
        return node->next;
    }
};

46. 判断一个链表是否为回文结构_牛客题霸_牛客网 (nowcoder.com)

 

class Solution {
public:
    /**
     *
     * @param head ListNode类 the head
     * @return bool布尔型
     */
     ListNode *reverse (ListNode* head) {
         if (!head) return head;
         ListNode* cur = head, *p = NULL;
         while (cur) {
             ListNode* temp = cur->next;
             cur->next = p;
             p = cur;
             cur = temp;
         }
         return p;
     }
    bool isPail(ListNode* head) {
       ListNode* fast = head, *slow = head;
       while (fast && fast->next) {
           fast = fast->next->next;
           slow = slow->next;
       }
       if (fast) {
           slow = slow->next;
       }
       fast = reverse(slow);
       slow = head;
       while (fast) {
           if (fast->val != slow->val) {
               return false;
           }
           fast = fast->next;
           slow = slow->next;
       }
       return true;
    }
    
};

47.链表的奇偶重排_牛客题霸_牛客网 (nowcoder.com)

ListNode* oddEvenList(ListNode* head) {
        if (!head) return head;
        ListNode *odd = head, *even = head->next;
        ListNode *head2 = even;
        while (even && even->next) {
            odd->next = even->next;
            odd = odd->next;
            even->next = odd->next;
            even = even->next;
        }
        odd->next = head2;
        return head;
    }

48.删除有序链表中重复的元素-I_牛客题霸_牛客网 (nowcoder.com)

 ListNode* deleteDuplicates(ListNode* head) {
        if (!head) return head;
        ListNode *cur = head;
        while (cur->next) {
            if (cur->val == cur->next->val) {
                ListNode *temp = cur->next;
                cur->next = temp->next;
                delete (temp);
            }
            else {
                cur = cur->next;
            }
        }
        return head;
    }

49.删除有序链表中重复的元素-II_牛客题霸_牛客网 (nowcoder.com)

ListNode* deleteDuplicates(ListNode* head) {
        if (!head) return head;
        ListNode *node = new ListNode(0);
        ListNode *cur = node;
        cur->next = head;
        while(cur->next && cur->next->next) {
            if (cur->next->val == cur->next->next->val) {
                int temp = cur->next->val;
                while(cur->next && cur->next->val == temp) {
                    cur->next = cur->next->next;
                }
            }
            else {
                cur = cur->next;
            }
        }
        return node->next;
    }

50.二维数组中的查找_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if (array.size() == 0) return false;
        if (array[0].size() == 0) return false;
        int row = array.size(), col = array[0].size();
        for (int i = row - 1, j = 0; i >= 0 && j < col;){
            if (array[i][j] < target) {
                j++;
            }
            else if(array[i][j] > target) {
                i--;
            }
            else {
                return true;
            }
        }
        return false;
    }
};

 51.寻找峰值_牛客题霸_牛客网 (nowcoder.com)

int findPeakElement(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        int start = 0, end = nums.size()-1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] < nums[mid + 1]) {
                start = mid + 1;
            }
            else {
                end = mid;
            }
        }
        if (nums[start] < nums[end]) return end;
        return start;
    }

52.数组中的逆序对_牛客题霸_牛客网 (nowcoder.com)

class Solution {
private:
    const int kmod = 1000000007;
public:
    void merge (vector<int>& data, int start, int end, vector<int>& temp, int& ret) {
        int left = start;
        int mid = start + (end - start) / 2;
        int right = mid + 1, index = left;
        while (left <= mid && right <= end) {
            while (right <= end && data[left] > data[right]) {
                temp[index++] = data[right++];
                ret += mid - left + 1;
                ret %= kmod;
            }
            while (left <= mid && data[left] <= data[right]) {
                temp[index++] = data[left++];
            }
        }
        while (left <= mid) {
            temp[index++] = data[left++];
        }
        while (right <= end) {
            temp[index++] = data[right++];
        }
        for (int i = start; i<=end; i++) {
            data[i] = temp[i];
        }
    }
    void mergesort(vector<int>& data, int start, int end, vector<int>& temp, int& ret) {
        if (start >= end) return;
        mergesort(data, start, start + (end-start)/2, temp, ret);
        mergesort(data, start + (end-start)/2 +1, end, temp, ret);
        merge (data, start, end, temp, ret);
    }
    int InversePairs(vector<int> data) {
        int ret = 0;
        vector<int> temp (data.size());
        mergesort(data, 0, data.size()-1, temp, ret);
        return ret;
    }
};

53.旋转数组的最小数字_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if (rotateArray.size() == 0) return 0;
        int start = 0, end = rotateArray.size()-1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (rotateArray[mid] < rotateArray[end]) {
                end = mid;
            }
            else if (rotateArray[mid] > rotateArray[end]){
                start = mid;
            }
            else {
                end--;
            }
        }
        if (rotateArray[start] > rotateArray[end]) return rotateArray[end];
        return rotateArray[start];
    }
};

54.比较版本号_牛客题霸_牛客网 (nowcoder.com)

int compare(string version1, string version2) {
        int len1 = version1.length();
        int len2 = version2.length();
        int p1=0, p2=0;
        while (p1 < len1 || p2 < len2) {
            long num1 = 0;
            while (p1 < len1 && version1[p1] != '.') {
                num1 = num1 * 10 + (version1[p1++] - '0');
            }
            p1++;
            long num2 = 0;
            while (p2 < len2 && version2[p2] != '.') {
                num2 = num2 * 10 + (version2[p2++] - '0');
            }
            p2++;
            if (num1 > num2) return 1;
            if (num2 > num1) return -1;
        }
        return 0;
    }

 55.二叉树的前序遍历_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    void getpreorder(TreeNode *node, vector<int> &res) {
        if (!node) return;
        res.push_back(node->val);
        getpreorder(node->left,res);
        getpreorder(node->right,res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        getpreorder(root, res);
        return res;

    }
};

56.二叉树的中序遍历_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        getinorder(root, res);
        return res;
    }
    void getinorder(TreeNode* node, vector<int> &res) {
        if (!node) return;
        getinorder(node->left, res);
        res.push_back(node->val);
        getinorder(node->right,res);
    }
};

57.二叉树的后序遍历_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        getpostorder(root, res);
        return res;
    }
    void getpostorder(TreeNode* node, vector<int> &res) {
        if (!node) return;
        getpostorder(node->left,res);
        getpostorder(node->right,res);
        res.push_back(node->val);
    }
};

58.按之字形顺序打印二叉树_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > res;
        if (!pRoot) return res;
        deque<TreeNode*> que;
        que.push_back(pRoot);
        bool right = false;
        while(!que.empty()) {
            int len = que.size();
            vector<int> vec;
            for (int i = 0; i < len; i++) {
                TreeNode* temp;
                if (right) {
                    temp = que.back();
                    que.pop_back();
                    if (temp->right) que.push_front(temp->right);
                    if (temp->left)  que.push_front(temp->left);
                }
                else{
                    temp = que.front();
                    que.pop_front();
                    if (temp->left)  que.push_back(temp->left);
                    if (temp->right) que.push_back(temp->right);
                }
                vec.push_back(temp->val);
            }
            right = !right;
            res.push_back(vec);
        }
        return res;
    }
    
};

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        if (!pRoot) return res;
        queue<TreeNode*> que;
        que.push(pRoot);
        bool right = true;
        while(!que.empty()) {
            vector<int> vec;
            int len = que.size();
            for (int i = 0; i<len; i++) {
                TreeNode* temp = que.front();
                que.pop();
                if (temp->left) que.push(temp->left);
                if (temp->right) que.push(temp->right);
                if (right) {
                    vec.push_back(temp->val);
                }
                else {
                    vec.insert(vec.begin(), temp->val);
                }
            }
            right = !right;
            res.push_back(vec);
        }
        return res;
    }
    
};

59.二叉树的最大深度_牛客题霸_牛客网 (nowcoder.com)

int maxDepth(TreeNode* root) {
        if (!root) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }

60.二叉树中和为某一值的路径(一)_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return bool布尔型
     */
    bool hasPathSum(TreeNode* root, int sum) {
        if (!root) return false;
        return hasPath(root, sum, 0);
    }
    bool hasPath(TreeNode* root, int& sum, int res) {
        if (!root) return sum == res;
        if (root->left && root->right)  
            return hasPath(root->left, sum, res + root->val) || hasPath(root->right, sum, res + root->val);
        else if (root->left)
            return hasPath(root->left, sum, res + root->val);
        return hasPath(root->right, sum, res + root->val);;
    }
};

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return bool布尔型
     */
    bool hasPathSum(TreeNode* root, int sum) {
        if (!root) return false;
        return hasPath(root, sum);
    }
    bool hasPath(TreeNode* root, int sum) {
        if (!root) return false;
        sum -= root->val;
        if (!root->left && !root->right && sum == 0){
            return true;
        }
        return hasPath(root->left, sum) || hasPath(root->right, sum);
    }
};

 61.二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    TreeNode* pre = NULL;
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if (!pRootOfTree) return NULL;
        TreeNode* p = pRootOfTree;
        while (p->left) p = p->left;
        inorder(pRootOfTree);
        return p;
    }
    void inorder(TreeNode* root) {
        if (!root) return;
        inorder (root->left);
        root->left = pre;
        if (pre) {
            pre->right = root;
        }
        pre = root;
        inorder (root->right);
    }
};

 62.对称的二叉树_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot) {
        return recursion(pRoot, pRoot);
    }
    bool recursion(TreeNode* root1, TreeNode* root2) {
        if (!root1 && !root2) return true;
        if (root1 == NULL || root2 == NULL || root1->val != root2->val) {
            return false;
        }
        return recursion(root1->left, root2->right) && recursion(root1->right, root2->left);
    }

};

63.合并二叉树_牛客题霸_牛客网 (nowcoder.com)

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (!t1 || !t2) return !t1 ? t2 : t1;
        TreeNode* p = new TreeNode(t1->val + t2->val);
        p->left = mergeTrees(t1->left, t2->left);
        p->right = mergeTrees(t1->right, t2->right);
        return p;
    }

64.二叉树的镜像_牛客题霸_牛客网 (nowcoder.com)

    TreeNode* Mirror(TreeNode* pRoot) {
        if (!pRoot) return NULL;
        TreeNode* p = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = p;
        Mirror(pRoot->left);
        Mirror(pRoot->right);
        return pRoot;
    }

65.判断是不是二叉搜索树_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    long pre = INT_MIN;
    bool isValidBST(TreeNode* root) {
        if (!root) return true;
        if (!isValidBST(root->left)) {
            return false;
        }
        if (pre < root->val) {
            pre = root->val;
        }
        else return false;
        return isValidBST(root->right);
    }
};

 66.判断是不是完全二叉树_牛客题霸_牛客网 (nowcoder.com)

class Solution {
  public:
    bool isCompleteTree(TreeNode* root) {
        //空树一定是完全二叉树
        if(root == NULL) 
            return true;
        queue<TreeNode*> q;
        //根节点先访问
        q.push(root); 
        //定义一个首次出现的标记位
        bool flag = false; 
        //层次遍历
        while(!q.empty()){ 
            int sz = q.size();
            for (int i = 0; i < sz; i++) {
                TreeNode* cur = q.front();
                q.pop();
                //标记第一次遇到空节点
                if (cur == NULL) 
                    flag = true; 
                else{
                    //后续访问已经遇到空节点了，说明经过了叶子
                    if (flag) return false;
                    q.push(cur->left);
                    q.push(cur->right);
                }
            }
        }
        return true;
    }
};

 67.判断是不是平衡二叉树_牛客题霸_牛客网 (nowcoder.com)

 

class Solution {
public:

    bool IsBalanced_Solution(TreeNode* pRoot) {
        if (!pRoot) return true;
        pair<bool, int> p = isBalance(pRoot);
        return p.first;
    }
    pair<bool, int> isBalance (TreeNode* root) {
        if (!root) return pair<bool, int> (true, 0);
        pair<bool, int> p1 = isBalance(root->left);
        pair<bool, int> p2 = isBalance(root->right);
        if (!p1.first || !p2.first || abs(p1.second - p2.second) > 1) {
            return pair<bool, int>(false, max(p1.second, p2.second) + 1);
        }
        return pair<bool, int>(true, max(p1.second, p2.second) + 1);
    }
};

68.二叉搜索树的最近公共祖先_牛客题霸_牛客网 (nowcoder.com)

int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
        if (!root) return -1;
        if (root->val == o1 || root->val == o2) return root->val;
        int temp1 = lowestCommonAncestor(root->left, o1, o2);
        int temp2 = lowestCommonAncestor(root->right, o1, o2);
        if (temp1 != -1 && temp2 != -1) {
            return root->val;
        }
        if (temp1 != -1) return temp1;
        return temp2;
    }

 

69重建二叉树_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if (pre.size() == 0) return NULL;
        TreeNode* root = new TreeNode(pre[0]);
        int index = find(vin.begin(), vin.end(), pre[0]) - vin.begin();
        root->left = reConstructBinaryTree(vector<int> (pre.begin()+1, pre.begin()+index+1), vector<int> (vin.begin(), vin.begin()+index));
        root->right = reConstructBinaryTree(vector<int> (pre.begin()+index+1, pre.end()), vector<int> (vin.begin()+index+1, vin.end()));
        return root;
    }
};

 

70.输出二叉树的右视图_牛客题霸_牛客网 (nowcoder.com)

vector<int> solve(vector<int>& xianxu, vector<int>& zhongxu) {
        vector<int> vec;
        if (xianxu.size() == 0) return vec;
        TreeNode* root = getTree(xianxu, zhongxu);
        queue<TreeNode* > que;
        que.push(root);
        while(!que.empty()){
            int len = que.size();
            int num;
            for (int i = 0; i < len; i++){
                TreeNode* temp = que.front();
                que.pop();
                if (temp->left) que.push(temp->left);
                if (temp->right) que.push(temp->right);
                num = temp->val;
            }
            vec.push_back(num);
        }
        return vec;
    }
    TreeNode* getTree(vector<int> xianxu, vector<int> zhongxu) {
        if (xianxu.size() == 0) return NULL;
        TreeNode* root = new TreeNode(xianxu[0]);
        int index = find(zhongxu.begin(), zhongxu.end(), xianxu[0]) - zhongxu.begin();
        root->left = getTree(vector<int> (xianxu.begin() + 1, xianxu.begin()+index+1), vector<int> (zhongxu.begin(), zhongxu.begin()+index));
        root->right = getTree(vector<int> (xianxu.begin() + index + 1, xianxu.end()), vector<int> (zhongxu.begin() + index + 1, zhongxu.end()));
        return root;
    }

//建树时可以采用原始的vector，加上两个索引参数getTree(vector<int>& xianxu, int l1, int r1, vector<int>& zhongxu, int l2, int r2)

 71.用两个栈实现队列_牛客题霸_牛客网 (nowcoder.com)

class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        if (stack2.empty() && !stack1.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
        int temp = stack2.top();
        stack2.pop();
        return temp;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

72.包含min函数的栈_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    void push(int value) {
        if (vec.size() == 0 || value < min_num.back()) {
            vec.push_back(value);
            min_num.push_back(value);
        }
        else {
            vec.push_back(value);
            min_num.push_back(min_num.back());
        }
    }
    void pop() {
        if (vec.size()) {
            vec.pop_back();
            min_num.pop_back();
        }
    }
    int top() {
        return vec.back();
    }
    int min() {
        return min_num.back();
    }
private:
    vector<int> min_num;
    vector<int> vec;
};

73.有效括号序列_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param s string字符串 
     * @return bool布尔型
     */
    bool isValid(string s) {
        stack<char> st;
        int len = s.length();
        for (int i = 0; i<len; i++){
            if (s[i] == '(' || s[i] == '{' || s[i] == '[') {
                st.push(s[i]);
            }
            else if (s[i] == ')') {
                if (st.empty() || st.top() != '(') {
                    return false;
                }
                else {
                    st.pop();
                }
            }
            else if (s[i] == ']') {
                if (st.empty() || st.top() != '[') {
                    return false;
                }
                else {
                    st.pop();
                }
            }
            else if (s[i] == '}') {
                if (st.empty() || st.top() != '{') {
                    return false;
                }
                else {
                    st.pop();
                }
            }
        }
        if (st.empty()) return true;
        return false;
    }
};

74.滑动窗口的最大值_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
        vector<int> res;
        int len = num.size();
        if (len == 0 || size == 0 || size > len) return res;
        priority_queue<pair<int, int>> que;
        for (int i = 0; i< size; i++){
            que.push({num[i], i});
        }
        res.push_back(que.top().first);
        for (int i = size; i<len; i++){
            que.push({num[i], i});
            while(que.top().second <= i-size) {
                que.pop();
            }
            res.push_back(que.top().first);
        }
        return res;
    }
};

75.最小的K个数_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> res;
        int len = input.size();
        if (len ==0 || k == 0 ||len < k) return res;
        priority_queue<int> que;
        for (int i = 0; i < len; i++){
            if(que.size() < k) {
                que.push(input[i]);
            }
            else {
                if (que.top() > input[i]){
                    que.pop();
                    que.push(input[i]);
                }
            }
        }
        while (!que.empty()){
            res.push_back(que.top());
            que.pop();
        }
        return res;
    }
};

76.寻找第K大_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    int findKth(vector<int> a, int n, int K) {
        priority_queue<int, vector<int>, greater<>> que;
        for (int i = 0; i<n; i++){
            if (que.size() < K) {
                que.push(a[i]);
            }
            else if (que.top() < a[i]){
                que.pop();
                que.push(a[i]);
            }
        }
        return que.top();
    }
};

77.数据流中的中位数_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
#define SCD static_cast<double>
    void Insert(int num) {
        if (vec.empty()) {
            vec.push_back(num);
        }
        else {
            int index = 0;
            for (; index < vec.size(); index++) {
                if (num <= vec[index])
                 break;
            }
            vec.insert(vec.begin()+index, num);
        }

    }

    double GetMedian() { 
        int len = vec.size();
        if (len & 1) {
            return SCD(vec[len >> 1]);
        }
        else {
            return SCD((vec[(len-1) >> 1]+vec[len >> 1])/2.0);
        }
    }
private:
    vector<int> vec;
};

78.表达式求值_牛客题霸_牛客网 (nowcoder.com)

vector<int> function(string& s, int index) {
        stack<int> st;
        char op = '+';
        int num = 0;
        int n = s.length();
        int i;
        for (i = index; i<n; i++){
            if (isdigit(s[i])) {
                num = num*10 + s[i] - '0';
                if (i != n-1) continue;
            }

            if (s[i] == '(') {
                vector<int> temp = function(s, i+1);
                num = temp[0];
                i = temp[1];
                if (i != n-1) continue;
            }
            if (op == '+'){
                st.push(num);
            }
            else if(op == '-'){
                st.push(-num);
            }
            else if (op == '*') {
                int t = st.top();
                st.pop();
                st.push(num*t);
            }
            num = 0;
            if (s[i] == ')') {
                break;
            }else {
                op = s[i];
            }
        }
        int sum = 0;
        while (!st.empty()) {
            sum += st.top();
            st.pop();
        } 
        return vector<int> {sum, i};
    }
    int solve(string s) {
        return function(s, 0)[0];
    }

79.两数之和_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param numbers int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> res;
        if (numbers.size() == 0) return res;
        unordered_map<int, int> mp;
        int len = numbers.size();
        for (int i = 0; i < len; i++){
            if (mp.find(target-numbers[i]) != mp.end()) {
                res.push_back(mp[target-numbers[i]] + 1);
                res.push_back(i+1);
                break;
            }
            else {
                mp[numbers[i]] = i;
            }
        }
        return res;
    }
};

80.数组中出现次数超过一半的数字_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int cont;
        int cnt = 0;
        int len = numbers.size();
        for (int i = 0; i < len; i++){
            if (cnt == 0) {
                cont = numbers[i];
                cnt++;
            }
            else {
                if (cont == numbers[i]) cnt++;
                else cnt--;
            }
        }
        cnt = 0;
        for (auto& v:numbers) {
            if (v == cont) cnt++;
        }
        if (cnt > len/2) return cont;
        return 0;
    }
};

81.数组中只出现一次的两个数字_牛客题霸_牛客网 (nowcoder.com)

vector<int> FindNumsAppearOnce(vector<int>& array) {
        vector<int> res;
        if (array.size() == 0) return res;
        map<int, int> mp;
        int len = array.size();
        for (int i = 0; i< len; i++){
            mp[array[i]]++;
        }
        for (auto &v : mp) {
            if (v.second == 1) {
                res.push_back(v.first);
            }
        }
        return res;
    }

82.缺失的第一个正整数_牛客题霸_牛客网 (nowcoder.com)

int minNumberDisappeared(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int temp = 1;
        for (auto &v: nums){
            if (v <= 0) continue;
            if (v == temp) {
                temp++;
                continue;
            }
            else {
                return temp;
            }
        }
        return temp;
    }

83.三数之和_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        vector<vector<int> > res;
        int n = num.size();
        sort(num.begin(), num.end());
        for (int i = 0; i < n; i++) {
            if (i != 0 && num[i] == num[i-1]){
                continue;
            }
            twoSum(num, i+1, n - 1, res, -num[i]);
        }
        return res;
    }
    void twoSum(vector<int> &num, int start, int end, vector<vector<int>>& res, int target) {
        int left = start;
        int right = end;
        while(left < right) {
            if (num[left] + num[right] == target){
                res.push_back(vector<int>{-target, num[left], num[right]});
                left++;
                while(left < right && num[left] == num[left-1]){
                    left++;
                }
            }
            else if(num[left] + num[right] > target){
                right--;
            }
            else {
                left++;
            }
        }
    }
};

84.没有重复项数字的全排列_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:

    vector<vector<int> > permute(vector<int> &num) {
       vector<vector<int> > res;
       int n = num.size();
       vector<int> path;
       vector<bool> used(n, false);
       dfs(num, path, used, res);
       return res;
    }
    void dfs(vector<int> &num, vector<int>& path, vector<bool>& used, vector<vector<int> >& res) {
        if (path.size() == num.size()) {
            res.emplace_back(path);
            return;
        }
        int n = num.size();
        for (int i =0; i< n; i++){
            if (used[i]) continue;
            path.push_back(num[i]);
            used[i] = true;
            dfs(num, path, used, res);
            used[i] = false;
            path.pop_back();
        }
    }
    
};

85.有重复项数字的全排列_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<vector<int> > res;
        if (num.size() == 0) return res;
        int n = num.size();
       vector<int> path;
       vector<bool> used(n, false);
       sort(num.begin(), num.end());
       dfs(num, path, used, res);
       return res;
    }

    void dfs(vector<int> &num, vector<int>& path, vector<bool>& used, vector<vector<int> >& res) {
        if (path.size() == num.size()) {
            res.emplace_back(path);
            return;
        }
        int n = num.size();
        for (int i =0; i< n; i++){
            if (used[i]) continue;
            if (i > 0 && num[i-1] == num[i] && !used[i-1]) continue;
            path.push_back(num[i]);
            used[i] = true;
            dfs(num, path, used, res);
            used[i] = false;
            path.pop_back();
        }
    }
};

86.岛屿数量_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 判断岛屿数量
     * @param grid char字符型vector<vector<>> 
     * @return int整型
     */
    int delX[4] = {-1, 0, 0, 1};
    int delY[4] = {0, -1, 1, 0};
    int solve(vector<vector<char> >& grid) {
        if (grid.size() == 0) return 0;
        int row = grid.size();
        int col = grid[0].size();
        vector<vector<bool> > used(row, vector<bool> (col, false));
        int res = 0;
        for (int i = 0; i < row; i++) {
            for (int j=0; j<col; j++) {
                if (grid[i][j] == '1' && !used[i][j]) {
                    res++;
                    bfs(grid, used, i, j);
                }
            }
        }
        return res;
    }
    void bfs(vector<vector<char> >& grid, vector<vector<bool> >& used, int x, int y) {
        queue<pair<int, int>> que;
        que.push({x,y});
        used[x][y] = true;
        while(!que.empty()) {
            pair<int, int> temp = que.front();
            que.pop();
            for (int i =0; i< 4; i++){
                int nx = temp.first + delX[i];
                int ny = temp.second + delY[i];
                if (isvalid(grid, used, nx, ny)) {
                    used[nx][ny] = true;
                    que.push({nx,ny});
                }
            }
        }
    }
    bool isvalid(vector<vector<char> >& grid, vector<vector<bool> >& used, int x, int y) {
        if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || used[x][y]){
            return false;
        }
        if (grid[x][y] == '1'){
            return true;
        }
        return false;
    }

};

 87.字符串的排列_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    vector<string> Permutation(string str) {
        vector<string> res;
        if (str.length() == 0) return res;
        int len = str.length();
        sort(str.begin(), str.end());
    
        vector<bool> used(len, false);
        string temp;
        dfs(str, temp, used, res);
        return res;
    }
    void dfs(string& str, string& temp, vector<bool>& used, vector<string>& res) {
        if (str.length() == temp.length()) {
            res.emplace_back(temp);
            return;
        }
        int len = str.length();
        for (int i = 0; i<len; i++) {
            if (i != 0 && str[i] == str[i-1] && !used[i-1] || used[i]) continue;
            temp.push_back(str[i]);
            used[i] = true;
            dfs(str, temp, used, res);
            used[i] = false;
            temp.pop_back();
        }
    }
};

88.括号生成_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param n int整型 
     * @return string字符串vector
     */
    vector<string> generateParenthesis(int n) {
        vector <string> res;
        string str;
        dfs(res, str, 0, 0, n);
        return res;
    }
    void dfs(vector<string>& res, string str, int left, int right, int n) {
        if (left == n && right == n) {
            res.emplace_back(str);
            return;
        }
        if (left < n) {
            dfs(res, str+'(', left+1, right, n);
        }
        if (right < n && left > right) {
            dfs(res, str+')', left, right+1, n);
        }
    }
   
};

89.N皇后问题_牛客题霸_牛客网 (nowcoder.com)

class Solution {
public:
    /**
     * 
     * @param n int整型 the n
     * @return int整型
     */
    int Nqueen(int n) {
        vector<int> cols;
        int res = 0;
        dfs(n, cols, res);
        return res;
    }
    void dfs(int n, vector<int>& cols, int& res) {
        if (cols.size() == n) {
            res++;
            return;
        }
        int row = cols.size();
        for (int i = 0; i<n; i++){
            if (!isvalid (cols, row, i)){
                continue;
            }
            cols.push_back(i);
            dfs(n, cols, res);
            cols.pop_back();
        }
    }
    bool isvalid(vector<int>& cols, int row, int index) {
        for(int i = 0; i < row; i++){
            if (cols[i] == index) return false;
            if ((cols[i] - i == index - row) || (cols[i] + i == index + row)) return false;
        }
        return true;
    }
};

90.数据流中第一个独特的数 II960 · 数据流中第一个独特的数 II - LintCode

class DataStream {
public:
    DataStream(){
        head = new ListNode(0);
        tail = head;
    }
    
    ~ DataStream(){
        while(head) {
            ListNode * temp = head;
            head = head->next;
            delete(temp);
        }
    }
    /**
     * @param num: next number in stream
     * @return: nothing
     */
    void add(int num) {
        if (doubleset.find(num) != doubleset.end()) {
            return;
        }
        if (mp.find(num) != mp.end()) {
            remove(num);
            doubleset.insert(num);
            return;
        }
        tail->next = new ListNode(num);
        mp[num] = tail;
        tail = tail->next;

    }

    /**
     * @return: the first unique number in stream
     */
    int firstUnique() {
        return head->next->val;
    }
    void remove (int num) {
        ListNode* temp = mp[num];
        ListNode* s = temp->next;
        temp->next = s->next;
        delete(s);
        mp.erase(mp.find(num));
        if (temp->next) {
            mp[temp->next->val] = temp;
        }
        else {
            tail = temp;
        }
    }
private:
    unordered_map<int, ListNode*> mp;
    unordered_set<int> doubleset;
    ListNode* head;
    ListNode* tail;
};

 91.146. LRU 缓存 - 力扣（LeetCode）

class Listnode {
public:
    int key;
    int val;
    Listnode* next;
    Listnode(int k, int v) : key(k), val(v), next(NULL){}
};
class LRUCache {
public:
    LRUCache(int capacity) {
        _capacity = capacity;
        dummy = new Listnode(0,0);
        tail = dummy;
    }
    ~LRUCache(){
        while(dummy) {
            Listnode* temp = dummy;
            dummy = dummy->next;
            delete temp;
        }
    }
    
    int get(int key) {
        if (mp.find(key) == mp.end()) {
            return -1;
        }
        kick(key);
        return tail->val;
    }
    
    void put(int key, int value) {
        if (mp.find(key) == mp.end()) {
            tail->next = new Listnode(key, value);
            mp[key] = tail;
            tail = tail->next;
        }
        else {
            kick(key);
            tail->val = value;
            return;
        }
        if (mp.size() > _capacity) {
            remove();
        }
    }
    void kick(int key) {
        Listnode* pre = mp[key];
        Listnode* temp = pre->next;
        if (temp == tail) {
            return;
        }
        pre->next = temp->next;
        mp[temp->next->key] = pre;
        tail->next = temp;
        mp[temp->key] = tail;
        tail = temp;
        temp->next = NULL;
    }
    void remove () {
        Listnode* temp = dummy->next;
        mp.erase(temp->key);
        dummy->next = temp->next;
        mp[temp->next->key] = dummy;
        delete temp;
    }
private:
    int _capacity;
    Listnode* dummy;
    Listnode* tail;
    unordered_map<int, Listnode*> mp;
};

92.剑指 Offer 49. 丑数 - 力扣（LeetCode）

class Solution {
public:
    int nthUglyNumber(int n) {
        unordered_set<long> st;
        priority_queue<long, vector<long>, greater<long>> que;
        st.insert(1);
        que.push(1);
        int factor[] = {2,3,5};
        long temp;
        for (int i = 0; i < n; i++) {
            temp = que.top();
            que.pop();
            for (int j = 0; j < 3; j++){
                long t = temp * factor[j];
                if (st.find(t) == st.end() ) {
                    st.insert(t);
                    que.push(t);
                }
            }
        }
        return temp;
    }
};

 93.120. 三角形最小路径和 - 力扣（LeetCode）

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        if (triangle.size() == 0 || triangle[0].size() == 0) return 0;
        int n = triangle.size();
        vector<vector<int> > dp(2, vector<int> (n, 0));
        dp[0][0] = triangle[0][0];
        for (int i = 1; i < n; i++) {
            dp[i%2][0] = dp[(i-1)%2][0] + triangle[i][0];
            dp[i%2][i] = dp[(i-1)%2][i-1] + triangle[i][i];
            for (int j = 1; j < i; j++){
                dp[i%2][j] = min(dp[(i-1)%2][j-1], dp[(i-1)%2][j]) + triangle[i][j];
            }
        }
        int num = INT_MAX;
        for (int i = 0; i < n; i++){
            num = min(num, dp[(n-1)%2][i]);
        }
        return num;
    }
};

94.300. 最长递增子序列 - 力扣（LeetCode）

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

95. 给定一个整数矩阵，找出矩阵中的最长连续上升子序列，返回它的长度。最长连续上升子序列可以从任意位置开始，向上下左右移动

 

 

class listnode {
public:
    int x;
    int y;
    int val;
    listnode(int a, int b, int num) : x(a), y(b), val(num){}
    bool operator < (const listnode& li) {
        return this->val < li.val;
    }
};
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 给定数组的最长严格上升子序列的长度。
     * @param arr int整型vector 给定的数组
     * @return int整型
     */
    int LIS(vector<vector<int>>& arr) {
        if (arr.size() == 0 || arr[0].size() == 0) return 0;
        int n = arr.size();
        int m = arr[0].size();
        vector<listnode> vec;
        for (int i = 0; i<n; i++) {
            for (int j = 0; j<m; j++) {
                vec.emplace_back(i, j, arr[i][j]);
            }
        }
        sort(vec.begin(),vec.end());
        vector<vector<int>> dp(n, vector<int> (m, 0));
        int Dx[4] = {0,0,-1,1};
        int Dy[4] = {-1,1,0,0};
        for (int i =0; i<vec.size(); i++) {
            int x = vec[i].x;
            int y = vec[i].y;
            dp[x][y] = 1;
            for (int j = 0; j < 4; j++){
                int dx = x + Dx[j];
                int dy = y + Dy[j];
                if (dx < 0 || dy < 0 || dx >= n || dy >= m) continue;
                if (arr[dx][dy] < arr[x][y]) {
                    dp[x][y] = max(dp[x][y], dp[dx][dy]+1);
                }
            }
        }
        int longnum = dp[0][0];
        for (int i = 0; i<n; i++){
            longnum = max(longnum, *max_element(dp[i].begin(), dp[i].end()));
        }
        return longnum;
    }
};

96.