diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/100_\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/100_\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..866185798b25413bb71cfa61931a3d0ef9a2299f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/100_\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/100_\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/solution.cpp" @@ -0,0 +1,46 @@ +#include +#include + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + bool isSymmetric(TreeNode *root) + { + if (root == NULL) + return true; + TreeNode *lt = root->left, *rt = root->right; + for (std::stack stack; !stack.empty() || (lt && rt);) + { + if (lt && rt) + { + if (lt->val != rt->val) + return false; + stack.push(lt->right); + stack.push(rt->left); + lt = lt->left; + rt = rt->right; + } + else if (lt || rt) + return false; + else + { + lt = stack.top(); + stack.pop(); + rt = stack.top(); + stack.pop(); + } + } + if (lt || rt) + return false; + else + return true; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/101_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/101_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..35ef92eada7dc73568d2a76991fe4bff4ac2430a 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/101_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/101_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" @@ -0,0 +1,43 @@ +#include +#include +#include + +using std::deque; +using std::vector; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + vector> levelOrder(TreeNode *root) + { + vector> retv; + if (root) + { + deque q{root}; + while (!q.empty()) + { + vector v; + for (decltype(q.size()) i = 0, n = q.size(); i != n; ++i) + { + TreeNode *node = q.front(); + q.pop_front(); + v.push_back(node->val); + if (node->left) + q.push_back(node->left); + if (node->right) + q.push_back(node->right); + } + retv.push_back(v); + } + } + return retv; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/102_\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/102_\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a7acb40f8a9109f0f189815d1c4a7f4c6060a19f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/102_\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/102_\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\345\272\217\351\201\215\345\216\206/solution.cpp" @@ -0,0 +1,54 @@ +#include +#include +#include + +using std::vector; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + vector> zigzagLevelOrder(TreeNode *root) + { + vector> retv; + if (!root) + return retv; + std::queue q; + q.push(root); + bool reverse = false; + vector v; + for (int cur_level_sz = 1, next_level_sz = 0; !q.empty();) + { + TreeNode *node = q.front(); + q.pop(); + v.push_back(node->val); + --cur_level_sz; + if (node->left) + { + q.push(node->left); + ++next_level_sz; + } + if (node->right) + { + q.push(node->right); + ++next_level_sz; + } + if (!cur_level_sz) + { + retv.push_back(reverse ? vector(v.crbegin(), v.crend()) : v); + v.clear(); + cur_level_sz = next_level_sz; + next_level_sz = 0; + reverse = !reverse; + } + } + return retv; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/103_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/103_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..5e71896365d7a7614ea946e2dd36882848fe32c0 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/103_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/103_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/solution.cpp" @@ -0,0 +1,27 @@ +/** + * Definition for binary tree + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode(int x) : val(x), left(NULL), right(NULL) {} + * }; + */ +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + int maxDepth(TreeNode *root) + { + if (root == NULL) + return 0; + return std::max(maxDepth(root->left), maxDepth(root->right)) + 1; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/104_\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/104_\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..639c448d76963e3ed19e6f015865261f2336347f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/104_\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/104_\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" @@ -0,0 +1,35 @@ +#include +#include +#include + +using std::next; +using std::prev; +using std::vector; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + using cIter = vector::const_iterator; + TreeNode *buildTree(vector &preorder, vector &inorder) + { + return buildTree(preorder.cbegin(), preorder.cend(), inorder.cbegin(), inorder.cend()); + } + TreeNode *buildTree(cIter preBeg, cIter preEnd, cIter inBeg, cIter inEnd) + { + if (preBeg >= preEnd || inBeg >= inEnd) + return NULL; + TreeNode *root = new TreeNode(*preBeg); + auto inRoot = std::find(inBeg, inEnd, root->val); + root->left = buildTree(next(preBeg), next(preBeg, inRoot - inBeg + 1), inBeg, inRoot); + root->right = buildTree(next(preBeg, inRoot - inBeg + 1), preEnd, next(inRoot), inEnd); + return root; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/105_\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/105_\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..7faf359232f70c7229de2774206d02f4b26b4047 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/105_\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/105_\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/solution.cpp" @@ -0,0 +1,33 @@ +#include +#include +#include + +using namespace std; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + using vcIt = vector::const_iterator; + TreeNode *buildTree(vector &inorder, vector &postorder) + { + return buildTree(inorder.cbegin(), inorder.cend(), postorder.cbegin(), postorder.cend()); + } + TreeNode *buildTree(vcIt inBeg, vcIt inEnd, vcIt postBeg, vcIt postEnd) + { + if (inBeg >= inEnd || postBeg >= postEnd) + return NULL; + TreeNode *root = new TreeNode(*prev(postEnd)); + auto inRoot = find(inBeg, inEnd, root->val); + root->left = buildTree(inBeg, inRoot, postBeg, next(postBeg, inRoot - inBeg)); + root->right = buildTree(next(inRoot), inEnd, next(postBeg, inRoot - inBeg), prev(postEnd)); + return root; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/106_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/106_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..d8d7c1ca613fddb72f2067a2e3a98e8d827c159c 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/106_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/106_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206 II/solution.cpp" @@ -0,0 +1,38 @@ + + +#include +using std::vector; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + vector> levelOrderBottom(TreeNode *root) + { + levelOrderBottom(root, 0); + return vector>(vec_.rbegin(), vec_.rend()); + } + +private: + void levelOrderBottom(TreeNode *root, int level) + { + if (root == NULL) + return; + if (vec_.size() == level) + vec_.push_back({root->val}); + else + vec_[level].push_back(root->val); + levelOrderBottom(root->left, level + 1); + levelOrderBottom(root->right, level + 1); + } + +private: + vector> vec_; +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/107_\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/107_\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a45de7e740d7a0f780e52abd09724a2c3ba44a36 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/107_\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/107_\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" @@ -0,0 +1,31 @@ +#include +#include +using std::vector; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + TreeNode *sortedArrayToBST(vector &num) + { + return sortedArrayToBST(num.begin(), num.end()); + } + + TreeNode *sortedArrayToBST(vector::iterator beg, vector::iterator end) + { + if (beg == end) + return NULL; + auto mid = beg + (end - beg) / 2; + TreeNode *root = new TreeNode(*mid); + root->left = sortedArrayToBST(beg, mid); + root->right = sortedArrayToBST(std::next(mid), end); + return root; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/108_\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/108_\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..6911a1b42d8eb5bacb7ce7c7af72313865138e2b 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/108_\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/108_\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/solution.cpp" @@ -0,0 +1,43 @@ +#include + +struct ListNode +{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + TreeNode *sortedListToBST(ListNode *head) + { + auto n = [](ListNode *p) + { + int count{0}; + for (; p; p = p->next, ++count) + ; + return count; + }(head); + return sortedListToBST(&head, n); + } + TreeNode *sortedListToBST(ListNode **head_ref, int n) + { + if (n < 1) + return NULL; + TreeNode *left = sortedListToBST(head_ref, n / 2); + TreeNode *root = new TreeNode((*head_ref)->val); + root->left = left; + *head_ref = (*head_ref)->next; + root->right = sortedListToBST(head_ref, n - n / 2 - 1); + return root; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/109_\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/109_\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..d2c2e3a15047afdfa4a93a62594800a9155281f1 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/109_\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/109_\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/solution.cpp" @@ -0,0 +1,36 @@ +#include + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + bool isBalanced(TreeNode *root) + { + height(root); + return bBalanced; + } + +private: + int height(TreeNode *node) + { + if (node == NULL || !bBalanced) + return 0; + else + { + int leftHeight = height(node->left); + int rightHeight = height(node->right); + if (std::abs(leftHeight - rightHeight) > 1) + bBalanced = false; + return std::max(leftHeight, rightHeight) + 1; + } + } + + bool bBalanced = true; +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/110_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/110_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..b15df53b1bf947640743bb5ffabb51545757e650 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/110_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/110_\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/solution.cpp" @@ -0,0 +1,25 @@ +#include + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + int minDepth(TreeNode *root) + { + if (!root) + return 0; + else if (!root->left and !root->right) + return 1; + else if (root->left and root->right) + return 1 + std::min(minDepth(root->left), minDepth(root->right)); + else + return 1 + (root->left ? minDepth(root->left) : minDepth(root->right)); + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/111_\350\267\257\345\276\204\346\200\273\345\222\214/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/111_\350\267\257\345\276\204\346\200\273\345\222\214/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..21b7e1c3722ec4a064d41a240ec3c4393f955e47 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/111_\350\267\257\345\276\204\346\200\273\345\222\214/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/111_\350\267\257\345\276\204\346\200\273\345\222\214/solution.cpp" @@ -0,0 +1,21 @@ +#include +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + bool hasPathSum(TreeNode *root, int sum) + { + if (!root) + return false; + if (!root->left and !root->right and sum - root->val == 0) + return true; + return hasPathSum(root->left, sum - root->val) or hasPathSum(root->right, sum - root->val); + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/112_\350\267\257\345\276\204\346\200\273\345\222\214 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/112_\350\267\257\345\276\204\346\200\273\345\222\214 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..d07464c23e30ba192075c0637677ff749c43bf5e 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/112_\350\267\257\345\276\204\346\200\273\345\222\214 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/112_\350\267\257\345\276\204\346\200\273\345\222\214 II/solution.cpp" @@ -0,0 +1,38 @@ +#include +#include +#include +#include +using std::vector; + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + vector> pathSum(TreeNode *root, int sum) + { + vector> ret; + vector path; + pathSum(root, sum, path, ret); + return ret; + } + void pathSum(TreeNode *root, int sum, vector &path, vector> &ret) + { + if (!root) + return; + path.push_back(root->val); + if (!root->left && !root->right && root->val == sum) + ret.push_back(path); + if (root->left) + pathSum(root->left, sum - root->val, path, ret); + if (root->right) + pathSum(root->right, sum - root->val, path, ret); + path.pop_back(); + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/113_\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/113_\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..78e8f1b729c3fe0a96bc8b012d3daa4c5a5297d9 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/113_\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/113_\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/solution.cpp" @@ -0,0 +1,29 @@ + + +#include + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + void flatten(TreeNode *root) + { + for (; root; root = root->right) + if (root->left) + { + TreeNode *end = root->left; + while (end->right) + end = end->right; + end->right = root->right; + root->right = root->left; + root->left = NULL; + } + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/114_\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/114_\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..1746eef90900185b53c8843d710c59c494941350 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/114_\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/114_\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227/solution.cpp" @@ -0,0 +1,24 @@ +#include +using std::string; +#include +using std::vector; + +class Solution +{ +public: + int numDistinct(string S, string T) + { + int m = static_cast(S.size()); + int n = static_cast(T.size()); + if (m < n) + return 0; + vector v(n + 1, 0); + v[0] = 1; + for (int i = 1; i <= m; ++i) + for (int j = std::min(i, n) + 1; j > 0; --j) + if (S[i - 1] == T[j - 1]) + v[j] += v[j - 1]; + + return v.back(); + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..54bddf8a42856d483d207529294074feb4f01699 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/desc.html" @@ -0,0 +1,43 @@ +

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

+ +
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+ +

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

+ +

初始状态下，所有 next 指针都被设置为 NULL。

+ +

 

+ +

进阶：

+ +
    +
  • 你只能使用常量级额外空间。
    • +
  • 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
    • +
+ +

 

+ +

示例：

+ +

+ +
+输入：root = [1,2,3,4,5,6,7]
+输出：[1,#,2,3,#,4,5,6,7,#]
+解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
+
+ +

 

+ +

提示：

+ +
    +
  • 树中节点的数量少于 4096
    • +
  • -1000 <= node.val <= 1000
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..db45b6e71252906f8949155088cc1fc873b1495a 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/115_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/solution.cpp" @@ -0,0 +1,28 @@ +#include + +struct TreeLinkNode +{ + int val; + TreeLinkNode *left, *right, *next; + TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} +}; + +class Solution +{ +public: + void connect(TreeLinkNode *root) + { + if (root == NULL) + return; + while (root->left) + { + root->left->next = root->right; + for (TreeLinkNode *cur = root; cur->next; cur = cur->next) + { + cur->right->next = cur->next->left; + cur->next->left->next = cur->next->right; + } + root = root->left; + } + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/116_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/116_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..1c99ebd4fbc4d252bfcc698e686bab2585dbe9c0 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/116_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/116_\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210 II/solution.cpp" @@ -0,0 +1,31 @@ +struct TreeLinkNode +{ + int val; + TreeLinkNode *left, *right, *next; + TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} +}; + +class Solution +{ +public: + void connect(TreeLinkNode *root) + { + while (root and (root->left or root->right)) + { + if (root->left and root->right) + root->left->next = root->right; + for (TreeLinkNode *cur = root, *find = root->next; find; find = find->next) + { + if (!find->left and !find->right) + continue; + if (find->left and find->right) + find->left->next = find->right; + (cur->right ? cur->right->next : cur->left->next) = find->left ? find->left : find->right; + cur = find; + } + root = root->left ? root->left : root->right; + while (root->next && !root->left and !root->right) + root = root->next; + } + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/117_\346\235\250\350\276\211\344\270\211\350\247\222/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/117_\346\235\250\350\276\211\344\270\211\350\247\222/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..451f1bc9c6d63bfaeb3c165a902cd2927449c1bc 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/117_\346\235\250\350\276\211\344\270\211\350\247\222/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/117_\346\235\250\350\276\211\344\270\211\350\247\222/solution.cpp" @@ -0,0 +1,23 @@ +#include + +using std::vector; + +class Solution +{ +public: + vector> generate(int numRows) + { + vector> vec; + for (int i = 0; i < numRows; ++i) + { + vector row; + if (!vec.empty()) + row.assign(vec.at(i - 1).begin(), vec.at(i - 1).end()); + row.push_back(1); + for (int j = i - 1; j > 0; --j) + row[j] += row[j - 1]; + vec.push_back(row); + } + return vec; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1183_\345\205\254\344\272\244\347\253\231\351\227\264\347\232\204\350\267\235\347\246\273/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1183_\345\205\254\344\272\244\347\253\231\351\227\264\347\232\204\350\267\235\347\246\273/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..173ccf1a007dc8590065625689b3e12602297d10 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1183_\345\205\254\344\272\244\347\253\231\351\227\264\347\232\204\350\267\235\347\246\273/desc.html" @@ -0,0 +1,48 @@ +

环形公交路线上有 n 个站，按次序从 0 到 n - 1 进行编号。我们已知每一对相邻公交站之间的距离，distance[i] 表示编号为 i 的车站和编号为 (i + 1) % n 的车站之间的距离。

+ +

环线上的公交车都可以按顺时针和逆时针的方向行驶。

+ +

返回乘客从出发点 start 到目的地 destination 之间的最短距离。

+ +

 

+ +

示例 1：

+ +

+ +
输入：distance = [1,2,3,4], start = 0, destination = 1
+输出：1
+解释：公交站 0 和 1 之间的距离是 1 或 9，最小值是 1。
+ +

 

+ +

示例 2：

+ +

+ +
输入：distance = [1,2,3,4], start = 0, destination = 2
+输出：3
+解释：公交站 0 和 2 之间的距离是 3 或 7，最小值是 3。
+
+ +

 

+ +

示例 3：

+ +

+ +
输入：distance = [1,2,3,4], start = 0, destination = 3
+输出：4
+解释：公交站 0 和 3 之间的距离是 6 或 4，最小值是 4。
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 10^4
    • +
  • distance.length == n
    • +
  • 0 <= start, destination < n
    • +
  • 0 <= distance[i] <= 10^4
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1184_\344\270\200\345\221\250\344\270\255\347\232\204\347\254\254\345\207\240\345\244\251/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1184_\344\270\200\345\221\250\344\270\255\347\232\204\347\254\254\345\207\240\345\244\251/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..034bd64d4dec2196b738918c241b66736c4a74bf --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1184_\344\270\200\345\221\250\344\270\255\347\232\204\347\254\254\345\207\240\345\244\251/desc.html" @@ -0,0 +1,33 @@ +

给你一个日期，请你设计一个算法来判断它是对应一周中的哪一天。

+ +

输入为三个整数：day、month 和 year，分别表示日、月、年。

+ +

您返回的结果必须是这几个值中的一个 {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}。

+ +

 

+ +

示例 1：

+ +
输入：day = 31, month = 8, year = 2019
+输出："Saturday"
+
+ +

示例 2：

+ +
输入：day = 18, month = 7, year = 1999
+输出："Sunday"
+
+ +

示例 3：

+ +
输入：day = 15, month = 8, year = 1993
+输出："Sunday"
+
+ +

 

+ +

提示：

+ +
    +
  • 给出的日期一定是在 1971 到 2100 年之间的有效日期。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1188_\342\200\234\346\260\224\347\220\203\342\200\235 \347\232\204\346\234\200\345\244\247\346\225\260\351\207\217/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1188_\342\200\234\346\260\224\347\220\203\342\200\235 \347\232\204\346\234\200\345\244\247\346\225\260\351\207\217/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..330a39f712945cf684f9f4df64e4743aaedfe0e6 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1188_\342\200\234\346\260\224\347\220\203\342\200\235 \347\232\204\346\234\200\345\244\247\346\225\260\351\207\217/desc.html" @@ -0,0 +1,36 @@ +

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 "balloon"（气球）。

+ +

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 "balloon"。

+ +

 

+ +

示例 1：

+ +

+ +
输入：text = "nlaebolko"
+输出：1
+
+ +

示例 2：

+ +

+ +
输入：text = "loonbalxballpoon"
+输出：2
+
+ +

示例 3：

+ +
输入：text = "leetcode"
+输出：0
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= text.length <= 10^4
    • +
  • text 全部由小写英文字母组成
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1189_\345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1189_\345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..b91f8e551391aea3cca9016aa0f59bbb6d4cf95f --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1189_\345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262/desc.html" @@ -0,0 +1,45 @@ +

给出一个字符串 s（仅含有小写英文字母和括号）。

+ +

请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。

+ +

注意，您的结果中 不应 包含任何括号。

+ +

 

+ +

示例 1：

+ +
+输入：s = "(abcd)"
+输出："dcba"
+
+ +

示例 2：

+ +
+输入：s = "(u(love)i)"
+输出："iloveu"
+解释：先反转子字符串 "love" ，然后反转整个字符串。
+ +

示例 3：

+ +
+输入：s = "(ed(et(oc))el)"
+输出："leetcode"
+解释：先反转子字符串 "oc" ，接着反转 "etco" ，然后反转整个字符串。
+ +

示例 4：

+ +
+输入：s = "a(bcdefghijkl(mno)p)q"
+输出："apmnolkjihgfedcbq"
+
+ +

 

+ +

提示：

+ +
    +
  • 0 <= s.length <= 2000
    • +
  • s 中只有小写英文字母和括号
    • +
  • 题目测试用例确保所有括号都是成对出现的
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..727a5c3b9e78132cb8fd51e4fc6f1c65f6c5fd6b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/desc.html" @@ -0,0 +1,42 @@ +

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。

+ +

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

+ +

+ +

 

+ +

示例 1:

+ +
+输入: rowIndex = 3
+输出: [1,3,3,1]
+
+ +

示例 2:

+ +
+输入: rowIndex = 0
+输出: [1]
+
+ +

示例 3:

+ +
+输入: rowIndex = 1
+输出: [1,1]
+
+ +

 

+ +

提示:

+ +
    +
  • 0 <= rowIndex <= 33
    • +
+ +

 

+ +

进阶：

+ +

你可以优化你的算法到 O(rowIndex) 空间复杂度吗？

diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..864c336fb2f9dacd60eacd408a48f9f61a868631 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/118_\346\235\250\350\276\211\344\270\211\350\247\222 II/solution.cpp" @@ -0,0 +1,16 @@ +#include +using std::vector; + +class Solution +{ +public: + vector getRow(int rowIndex) + { + vector vec(rowIndex + 1, 0); + vec[0] = 1; + for (int i = 0; i <= rowIndex; ++i) + for (int j = i; j > 0; --j) + vec[j] += vec[j - 1]; + return vec; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1191_\346\237\245\346\211\276\351\233\206\347\276\244\345\206\205\347\232\204\343\200\214\345\205\263\351\224\256\350\277\236\346\216\245\343\200\215/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1191_\346\237\245\346\211\276\351\233\206\347\276\244\345\206\205\347\232\204\343\200\214\345\205\263\351\224\256\350\277\236\346\216\245\343\200\215/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..5b0036334c265caae7acb6cba73b90856fcb311d --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1191_\346\237\245\346\211\276\351\233\206\347\276\244\345\206\205\347\232\204\343\200\214\345\205\263\351\224\256\350\277\236\346\216\245\343\200\215/desc.html" @@ -0,0 +1,30 @@ +

力扣数据中心有 n 台服务器，分别按从 0 到 n-1 的方式进行了编号。

+ +

它们之间以「服务器到服务器」点对点的形式相互连接组成了一个内部集群，其中连接 connections 是无向的。

+ +

从形式上讲，connections[i] = [a, b] 表示服务器 a 和 b 之间形成连接。任何服务器都可以直接或者间接地通过网络到达任何其他服务器。

+ +

「关键连接」是在该集群中的重要连接，也就是说，假如我们将它移除，便会导致某些服务器无法访问其他服务器。

+ +

请你以任意顺序返回该集群内的所有 「关键连接」。

+ +

 

+ +

示例 1：

+ +

+ +
输入：n = 4, connections = [[0,1],[1,2],[2,0],[1,3]]
+输出：[[1,3]]
+解释：[[3,1]] 也是正确的。
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 10^5
    • +
  • n-1 <= connections.length <= 10^5
    • +
  • connections[i][0] != connections[i][1]
    • +
  • 不存在重复的连接
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..bbce414d804ddad43e5389daba3e207c43bc3322 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/desc.html" @@ -0,0 +1,44 @@ +

给定一个三角形 triangle ，找出自顶向下的最小路径和。

+ +

每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

+ +

 

+ +

示例 1：

+ +
+输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+输出：11
+解释：如下面简图所示：
+   2
+  3 4
+ 6 5 7
+4 1 8 3
+自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
+
+ +

示例 2：

+ +
+输入：triangle = [[-10]]
+输出：-10
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= triangle.length <= 200
    • +
  • triangle[0].length == 1
    • +
  • triangle[i].length == triangle[i - 1].length + 1
    • +
  • -104 <= triangle[i][j] <= 104
    • +
+ +

 

+ +

进阶：

+ +
    +
  • 你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..1e890fa7509599f9d721a8fe5117e9930b5dbc9e 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/119_\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/solution.cpp" @@ -0,0 +1,26 @@ +#include +#include +#include + +using namespace std; + +class Solution +{ +public: + int minimumTotal(vector> &triangle) + { + vector steps; + for (auto &v : triangle) + { + if (!steps.empty()) + { + v.front() += steps.front(); + v.back() += steps.back(); + } + for (size_t i = 1; i < steps.size(); ++i) + v[i] += min(steps.at(i - 1), steps.at(i)); + steps = v; + } + return *min_element(steps.cbegin(), steps.cend()); + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/120_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/120_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..e7e4eb0f65fc5f3555ba5c4b7893c6a0b57c7472 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/120_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/120_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/solution.cpp" @@ -0,0 +1,22 @@ +#include +#include +using std::max; +using std::min; +using std::vector; + +class Solution +{ +public: + int maxProfit(vector &prices) + { + if (prices.empty()) + return 0; + int ret{0}, low{prices[0]}; + for (auto price : prices) + { + low = min(low, price); + ret = max(ret, price - low); + } + return ret; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/121_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/121_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..cf8b903836c27230e3a5cb7ec22f75067a1131c2 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/121_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/121_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II/solution.cpp" @@ -0,0 +1,17 @@ + + +#include +using std::vector; + +class Solution +{ +public: + int maxProfit(vector &prices) + { + int profit = 0; + for (auto i = prices.begin(); i != prices.end(); ++i) + if (i + 1 != prices.end() && *(i + 1) > *i) + profit += *(i + 1) - *i; + return profit; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/122_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 III/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/122_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 III/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..4b7b1f8eccf1a1e62f2dd29abd7f83395d185539 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/122_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 III/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/122_\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 III/solution.cpp" @@ -0,0 +1,30 @@ +#include +using std::vector; +#include +using std::max; +using std::min; + +class Solution +{ +public: + int maxProfit(vector &prices) + { + if (prices.empty()) + return 0; + int low = prices.front(), high = prices.back(), ret = 0; + vector history; + history.reserve(prices.size()); + for (auto today : prices) + { + low = min(low, today); + ret = max(ret, today - low); + history.push_back(ret); + } + for (auto today = prices.crbegin(), past = history.crbegin(); today != prices.crend(); ++today, ++past) + { + high = max(high, *today); + ret = max(ret, *past + high - *today); + } + return ret; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..a15dafc2426e86df51a865ed02168673ce088d28 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/desc.html" @@ -0,0 +1,31 @@ +

路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

+ +

路径和 是路径中各节点值的总和。

+ +

给你一个二叉树的根节点 root ，返回其 最大路径和 。

+ +

 

+ +

示例 1：

+ +
+输入：root = [1,2,3]
+输出：6
+解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6
+ +

示例 2：

+ +
+输入：root = [-10,9,20,null,null,15,7]
+输出：42
+解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
+
+ +

 

+ +

提示：

+ +
    +
  • 树中节点数目范围是 [1, 3 * 104]
    • +
  • -1000 <= Node.val <= 1000
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..be597feb15d8861c54618fdd922589099c54408f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/123_\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214/solution.cpp" @@ -0,0 +1,31 @@ +#include +#include + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ + int maxPathSum(TreeNode *root, int &maxSum) + { + if (!root) + return 0; + int leftMax = std::max(0, maxPathSum(root->left, maxSum)); + int rightMax = std::max(0, maxPathSum(root->right, maxSum)); + maxSum = std::max(maxSum, leftMax + rightMax + root->val); + return root->val + std::max(leftMax, rightMax); + } + +public: + int maxPathSum(TreeNode *root) + { + int maxSum = INT_MIN; + maxPathSum(root, maxSum); + return maxSum; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..2a848a695a28672a3955e4703b3f5e714d4dd2bc --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/desc.html" @@ -0,0 +1,30 @@ +

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

+ +

说明：本题中，我们将空字符串定义为有效的回文串。

+ +

 

+ +

示例 1:

+ +
+输入: "A man, a plan, a canal: Panama"
+输出: true
+解释："amanaplanacanalpanama" 是回文串
+
+ +

示例 2:

+ +
+输入: "race a car"
+输出: false
+解释："raceacar" 不是回文串
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= s.length <= 2 * 105
    • +
  • 字符串 s 由 ASCII 字符组成
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..171f1e89b65ba56a43a618f3282bb01b498ccc2c 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/124_\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/solution.cpp" @@ -0,0 +1,23 @@ + + +#include +using std::string; +#include + +class Solution +{ +public: + bool isPalindrome(string s) + { + for (auto b = s.cbegin(), e = std::prev(s.cend()); b < e; ++b, --e) + { + while (!isalnum(*b)) + ++b; + while (!isalnum(*e)) + --e; + if (b < e && tolower(*b) != tolower(*e)) + return false; + } + return true; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/125_\345\215\225\350\257\215\346\216\245\351\276\231 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/125_\345\215\225\350\257\215\346\216\245\351\276\231 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..2fa727e314f812f79ca99418458b65bff3141048 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/125_\345\215\225\350\257\215\346\216\245\351\276\231 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/125_\345\215\225\350\257\215\346\216\245\351\276\231 II/solution.cpp" @@ -0,0 +1,71 @@ + +class Solution +{ +public: + unordered_map> tree; // 构建图 + vector> ans; // 存放最终结果 + + void dfs(vector &cur, string curWord, string endWord) + { + if (curWord == endWord) + { + ans.push_back(cur); + return; + } + for (string s : tree[curWord]) + { + cur.push_back(s); + dfs(cur, s, endWord); + cur.pop_back(); + } + } + + vector> findLadders(string beginWord, string endWord, vector &wordList) + { + if (wordList.size() == 0 || find(wordList.begin(), wordList.end(), endWord) == wordList.end()) + return {}; + unordered_set bfsFromBegin{beginWord}; // 自顶向下的BFS队列 !!!注意使用集合 + unordered_set bfsFromEnd{endWord}; // 自底向上的BFS队列 !!!注意使用集合 + unordered_set dirc(wordList.begin(), wordList.end()); // 初始化字典 记录未被访问过的字符串 !!!注意初始化方式 + bool findFlag = false, reverseFlag = false; // findFlag两队列是否存在相同的元素 reverseflag时刻标记当前BFS遍历的方向（false为自顶向下，true为自底向上） + while (!bfsFromBegin.empty()) + { + unordered_set next; // 存放下一层需要遍历的节点（由于此处BFS的特殊性【一次性扩展所有节点】，所以不是直接添加到原先队列的末尾，而是借助next） + for (string s : bfsFromBegin) // 遍历过的节点从set中删除 避免成环 + dirc.erase(s); + for (string s1 : bfsFromBegin) + { // 扩展下一层的节点 + for (int i = 0; i < s1.size(); ++i) + { + string s2 = s1; // s2记录由s1扩展而来字符串 !!!注意这条语句不要放错位置 + for (char c = 'a'; c <= 'z'; ++c) + { + s2[i] = c; + if (dirc.count(s2) == 0) + continue; + if (bfsFromEnd.count(s2)) + { + findFlag = true; // 找到双向BFS重合的字符串，BFS过程即可终止 + } + else + { + next.insert(s2); // 将字符串加入扩展队列 + } + reverseFlag ? tree[s2].push_back(s1) : tree[s1].push_back(s2); // 构建树 并始终保持方向从beginWord指向endWord + } + } + } + bfsFromBegin = next; // 更新队列 + if (bfsFromBegin.size() > bfsFromEnd.size()) + { + reverseFlag = !reverseFlag; // 取反 + swap(bfsFromBegin, bfsFromEnd); // 交换BFS的队列 改变BFS的方向 + } + if (findFlag) + break; // 双向BFS交汇 BFS过程终止 + } + vector cur = {beginWord}; + dfs(cur, beginWord, endWord); // 遍历形成的树 得到起点到终点的路径 + return ans; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/126_\345\215\225\350\257\215\346\216\245\351\276\231/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/126_\345\215\225\350\257\215\346\216\245\351\276\231/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..e9ecd50ab65e43a0db85957dfdcceca9b84beda1 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/126_\345\215\225\350\257\215\346\216\245\351\276\231/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/126_\345\215\225\350\257\215\346\216\245\351\276\231/solution.cpp" @@ -0,0 +1,40 @@ +//Dijkstra算法的思路 +class Solution +{ +public: + int ladderLength(string beginWord, string endWord, vector &wordList) + { + unordered_set set(wordList.begin(), wordList.end()); + if (!set.count(endWord)) + return 0; + queue> q; //<字符串，该字符串到beginword的距离> + q.push({beginWord, 1}); + while (!q.empty()) + { + string cur = q.front().first; + int step = q.front().second; + q.pop(); + if (cur == endWord) + return step; + + for (int i = 0; i < cur.size(); ++i) + { + char ch = cur[i]; + //遍历字母来寻找距离为1（只用改变一个字母）的单词，也即可达的单词 + for (char c = 'a'; c <= 'z'; ++c) + { + if (c == ch) + continue; + cur[i] = c; //替换单个字符 + if (set.count(cur)) + { + q.push({cur, 1 + step}); + set.erase(cur); //该节点使用过了，需要进行删除 + } + } + cur[i] = ch; //复原 + } + } + return 0; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1276_\347\273\237\350\256\241\345\205\250\344\270\272 1 \347\232\204\346\255\243\346\226\271\345\275\242\345\255\220\347\237\251\351\230\265/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1276_\347\273\237\350\256\241\345\205\250\344\270\272 1 \347\232\204\346\255\243\346\226\271\345\275\242\345\255\220\347\237\251\351\230\265/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..81f4463204fcfc442c2183e29e62ec218fc46c9c --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1276_\347\273\237\350\256\241\345\205\250\344\270\272 1 \347\232\204\346\255\243\346\226\271\345\275\242\345\255\220\347\237\251\351\230\265/desc.html" @@ -0,0 +1,44 @@ +

给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的 正方形 子矩阵的个数。

+ +

 

+ +

示例 1：

+ +
输入：matrix =
+[
+  [0,1,1,1],
+  [1,1,1,1],
+  [0,1,1,1]
+]
+输出：15
+解释： 
+边长为 1 的正方形有 10 个。
+边长为 2 的正方形有 4 个。
+边长为 3 的正方形有 1 个。
+正方形的总数 = 10 + 4 + 1 = 15.
+
+ +

示例 2：

+ +
输入：matrix = 
+[
+  [1,0,1],
+  [1,1,0],
+  [1,1,0]
+]
+输出：7
+解释：
+边长为 1 的正方形有 6 个。 
+边长为 2 的正方形有 1 个。
+正方形的总数 = 6 + 1 = 7.
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= arr.length <= 300
    • +
  • 1 <= arr[0].length <= 300
    • +
  • 0 <= arr[i][j] <= 1
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1277_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 III/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1277_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 III/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..ed8a8dd47210427839f82de713c222b3e5ab849d --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1277_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 III/desc.html" @@ -0,0 +1,40 @@ +

给你一个由小写字母组成的字符串 s，和一个整数 k。

+ +

请你按下面的要求分割字符串：

+ +
    +
  • 首先，你可以将 s 中的部分字符修改为其他的小写英文字母。
    • +
  • 接着，你需要把 s 分割成 k 个非空且不相交的子串，并且每个子串都是回文串。
    • +
+ +

请返回以这种方式分割字符串所需修改的最少字符数。

+ +

 

+ +

示例 1：

+ +
输入：s = "abc", k = 2
+输出：1
+解释：你可以把字符串分割成 "ab" 和 "c"，并修改 "ab" 中的 1 个字符，将它变成回文串。
+
+ +

示例 2：

+ +
输入：s = "aabbc", k = 3
+输出：0
+解释：你可以把字符串分割成 "aa"、"bb" 和 "c"，它们都是回文串。
+ +

示例 3：

+ +
输入：s = "leetcode", k = 8
+输出：0
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= k <= s.length <= 100
    • +
  • s 中只含有小写英文字母。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/127_\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/127_\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..292f2f257d2a3934309eede29ae0f5206c16cfd1 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/127_\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/127_\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/solution.cpp" @@ -0,0 +1,22 @@ +#include +#include +using std::unordered_map; +using std::vector; + +class Solution +{ +public: + int longestConsecutive(vector &num) + { + unordered_map map; + int max{0}; + for (auto i : num) + if (!map[i]) + { + map[i] = map[i + 1] + map[i - 1] + 1; + map[i - map[i - 1]] = map[i + map[i + 1]] = map[i]; + max = std::max(max, map[i]); + } + return max; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1280_\346\225\264\346\225\260\347\232\204\345\220\204\344\275\215\347\247\257\345\222\214\344\271\213\345\267\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1280_\346\225\264\346\225\260\347\232\204\345\220\204\344\275\215\347\247\257\345\222\214\344\271\213\345\267\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..5694dcf5bd0ba94c49ae7731ec4e130c7c6336cc --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1280_\346\225\264\346\225\260\347\232\204\345\220\204\344\275\215\347\247\257\345\222\214\344\271\213\345\267\256/desc.html" @@ -0,0 +1,31 @@ +

给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。

+ +

 

+ +

示例 1：

+ +
输入：n = 234
+输出：15 
+解释：
+各位数之积 = 2 * 3 * 4 = 24 
+各位数之和 = 2 + 3 + 4 = 9 
+结果 = 24 - 9 = 15
+
+ +

示例 2：

+ +
输入：n = 4421
+输出：21
+解释： 
+各位数之积 = 4 * 4 * 2 * 1 = 32 
+各位数之和 = 4 + 4 + 2 + 1 = 11 
+结果 = 32 - 11 = 21
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 10^5
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1281_\347\224\250\346\210\267\345\210\206\347\273\204/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1281_\347\224\250\346\210\267\345\210\206\347\273\204/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..5b8bc3ede6d4e350d552a8ddd307ffe9d88c82c0 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1281_\347\224\250\346\210\267\345\210\206\347\273\204/desc.html" @@ -0,0 +1,29 @@ +

有 n 位用户参加活动，他们的 ID 从 0 到 n - 1，每位用户都 恰好 属于某一用户组。给你一个长度为 n 的数组 groupSizes，其中包含每位用户所处的用户组的大小，请你返回用户分组情况（存在的用户组以及每个组中用户的 ID）。

+ +

你可以任何顺序返回解决方案，ID 的顺序也不受限制。此外，题目给出的数据保证至少存在一种解决方案。

+ +

 

+ +

示例 1：

+ +
输入：groupSizes = [3,3,3,3,3,1,3]
+输出：[[5],[0,1,2],[3,4,6]]
+解释： 
+其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。
+
+ +

示例 2：

+ +
输入：groupSizes = [2,1,3,3,3,2]
+输出：[[1],[0,5],[2,3,4]]
+
+ +

 

+ +

提示：

+ +
    +
  • groupSizes.length == n
    • +
  • 1 <= n <= 500
    • +
  • 1 <= groupSizes[i] <= n
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/128_\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/128_\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3de2b893e6d811a262f0a0ac98203335cf5a7126 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/128_\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/128_\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/solution.cpp" @@ -0,0 +1,31 @@ + + +#include + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + int sumNumbers(TreeNode *root) + { + return sumNumbers(root, 0); + } + +private: + int sumNumbers(TreeNode *root, int sum) + { + if (!root) + return 0; + else if (!root->left && !root->right) + return sum + root->val; + else + return sumNumbers(root->left, (root->val + sum) * 10) + sumNumbers(root->right, (root->val + sum) * 10); + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1292_\347\275\221\346\240\274\344\270\255\347\232\204\346\234\200\347\237\255\350\267\257\345\276\204/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1292_\347\275\221\346\240\274\344\270\255\347\232\204\346\234\200\347\237\255\350\267\257\345\276\204/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..5c325cb0c3cea13ad2b5fa80e0be946bce5e45f9 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1292_\347\275\221\346\240\274\344\270\255\347\232\204\346\234\200\347\237\255\350\267\257\345\276\204/desc.html" @@ -0,0 +1,49 @@ +

给你一个 m * n 的网格，其中每个单元格不是 0（空）就是 1（障碍物）。每一步，您都可以在空白单元格中上、下、左、右移动。

+ +

如果您 最多 可以消除 k 个障碍物，请找出从左上角 (0, 0) 到右下角 (m-1, n-1) 的最短路径，并返回通过该路径所需的步数。如果找不到这样的路径，则返回 -1。

+ +

 

+ +

示例 1：

+ +
输入： 
+grid = 
+[[0,0,0],
+ [1,1,0],
+ [0,0,0],
+ [0,1,1],
+ [0,0,0]], 
+k = 1
+输出：6
+解释：
+不消除任何障碍的最短路径是 10。
+消除位置 (3,2) 处的障碍后，最短路径是 6 。该路径是 (0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (3,2) -> (4,2).
+
+ +

 

+ +

示例 2：

+ +
输入：
+grid = 
+[[0,1,1],
+ [1,1,1],
+ [1,0,0]], 
+k = 1
+输出：-1
+解释：
+我们至少需要消除两个障碍才能找到这样的路径。
+
+ +

 

+ +

提示：

+ +
    +
  • grid.length == m
    • +
  • grid[0].length == n
    • +
  • 1 <= m, n <= 40
    • +
  • 1 <= k <= m*n
    • +
  • grid[i][j] == 0 or 1
    • +
  • grid[0][0] == grid[m-1][n-1] == 0
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/129_\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/129_\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..ba0fe735bd914e18b0c5cf95587d033ac3a6b0cf 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/129_\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/129_\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/solution.cpp" @@ -0,0 +1,38 @@ +class Solution +{ +public: + int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0}, n, m; + void dfs(int row, int col, vector> &board) + { + board[row][col] = 'o'; + for (int i = 0; i < 4; ++i) + if (row + dx[i] >= 0 && row + dx[i] < n && col + dy[i] >= 0 && col + dy[i] < m && board[row + dx[i]][col + dy[i]] == 'O') + dfs(row + dx[i], col + dy[i], board); + } + void solve(vector> &board) + { + n = board.size(), m = n ? board[0].size() : 0; + if (!(m & n)) + return; + for (int i = 0; i < n; ++i) + { + if (board[i][0] == 'O') + dfs(i, 0, board); + if (board[i][m - 1] == 'O') + dfs(i, m - 1, board); + } + for (int j = 0; j < m; ++j) + { + if (board[0][j] == 'O') + dfs(0, j, board); + if (board[n - 1][j] == 'O') + dfs(n - 1, j, board); + } + for (int i = 0; i < n; ++i) + for (int j = 0; j < m; ++j) + if (board[i][j] == 'O') + board[i][j] = 'X'; + else if (board[i][j] == 'o') + board[i][j] = 'O'; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/130_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/130_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0113ceed5bea1cd8d34cae4996136583b71d92c3 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/130_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/130_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262/solution.cpp" @@ -0,0 +1,40 @@ +#include +using std::vector; +#include +using std::string; + +class Solution +{ + vector> ret; + +public: + using cIter = string::const_iterator; + vector> partition(string s) + { + vector v; + partition(s.cbegin(), s.cend(), v); + return ret; + } + void partition(cIter beg, cIter end, vector &v) + { + if (beg == end) + { + ret.push_back(v); + return; + } + for (auto it = beg; it != end; ++it) + if (isPalindrome(beg, it)) + { + v.emplace_back(beg, std::next(it)); + partition(std::next(it), end, v); + v.pop_back(); + } + } + bool isPalindrome(cIter first, cIter last) + { + for (; first < last; ++first, --last) + if (*first != *last) + return false; + return true; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/131_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/131_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..8c2f99eb3a99016539f8edaf561cb612411a53d2 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/131_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/131_\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II/solution.cpp" @@ -0,0 +1,25 @@ +class Solution +{ +public: + int minCut(string s) + { + if (s.empty()) + return 0; + int n = s.size(); + vector> p(n, vector(n)); + vector dp(n); + for (int i = 0; i < n; ++i) + { + dp[i] = i; + for (int j = 0; j <= i; ++j) + { + if (s[i] == s[j] && (i - j < 2 || p[j + 1][i - 1])) + { + p[j][i] = true; + dp[i] = (j == 0) ? 0 : min(dp[i], dp[j - 1] + 1); + } + } + } + return dp[n - 1]; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/132_\345\205\213\351\232\206\345\233\276/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/132_\345\205\213\351\232\206\345\233\276/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..303100ce28a7c329ec2be49731e96693971362fd 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/132_\345\205\213\351\232\206\345\233\276/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/132_\345\205\213\351\232\206\345\233\276/solution.cpp" @@ -0,0 +1,36 @@ +#include +using std::vector; +#include +using std::unordered_map; + +struct UndirectedGraphNode +{ + int label; + vector neighbors; + UndirectedGraphNode(int x) : label(x){}; +}; + +class Solution +{ + unordered_map map; + void dfs(UndirectedGraphNode *node) + { + if (map.find(node) != map.end()) + return; + map[node] = new UndirectedGraphNode(node->label); + for (UndirectedGraphNode *neighbor : node->neighbors) + { + dfs(neighbor); + map[node]->neighbors.push_back(map[neighbor]); + } + } + +public: + UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) + { + if (!node) + return node; + dfs(node); + return map[node]; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/133_\345\212\240\346\262\271\347\253\231/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/133_\345\212\240\346\262\271\347\253\231/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..332ae440f658022d841e47bb70739d7c986f3ba0 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/133_\345\212\240\346\262\271\347\253\231/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/133_\345\212\240\346\262\271\347\253\231/solution.cpp" @@ -0,0 +1,19 @@ +#include +using std::vector; + +class Solution +{ +public: + int canCompleteCircuit(vector &gas, vector &cost) + { + int tank{0}, start{0}, stored{0}; + for (decltype(gas.size()) i = 0; i < gas.size(); ++i) + if ((tank += gas[i] - cost[i]) < 0) + { + start = i + 1; + stored += tank; + tank = 0; + } + return (tank + stored) < 0 ? -1 : start; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/134_\345\210\206\345\217\221\347\263\226\346\236\234/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/134_\345\210\206\345\217\221\347\263\226\346\236\234/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..df79d39a640014a528c283721361ba7f6cf83cf0 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/134_\345\210\206\345\217\221\347\263\226\346\236\234/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/134_\345\210\206\345\217\221\347\263\226\346\236\234/solution.cpp" @@ -0,0 +1,24 @@ +class Solution +{ +public: + int candy(vector &ratings) + { + int n = ratings.size(); + int ans = 0; + vector sum(n, 1); + if (n < 2) + return n; + for (int i = 0; i < n; ++i) + { + if (i > 0 && ratings[i] > ratings[i - 1]) + sum[i] = sum[i - 1] + 1; + } + for (int i = n - 1; i >= 0; --i) + { + if (i < n - 1 && ratings[i] > ratings[i + 1]) + sum[i] = max(sum[i + 1] + 1, sum[i]); + ans += sum[i]; + } + return ans; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/135_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/135_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..bea821519851ceb83515257927c70fa45eb0803f 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/135_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/135_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/solution.cpp" @@ -0,0 +1,11 @@ +class Solution +{ +public: + int singleNumber(int A[], int n) + { + int r{0}; + for (int i = 0; i != n; ++i) + r ^= A[i]; + return r; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/136_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/136_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..de1dcf69ee3489eabe66a447243eeac8409de6d0 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/136_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/136_\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II/solution.cpp" @@ -0,0 +1,16 @@ + + +class Solution +{ +public: + int singleNumber(int A[], int n) + { + int low = 0; + for (int i = 0, high = 0; i != n; ++i) + { + low ^= A[i] & ~high; + high ^= A[i] & ~low; + } + return low; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/137_\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/137_\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..5d4f868d544548e274e5862d01f920a2c0eaf7ce 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/137_\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/137_\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/solution.cpp" @@ -0,0 +1,35 @@ +#include +#include + +struct RandomListNode +{ + int label; + RandomListNode *next, *random; + RandomListNode(int x) : label(x), next(NULL), random(NULL) {} +}; + +class Solution +{ +public: + RandomListNode *copyRandomList(RandomListNode *head) + { + std::unordered_map map; + RandomListNode preHead(0); + for (RandomListNode *next = &preHead; head; next = next->next, head = head->next) + { + if (map[head] == NULL) + { + RandomListNode *node = new RandomListNode(head->label); + map[head] = node; + } + next->next = map[head]; + if (head->random && map[head->random] == NULL) + { + RandomListNode *node = new RandomListNode(head->random->label); + map[head->random] = node; + } + map[head]->random = map[head->random]; + } + return preHead.next; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1382_\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1382_\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..86b129837a9516482eaedc30c7454b43fb46613a --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1382_\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274/desc.html" @@ -0,0 +1,40 @@ +

公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的 ​​​​​​最大团队表现值 ，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。

+ +

团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。

+ +

 

+ +

示例 1：

+ +
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
+输出：60
+解释：
+我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。
+
+ +

示例 2：

+ +
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
+输出：68
+解释：
+此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。
+
+ +

示例 3：

+ +
输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
+输出：72
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 10^5
    • +
  • speed.length == n
    • +
  • efficiency.length == n
    • +
  • 1 <= speed[i] <= 10^5
    • +
  • 1 <= efficiency[i] <= 10^8
    • +
  • 1 <= k <= n
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/138_\345\215\225\350\257\215\346\213\206\345\210\206/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/138_\345\215\225\350\257\215\346\213\206\345\210\206/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..08ecbe90144c11b0dae85bbe17da5a610dd46c74 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/138_\345\215\225\350\257\215\346\213\206\345\210\206/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/138_\345\215\225\350\257\215\346\213\206\345\210\206/solution.cpp" @@ -0,0 +1,26 @@ +#include +using std::string; +#include +using std::unordered_set; +#include + +class Solution +{ +public: + bool wordBreak(string s, unordered_set &dict) + { + if (dict.find(s) != dict.end()) + return true; + std::vector cache{s.cbegin()}; + for (auto subEnd = s.cbegin(); subEnd != s.cend(); ++subEnd) + for (auto subBeg : cache) + if (subBeg < subEnd && dict.find(string(subBeg, subEnd)) != dict.end()) + { + if (dict.find(string(subEnd, s.cend())) != dict.end()) + return true; + cache.push_back(subEnd); + break; + } + return false; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1396_\346\211\276\345\210\260\346\211\200\346\234\211\345\245\275\345\255\227\347\254\246\344\270\262/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1396_\346\211\276\345\210\260\346\211\200\346\234\211\345\245\275\345\255\227\347\254\246\344\270\262/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..f45be29400d32c5104a808ff3819726af63a16ff --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1396_\346\211\276\345\210\260\346\211\200\346\234\211\345\245\275\345\255\227\347\254\246\344\270\262/desc.html" @@ -0,0 +1,40 @@ +

给你两个长度为 n 的字符串 s1 和 s2 ，以及一个字符串 evil 。请你返回 好字符串 的数目。

+ +

好字符串 的定义为：它的长度为 n ，字典序大于等于 s1 ，字典序小于等于 s2 ，且不包含 evil 为子字符串。

+ +

由于答案可能很大，请你返回答案对 10^9 + 7 取余的结果。

+ +

 

+ +

示例 1：

+ +
输入：n = 2, s1 = "aa", s2 = "da", evil = "b"
+输出：51 
+解释：总共有 25 个以 'a' 开头的好字符串："aa"，"ac"，"ad"，...，"az"。还有 25 个以 'c' 开头的好字符串："ca"，"cc"，"cd"，...，"cz"。最后，还有一个以 'd' 开头的好字符串："da"。
+
+ +

示例 2：

+ +
输入：n = 8, s1 = "leetcode", s2 = "leetgoes", evil = "leet"
+输出：0 
+解释：所有字典序大于等于 s1 且小于等于 s2 的字符串都以 evil 字符串 "leet" 开头。所以没有好字符串。
+
+ +

示例 3：

+ +
输入：n = 2, s1 = "gx", s2 = "gz", evil = "x"
+输出：2
+
+ +

 

+ +

提示：

+ +
    +
  • s1.length == n
    • +
  • s2.length == n
    • +
  • s1 <= s2
    • +
  • 1 <= n <= 500
    • +
  • 1 <= evil.length <= 50
    • +
  • 所有字符串都只包含小写英文字母。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1398_\347\273\237\350\256\241\346\234\200\345\244\247\347\273\204\347\232\204\346\225\260\347\233\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1398_\347\273\237\350\256\241\346\234\200\345\244\247\347\273\204\347\232\204\346\225\260\347\233\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..d9b50f33528a1af98f32ca84062dbb5790f3eddb --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1398_\347\273\237\350\256\241\346\234\200\345\244\247\347\273\204\347\232\204\346\225\260\347\233\256/desc.html" @@ -0,0 +1,40 @@ +

给你一个整数 n 。请你先求出从 1 到 n 的每个整数 10 进制表示下的数位和（每一位上的数字相加），然后把数位和相等的数字放到同一个组中。

+ +

请你统计每个组中的数字数目，并返回数字数目并列最多的组有多少个。

+ +

 

+ +

示例 1：

+ +
输入：n = 13
+输出：4
+解释：总共有 9 个组，将 1 到 13 按数位求和后这些组分别是：
+[1,10]，[2,11]，[3,12]，[4,13]，[5]，[6]，[7]，[8]，[9]。总共有 4 个组拥有的数字并列最多。
+
+ +

示例 2：

+ +
输入：n = 2
+输出：2
+解释：总共有 2 个大小为 1 的组 [1]，[2]。
+
+ +

示例 3：

+ +
输入：n = 15
+输出：6
+
+ +

示例 4：

+ +
输入：n = 24
+输出：5
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 10^4
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/139_\345\215\225\350\257\215\346\213\206\345\210\206 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/139_\345\215\225\350\257\215\346\213\206\345\210\206 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0d47a45c79e17e265c81aabb0a181c968e3f9870 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/139_\345\215\225\350\257\215\346\213\206\345\210\206 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/139_\345\215\225\350\257\215\346\213\206\345\210\206 II/solution.cpp" @@ -0,0 +1,28 @@ +class Solution +{ +public: + vector wordBreak(string s, vector &wordDict) + { + unordered_map> m; + return helper(s, wordDict, m); + } + vector helper(string s, vector &wordDict, unordered_map> &m) + { + if (m.count(s)) + return m[s]; + if (s.empty()) + return {""}; + vector ans; + for (string word : wordDict) + { + if (word != s.substr(0, word.size())) + continue; + vector res = helper(s.substr(word.size()), wordDict, m); + for (string str : res) + { + ans.push_back(word + (str.empty() ? "" : " ") + str); + } + } + return m[s] = ans; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/140_\347\216\257\345\275\242\351\223\276\350\241\250/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/140_\347\216\257\345\275\242\351\223\276\350\241\250/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..f30ab3e408b4f62c9cd06dbe62b5b3f689989e68 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/140_\347\216\257\345\275\242\351\223\276\350\241\250/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/140_\347\216\257\345\275\242\351\223\276\350\241\250/solution.cpp" @@ -0,0 +1,27 @@ + +struct ListNode +{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +class Solution +{ +public: + bool hasCycle(ListNode *head) + { + ListNode *low = head; //慢指针 + ListNode *quick = head; //快指针 + while (low && quick && quick->next) + { + low = low->next; + quick = quick->next->next; + if (low == quick) + { + return true; + } + } + return false; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1412_\351\200\220\346\255\245\346\261\202\345\222\214\345\276\227\345\210\260\346\255\243\346\225\260\347\232\204\346\234\200\345\260\217\345\200\274/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1412_\351\200\220\346\255\245\346\261\202\345\222\214\345\276\227\345\210\260\346\255\243\346\225\260\347\232\204\346\234\200\345\260\217\345\200\274/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..3d508e3cf1dfb06dba86cc442c45ca86576484da --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1412_\351\200\220\346\255\245\346\261\202\345\222\214\345\276\227\345\210\260\346\255\243\346\225\260\347\232\204\346\234\200\345\260\217\345\200\274/desc.html" @@ -0,0 +1,46 @@ +

给你一个整数数组 nums 。你可以选定任意的 正数 startValue 作为初始值。

+ +

你需要从左到右遍历 nums 数组，并将 startValue 依次累加上 nums 数组中的值。

+ +

请你在确保累加和始终大于等于 1 的前提下，选出一个最小的 正数 作为 startValue 。

+ +

 

+ +

示例 1：

+ +
+输入：nums = [-3,2,-3,4,2]
+输出：5
+解释：如果你选择 startValue = 4，在第三次累加时，和小于 1 。
+                累加求和
+                startValue = 4 | startValue = 5 | nums
+                  (4 -3 ) = 1  | (5 -3 ) = 2    |  -3
+                  (1 +2 ) = 3  | (2 +2 ) = 4    |   2
+                  (3 -3 ) = 0  | (4 -3 ) = 1    |  -3
+                  (0 +4 ) = 4  | (1 +4 ) = 5    |   4
+                  (4 +2 ) = 6  | (5 +2 ) = 7    |   2
+
+ +

示例 2：

+ +
+输入：nums = [1,2]
+输出：1
+解释：最小的 startValue 需要是正数。
+
+ +

示例 3：

+ +
+输入：nums = [1,-2,-3]
+输出：5
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= nums.length <= 100
    • +
  • -100 <= nums[i] <= 100
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1413_\345\222\214\344\270\272 K \347\232\204\346\234\200\345\260\221\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\255\227\346\225\260\347\233\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1413_\345\222\214\344\270\272 K \347\232\204\346\234\200\345\260\221\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\255\227\346\225\260\347\233\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..c58874c610765e4b56e218748ac020f4da2fa4bf --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1413_\345\222\214\344\270\272 K \347\232\204\346\234\200\345\260\221\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\255\227\346\225\260\347\233\256/desc.html" @@ -0,0 +1,42 @@ +

给你数字 k ，请你返回和为 k 的斐波那契数字的最少数目，其中，每个斐波那契数字都可以被使用多次。

+ +

斐波那契数字定义为：

+ +
    +
  • F1 = 1
    • +
  • F2 = 1
    • +
  • Fn = Fn-1 + Fn-2 ， 其中 n > 2 。
    • +
+ +

数据保证对于给定的 k ，一定能找到可行解。

+ +

 

+ +

示例 1：

+ +
输入：k = 7
+输出：2 
+解释：斐波那契数字为：1，1，2，3，5，8，13，……
+对于 k = 7 ，我们可以得到 2 + 5 = 7 。
+ +

示例 2：

+ +
输入：k = 10
+输出：2 
+解释：对于 k = 10 ，我们可以得到 2 + 8 = 10 。
+
+ +

示例 3：

+ +
输入：k = 19
+输出：3 
+解释：对于 k = 19 ，我们可以得到 1 + 5 + 13 = 19 。
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= k <= 10^9
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1414_\351\225\277\345\272\246\344\270\272 n \347\232\204\345\274\200\345\277\203\345\255\227\347\254\246\344\270\262\344\270\255\345\255\227\345\205\270\345\272\217\347\254\254 k \345\260\217\347\232\204\345\255\227\347\254\246\344\270\262/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1414_\351\225\277\345\272\246\344\270\272 n \347\232\204\345\274\200\345\277\203\345\255\227\347\254\246\344\270\262\344\270\255\345\255\227\345\205\270\345\272\217\347\254\254 k \345\260\217\347\232\204\345\255\227\347\254\246\344\270\262/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..ff0fb9abaa46c58c8ab71d19f2439ddfa1e80845 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1414_\351\225\277\345\272\246\344\270\272 n \347\232\204\345\274\200\345\277\203\345\255\227\347\254\246\344\270\262\344\270\255\345\255\227\345\205\270\345\272\217\347\254\254 k \345\260\217\347\232\204\345\255\227\347\254\246\344\270\262/desc.html" @@ -0,0 +1,58 @@ +

一个 「开心字符串」定义为：

+ +
    +
  • 仅包含小写字母 ['a', 'b', 'c'].
    • +
  • 对所有在 1 到 s.length - 1 之间的 i ，满足 s[i] != s[i + 1] （字符串的下标从 1 开始）。
    • +
+ +

比方说，字符串 "abc"，"ac"，"b" 和 "abcbabcbcb" 都是开心字符串，但是 "aa"，"baa" 和 "ababbc" 都不是开心字符串。

+ +

给你两个整数 n 和 k ，你需要将长度为 n 的所有开心字符串按字典序排序。

+ +

请你返回排序后的第 k 个开心字符串，如果长度为 n 的开心字符串少于 k 个，那么请你返回 空字符串 。

+ +

 

+ +

示例 1：

+ +
输入：n = 1, k = 3
+输出："c"
+解释：列表 ["a", "b", "c"] 包含了所有长度为 1 的开心字符串。按照字典序排序后第三个字符串为 "c" 。
+
+ +

示例 2：

+ +
输入：n = 1, k = 4
+输出：""
+解释：长度为 1 的开心字符串只有 3 个。
+
+ +

示例 3：

+ +
输入：n = 3, k = 9
+输出："cab"
+解释：长度为 3 的开心字符串总共有 12 个 ["aba", "abc", "aca", "acb", "bab", "bac", "bca", "bcb", "cab", "cac", "cba", "cbc"] 。第 9 个字符串为 "cab"
+
+ +

示例 4：

+ +
输入：n = 2, k = 7
+输出：""
+
+ +

示例 5：

+ +
输入：n = 10, k = 100
+输出："abacbabacb"
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 10
    • +
  • 1 <= k <= 100
    • +
+ +

 

diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1415_\346\201\242\345\244\215\346\225\260\347\273\204/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1415_\346\201\242\345\244\215\346\225\260\347\273\204/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..dea6dffa6941c71854ad1418fb81e5735103eb8e --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1415_\346\201\242\345\244\215\346\225\260\347\273\204/desc.html" @@ -0,0 +1,53 @@ +

某个程序本来应该输出一个整数数组。但是这个程序忘记输出空格了以致输出了一个数字字符串，我们所知道的信息只有：数组中所有整数都在 [1, k] 之间，且数组中的数字都没有前导 0 。

+ +

给你字符串 s 和整数 k 。可能会有多种不同的数组恢复结果。

+ +

按照上述程序，请你返回所有可能输出字符串 s 的数组方案数。

+ +

由于数组方案数可能会很大，请你返回它对 10^9 + 7 取余 后的结果。

+ +

 

+ +

示例 1：

+ +
输入：s = "1000", k = 10000
+输出：1
+解释：唯一一种可能的数组方案是 [1000]
+
+ +

示例 2：

+ +
输入：s = "1000", k = 10
+输出：0
+解释：不存在任何数组方案满足所有整数都 >= 1 且 <= 10 同时输出结果为 s 。
+
+ +

示例 3：

+ +
输入：s = "1317", k = 2000
+输出：8
+解释：可行的数组方案为 [1317]，[131,7]，[13,17]，[1,317]，[13,1,7]，[1,31,7]，[1,3,17]，[1,3,1,7]
+
+ +

示例 4：

+ +
输入：s = "2020", k = 30
+输出：1
+解释：唯一可能的数组方案是 [20,20] 。 [2020] 不是可行的数组方案，原因是 2020 > 30 。 [2,020] 也不是可行的数组方案，因为 020 含有前导 0 。
+
+ +

示例 5：

+ +
输入：s = "1234567890", k = 90
+输出：34
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= s.length <= 10^5.
    • +
  • s 只包含数字且不包含前导 0 。
    • +
  • 1 <= k <= 10^9.
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/141_\347\216\257\345\275\242\351\223\276\350\241\250 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/141_\347\216\257\345\275\242\351\223\276\350\241\250 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..a0a7f1637570aa4675a66c06b613e9394183df87 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/141_\347\216\257\345\275\242\351\223\276\350\241\250 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/141_\347\216\257\345\275\242\351\223\276\350\241\250 II/solution.cpp" @@ -0,0 +1,38 @@ + +struct ListNode +{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +class Solution +{ +public: + ListNode *detectCycle(ListNode *head) + { + ListNode *slow = head; //记录慢指针 + ListNode *fast = head; //记录快指针 + ListNode *meet = NULL; //记录相遇点 + while (slow && fast && fast->next) + { //找出相遇点 + slow = slow->next; + fast = fast->next->next; + if (slow == fast) + { + meet = slow; + break; + } + } + while (head && meet) + { //根据相遇的的位置找出环的入口点 + if (meet == head) + { + break; + } + head = head->next; + meet = meet->next; + } + return meet; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/142_\351\207\215\346\216\222\351\223\276\350\241\250/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/142_\351\207\215\346\216\222\351\223\276\350\241\250/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..b1813f75d2b6bf3512b5c3955e5ad5666cf2bd92 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/142_\351\207\215\346\216\222\351\223\276\350\241\250/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/142_\351\207\215\346\216\222\351\223\276\350\241\250/solution.cpp" @@ -0,0 +1,38 @@ +struct ListNode +{ + int val; + ListNode *next; + ListNode() : val(0), next(nullptr) {} + ListNode(int x) : val(x), next(nullptr) {} + ListNode(int x, ListNode *next) : val(x), next(next) {} +}; + +//利用数组可以索引来做 +class Solution +{ +public: + void reorderList(ListNode *head) + { + if (head == nullptr || head->next == nullptr || head->next->next == nullptr) + return; + ListNode *cur = head; + vector vec; + while (cur) + { + // vec.push_back(cur); + vec.emplace_back(cur); + cur = cur->next; + } + int i = 0, j = vec.size() - 1; + while (i < j) + { + if (i == j) + break; + vec[i]->next = vec[j]; + vec[j]->next = vec[i + 1]; + i++; + j--; + } + vec[i]->next = nullptr; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/143_\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/143_\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..053a7b3b30c14ed433e656fd39c97984bac28305 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/143_\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/143_\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/solution.cpp" @@ -0,0 +1,37 @@ + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; +* / + class Solution +{ +public: + vector preorderTraversal(TreeNode *root) + { + //中前后 + //非递归：栈 + stack sta; + vector ans; + while (root != NULL || !sta.empty()) + { + + while (root != NULL) + { + ans.push_back(root->val); + sta.push(root); + root = root->left; + } + if (!sta.empty()) + { + root = sta.top(); + sta.pop(); + root = root->right; + } + } + return ans; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/144_\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/144_\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..2487efbbc7ab36754261d609f371c1ce90030ca2 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/144_\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/144_\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/solution.cpp" @@ -0,0 +1,43 @@ + + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + vector postorderTraversal(TreeNode *root) + { + vector ret; + if (root == NULL) + return ret; + TreeNode *p = root; + stack toTraversal; + TreeNode *last = root; + toTraversal.push(p); + while (!toTraversal.empty()) + { + p = toTraversal.top(); + if ((p->left == NULL && p->right == NULL) || (p->right == NULL && last == p->left) || (last == p->right)) + { + ret.push_back(p->val); + last = p; + toTraversal.pop(); + } + else + { + if (p->right) + toTraversal.push(p->right); + if (p->left) + toTraversal.push(p->left); + } + } + + return ret; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/145_LRU \347\274\223\345\255\230\346\234\272\345\210\266/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/145_LRU \347\274\223\345\255\230\346\234\272\345\210\266/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..b4a375907bba6014a15de7f6abb2c195eb8025e2 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/145_LRU \347\274\223\345\255\230\346\234\272\345\210\266/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/145_LRU \347\274\223\345\255\230\346\234\272\345\210\266/solution.cpp" @@ -0,0 +1,43 @@ +class LRUCache +{ +public: + LRUCache(int capacity) : cap(capacity) {} + + int get(int key) + { + if (m.count(key) != 0) + { + int val = m[key]->second; + l.erase(m[key]); + l.push_front({key, val}); //访问过的元素移动到头部 + m[key] = l.begin(); + return val; + } + return -1; + } + + void put(int key, int value) + { + if (m.count(key) != 0) + { //已经存在 + l.erase(m[key]); + l.push_front({key, value}); + m[key] = l.begin(); + } + else + { + if (l.size() == cap) + { //同步删除 + m.erase(l.back().first); + l.pop_back(); + } + l.push_front({key, value}); + m[key] = l.begin(); + } + } + +private: + int cap; + list> l; + unordered_map>::iterator> m; +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/146_\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/146_\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..acfa93b8391ea67cd3beaf3d62de2f4481d6c243 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/146_\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/146_\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/solution.cpp" @@ -0,0 +1,37 @@ + +struct ListNode +{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +class Solution +{ +public: + ListNode *insertionSortList(ListNode *head) + { + ListNode dummy(-1); + ListNode *prev = &dummy; + ListNode *curr = head; + while (curr) + { + ListNode *next = curr->next; + if (!prev->next || prev->next->val > curr->val) + { + prev = &dummy; + } + + while (prev->next && prev->next->val <= curr->val) + { + prev = prev->next; + } + + curr->next = prev->next; + prev->next = curr; + curr = next; + } + + return dummy.next; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/147_\346\216\222\345\272\217\351\223\276\350\241\250/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/147_\346\216\222\345\272\217\351\223\276\350\241\250/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..c970c7f85b89c1b9c330bd6f7160a9b84cf6e87b 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/147_\346\216\222\345\272\217\351\223\276\350\241\250/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/147_\346\216\222\345\272\217\351\223\276\350\241\250/solution.cpp" @@ -0,0 +1,50 @@ + +struct ListNode +{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +class Solution +{ +public: + ListNode *sortList(ListNode *head) + { + if (!head || !head->next) + return head; + ListNode *pre = head, *slow = head, *fast = head; + while (fast && fast->next) + { + pre = slow; + slow = slow->next; + fast = fast->next->next; + } + pre->next = NULL; + return merge(sortList(head), sortList(slow)); + } + ListNode *merge(ListNode *l1, ListNode *l2) + { + ListNode *dummy = new ListNode(-1); + ListNode *cur = dummy; + while (l1 && l2) + { + if (l1->val > l2->val) + { + cur->next = l2; + l2 = l2->next; + } + else + { + cur->next = l1; + l1 = l1->next; + } + cur = cur->next; + } + if (l1) + cur->next = l1; + if (l2) + cur->next = l2; + return dummy->next; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1482_\346\240\221\350\212\202\347\202\271\347\232\204\347\254\254 K \344\270\252\347\245\226\345\205\210/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1482_\346\240\221\350\212\202\347\202\271\347\232\204\347\254\254 K \344\270\252\347\245\226\345\205\210/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..8e393a24dedc056557dab249e047d1fcf9bf3bad --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1482_\346\240\221\350\212\202\347\202\271\347\232\204\347\254\254 K \344\270\252\347\245\226\345\205\210/desc.html" @@ -0,0 +1,38 @@ +

给你一棵树，树上有 n 个节点，按从 0 到 n-1 编号。树以父节点数组的形式给出，其中 parent[i] 是节点 i 的父节点。树的根节点是编号为 0 的节点。

+ +

请你设计并实现 getKthAncestor(int node, int k) 函数，函数返回节点 node 的第 k 个祖先节点。如果不存在这样的祖先节点，返回 -1 。

+ +

树节点的第 k 个祖先节点是从该节点到根节点路径上的第 k 个节点。

+ +

 

+ +

示例：

+ +

+ +
输入：
+["TreeAncestor","getKthAncestor","getKthAncestor","getKthAncestor"]
+[[7,[-1,0,0,1,1,2,2]],[3,1],[5,2],[6,3]]
+
+输出：
+[null,1,0,-1]
+
+解释：
+TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);
+
+treeAncestor.getKthAncestor(3, 1);  // 返回 1 ，它是 3 的父节点
+treeAncestor.getKthAncestor(5, 2);  // 返回 0 ，它是 5 的祖父节点
+treeAncestor.getKthAncestor(6, 3);  // 返回 -1 因为不存在满足要求的祖先节点
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= k <= n <= 5*10^4
    • +
  • parent[0] == -1 表示编号为 0 的节点是根节点。
    • +
  • 对于所有的 0 < i < n ，0 <= parent[i] < n 总成立
    • +
  • 0 <= node < n
    • +
  • 至多查询 5*10^4 次
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/148_\347\233\264\347\272\277\344\270\212\346\234\200\345\244\232\347\232\204\347\202\271\346\225\260/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/148_\347\233\264\347\272\277\344\270\212\346\234\200\345\244\232\347\232\204\347\202\271\346\225\260/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..9e29789d08f24b0889df1ea5654130c39b05559d 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/148_\347\233\264\347\272\277\344\270\212\346\234\200\345\244\232\347\232\204\347\202\271\346\225\260/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/148_\347\233\264\347\272\277\344\270\212\346\234\200\345\244\232\347\232\204\347\202\271\346\225\260/solution.cpp" @@ -0,0 +1,45 @@ + + +struct Point +{ + int x; + int y; + Point() : x(0), y(0) {} + Point(int a, int b) : x(a), y(b) {} +}; + +class Solution +{ +public: + int maxPoints(vector &points) + { + int ans = 0; + for (int i = 0; i < points.size(); ++i) + { + map, int> m; + int p = 1; + for (int j = i + 1; j < points.size(); ++j) + { + if (points[i].x == points[j].x && (points[i].y == points[j].y)) + { + ++p; + continue; + } + int dx = points[j].x - points[i].x; + int dy = points[j].y - points[i].y; + int d = gcd(dx, dy); + ++m[{dx / d, dy / d}]; + } + ans = max(ans, p); + for (auto it = m.begin(); it != m.end(); ++it) + { + ans = max(ans, it->second + p); + } + } + return ans; + } + int gcd(int a, int b) + { + return (b == 0) ? a : gcd(b, a % b); + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/149_\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/149_\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..84aa598d0e5044247304507c9b16be961065c396 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/149_\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/149_\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/solution.cpp" @@ -0,0 +1,45 @@ +int evalRPN(vector &tokens) +{ + stack sp; + int n = tokens.size(); + for (int i = 0; i < n; i++) + { + if (tokens[i] == "+") + { + int x = sp.top(); + sp.pop(); + int y = sp.top(); + sp.pop(); + sp.push(x + y); + } + else if (tokens[i] == "-") + { + int x = sp.top(); + sp.pop(); + int y = sp.top(); + sp.pop(); + sp.push(y - x); + } + else if (tokens[i] == "*") + { + int x = sp.top(); + sp.pop(); + int y = sp.top(); + sp.pop(); + sp.push(x * y); + } + else if (tokens[i] == "/") + { + int x = sp.top(); + sp.pop(); + int y = sp.top(); + sp.pop(); + sp.push(y / x); + } + else + { + sp.push(stoi(tokens[i])); + } + } + return sp.top(); +} diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/150_\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/150_\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..5b0817e9123298d4e76c57877c458e0a9a0d7e9b 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/150_\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/150_\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/solution.cpp" @@ -0,0 +1,35 @@ +class Solution +{ +public: + void reverseWords(string &s) + { + if (s.empty()) + return; + vector words; + auto p1 = s.begin(), p2 = s.begin(), p3 = s.end(); + while (p2 != p3) + { + while (' ' == *p1 && p1 != p3) + { + ++p1; + } + p2 = p1; + while (' ' != *p2 && p2 != p3) + ++p2; + if (p1 != p3) + words.push_back(string(p1, p2)); + p1 = p2; + } + reverse(words.begin(), words.end()); + s.clear(); + for (int i = 0; i < words.size(); ++i) + { + if (1 == words.size()) + s = words[i]; + else if (i == words.size() - 1) + s += words[i]; + else + s += words[i] + ' '; + } + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/151_\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\204/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/151_\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\204/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..ce1d1df62b957fd61450ec5e017c5a81ac5b7cab 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/151_\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\204/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/151_\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\346\225\260\347\273\204/solution.cpp" @@ -0,0 +1,17 @@ +class Solution +{ +public: + int maxProduct(vector &nums) + { + int n = nums.size(), res = nums[0]; + vector f(n + 1, 0), g(n + 1, 0); + f[0] = nums[0], g[0] = nums[0]; // 初始化 + for (int i = 1; i < n; i++) + { + f[i] = max(nums[i], max(f[i - 1] * nums[i], g[i - 1] * nums[i])); //乘积最大值 + g[i] = min(nums[i], min(g[i - 1] * nums[i], f[i - 1] * nums[i])); //乘积最小值 + res = max(res, f[i]); + } + return res; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/152_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/152_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..c28a53a4c398395b8cd0b7c1110a7db0f809c3ae 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/152_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/152_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/solution.cpp" @@ -0,0 +1,22 @@ +class Solution +{ +public: + int findMin(vector &nums) + { + int ans, n = nums.size(); + int l = 0, r = n - 1; + if (nums[l] > nums[r]) + { + while (l != (r - 1)) + { + int mid = (l + r) / 2; + if (nums[mid] > nums[l]) + l = mid; + else + r = mid; + } + return min(nums[l], nums[r]); + } + return nums[0]; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/153_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/153_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..89f5c944940173e189c31ba418b98c237b8e417e 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/153_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/153_\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274 II/solution.cpp" @@ -0,0 +1,36 @@ +class Solution +{ +public: + int findMin(vector &nums) + { + int size = nums.size(); + if (size == 1) + return nums[0]; + if (nums[0] < nums[size - 1]) + return nums[0]; + data = nums; + return find(0, size - 1); + } + int find(int first, int second) + { //闭区间 + if (first == second) + return data[second]; + if (first + 1 == second) + return data[second]; + int min = data[second]; + int mid = data[(first + second) / 2]; + if (mid == min) + { + int sgn1 = find((first + second) / 2, second); + int sgn2 = find(first, (first + second) / 2); + return (sgn1 < sgn2 ? sgn1 : sgn2); + } + if (mid > min) + return find((first + second) / 2, second); + if (mid < min) + return find(first, (first + second) / 2); + } + +private: + vector data; +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/154_\346\234\200\345\260\217\346\240\210/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/154_\346\234\200\345\260\217\346\240\210/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..7370bcee21e1418ee071ae9653910d0e21caea2c 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/154_\346\234\200\345\260\217\346\240\210/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/154_\346\234\200\345\260\217\346\240\210/solution.cpp" @@ -0,0 +1,29 @@ +class MinStack +{ +private: + stack s1; + stack s2; + +public: + void push(int x) + { + s1.push(x); + if (s2.empty() || x <= getMin()) + s2.push(x); + } + void pop() + { + //在这里判断一下就是s2最小栈 二个栈中栈顶元素相同最小栈中的元素才会出栈; + if (s1.top() == getMin()) + s2.pop(); + s1.pop(); + } + int top() + { + return s1.top(); + } + int getMin() + { + return s2.top(); + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/155_\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/155_\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..7d9286bba8df0c3f32f7a06755f520a7feb108c8 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/155_\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/155_\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/solution.cpp" @@ -0,0 +1,26 @@ + +struct TreeNode +{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution +{ +public: + TreeNode *upsideDownBinaryTree(TreeNode *root) + { + if (!root || !root->left) + return root; + TreeNode *l = root->left; //左右子节点存取来 + TreeNode *r = root->right; + root->left = NULL; //上下断开 + root->right = NULL; + TreeNode *p = upsideDownBinaryTree(l); //根节点 + l->left = r; //跟上面连接起来 + l->right = root; + return p; + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/156_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/156_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..6872f4dc8d7993949405cf787a033f2bb2939749 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/156_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/156_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246/solution.cpp" @@ -0,0 +1,27 @@ +// Forward declaration of the read4 API. +int read4(char *buf); + +class Solution +{ +public: + /** + * @param buf Destination buffer + * @param n Number of characters to read + * @return The number of actual characters read + */ + int read(char *buf, int n) + { + int total = 0; + while (1) + { + int ret = read4(buf + total); + total += ret; + if (ret < 4 || total >= n) + break; + } + if (total > n) + total = n; + buf[total] = '\0'; + return total; + } +}; \ No newline at end of file diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/157_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246 II/solution.cpp" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/157_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246 II/solution.cpp" index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..10dc11d98cfa1bbda7ef3c3da376cd9018abefcf 100644 --- "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/157_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246 II/solution.cpp" +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/157_\347\224\250 Read4 \350\257\273\345\217\226 N \344\270\252\345\255\227\347\254\246 II/solution.cpp" @@ -0,0 +1,41 @@ + +int read4(char *buf); + +class Solution +{ + queue q; //一次读取4个，可能多了，存储起来 +public: + /** + * @param buf Destination buffer + * @param n Number of characters to read + * @return The number of actual characters read + */ + int read(char *buf, int n) + { + if (!buf || n <= 0) + return 0; + int len = 0, total = 0; + int offset = 0; + while (!q.empty()) //临时存储区还有先用掉 + { + buf[offset++] = q.front(); + q.pop(); + total++; + if (offset == n) //个数到了 + return n; + } + do + { + len = read4(buf + offset); //读取了len个有效字符，写入offset位置 + total += len; + offset += len; + } while (len == 4 && len < n); + + if (total > n) + { //读取多了，存到临时存储区 + for (int i = n; i < total; i++) + q.push(buf[i]); + } + return min(n, total); + } +}; diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1704_\345\220\203\350\213\271\346\236\234\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1704_\345\220\203\350\213\271\346\236\234\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..c5e7cc737a9016e741b42bddb361aa3bf492174b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1704_\345\220\203\350\213\271\346\236\234\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256/desc.html" @@ -0,0 +1,40 @@ +

有一棵特殊的苹果树，一连 n 天，每天都可以长出若干个苹果。在第 i 天，树上会长出 apples[i] 个苹果，这些苹果将会在 days[i] 天后（也就是说，第 i + days[i] 天时）腐烂，变得无法食用。也可能有那么几天，树上不会长出新的苹果，此时用 apples[i] == 0 且 days[i] == 0 表示。

+ +

你打算每天 最多 吃一个苹果来保证营养均衡。注意，你可以在这 n 天之后继续吃苹果。

+ +

给你两个长度为 n 的整数数组 days 和 apples ，返回你可以吃掉的苹果的最大数目。

+ +

 

+ +

示例 1：

+ +
输入：apples = [1,2,3,5,2], days = [3,2,1,4,2]
+输出：7
+解释：你可以吃掉 7 个苹果：
+- 第一天，你吃掉第一天长出来的苹果。
+- 第二天，你吃掉一个第二天长出来的苹果。
+- 第三天，你吃掉一个第二天长出来的苹果。过了这一天，第三天长出来的苹果就已经腐烂了。
+- 第四天到第七天，你吃的都是第四天长出来的苹果。
+
+ +

示例 2：

+ +
输入：apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]
+输出：5
+解释：你可以吃掉 5 个苹果：
+- 第一天到第三天，你吃的都是第一天长出来的苹果。
+- 第四天和第五天不吃苹果。
+- 第六天和第七天，你吃的都是第六天长出来的苹果。
+
+ +

 

+ +

提示：

+ +
    +
  • apples.length == n
    • +
  • days.length == n
    • +
  • 1 <= n <= 2 * 104
    • +
  • 0 <= apples[i], days[i] <= 2 * 104
    • +
  • 只有在 apples[i] = 0 时，days[i] = 0 才成立
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1709_\345\215\241\350\275\246\344\270\212\347\232\204\346\234\200\345\244\247\345\215\225\345\205\203\346\225\260/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1709_\345\215\241\350\275\246\344\270\212\347\232\204\346\234\200\345\244\247\345\215\225\345\205\203\346\225\260/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..98117b5fe4e7ab877199ff91cad53d48fa6db66c --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1709_\345\215\241\350\275\246\344\270\212\347\232\204\346\234\200\345\244\247\345\215\225\345\205\203\346\225\260/desc.html" @@ -0,0 +1,41 @@ +

请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi] ：

+ +
    +
  • numberOfBoxesi 是类型 i 的箱子的数量。
    • +
  • numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。
    • +
+ +

整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。

+ +

返回卡车可以装载 单元 的 最大 总数。

+ +

 

+ +

示例 1：

+ +
+输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
+输出：8
+解释：箱子的情况如下：
+- 1 个第一类的箱子，里面含 3 个单元。
+- 2 个第二类的箱子，每个里面含 2 个单元。
+- 3 个第三类的箱子，每个里面含 1 个单元。
+可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
+单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8
+ +

示例 2：

+ +
+输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
+输出：91
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= boxTypes.length <= 1000
    • +
  • 1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000
    • +
  • 1 <= truckSize <= 106
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1712_\345\276\227\345\210\260\345\255\220\345\272\217\345\210\227\347\232\204\346\234\200\345\260\221\346\223\215\344\275\234\346\254\241\346\225\260/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1712_\345\276\227\345\210\260\345\255\220\345\272\217\345\210\227\347\232\204\346\234\200\345\260\221\346\223\215\344\275\234\346\254\241\346\225\260/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..96998259066ad3142cc50994d5091b1bad300295 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1712_\345\276\227\345\210\260\345\255\220\345\272\217\345\210\227\347\232\204\346\234\200\345\260\221\346\223\215\344\275\234\346\254\241\346\225\260/desc.html" @@ -0,0 +1,32 @@ +

给你一个数组 target ，包含若干 互不相同 的整数，以及另一个整数数组 arr ，arr 可能 包含重复元素。

+ +

每一次操作中，你可以在 arr 的任意位置插入任一整数。比方说，如果 arr = [1,4,1,2] ，那么你可以在中间添加 3 得到 [1,4,3,1,2] 。你可以在数组最开始或最后面添加整数。

+ +

请你返回 最少 操作次数，使得 target 成为 arr 的一个子序列。

+ +

一个数组的 子序列 指的是删除原数组的某些元素（可能一个元素都不删除），同时不改变其余元素的相对顺序得到的数组。比方说，[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列（加粗元素），但 [2,4,2] 不是子序列。

+ +

 

+ +

示例 1：

+ +
输入：target = [5,1,3], arr = [9,4,2,3,4]
+输出：2
+解释：你可以添加 5 和 1 ，使得 arr 变为 [5,9,4,1,2,3,4] ，target 为 arr 的子序列。
+
+ +

示例 2：

+ +
输入：target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]
+输出：3
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= target.length, arr.length <= 105
    • +
  • 1 <= target[i], arr[i] <= 109
    • +
  • target 不包含任何重复元素。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1719_\350\247\243\347\240\201\345\274\202\346\210\226\345\220\216\347\232\204\346\225\260\347\273\204/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1719_\350\247\243\347\240\201\345\274\202\346\210\226\345\220\216\347\232\204\346\225\260\347\273\204/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..65ac6b5b7dd9b8ef9d92db07e8d512caf50df477 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1719_\350\247\243\347\240\201\345\274\202\346\210\226\345\220\216\347\232\204\346\225\260\347\273\204/desc.html" @@ -0,0 +1,35 @@ +

未知 整数数组 arr 由 n 个非负整数组成。

+ +

经编码后变为长度为 n - 1 的另一个整数数组 encoded ，其中 encoded[i] = arr[i] XOR arr[i + 1] 。例如，arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。

+ +

给你编码后的数组 encoded 和原数组 arr 的第一个元素 first（arr[0]）。

+ +

请解码返回原数组 arr 。可以证明答案存在并且是唯一的。

+ +

 

+ +

示例 1：

+ +
+输入：encoded = [1,2,3], first = 1
+输出：[1,0,2,1]
+解释：若 arr = [1,0,2,1] ，那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]
+
+ +

示例 2：

+ +
+输入：encoded = [6,2,7,3], first = 4
+输出：[4,2,0,7,4]
+
+ +

 

+ +

提示：

+ +
    +
  • 2 <= n <= 104
    • +
  • encoded.length == n - 1
    • +
  • 0 <= encoded[i] <= 105
    • +
  • 0 <= first <= 105
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1721_\346\211\247\350\241\214\344\272\244\346\215\242\346\223\215\344\275\234\345\220\216\347\232\204\346\234\200\345\260\217\346\261\211\346\230\216\350\267\235\347\246\273/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1721_\346\211\247\350\241\214\344\272\244\346\215\242\346\223\215\344\275\234\345\220\216\347\232\204\346\234\200\345\260\217\346\261\211\346\230\216\350\267\235\347\246\273/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..36d1892687449824657be4ffe8257ea2282b925c --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1721_\346\211\247\350\241\214\344\272\244\346\215\242\346\223\215\344\275\234\345\220\216\347\232\204\346\234\200\345\260\217\346\261\211\346\230\216\350\267\235\347\246\273/desc.html" @@ -0,0 +1,44 @@ +

给你两个整数数组 source 和 target ，长度都是 n 。还有一个数组 allowedSwaps ，其中每个 allowedSwaps[i] = [ai, bi] 表示你可以交换数组 source 中下标为 ai 和 bi（下标从 0 开始）的两个元素。注意，你可以按 任意 顺序 多次 交换一对特定下标指向的元素。

+ +

相同长度的两个数组 source 和 target 间的 汉明距离 是元素不同的下标数量。形式上，其值等于满足 source[i] != target[i] （下标从 0 开始）的下标 i（0 <= i <= n-1）的数量。

+ +

在对数组 source 执行 任意 数量的交换操作后，返回 source 和 target 间的 最小汉明距离 。

+ +

 

+ +

示例 1：

+ +
输入：source = [1,2,3,4], target = [2,1,4,5], allowedSwaps = [[0,1],[2,3]]
+输出：1
+解释：source 可以按下述方式转换：
+- 交换下标 0 和 1 指向的元素：source = [2,1,3,4]
+- 交换下标 2 和 3 指向的元素：source = [2,1,4,3]
+source 和 target 间的汉明距离是 1 ，二者有 1 处元素不同，在下标 3 。
+
+ +

示例 2：

+ +
输入：source = [1,2,3,4], target = [1,3,2,4], allowedSwaps = []
+输出：2
+解释：不能对 source 执行交换操作。
+source 和 target 间的汉明距离是 2 ，二者有 2 处元素不同，在下标 1 和下标 2 。
+ +

示例 3：

+ +
输入：source = [5,1,2,4,3], target = [1,5,4,2,3], allowedSwaps = [[0,4],[4,2],[1,3],[1,4]]
+输出：0
+
+ +

 

+ +

提示：

+ +
    +
  • n == source.length == target.length
    • +
  • 1 <= n <= 105
    • +
  • 1 <= source[i], target[i] <= 105
    • +
  • 0 <= allowedSwaps.length <= 105
    • +
  • allowedSwaps[i].length == 2
    • +
  • 0 <= ai, bi <= n - 1
    • +
  • ai != bi
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1722_\345\256\214\346\210\220\346\211\200\346\234\211\345\267\245\344\275\234\347\232\204\346\234\200\347\237\255\346\227\266\351\227\264/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1722_\345\256\214\346\210\220\346\211\200\346\234\211\345\267\245\344\275\234\347\232\204\346\234\200\347\237\255\346\227\266\351\227\264/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..3604923f32bb4e74a6207a10ab9d002dc006828b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1722_\345\256\214\346\210\220\346\211\200\346\234\211\345\267\245\344\275\234\347\232\204\346\234\200\347\237\255\346\227\266\351\227\264/desc.html" @@ -0,0 +1,34 @@ +

给你一个整数数组 jobs ，其中 jobs[i] 是完成第 i 项工作要花费的时间。

+ +

请你将这些工作分配给 k 位工人。所有工作都应该分配给工人，且每项工作只能分配给一位工人。工人的 工作时间 是完成分配给他们的所有工作花费时间的总和。请你设计一套最佳的工作分配方案，使工人的 最大工作时间 得以 最小化 。

+ +

返回分配方案中尽可能 最小 的 最大工作时间 。

+ +

 

+ +

示例 1：

+ +
+输入：jobs = [3,2,3], k = 3
+输出：3
+解释：给每位工人分配一项工作，最大工作时间是 3 。
+
+ +

示例 2：

+ +
+输入：jobs = [1,2,4,7,8], k = 2
+输出：11
+解释：按下述方式分配工作：
+1 号工人：1、2、8（工作时间 = 1 + 2 + 8 = 11）
+2 号工人：4、7（工作时间 = 4 + 7 = 11）
+最大工作时间是 11 。
+ +

 

+ +

提示：

+ +
    +
  • 1 <= k <= jobs.length <= 12
    • +
  • 1 <= jobs[i] <= 107
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1731_\346\211\276\345\210\260\346\234\200\351\253\230\346\265\267\346\213\224/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1731_\346\211\276\345\210\260\346\234\200\351\253\230\346\265\267\346\213\224/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..8113fe1c93a2e2fc2a7a2c3c6310228333cba1ed --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1731_\346\211\276\345\210\260\346\234\200\351\253\230\346\265\267\346\213\224/desc.html" @@ -0,0 +1,31 @@ +

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

+ +

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

+ +

 

+ +

示例 1：

+ +
+输入：gain = [-5,1,5,0,-7]
+输出：1
+解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
+
+ +

示例 2：

+ +
+输入：gain = [-4,-3,-2,-1,4,3,2]
+输出：0
+解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。
+
+ +

 

+ +

提示：

+ +
    +
  • n == gain.length
    • +
  • 1 <= n <= 100
    • +
  • -100 <= gain[i] <= 100
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1732_\351\234\200\350\246\201\346\225\231\350\257\255\350\250\200\347\232\204\346\234\200\345\260\221\344\272\272\346\225\260/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1732_\351\234\200\350\246\201\346\225\231\350\257\255\350\250\200\347\232\204\346\234\200\345\260\221\344\272\272\346\225\260/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..fe198a5f1a38b0d033020350d6d6c3fc478401a2 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1732_\351\234\200\350\246\201\346\225\231\350\257\255\350\250\200\347\232\204\346\234\200\345\260\221\344\272\272\346\225\260/desc.html" @@ -0,0 +1,46 @@ +

在一个由 m 个用户组成的社交网络里，我们获取到一些用户之间的好友关系。两个用户之间可以相互沟通的条件是他们都掌握同一门语言。

+ +

给你一个整数 n ，数组 languages 和数组 friendships ，它们的含义如下：

+ +
    +
  • 总共有 n 种语言，编号从 1 到 n 。
    • +
  • languages[i] 是第 i 位用户掌握的语言集合。
    • +
  • friendships[i] = [u​​​​​​i​​​, v​​​​​​i] 表示 u​​​​​​​​​​​i​​​​​ 和 vi 为好友关系。
    • +
+ +

你可以选择 一门 语言并教会一些用户，使得所有好友之间都可以相互沟通。请返回你 最少 需要教会多少名用户。

+请注意，好友关系没有传递性，也就是说如果 x 和 y 是好友，且 y 和 z 是好友， x 和 z 不一定是好友。 + +

 

+ +

示例 1：

+ +
+输入：n = 2, languages = [[1],[2],[1,2]], friendships = [[1,2],[1,3],[2,3]]
+输出：1
+解释：你可以选择教用户 1 第二门语言，也可以选择教用户 2 第一门语言。
+
+ +

示例 2：

+ +
+输入：n = 3, languages = [[2],[1,3],[1,2],[3]], friendships = [[1,4],[1,2],[3,4],[2,3]]
+输出：2
+解释：教用户 1 和用户 3 第三门语言，需要教 2 名用户。
+
+ +

 

+ +

提示：

+ +
    +
  • 2 <= n <= 500
    • +
  • languages.length == m
    • +
  • 1 <= m <= 500
    • +
  • 1 <= languages[i].length <= n
    • +
  • 1 <= languages[i][j] <= n
    • +
  • 1 <= u​​​​​​i < v​​​​​​i <= languages.length
    • +
  • 1 <= friendships.length <= 500
    • +
  • 所有的好友关系 (u​​​​​i, v​​​​​​i) 都是唯一的。
    • +
  • languages[i] 中包含的值互不相同。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1733_\350\247\243\347\240\201\345\274\202\346\210\226\345\220\216\347\232\204\346\216\222\345\210\227/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1733_\350\247\243\347\240\201\345\274\202\346\210\226\345\220\216\347\232\204\346\216\222\345\210\227/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..03bad48604777cfd75e62d4bc590b4331c1c1040 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1733_\350\247\243\347\240\201\345\274\202\346\210\226\345\220\216\347\232\204\346\216\222\345\210\227/desc.html" @@ -0,0 +1,30 @@ +

给你一个整数数组 perm ，它是前 n 个正整数的排列，且 n 是个 奇数 。

+ +

它被加密成另一个长度为 n - 1 的整数数组 encoded ，满足 encoded[i] = perm[i] XOR perm[i + 1] 。比方说，如果 perm = [1,3,2] ，那么 encoded = [2,1] 。

+ +

给你 encoded 数组，请你返回原始数组 perm 。题目保证答案存在且唯一。

+ +

 

+ +

示例 1：

+ +
输入：encoded = [3,1]
+输出：[1,2,3]
+解释：如果 perm = [1,2,3] ，那么 encoded = [1 XOR 2,2 XOR 3] = [3,1]
+
+ +

示例 2：

+ +
输入：encoded = [6,5,4,6]
+输出：[2,4,1,5,3]
+
+ +

 

+ +

提示：

+ +
    +
  • 3 <= n < 105
    • +
  • n 是奇数。
    • +
  • encoded.length == n - 1
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1818_\345\272\217\345\210\227\344\270\255\344\270\215\345\220\214\346\234\200\345\244\247\345\205\254\347\272\246\346\225\260\347\232\204\346\225\260\347\233\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1818_\345\272\217\345\210\227\344\270\255\344\270\215\345\220\214\346\234\200\345\244\247\345\205\254\347\272\246\346\225\260\347\232\204\346\225\260\347\233\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..dde1ce5358a74e86823ec67e5e1693c772ddfb06 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1818_\345\272\217\345\210\227\344\270\255\344\270\215\345\220\214\346\234\200\345\244\247\345\205\254\347\272\246\346\225\260\347\232\204\346\225\260\347\233\256/desc.html" @@ -0,0 +1,42 @@ +

给你一个由正整数组成的数组 nums 。

+ +

数字序列的 最大公约数 定义为序列中所有整数的共有约数中的最大整数。

+ +
    +
  • 例如，序列 [4,6,16] 的最大公约数是 2 。
    • +
+ +

数组的一个 子序列 本质是一个序列，可以通过删除数组中的某些元素（或者不删除）得到。

+ +
    +
  • 例如，[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
    • +
+ +

计算并返回 nums 的所有 非空 子序列中 不同 最大公约数的 数目 。

+ +

 

+ +

示例 1：

+ +
+输入：nums = [6,10,3]
+输出：5
+解释：上图显示了所有的非空子序列与各自的最大公约数。
+不同的最大公约数为 6 、10 、3 、2 和 1 。
+
+ +

示例 2：

+ +
+输入：nums = [5,15,40,5,6]
+输出：7
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= nums.length <= 105
    • +
  • 1 <= nums[i] <= 2 * 105
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1900_\346\211\276\345\207\272\351\241\266\345\263\260\345\205\203\347\264\240 II/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1900_\346\211\276\345\207\272\351\241\266\345\263\260\345\205\203\347\264\240 II/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..ea45ac9dfb0c4facc41cd967cffa669520a75415 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1900_\346\211\276\345\207\272\351\241\266\345\263\260\345\205\203\347\264\240 II/desc.html" @@ -0,0 +1,43 @@ +

一个 2D 网格中的 顶峰元素 是指那些 严格大于 其相邻格子(上、下、左、右)的元素。

+ +

给你一个 从 0 开始编号 的 m x n 矩阵 mat ，其中任意两个相邻格子的值都 不相同 。找出 任意一个 顶峰元素 mat[i][j] 并 返回其位置 [i,j] 。

+ +

你可以假设整个矩阵周边环绕着一圈值为 -1 的格子。

+ +

要求必须写出时间复杂度为 O(m log(n)) 或 O(n log(m)) 的算法

+ +

 

+ +

 

+ +

示例 1:

+ +

+ +
+输入: mat = [[1,4],[3,2]]
+输出: [0,1]
+解释: 3和4都是顶峰元素，所以[1,0]和[0,1]都是可接受的答案。
+
+ +

示例 2:

+ +

+ +
+输入: mat = [[10,20,15],[21,30,14],[7,16,32]]
+输出: [1,1]
+解释: 30和32都是顶峰元素，所以[1,1]和[2,2]都是可接受的答案。
+
+ +

 

+ +

提示：

+ +
    +
  • m == mat.length
    • +
  • n == mat[i].length
    • +
  • 1 <= m, n <= 500
    • +
  • 1 <= mat[i][j] <= 105
    • +
  • 任意两个相邻元素均不相等.
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1913_\345\276\252\347\216\257\350\275\256\350\275\254\347\237\251\351\230\265/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1913_\345\276\252\347\216\257\350\275\256\350\275\254\347\237\251\351\230\265/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..d82b6227d32f5bf062976e7e6d4a9b091a6e154b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1913_\345\276\252\347\216\257\350\275\256\350\275\254\347\237\251\351\230\265/desc.html" @@ -0,0 +1,38 @@ +

给你一个大小为 m x n 的整数矩阵 grid​​​ ，其中 m 和 n 都是 偶数 ；另给你一个整数 k 。

+ +

矩阵由若干层组成，如下图所示，每种颜色代表一层：

+ +

+ +

矩阵的循环轮转是通过分别循环轮转矩阵中的每一层完成的。在对某一层进行一次循环旋转操作时，层中的每一个元素将会取代其 逆时针 方向的相邻元素。轮转示例如下：

+ +

返回执行 k 次循环轮转操作后的矩阵。

+ +

 

+ +

示例 1：

+ +
输入：grid = [[40,10],[30,20]], k = 1
+输出：[[10,20],[40,30]]
+解释：上图展示了矩阵在执行循环轮转操作时每一步的状态。
+ +

示例 2：

+ + +
输入：grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], k = 2
+输出：[[3,4,8,12],[2,11,10,16],[1,7,6,15],[5,9,13,14]]
+解释：上图展示了矩阵在执行循环轮转操作时每一步的状态。
+
+ +

 

+ +

提示：

+ +
    +
  • m == grid.length
    • +
  • n == grid[i].length
    • +
  • 2 <= m, n <= 50
    • +
  • m 和 n 都是 偶数
    • +
  • 1 <= grid[i][j] <= 5000
    • +
  • 1 <= k <= 109
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1914_\346\234\200\347\276\216\345\255\220\345\255\227\347\254\246\344\270\262\347\232\204\346\225\260\347\233\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1914_\346\234\200\347\276\216\345\255\220\345\255\227\347\254\246\344\270\262\347\232\204\346\225\260\347\233\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..7c7f72a884df71273f718eaf2723c474a2c5cb22 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1914_\346\234\200\347\276\216\345\255\220\345\255\227\347\254\246\344\270\262\347\232\204\346\225\260\347\233\256/desc.html" @@ -0,0 +1,59 @@ +

如果某个字符串中 至多一个 字母出现 奇数 次，则称其为 最美 字符串。

+ +
    +
  • 例如，"ccjjc" 和 "abab" 都是最美字符串，但 "ab" 不是。
    • +
+ +

给你一个字符串 word ，该字符串由前十个小写英文字母组成（'a' 到 'j'）。请你返回 word 中 最美非空子字符串 的数目。如果同样的子字符串在 word 中出现多次，那么应当对 每次出现 分别计数。

+ +

子字符串 是字符串中的一个连续字符序列。

+ +

 

+ +

示例 1：

+ +
+输入：word = "aba"
+输出：4
+解释：4 个最美子字符串如下所示：
+- "aba" -> "a"
+- "aba" -> "b"
+- "aba" -> "a"
+- "aba" -> "aba"
+
+ +

示例 2：

+ +
+输入：word = "aabb"
+输出：9
+解释：9 个最美子字符串如下所示：
+- "aabb" -> "a"
+- "aabb" -> "aa"
+- "aabb" -> "aab"
+- "aabb" -> "aabb"
+- "aabb" -> "a"
+- "aabb" -> "abb"
+- "aabb" -> "b"
+- "aabb" -> "bb"
+- "aabb" -> "b"
+
+ +

示例 3：

+ +
+输入：word = "he"
+输出：2
+解释：2 个最美子字符串如下所示：
+- "he" -> "h"
+- "he" -> "e"
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= word.length <= 105
    • +
  • word 由从 'a' 到 'j' 的小写英文字母组成
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1922_\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\350\267\257\345\276\204/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1922_\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\350\267\257\345\276\204/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..c25c675278d7fe8d72ffaaa55199907a8c6dfa9e --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1922_\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\350\267\257\345\276\204/desc.html" @@ -0,0 +1,48 @@ +

一个国家由 n 个编号为 0 到 n - 1 的城市组成。在这个国家里，每两个 城市之间都有一条道路连接。

+ +

总共有 m 个编号为 0 到 m - 1 的朋友想在这个国家旅游。他们每一个人的路径都会包含一些城市。每条路径都由一个整数数组表示，每个整数数组表示一个朋友按顺序访问过的城市序列。同一个城市在一条路径中可能 重复 出现，但同一个城市在一条路径中不会连续出现。

+ +

给你一个整数 n 和二维数组 paths ，其中 paths[i] 是一个整数数组，表示第 i 个朋友走过的路径，请你返回 每一个 朋友都走过的 最长公共子路径 的长度，如果不存在公共子路径，请你返回 0 。

+ +

一个 子路径 指的是一条路径中连续的城市序列。

+ +

 

+ +

示例 1：

+ +
+输入：n = 5, paths = [[0,1,2,3,4],
+                     [2,3,4],
+                     [4,0,1,2,3]]
+输出：2
+解释：最长公共子路径为 [2,3] 。
+
+ +

示例 2：

+ +
+输入：n = 3, paths = [[0],[1],[2]]
+输出：0
+解释：三条路径没有公共子路径。
+
+ +

示例 3：

+ +
+输入：n = 5, paths = [[0,1,2,3,4],
+                     [4,3,2,1,0]]
+输出：1
+解释：最长公共子路径为 [0]，[1]，[2]，[3] 和 [4] 。它们长度都为 1 。
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 105
    • +
  • m == paths.length
    • +
  • 2 <= m <= 105
    • +
  • sum(paths[i].length) <= 105
    • +
  • 0 <= paths[i][j] < n
    • +
  • paths[i] 中同一个城市不会连续重复出现。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1925_\350\277\267\345\256\253\344\270\255\347\246\273\345\205\245\345\217\243\346\234\200\350\277\221\347\232\204\345\207\272\345\217\243/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1925_\350\277\267\345\256\253\344\270\255\347\246\273\345\205\245\345\217\243\346\234\200\350\277\221\347\232\204\345\207\272\345\217\243/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..22b5d66b33346e7233ad2c358c3a5387a8225dee --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1925_\350\277\267\345\256\253\344\270\255\347\246\273\345\205\245\345\217\243\346\234\200\350\277\221\347\232\204\345\207\272\345\217\243/desc.html" @@ -0,0 +1,52 @@ +

给你一个 m x n 的迷宫矩阵 maze （下标从 0 开始），矩阵中有空格子（用 '.' 表示）和墙（用 '+' 表示）。同时给你迷宫的入口 entrance ，用 entrance = [entrancerow, entrancecol] 表示你一开始所在格子的行和列。

+ +

每一步操作，你可以往 上，下，左 或者 右 移动一个格子。你不能进入墙所在的格子，你也不能离开迷宫。你的目标是找到离 entrance 最近 的出口。出口 的含义是 maze 边界 上的 空格子。entrance 格子 不算 出口。

+ +

请你返回从 entrance 到最近出口的最短路径的 步数 ，如果不存在这样的路径，请你返回 -1 。

+ +

 

+ +

示例 1：

+ +
输入：maze = [["+","+",".","+"],[".",".",".","+"],["+","+","+","."]], entrance = [1,2]
+输出：1
+解释：总共有 3 个出口，分别位于 (1,0)，(0,2) 和 (2,3) 。
+一开始，你在入口格子 (1,2) 处。
+- 你可以往左移动 2 步到达 (1,0) 。
+- 你可以往上移动 1 步到达 (0,2) 。
+从入口处没法到达 (2,3) 。
+所以，最近的出口是 (0,2) ，距离为 1 步。
+
+ +

示例 2：

+ +
输入：maze = [["+","+","+"],[".",".","."],["+","+","+"]], entrance = [1,0]
+输出：2
+解释：迷宫中只有 1 个出口，在 (1,2) 处。
+(1,0) 不算出口，因为它是入口格子。
+初始时，你在入口与格子 (1,0) 处。
+- 你可以往右移动 2 步到达 (1,2) 处。
+所以，最近的出口为 (1,2) ，距离为 2 步。
+
+ +

示例 3：

+ +
输入：maze = [[".","+"]], entrance = [0,0]
+输出：-1
+解释：这个迷宫中没有出口。
+
+ +

 

+ +

提示：

+ +
    +
  • maze.length == m
    • +
  • maze[i].length == n
    • +
  • 1 <= m, n <= 100
    • +
  • maze[i][j] 要么是 '.' ，要么是 '+' 。
    • +
  • entrance.length == 2
    • +
  • 0 <= entrancerow < m
    • +
  • 0 <= entrancecol < n
    • +
  • entrance 一定是空格子。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1927_\350\247\204\345\256\232\346\227\266\351\227\264\345\206\205\345\210\260\350\276\276\347\273\210\347\202\271\347\232\204\346\234\200\345\260\217\350\212\261\350\264\271/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1927_\350\247\204\345\256\232\346\227\266\351\227\264\345\206\205\345\210\260\350\276\276\347\273\210\347\202\271\347\232\204\346\234\200\345\260\217\350\212\261\350\264\271/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..b1be84d40699a730c67c32a36caa09c5f5aa95da --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1927_\350\247\204\345\256\232\346\227\266\351\227\264\345\206\205\345\210\260\350\276\276\347\273\210\347\202\271\347\232\204\346\234\200\345\260\217\350\212\261\350\264\271/desc.html" @@ -0,0 +1,54 @@ +

一个国家有 n 个城市，城市编号为 0 到 n - 1 ，题目保证 所有城市 都由双向道路 连接在一起 。道路由二维整数数组 edges 表示，其中 edges[i] = [xi, yi, timei] 表示城市 xi 和 yi 之间有一条双向道路，耗费时间为 timei 分钟。两个城市之间可能会有多条耗费时间不同的道路，但是不会有道路两头连接着同一座城市。

+ +

每次经过一个城市时，你需要付通行费。通行费用一个长度为 n 且下标从 0 开始的整数数组 passingFees 表示，其中 passingFees[j] 是你经过城市 j 需要支付的费用。

+ +

一开始，你在城市 0 ，你想要在 maxTime 分钟以内 （包含 maxTime 分钟）到达城市 n - 1 。旅行的 费用 为你经过的所有城市 通行费之和 （包括 起点和终点城市的通行费）。

+ +

给你 maxTime，edges 和 passingFees ，请你返回完成旅行的 最小费用 ，如果无法在 maxTime 分钟以内完成旅行，请你返回 -1 。

+ +

 

+ +

示例 1：

+ +

+ +
+输入：maxTime = 30, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]
+输出：11
+解释：最优路径为 0 -> 1 -> 2 -> 5 ，总共需要耗费 30 分钟，需要支付 11 的通行费。
+
+ +

示例 2：

+ +

+ +
+输入：maxTime = 29, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]
+输出：48
+解释：最优路径为 0 -> 3 -> 4 -> 5 ，总共需要耗费 26 分钟，需要支付 48 的通行费。
+你不能选择路径 0 -> 1 -> 2 -> 5 ，因为这条路径耗费的时间太长。
+
+ +

示例 3：

+ +
+输入：maxTime = 25, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]
+输出：-1
+解释：无法在 25 分钟以内从城市 0 到达城市 5 。
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= maxTime <= 1000
    • +
  • n == passingFees.length
    • +
  • 2 <= n <= 1000
    • +
  • n - 1 <= edges.length <= 1000
    • +
  • 0 <= xi, yi <= n - 1
    • +
  • 1 <= timei <= 1000
    • +
  • 1 <= passingFees[j] <= 1000 
    • +
  • 图中两个节点之间可能有多条路径。
    • +
  • 图中不含有自环。
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1928_\346\225\260\347\273\204\344\270\262\350\201\224/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1928_\346\225\260\347\273\204\344\270\262\350\201\224/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..a3560f0d7439296be4e11b0cbe1e49d022da8e2c --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1928_\346\225\260\347\273\204\344\270\262\350\201\224/desc.html" @@ -0,0 +1,41 @@ +

给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：

+ +
    +
  • ans[i] == nums[i]
    • +
  • ans[i + n] == nums[i]
    • +
+ +

具体而言，ans 由两个 nums 数组 串联 形成。

+ +

返回数组 ans 。

+ +

 

+ +

示例 1：

+ +
+输入：nums = [1,2,1]
+输出：[1,2,1,1,2,1]
+解释：数组 ans 按下述方式形成：
+- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
+- ans = [1,2,1,1,2,1]
+ +

示例 2：

+ +
+输入：nums = [1,3,2,1]
+输出：[1,3,2,1,1,3,2,1]
+解释：数组 ans 按下述方式形成：
+- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
+- ans = [1,3,2,1,1,3,2,1]
+
+ +

 

+ +

提示：

+ +
    +
  • n == nums.length
    • +
  • 1 <= n <= 1000
    • +
  • 1 <= nums[i] <= 1000
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1929_\351\225\277\345\272\246\344\270\272 3 \347\232\204\344\270\215\345\220\214\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1929_\351\225\277\345\272\246\344\270\272 3 \347\232\204\344\270\215\345\220\214\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..067d00a4356c172c42c6aafdf1872c97f92d5ac2 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1929_\351\225\277\345\272\246\344\270\272 3 \347\232\204\344\270\215\345\220\214\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227/desc.html" @@ -0,0 +1,53 @@ +

给你一个字符串 s ，返回 s 中 长度为 3 的不同回文子序列 的个数。

+ +

即便存在多种方法来构建相同的子序列，但相同的子序列只计数一次。

+ +

回文 是正着读和反着读一样的字符串。

+ +

子序列 是由原字符串删除其中部分字符（也可以不删除）且不改变剩余字符之间相对顺序形成的一个新字符串。

+ +
    +
  • 例如，"ace" 是 "abcde" 的一个子序列。
    • +
+ +

 

+ +

示例 1：

+ +
+输入：s = "aabca"
+输出：3
+解释：长度为 3 的 3 个回文子序列分别是：
+- "aba" ("aabca" 的子序列)
+- "aaa" ("aabca" 的子序列)
+- "aca" ("aabca" 的子序列)
+
+ +

示例 2：

+ +
+输入：s = "adc"
+输出：0
+解释："adc" 不存在长度为 3 的回文子序列。
+
+ +

示例 3：

+ +
+输入：s = "bbcbaba"
+输出：4
+解释：长度为 3 的 4 个回文子序列分别是：
+- "bbb" ("bbcbaba" 的子序列)
+- "bcb" ("bbcbaba" 的子序列)
+- "bab" ("bbcbaba" 的子序列)
+- "aba" ("bbcbaba" 的子序列)
+
+ +

 

+ +

提示：

+ +
    +
  • 3 <= s.length <= 105
    • +
  • s 仅由小写英文字母组成
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1931_\345\220\210\345\271\266\345\244\232\346\243\265\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1931_\345\220\210\345\271\266\345\244\232\346\243\265\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..479cf58b42199594c4bcaafc049d5b6b7bf57af4 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/1931_\345\220\210\345\271\266\345\244\232\346\243\265\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/desc.html" @@ -0,0 +1,76 @@ +

给你 n 个 二叉搜索树的根节点 ，存储在数组 trees 中（下标从 0 开始），对应 n 棵不同的二叉搜索树。trees 中的每棵二叉搜索树 最多有 3 个节点 ，且不存在值相同的两个根节点。在一步操作中，将会完成下述步骤：

+ +
    +
  • 选择两个 不同的 下标 i 和 j ，要求满足在 trees[i] 中的某个 叶节点 的值等于 trees[j] 的 根节点的值 。
    • +
  • 用 trees[j] 替换 trees[i] 中的那个叶节点。
    • +
  • 从 trees 中移除 trees[j] 。
    • +
+ +

如果在执行 n - 1 次操作后，能形成一棵有效的二叉搜索树，则返回结果二叉树的 根节点 ；如果无法构造一棵有效的二叉搜索树，返回 null 。

+ +

二叉搜索树是一种二叉树，且树中每个节点均满足下述属性：

+ +
    +
  • 任意节点的左子树中的值都 严格小于 此节点的值。
    • +
  • 任意节点的右子树中的值都 严格大于 此节点的值。
    • +
+ +

叶节点是不含子节点的节点。

+ +

 

+ +

示例 1：

+ +
+输入：trees = [[2,1],[3,2,5],[5,4]]
+输出：[3,2,5,1,null,4]
+解释：
+第一步操作中，选出 i=1 和 j=0 ，并将 trees[0] 合并到 trees[1] 中。
+删除 trees[0] ，trees = [[3,2,5,1],[5,4]] 。
+
+在第二步操作中，选出 i=0 和 j=1 ，将 trees[1] 合并到 trees[0] 中。
+删除 trees[1] ，trees = [[3,2,5,1,null,4]] 。
+
+结果树如上图所示，为一棵有效的二叉搜索树，所以返回该树的根节点。
+ +

示例 2：

+ +
+输入：trees = [[5,3,8],[3,2,6]]
+输出：[]
+解释：
+选出 i=0 和 j=1 ，然后将 trees[1] 合并到 trees[0] 中。
+删除 trees[1] ，trees = [[5,3,8,2,6]] 。
+
+结果树如上图所示。仅能执行一次有效的操作，但结果树不是一棵有效的二叉搜索树，所以返回 null 。
+
+ +

示例 3：

+ +
+输入：trees = [[5,4],[3]]
+输出：[]
+解释：无法执行任何操作。
+
+ +

示例 4：

+ +
+输入：trees = [[2,1,3]]
+输出：[2,1,3]
+解释：trees 中只有一棵树，且这棵树已经是一棵有效的二叉搜索树，所以返回该树的根节点。
+
+ +

 

+ +

提示：

+ +
    +
  • n == trees.length
    • +
  • 1 <= n <= 5 * 104
    • +
  • 每棵树中节点数目在范围 [1, 3] 内。
    • +
  • 输入数据的每个节点可能有子节点但不存在子节点的子节点
    • +
  • trees 中不存在两棵树根节点值相同的情况。
    • +
  • 输入中的所有树都是 有效的二叉树搜索树 。
    • +
  • 1 <= TreeNode.val <= 5 * 104.
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/434_\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/434_\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..ea1fbed3224efa62233e2a99eade969e39fd24fc --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/434_\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264/desc.html" @@ -0,0 +1,38 @@ +

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

+ +

注意:

+ +
    +
  1. 可以认为区间的终点总是大于它的起点。
    2. +
  2. 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
    3. +
+ +

示例 1:

+ +
+输入: [ [1,2], [2,3], [3,4], [1,3] ]
+
+输出: 1
+
+解释: 移除 [1,3] 后，剩下的区间没有重叠。
+
+ +

示例 2:

+ +
+输入: [ [1,2], [1,2], [1,2] ]
+
+输出: 2
+
+解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
+
+ +

示例 3:

+ +
+输入: [ [1,2], [2,3] ]
+
+输出: 0
+
+解释: 你不需要移除任何区间，因为它们已经是无重叠的了。
+
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/435_\345\257\273\346\211\276\345\217\263\345\214\272\351\227\264/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/435_\345\257\273\346\211\276\345\217\263\345\214\272\351\227\264/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..3bb8b1ff0cae7f63d6ac89f3702180aaad95f845 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/435_\345\257\273\346\211\276\345\217\263\345\214\272\351\227\264/desc.html" @@ -0,0 +1,44 @@ +

给你一个区间数组 intervals ，其中 intervals[i] = [starti, endi] ，且每个 starti 都 不同 。

+ +

区间 i 的 右侧区间 可以记作区间 j ，并满足 startj >= endi ，且 startj 最小化 。

+ +

返回一个由每个区间 i 的 右侧区间 的最小起始位置组成的数组。如果某个区间 i 不存在对应的 右侧区间 ，则下标 i 处的值设为 -1 。

+  + +

示例 1：

+ +
+输入：intervals = [[1,2]]
+输出：[-1]
+解释：集合中只有一个区间，所以输出-1。
+
+ +

示例 2：

+ +
+输入：intervals = [[3,4],[2,3],[1,2]]
+输出：[-1, 0, 1]
+解释：对于 [3,4] ，没有满足条件的“右侧”区间。
+对于 [2,3] ，区间[3,4]具有最小的“右”起点;
+对于 [1,2] ，区间[2,3]具有最小的“右”起点。
+
+ +

示例 3：

+ +
+输入：intervals = [[1,4],[2,3],[3,4]]
+输出：[-1, 2, -1]
+解释：对于区间 [1,4] 和 [3,4] ，没有满足条件的“右侧”区间。
+对于 [2,3] ，区间 [3,4] 有最小的“右”起点。
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= intervals.length <= 2 * 104
    • +
  • intervals[i].length == 2
    • +
  • -106 <= starti <= endi <= 106
    • +
  • 每个间隔的起点都 不相同
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/437_\346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/437_\346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..7eedef06ee2bedfb45aabe2f9605fda8bf1b8f22 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/437_\346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215/desc.html" @@ -0,0 +1,35 @@ +

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

+ +

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

+ +

 

+ +

示例 1:

+ +
+输入: s = "cbaebabacd", p = "abc"
+输出: [0,6]
+解释:
+起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
+起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
+
+ +

 示例 2:

+ +
+输入: s = "abab", p = "ab"
+输出: [0,1,2]
+解释:
+起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
+起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
+起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
+
+ +

 

+ +

提示:

+ +
    +
  • 1 <= s.length, p.length <= 3 * 104
    • +
  • s 和 p 仅包含小写字母
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/439_\345\255\227\345\205\270\345\272\217\347\232\204\347\254\254K\345\260\217\346\225\260\345\255\227/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/439_\345\255\227\345\205\270\345\272\217\347\232\204\347\254\254K\345\260\217\346\225\260\345\255\227/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..9df39670762e740ef8627ff4c6a659d143a0215b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/439_\345\255\227\345\205\270\345\272\217\347\232\204\347\254\254K\345\260\217\346\225\260\345\255\227/desc.html" @@ -0,0 +1,16 @@ +

给定整数 n 和 k，找到 1 到 n 中字典序第 k 小的数字。

+ +

注意：1 ≤ k ≤ n ≤ 109。

+ +

示例 :

+ +
+输入:
+n: 13   k: 2
+
+输出:
+10
+
+解释:
+字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。
+
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/440_\346\216\222\345\210\227\347\241\254\345\270\201/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/440_\346\216\222\345\210\227\347\241\254\345\270\201/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..dfb9e7b4d86f91de65411da459487b015241790b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/440_\346\216\222\345\210\227\347\241\254\345\270\201/desc.html" @@ -0,0 +1,29 @@ +

你总共有 n 枚硬币，并计划将它们按阶梯状排列。对于一个由 k 行组成的阶梯，其第 i 行必须正好有 i 枚硬币。阶梯的最后一行 可能 是不完整的。

+ +

给你一个数字 n ，计算并返回可形成 完整阶梯行 的总行数。

+ +

 

+ +

示例 1：

+ +
+输入：n = 5
+输出：2
+解释：因为第三行不完整，所以返回 2 。
+
+ +

示例 2：

+ +
+输入：n = 8
+输出：3
+解释：因为第四行不完整，所以返回 3 。
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= n <= 231 - 1
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/441_\346\225\260\347\273\204\344\270\255\351\207\215\345\244\215\347\232\204\346\225\260\346\215\256/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/441_\346\225\260\347\273\204\344\270\255\351\207\215\345\244\215\347\232\204\346\225\260\346\215\256/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..dc1cd3224f50fcaf1f1553e94c10f8e30880c478 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/441_\346\225\260\347\273\204\344\270\255\351\207\215\345\244\215\347\232\204\346\225\260\346\215\256/desc.html" @@ -0,0 +1,15 @@ +

给定一个整数数组 a，其中1 ≤ a[i] ≤ n （n为数组长度）, 其中有些元素出现两次而其他元素出现一次。

+ +

找到所有出现两次的元素。

+ +

你可以不用到任何额外空间并在O(n)时间复杂度内解决这个问题吗？

+ +

示例：

+ +
+输入:
+[4,3,2,7,8,2,3,1]
+
+输出:
+[2,3]
+
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/445_\347\255\211\345\267\256\346\225\260\345\210\227\345\210\222\345\210\206 II - \345\255\220\345\272\217\345\210\227/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/445_\347\255\211\345\267\256\346\225\260\345\210\227\345\210\222\345\210\206 II - \345\255\220\345\272\217\345\210\227/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..e0eb6258cf260009409af5a649c2653abdf50d99 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/445_\347\255\211\345\267\256\346\225\260\345\210\227\345\210\222\345\210\206 II - \345\255\220\345\272\217\345\210\227/desc.html" @@ -0,0 +1,50 @@ +

给你一个整数数组 nums ，返回 nums 中所有 等差子序列 的数目。

+ +

如果一个序列中 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该序列为等差序列。

+ +
    +
  • 例如，[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差序列。
    • +
  • 再例如，[1, 1, 2, 5, 7] 不是等差序列。
    • +
+ +

数组中的子序列是从数组中删除一些元素（也可能不删除）得到的一个序列。

+ +
    +
  • 例如，[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。
    • +
+ +

题目数据保证答案是一个 32-bit 整数。

+ +

 

+ +

示例 1：

+ +
+输入：nums = [2,4,6,8,10]
+输出：7
+解释：所有的等差子序列为：
+[2,4,6]
+[4,6,8]
+[6,8,10]
+[2,4,6,8]
+[4,6,8,10]
+[2,4,6,8,10]
+[2,6,10]
+
+ +

示例 2：

+ +
+输入：nums = [7,7,7,7,7]
+输出：16
+解释：数组中的任意子序列都是等差子序列。
+
+ +

 

+ +

提示：

+ +
    +
  • 1  <= nums.length <= 1000
    • +
  • -231 <= nums[i] <= 231 - 1
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/458_\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/458_\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..9c72ea05d05e7cd4eb384e36f5161cb3d108185d --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/458_\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262/desc.html" @@ -0,0 +1,29 @@ +

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

+ +

示例 1:

+ +
+输入: "abab"
+
+输出: True
+
+解释: 可由子字符串 "ab" 重复两次构成。
+
+ +

示例 2:

+ +
+输入: "aba"
+
+输出: False
+
+ +

示例 3:

+ +
+输入: "abcabcabcabc"
+
+输出: True
+
+解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)
+
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/460_\346\261\211\346\230\216\350\267\235\347\246\273/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/460_\346\261\211\346\230\216\350\267\235\347\246\273/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..dc994163ab4f40b8f2a19d04894ac9f6296f88a3 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/460_\346\261\211\346\230\216\350\267\235\347\246\273/desc.html" @@ -0,0 +1,32 @@ +

两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。

+ +

给你两个整数 x 和 y，计算并返回它们之间的汉明距离。

+ +

 

+ +

示例 1：

+ +
+输入：x = 1, y = 4
+输出：2
+解释：
+1   (0 0 0 1)
+4   (0 1 0 0)
+       ↑   ↑
+上面的箭头指出了对应二进制位不同的位置。
+
+ +

示例 2：

+ +
+输入：x = 3, y = 1
+输出：1
+
+ +

 

+ +

提示：

+ +
    +
  • 0 <= x, y <= 231 - 1
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/462_\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/462_\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..2ab0908921dbc987ad79d7673d4f64f365bdc199 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/462_\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277/desc.html" @@ -0,0 +1,41 @@ +

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

+ +

网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

+ +

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

+ +

 

+ +

示例 1：

+ +

+ +
+输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
+输出：16
+解释：它的周长是上面图片中的 16 个黄色的边
+ +

示例 2：

+ +
+输入：grid = [[1]]
+输出：4
+
+ +

示例 3：

+ +
+输入：grid = [[1,0]]
+输出：4
+
+ +

 

+ +

提示：

+ +
    +
  • row == grid.length
    • +
  • col == grid[i].length
    • +
  • 1 <= row, col <= 100
    • +
  • grid[i][j] 为 0 或 1
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/465_\347\273\237\350\256\241\351\207\215\345\244\215\344\270\252\346\225\260/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/465_\347\273\237\350\256\241\351\207\215\345\244\215\344\270\252\346\225\260/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..0299170de7699187fdaa7c184d50f5ee497fbc3b --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/465_\347\273\237\350\256\241\351\207\215\345\244\215\344\270\252\346\225\260/desc.html" @@ -0,0 +1,41 @@ +

定义 str = [s, n] 表示 str 由 n 个字符串 s 连接构成。

+ +
    +
  • 例如，str == ["abc", 3] =="abcabcabc" 。
    • +
+ +

如果可以从 s2 中删除某些字符使其变为 s1，则称字符串 s1 可以从字符串 s2 获得。

+ +
    +
  • 例如，根据定义，s1 = "abc" 可以从 s2 = "abdbec" 获得，仅需要删除加粗且用斜体标识的字符。
    • +
+ +

现在给你两个字符串 s1 和 s2 和两个整数 n1 和 n2 。由此构造得到两个字符串，其中 str1 = [s1, n1]、str2 = [s2, n2] 。

+ +

请你找出一个最大整数 m ，以满足 str = [str2, m] 可以从 str1 获得。

+ +

 

+ +

示例 1：

+ +
+输入：s1 = "acb", n1 = 4, s2 = "ab", n2 = 2
+输出：2
+
+ +

示例 2：

+ +
+输入：s1 = "acb", n1 = 1, s2 = "acb", n2 = 1
+输出：1
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= s1.length, s2.length <= 100
    • +
  • s1 和 s2 由小写英文字母组成
    • +
  • 1 <= n1, n2 <= 106
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/562_\344\272\214\345\217\211\346\240\221\347\232\204\345\235\241\345\272\246/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/562_\344\272\214\345\217\211\346\240\221\347\232\204\345\235\241\345\272\246/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..a174e4446201b99b996bf1833a3051133221f4fa --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/562_\344\272\214\345\217\211\346\240\221\347\232\204\345\235\241\345\272\246/desc.html" @@ -0,0 +1,50 @@ +

给定一个二叉树，计算 整个树 的坡度 。

+ +

一个树的 节点的坡度 定义即为，该节点左子树的节点之和和右子树节点之和的 差的绝对值 。如果没有左子树的话，左子树的节点之和为 0 ；没有右子树的话也是一样。空结点的坡度是 0 。

+ +

整个树 的坡度就是其所有节点的坡度之和。

+ +

 

+ +

示例 1：

+ +
+输入：root = [1,2,3]
+输出：1
+解释：
+节点 2 的坡度：|0-0| = 0（没有子节点）
+节点 3 的坡度：|0-0| = 0（没有子节点）
+节点 1 的坡度：|2-3| = 1（左子树就是左子节点，所以和是 2 ；右子树就是右子节点，所以和是 3 ）
+坡度总和：0 + 0 + 1 = 1
+
+ +

示例 2：

+ +
+输入：root = [4,2,9,3,5,null,7]
+输出：15
+解释：
+节点 3 的坡度：|0-0| = 0（没有子节点）
+节点 5 的坡度：|0-0| = 0（没有子节点）
+节点 7 的坡度：|0-0| = 0（没有子节点）
+节点 2 的坡度：|3-5| = 2（左子树就是左子节点，所以和是 3 ；右子树就是右子节点，所以和是 5 ）
+节点 9 的坡度：|0-7| = 7（没有左子树，所以和是 0 ；右子树正好是右子节点，所以和是 7 ）
+节点 4 的坡度：|(3+5+2)-(9+7)| = |10-16| = 6（左子树值为 3、5 和 2 ，和是 10 ；右子树值为 9 和 7 ，和是 16 ）
+坡度总和：0 + 0 + 0 + 2 + 7 + 6 = 15
+
+ +

示例 3：

+ +
+输入：root = [21,7,14,1,1,2,2,3,3]
+输出：9
+
+ +

 

+ +

提示：

+ +
    +
  • 树中节点数目的范围在 [0, 104] 内
    • +
  • -1000 <= Node.val <= 1000
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/563_\345\257\273\346\211\276\346\234\200\350\277\221\347\232\204\345\233\236\346\226\207\346\225\260/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/563_\345\257\273\346\211\276\346\234\200\350\277\221\347\232\204\345\233\236\346\226\207\346\225\260/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..9907b7045c23c95baebade6b6807d4d7ae692273 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/563_\345\257\273\346\211\276\346\234\200\350\277\221\347\232\204\345\233\236\346\226\207\346\225\260/desc.html" @@ -0,0 +1,17 @@ +

给定一个整数 n ，你需要找到与它最近的回文数（不包括自身）。

+ +

“最近的”定义为两个整数差的绝对值最小。

+ +

示例 1:

+ +
+输入: "123"
+输出: "121"
+
+ +

注意:

+ +
    +
  1. n 是由字符串表示的正整数，其长度不超过18。
    2. +
  2. 如果有多个结果，返回最小的那个。
    3. +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/564_\346\225\260\347\273\204\345\265\214\345\245\227/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/564_\346\225\260\347\273\204\345\265\214\345\245\227/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..48ee43bedffac8969f557f3bf4e6d37d4c90001c --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/564_\346\225\260\347\273\204\345\265\214\345\245\227/desc.html" @@ -0,0 +1,26 @@ +

索引从0开始长度为N的数组A，包含0到N - 1的所有整数。找到最大的集合S并返回其大小，其中 S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }且遵守以下的规则。

+ +

假设选择索引为i的元素A[i]为S的第一个元素，S的下一个元素应该是A[A[i]]，之后是A[A[A[i]]]... 以此类推，不断添加直到S出现重复的元素。

+ +

 

+ +

示例 1:

+ +
输入: A = [5,4,0,3,1,6,2]
+输出: 4
+解释: 
+A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.
+
+其中一种最长的 S[K]:
+S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
+
+ +

 

+ +

提示：

+ +
    +
  1. N是[1, 20,000]之间的整数。
    2. +
  2. A中不含有重复的元素。
    3. +
  3. A中的元素大小在[0, N-1]之间。
    4. +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/565_\351\207\215\345\241\221\347\237\251\351\230\265/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/565_\351\207\215\345\241\221\347\237\251\351\230\265/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..7e16e7990fe5b3727b2791473a997ef99dd8e5cc --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/565_\351\207\215\345\241\221\347\237\251\351\230\265/desc.html" @@ -0,0 +1,35 @@ +

在 MATLAB 中，有一个非常有用的函数 reshape ，它可以将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。

+ +

给你一个由二维数组 mat 表示的 m x n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。

+ +

重构后的矩阵需要将原始矩阵的所有元素以相同的 行遍历顺序 填充。

+ +

如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

+ +

 

+ +

示例 1：

+ +
+输入：mat = [[1,2],[3,4]], r = 1, c = 4
+输出：[[1,2,3,4]]
+
+ +

示例 2：

+ +
+输入：mat = [[1,2],[3,4]], r = 2, c = 4
+输出：[[1,2],[3,4]]
+
+ +

 

+ +

提示：

+ +
    +
  • m == mat.length
    • +
  • n == mat[i].length
    • +
  • 1 <= m, n <= 100
    • +
  • -1000 <= mat[i][j] <= 1000
    • +
  • 1 <= r, c <= 300
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/566_\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/566_\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..b182724a0ea4d5448d25262c8c95bc4f62048f84 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/566_\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/desc.html" @@ -0,0 +1,29 @@ +

给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。

+ +

换句话说，s1 的排列之一是 s2 的 子串 。

+ +

 

+ +

示例 1：

+ +
+输入：s1 = "ab" s2 = "eidbaooo"
+输出：true
+解释：s2 包含 s1 的排列之一 ("ba").
+
+ +

示例 2：

+ +
+输入：s1= "ab" s2 = "eidboaoo"
+输出：false
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= s1.length, s2.length <= 104
    • +
  • s1 和 s2 仅包含小写字母
    • +
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/571_\345\217\246\344\270\200\346\243\265\346\240\221\347\232\204\345\255\220\346\240\221/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/571_\345\217\246\344\270\200\346\243\265\346\240\221\347\232\204\345\255\220\346\240\221/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..96bcfe38fa6df1569b439bf924a2d33ff1d95a00 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/571_\345\217\246\344\270\200\346\243\265\346\240\221\347\232\204\345\255\220\346\240\221/desc.html" @@ -0,0 +1,34 @@ +
+
+

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

+ +

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

+ +

 

+ +

示例 1：

+ +
+输入：root = [3,4,5,1,2], subRoot = [4,1,2]
+输出：true
+
+ +

示例 2：

+ +
+输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
+输出：false
+
+ +

 

+ +

提示：

+ +
    +
  • root 树上的节点数量范围是 [1, 2000]
    • +
  • subRoot 树上的节点数量范围是 [1, 1000]
    • +
  • -104 <= root.val <= 104
    • +
  • -104 <= subRoot.val <= 104
    • +
+
+
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/580_\346\234\200\347\237\255\346\227\240\345\272\217\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/580_\346\234\200\347\237\255\346\227\240\345\272\217\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..b478345f5706d6dd2a113ec6f273d677b21822d0 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/580_\346\234\200\347\237\255\346\227\240\345\272\217\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204/desc.html" @@ -0,0 +1,44 @@ +

给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。

+ +

请你找出符合题意的 最短 子数组，并输出它的长度。

+ +

 

+ +
+
+

示例 1：

+ +
+输入：nums = [2,6,4,8,10,9,15]
+输出：5
+解释：你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。
+
+ +

示例 2：

+ +
+输入：nums = [1,2,3,4]
+输出：0
+
+ +

示例 3：

+ +
+输入：nums = [1]
+输出：0
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= nums.length <= 104
    • +
  • -105 <= nums[i] <= 105
    • +
+ +

 

+ +

进阶：你可以设计一个时间复杂度为 O(n) 的解决方案吗？

+
+
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/654_\350\276\223\345\207\272\344\272\214\345\217\211\346\240\221/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/654_\350\276\223\345\207\272\344\272\214\345\217\211\346\240\221/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..900a26ceab11991eab07a62e522a8cfbf2db5829 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/654_\350\276\223\345\207\272\344\272\214\345\217\211\346\240\221/desc.html" @@ -0,0 +1,56 @@ +

在一个 m*n 的二维字符串数组中输出二叉树，并遵守以下规则：

+ +
    +
  1. 行数 m 应当等于给定二叉树的高度。
    2. +
  2. 列数 n 应当总是奇数。
    3. +
  3. 根节点的值（以字符串格式给出）应当放在可放置的第一行正中间。根节点所在的行与列会将剩余空间划分为两部分（左下部分和右下部分）。你应该将左子树输出在左下部分，右子树输出在右下部分。左下和右下部分应当有相同的大小。即使一个子树为空而另一个非空，你不需要为空的子树输出任何东西，但仍需要为另一个子树留出足够的空间。然而，如果两个子树都为空则不需要为它们留出任何空间。
    4. +
  4. 每个未使用的空间应包含一个空的字符串""。
    5. +
  5. 使用相同的规则输出子树。
    6. +
+ +

示例 1:

+ +
+输入:
+     1
+    /
+   2
+输出:
+[["", "1", ""],
+ ["2", "", ""]]
+
+ +

示例 2:

+ +
+输入:
+     1
+    / \
+   2   3
+    \
+     4
+输出:
+[["", "", "", "1", "", "", ""],
+ ["", "2", "", "", "", "3", ""],
+ ["", "", "4", "", "", "", ""]]
+
+ +

示例 3:

+ +
+输入:
+      1
+     / \
+    2   5
+   / 
+  3 
+ / 
+4 
+输出:
+[["",  "",  "", "",  "", "", "", "1", "",  "",  "",  "",  "", "", ""]
+ ["",  "",  "", "2", "", "", "", "",  "",  "",  "",  "5", "", "", ""]
+ ["",  "3", "", "",  "", "", "", "",  "",  "",  "",  "",  "", "", ""]
+ ["4", "",  "", "",  "", "", "", "",  "",  "",  "",  "",  "", "", ""]]
+
+ +

注意: 二叉树的高度在范围 [1, 10] 中。

diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/656_\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/656_\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..f6bfb38c5cb1e491db5d2ce4aeacadc2c4eb6004 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/656_\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271/desc.html" @@ -0,0 +1,19 @@ +

在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。

+ +

移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。

+ +

注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。

+ +

 

+ +

示例 1:

+ +
输入: "UD"
+输出: true
+解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。
+ +

示例 2:

+ +
输入: "LL"
+输出: false
+解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 “移动” 的距离。我们返回 false，因为它在移动结束时没有返回原点。
diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/661_\344\272\214\345\217\211\346\240\221\346\234\200\345\244\247\345\256\275\345\272\246/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/661_\344\272\214\345\217\211\346\240\221\346\234\200\345\244\247\345\256\275\345\272\246/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..7565557fe4726d17e441545210974159c7393da1 --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/661_\344\272\214\345\217\211\346\240\221\346\234\200\345\244\247\345\256\275\345\272\246/desc.html" @@ -0,0 +1,66 @@ +

给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。

+ +

每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。

+ +

示例 1:

+ +
+输入: 
+
+           1
+         /   \
+        3     2
+       / \     \  
+      5   3     9 
+
+输出: 4
+解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。
+
+ +

示例 2:

+ +
+输入: 
+
+          1
+         /  
+        3    
+       / \       
+      5   3     
+
+输出: 2
+解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。
+
+ +

示例 3:

+ +
+输入: 
+
+          1
+         / \
+        3   2 
+       /        
+      5      
+
+输出: 2
+解释: 最大值出现在树的第 2 层，宽度为 2 (3,2)。
+
+ +

示例 4:

+ +
+输入: 
+
+          1
+         / \
+        3   2
+       /     \  
+      5       9 
+     /         \
+    6           7
+输出: 8
+解释: 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null,7)。
+
+ +

注意: 答案在32位有符号整数的表示范围内。

diff --git "a/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/928_\347\213\254\347\211\271\347\232\204\347\224\265\345\255\220\351\202\256\344\273\266\345\234\260\345\235\200/desc.html" "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/928_\347\213\254\347\211\271\347\232\204\347\224\265\345\255\220\351\202\256\344\273\266\345\234\260\345\235\200/desc.html" new file mode 100644 index 0000000000000000000000000000000000000000..4a8c31415ae8572ca16e30f3f8442c7d9fb7033e --- /dev/null +++ "b/data/3.\347\256\227\346\263\225\351\253\230\351\230\266/1.leetcode/928_\347\213\254\347\211\271\347\232\204\347\224\265\345\255\220\351\202\256\344\273\266\345\234\260\345\235\200/desc.html" @@ -0,0 +1,32 @@ +

每封电子邮件都由一个本地名称和一个域名组成，以 @ 符号分隔。

+ +

例如，在 alice@leetcode.com中， alice 是本地名称，而 leetcode.com 是域名。

+ +

除了小写字母，这些电子邮件还可能包含 '.' 或 '+'。

+ +

如果在电子邮件地址的本地名称部分中的某些字符之间添加句点（'.'），则发往那里的邮件将会转发到本地名称中没有点的同一地址。例如，"alice.z@leetcode.com” 和 “alicez@leetcode.com” 会转发到同一电子邮件地址。 （请注意，此规则不适用于域名。）

+ +

如果在本地名称中添加加号（'+'），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件，例如 m.y+name@email.com 将转发到 my@email.com。 （同样，此规则不适用于域名。）

+ +

可以同时使用这两个规则。

+ +

给定电子邮件列表 emails，我们会向列表中的每个地址发送一封电子邮件。实际收到邮件的不同地址有多少？

+ +

 

+ +

示例：

+ +
输入：["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]
+输出：2
+解释：实际收到邮件的是 "testemail@leetcode.com" 和 "testemail@lee.tcode.com"。
+
+ +

 

+ +

提示：

+ +
    +
  • 1 <= emails[i].length <= 100
    • +
  • 1 <= emails.length <= 100
    • +
  • 每封 emails[i] 都包含有且仅有一个 '@' 字符。
    • +