leetcode 栈 II
2024-05-15 01:43:53
栈
- 880. 索引处的解码字符串
- 895. 最大频率栈
- 901. 股票价格跨度
- 907. 子数组的最小值之和
- 921. 使括号有效的最少添加
- 946. 验证栈序列
- 962. 最大宽度坡*
- 1003. 检查替换后的词是否有效
- 1006. 笨阶乘
- 1019. 链表中下一更大结点
- 1021. 删除最外层的括号
- 1047. 删除字符串的所有相邻重复项
- 1081. 不同字符的最小子序列
- 1106. 解析布尔表达式
- 1111. 有效括号的嵌套深度
- 1124. 表现良好的最长时间段
- 1190. 翻转每对括号间的子串
- 1209. 删除字符串中所有相邻重复项II
- 1249. 移除无效的括号
- 1381. 设计一个支持增量操作的栈
- 1441. 用栈操作构建数组
- 1475.商品折扣后的最终价格*
- 1504. 统计全1子矩阵*
- 1541. 平衡括号字符串的最少插入次数
- 1544. 整理字符串
- 1574. 删除最短的子数组使剩余数组有序
- 1598. 文件夹操作日志搜集器
- 1614. 括号的最大嵌套深度
- 1653. 使字符串平衡的最少删除次数
- 1673. 找出最具竞争力的子序列
- 1700. 无法吃午餐的学生数量
- 1717. 删除子字符串的最大得分
- 1776. 车队 II
- 1793. 好子数组的最大分数
880. 索引处的解码字符串
题目链接
//逆向统计
string decodeAtIndex(string s, int k) {long size = 0;int n = s.size();for (int i = 0; i < n; ++i) { //统计解码后字符串长度if (isdigit(s[i]))size *= s[i] - '0';else size++;}for (int i = n - 1; i >= 0; i--) {k %= size;if (k == 0 && isalpha(s[i])) // k >= size 时才有可能 k % size == 0return (string)"" + s[i];if (isdigit(s[i])) size /= s[i] - '0'; //eg: leet2code3: leetleetcode leetleetcode leetleetcode 除后进入组elsesize--;}return "";
}
//Time O(n) Space O(1)
895. 最大频率栈
题目链接
class FreqStack {public:unordered_map<int, int> num_freq; // <val, freq> 值对应的频率unordered_map<int, vector<int>> freq_lists; // <freq, list> 同频率的列表int max_cnt = -1;FreqStack() {} void push(int val) {num_freq[val] += 1;freq_lists[num_freq[val]].emplace_back(val);max_cnt = max(num_freq[val], max_cnt);}int pop() {int num = freq_lists[max_cnt].back();int cnt = num_freq[num];num_freq[num] -= 1;freq_lists[cnt].pop_back();if (freq_lists[cnt].empty())--max_cnt;return num;}
};
//Time O(1) Space O(n)
901. 股票价格跨度
题目链接
/* 单调栈 */
class StockSpanner {public:stack<pair<int, int>> monoSt; // <price, weight>StockSpanner() {}int next(int price) {pair<int, int> ret(price, 1);while (!monoSt.empty() && monoSt.top().first <= price) {auto tmp = monoSt.top();ret.second += tmp.second;monoSt.pop();}monoSt.push(ret);return ret.second;}
};
/** StockSpanner* obj = new StockSpanner();* int param_1 = obj->next(price);
*/
907. 子数组的最小值之和
题目链接
/* 单调栈 */
//最小值是在一段连续数字钟被筛选出来的，也就是说每个最小值都有一定
int sumSubarrayMins(vector<int> &arr) {int n = arr.size();vector<int> left(n), right(n); //每个元素辐射范围的左右边界stack<int> st;for (int i = 0; i < n; i++) {//向左寻找第一个小于等于 E 的元素 （小于“等于”为了解决重复相同最小值元素）while (!st.empty() && arr[i] < arr[st.top()])st.pop();if (st.empty())left[i] = -1;else left[i] = st.top();st.push(i);}st = stack<int> ();for (int i = n - 1; i >= 0; i--) {//向右寻找第一个小于 E 的元素while (!st.empty() && arr[i] <= arr[st.top()]) st.pop();if (st.empty())right[i] = n;else right[i] = st.top();st.push(i);}//计算贡献值//左右边界实际上记录的是 左边界-1 和 右边界+1long ans = 0;for (int i = 0; i < n; i++) ans = (ans + (long)(i - left[i]) * (right[i] - i) * arr[i]) % 1000000007;return (int)ans;
}
//Time O(n) Space O(n)
921. 使括号有效的最少添加
题目链接
/* 平衡法 */
//计算每个前缀数组的平衡度，负值代表需要加 '('，正值代表需要加 ')'
int minAddToMakeValid(string s) {int ans = 0, bal = 0;for (int i = 0; i < s.size(); i++) {bal += s.[i] == '(' ? : 1 : -1;if (bal == -1) {ans++;bal++; //保持 bal >= -1}}return ans + bal;
}
946. 验证栈序列
题目链接
/* 栈模拟 */
bool validateStackSequences(vector<int> & pushed, vector<int> &popped) {stack<int> st;int n = pushed.size();for (int i = 0, j = 0; i < n; i++) {st.emplace(pushed[i]);while (!st.empty() && st.top() == popped[j]) {st.pop();j++;}}return st.empty();
}
962. 最大宽度坡*
题目链接
/* 单调栈 */
int maxWidthRamp(vector<int> &nums) {int n = nums.length();int maxWidth = 0;stack<int> st;//正序遍历存一个以 A[0] 开始的递减序列进栈，作为坡底for (int i = 0; i < n; i++) {if (st.empty() || nums[st.top()] > nums[i]) st.push(i);}//倒序遍历用坡顶去匹配坡底for (int i = n - 1; i >= 0; i--) {while (!st.empty() && nums[st.top()] <= nums[i]) {int pos = st.top();st.pop();maxWidth = fmax(maxWidth, i - pos);}} return maxWidth;
}
//Time O(n) Space O(n)
1003. 检查替换后的词是否有效
题目链接
bool isValid(string s) {stack<char> st;for (int i = 0; i < s.size(); i++) {if (s[i] == 'a' || s[i] == 'b')st.push(s[i]);else { //模拟祖玛if (st.size() < 2) return false;if (st.top() != 'b') return false;st.pop();if (st.top() != 'a') return false;st.pop();}}return st.empty();
}
1006. 笨阶乘
题目链接
int clumsy(int n) {stack<int> st;st.push(n);n--;int index = 0;while (n > 0) { //栈中存计算结果if (index % 4 == 0) st.top() *= n;else if (index % 4 == 1) st.top() /= n;else if (index % 4 == 2) st.push(n);elesst.push(-n);index++;n--;}int sum = 0;while (!st.empty()) {sum += st.top();st.pop();}return sum;
}
//Time O(n) Space O(n)
/* 数学 */
int clumsy(int n) {if (n == 1) return 1;else if (n == 2) return 2;else if (n == 3)return 6;else if (n == 4) return 7;if (n % 4 == 0) {return n + 1;else if (n % 4 <= 2) return n + 2;else return n - 1;
}
//Time O(1) Space O(1)
1019. 链表中下一更大结点
题目链接
/* 单调栈 */
vector<int> nextLargeNodes(ListNode *head) {int count = 0;vector<int> res;stack<pair<int, int>> monoSt; // <val, index>while (head) {res.push_back(0);while (!monoSt.empty() && monoSt.top().first < head->val) {res[monoSt.top().second] = head->val;monoSt.pop(); //修改一个弹一个}monoSt.push(make_pair(head->val, count++)); //count++ 而不是 ++count，即先执行 m_p<val, count> 再 count++head = head->next;}return res;
}
1021. 删除最外层的括号
题目链接
//栈从空到下一次空的过程就是扫描了一个原语的过程
string removeOuterParentheses(string s) {string res;stack<char> st;for (auto c : s) {if (c == ')') st.pop(); //先做pop动作保证最外层 '(' 被弹出而不进入 resif (!st.empty()) res.push_back(c); //栈非空才进行记录if (c == '(') st.emplace(c); }return res;
}
string removeOuterParentheses(string s) {int level = 0;string res;for (auto c : s) {if (c == ')') level--;if (level) res.push_back(c);if (c == '(') level++;}return res;
}
//Time O(n) Space O(n)
1047. 删除字符串的所有相邻重复项
题目链接
sring removeDuplicates(string s) {string st;for (char ch : s) {if (!st.empty() && st.back() == ch) st.pop_back();else st.push_back(ch);}return st;
}
1081. 不同字符的最小子序列
题目链接
/* 单调栈 + 贪心 same as 316*/
string smallestSubsequence(string s) {vector<int> vis(26), cnt(26);for (char ch : s) cnt[ch - 'a']++;string st;for (char ch : s) {if (!vis[ch - 'a']) {while (!st.empty() && st.back() > ch) {if (cnt[st.back() - 'a'] > 0) {vis[st.back() - 'a'] = 0;st.pop_back();} else break;}vis[ch - 'a'] = 1;st.push_back(ch);}cnt[ch - 'a']--;}return st;
}
1106. 解析布尔表达式
题目链接
bool parseBoolExpr(string expression) {stack<char> syb, val;for (int i = 0; i < expression.size(); i++) {if (expression[i] == '|' || expression[i] == '&' || expression[i] == '!')syb.push(expression[i]);else if (expression[i] == ')') {int t = 0, f = 0;while (val.top() != '(') { // 't' 'f' ',' 字符都被弹出直到遇到 (if (val.top() == 't') t++;if (val.top() == 'f') f++;val.pop();}val.pop(); // '(' 弹出char x = syb.top();syb.pop();if (x == '!') { //非运算if (t == 1) val.push('f');else val.push('f');}else if (x == '|') { //或运算if (t != 0) val.push('t');else val.push('f');}else if (x == '&') { //与运算if (f != 0) val.push('f');else val.push('t');} }else val.push(expression[i]);}if (val.top() == 't') return true;else return false;
}
1111. 有效括号的嵌套深度
题目链接
vector<int> maxDepthAfterSplit(string seq) {int d = 0;vector<int> ans;for (char &c : seq) {if (c == '(') {++d;ans.push_back(d % 2);} else {ans.push_back(d % 2);--d;}}return ans;
}
1124. 表现良好的最长时间段
题目链接
/* 前缀和 + 单调栈 */
//找到一个区间 [i, j]满足：prefix[j] - prefix[i] > 0 且 max(j - i)，类似找出前缀和数组 prefix 中的最长的上坡
int longestWPI(vector<int> &hours) {int n = hours.size();vector<int> prefix(n + 1, 0); //前缀和，prefix 开头增加一个哨兵for (int i = 1; i <= n; i++) prefix[i] = prefix[i - 1] + (hours[i - 1] > 8 ? 1 : -1); //统计前缀和stack<int> st;for (int i = 0; i <= n; i++) {if (st.empty() || prefix[st.top()] > prefix[i]) //以 prefix[0] 开始的递减序列进栈st.push(i);}int ans = 0;for (int i = n; i >= 0; i--) { //倒序遍历用坡顶匹配坡底while (!st.empty() && prefix[i] > prefix[st.top()]) {ans = fmax(ans, i - st.top());st.pop();} }return ans;
}
1190. 翻转每对括号间的子串
题目链接
string reverseParentheses(string s) {stack<string> stk;string str;for (auto &ch : s) {if (ch == '(') {stk.push(str);str = "";} else if (ch == ')') {reverse(str.begin(), str.end());str = stk.top() + str;stk.pop();} else {str.push_back(ch);}}return str;
}
//Time O(n^2) Space O(n)
//栈的最大深度为 n ， 每一层处理（翻转）的时间复杂度为 n 。
//预处理括号
//以括号索引向导前后往复遍历字符
string reverseParentheses(string s) {int n = s.length();vector<int> pair(n);stack<int> stk;for (int i = 0; i < n; i++) {if (s[i] == '(') {stk.push(i);} else if (s[i] == ')') {int j = stk.top();stk.pop();pair[i] = j, pair[j] = i; //对应括号索引成组，提供检索时的入口}}string ret;int index = 0, step = 1;while (index < n) {if (s[index] == ')' || s[index] == ')') {index = pair[index];step = -step; //step -1 向前遍历入栈， +1 向后遍历入栈} else {ret.push_back(s[index]);}index += step;}return ret;
}
//Time O(n) Space O(n)
1209. 删除字符串中所有相邻重复项II
题目链接
/* 记忆计数 */
string removeDuplicates(string s, int k) {vector<int> count(s.size());for (int i = 0; i < s.size(); i++) {if (i == 0 || s[i] != s[i - 1]) {count[i] = 1;} else {count[i] = count[i - 1] + 1;if (count[i] == k) {s.erase(i - k + 1, k);i = i - k;}}}return s;
}
//Time O(n) Space O(n)
string removeDuplicates(string s, int k) {stack<int> counts; //栈内如果一直保持压入 1 说明没有重复for (int i = 0; i < s.size(); i++) {if (i == 0 || s[i] != s[i - 1]) {counts.push(1);} else if (++counts.top() == k) {counts.pop();s.erase(i - k + 1, k);i = i - k;}}return s;
}
//Time O(n) Space O(n)
1249. 移除无效的括号
题目链接
string minRemoveToMakeValid(string s) {stack<int> braket;int n = s.size();for (int i = 0; i < n; i++) {if (s[i] == '(') {braket.push(i);} else if (s[i] == ')') {if (!braket.empty()) {braket.pop();} else {s.erase(i, 1);n--;i--;}} }while (!braket.empty()) { //删除多余 '('int i = braket.top();s.erase(i, 1);braket.pop();}return s;
}
1381. 设计一个支持增量操作的栈
题目链接
class CustomStack {public:vector<int> stk;int top;CustomStack(int maxSize) {stk.resize(maxSize);top = -1;}void push(int x) {if (top != stk.size() - 1) {++top;stk[top] = x;}}int pop() {if (top == -1) return -1;--top;return stk[top + 1];}void increment(int k, int val) {int lim = min(k, top + 1);for (int i = 0; i < lim; i++)stk[i] += val;}
};
1441. 用栈操作构建数组
题目链接
vector<string> buildArray(vector<int> &target, int n) {int i = 1;vector<string> res;for (int val : target) {while (val != i) {res.push_back("Push");res.push_back("Pop");i++;}res.push_back("Push");i++;}return res;
}
1475.商品折扣后的最终价格*
题目链接
/* 双指针直接遍历 */
vector<int> finalPrices(vector<int> &prices) {int n = prices.size();vector<int> ans;for (int i = 0; i < n; i++) {int discount = 0;for (int j = i + 1; j < n; j++) {if (prices[j] <= prices[i]) {discount = prices[j];break;}}ans.emplace_back(prices[i] - discount);}return ans;
}
//Time O(n^2) Space O(1)
/* 单调栈 */
vector<int> finalPrices(vector<int> &prices) {int n = prices.size();vector<int> ans(n);stack<int> monoSt; //单调递增栈for (int i = n - 1; i >= 0; i--) {while (!monoSt.empty() && monoSt.top() > prices[i]) { monoSt.pop();}ans[i] = monoSt.empty() ? prices[i] : prices[i] - monoSt.top();monoSt.push(prices[i]);}return ans;
}
1504. 统计全1子矩阵*
题目链接
/* 枚举 */
//枚举矩阵每个位置 (i, j) 作为右下角时有多少符合要求的子矩阵
//row 代表矩阵中 (i, j) 向左延伸连续的 1 的个数。有 row 数组后，枚举子矩阵高 k
int bumSubmat(vector<vector<int>> &mat) {int n = mat.size(), m = mat[0].size();vector<vector<int>> row(n, vector<int> (m, 0)); for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {if (j == 0) {row[i][j] = mat[i][j];} else if (mat[i][j]) {row[i][j] = row[i][j - 1] + 1;} else {row[i][j] = 0;}}}int ans = 0;for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {int col = row[i][j];for (int k = i; k >= 0 && col; k--) {col = min(col, row[k][j]);ans += col;}}}return ans;
}
//Time O(n^2 * m) Space O(nm)
/* 单调栈 */
int bumSubmat(vector<vector<int>> &mat) {int n = mat.size(), m = mat[0].size();vector<vector<int>> row(n, vector<int> (m, 0)); for (int i = 0; i < n; i++) {for (int j = 0; j < m; j++) {if (j == 0) {row[i][j] = mat[i][j];} else if (mat[i][j]) {row[i][j] = row[i][j - 1] + 1;} else {row[i][j] = 0;}}}int ans = 0;for (int j = 0; j < m; ++j) { //纵向由列开始统计stack<pair<int, int>> monost; // < row[i][j], height >int sum = 0;for (int i = 0; i < n; i++) {int height = 1;while (!monost.empty() && monost.top().first > row[i][j]) {sum -= monost.top().second * (monost.top().first - row[i][j]); //弹出时减去多于答案height += monost.top().second;monost.pop();}sum += row[i][j];ans += sum;monost.push({row[i][j], height});}}return ans;
}
//Time O(mn) Space O(?)
1541. 平衡括号字符串的最少插入次数
题目链接
int minInsertion(string s) {int ans = 0;int left = 0;int n = s.size();int index = 0;while (index < n) {char c = s[index];if (c == '(') { //char '('left++;index++;} else { //char ')'if (left > 0) {left--;} else {ans++;}if (index < n - 1 && s[index + 1] == ')') { index += 2; //char '))'} else {ans++;index++;}}}ans += left * 2;return ans;
}
1544. 整理字符串
题目链接
string makeGood(string s) {string ret;for (char ch : s) {if (!ret.empty() && tolower(ret.back()) == tolower(ch) && ret.back() != ch) ret.pop_back();elseret.push_back(ch);}return ret;
}
1574. 删除最短的子数组使剩余数组有序
题目链接
/* 单调栈 */
//将数组分成左中右三段，左段和右段是非递减的。
//一个坡顶匹配一群坡底
int findLengthOfShortestSubarray(vector<int>& arr) {stack<int> stk;for (int i = arr.size() - 1; i >= 0; i--) {if (stk.empty() || arr[stk.top()] >= arr[i]) {stk.push(i);continue; }break; //仅找到右段单调部分就停止}if (stk.size() == arr.size()) return 0;int ans = arr.size() - stk.size(); //相对最坏情况（直接删掉中段和左段）int prev = -1;for (int i = 0; i < arr.size(); i++) {if (arr[i] >= prev) { //保证左段单调while (!stk.empty() && arr[i] > arr[stk.top()])stk.pop();int pos = stk.empty() ? arr.size() : stk.top(); //pos 右段坡顶ans = min(ans, pos - i - 1);prev = arr[i];continue;}break;} return ans;
}
//Time O(n) Space O(n)
//同样也可以用一个坡底匹配一群坡顶，区别在于先正序遍历栈中存左段单调区间
/* 双指针优化栈 */
int findLengthOfShortestSubarray(vector<int> & arr) {int n = arr.size();int pos = n - 1;while (pos > 0 && arr[pos] >= arr[pos - 1])pos--;if (pos == 0) return 0;int ans = pos; //直接删掉左段和右段int prev = -1;for (int i = 0; i < arr.size(); i++) {if (arr[i] >= prev) {while (pos != n && arr[i] > arr[pos]) pos++;ans = min(ans, pos - i - 1);prev = arr[i];continue; //跳过当前循环的代码强迫开始下一次循环}break; //循环立即终止，程序流将继续执行紧接循环的下一条语句}return ans;
}
//Time O(n) Space O(1)
1598. 文件夹操作日志搜集器
题目链接
int minOperations(vector<string>& logs) {int depth = 0;for (auto & log : logs) {if (log == "./") {continue;} else if (log == "../") {if(depth > 0)depth--;} else {depth++;}}return depth;
}
1614. 括号的最大嵌套深度
题目链接
int maxDepth(string s) {int ans = 0, size = 0;for (char ch : s) {if (ch == '(') {++size;ans = max(ans,size);} else if (ch == ')') {--size;}}return ans;
}
1653. 使字符串平衡的最少删除次数
题目链接
int minimumDeletions(string s) {int ans = 0;stack<char> stk;for (char ch : s) {if (ch == 'b') {stk.push(ch);} else {if (!stk.empty()) {ans++; //不论是删除前面的 b 还是删除当前的 a， 都增加一次删除操作计数stk.pop();}} }return ans;
}
/* 指针优化 */
// {if ch = b; b++} {if ch = a && b > 0; ans++, b--}
/* 动态规划 */
int minimumDeletions(string s) {int b = 0;vector<int> dp(n + 1, 0);for (char ch : s) {if (ch == 'b') { //字符为 b，只要前 [0, i -1] 是平衡的 [0, i] 就是平衡的，故状态保持dp[i + 1] = dp[i];b++;} else { //字符为 a，要么删除前面多余的 b， 要么删除这个 dp[i + 1] = min(dp[i] + 1, b);}}return dp[n];
}
/* 滚动数组优化 */
// int ans = 0; ans = min(ans + 1, b);
1673. 找出最具竞争力的子序列
题目链接
/* 单调栈 + 贪心*/
//类似 leetcode.402
vector<int> mostCompetitive(vector<int> &nums, int k) {vector<int> stk;int cnt = nums.size() - k; //待删除的个数for (int & digit : nums) {while (!stk.empty() && stk.top() > digit && cnt) {stk.pop_back();cnt--;}stk.push_back(digit);} //维护一个单调递增的栈for (; cnt > 0; cnt--) {stk.pop_back(); } //栈内元素过多，从尾部开始弹return stk;
}
1700. 无法吃午餐的学生数量
题目链接
int countStudents(vector<int>& students, vector<int>& sandwiches) {int dp[2];int cnt = students.size();for (int i = 0; i < students.size(); i++) {dp[students[i]]++;}for (int i = 0; i < sandwiches.size(); i++) {if (dp[sandwiches[i]] > 0) {dp[sandwiches[i]]--;cnt--;} else break;}return cnt;
}
1717. 删除子字符串的最大得分
题目链接
/* 贪心 */
//优先处理得分高的字符串，然后处理栈中剩余的低分子串
int maximumGain(string s, int x, int y) { //ab 得 x 分， ba 得 y 分stack<char> ba, ab;int ret = 0;if (x > y) { //预处理，统一默认 ba 得 y 为高分swap(x, y);reverse(s.begin(), s.end());}for (char c : s) { //ba 高分if (c != 'a') { //栈中弹出顺序实际为 ba 故先判断 a ba.push(c);} else { //新扫描到的字符为 a if (!ba.empty() && ba.top() == 'b') {ba.pop(); //组成 baret += y;} else {ba.push(c);}}}while (!ba.empty()) { //处理 abchar c = ba.top();if (c != 'a') {ab.push(c);} else {if (!ab.empty() && ab.top() == 'b') {ab.pop();ret += x;} else {ab.push(c);}}ba.pop();}return ret;
}
1776. 车队 II
题目链接
vector<double> getCollisionTime(vector<vector<int>>& cars) {vector<double> ans(cars.size());stack<int> st; //单调增栈，栈顶序号代表的车的车速最快，栈底最慢for (int i = cars.size() - 1; i >= 0; i--) {while (!st.empty()) {if (cars[st.top()][1] >= cars[i][1]) {st.pop(); //栈顶车速太快了永远追不上，弹掉} else { if (ans[st.top()] < 0) break; //如果栈顶不会消失，则跳出循环执行计算相遇时间double dist = ans[st.top()] * (cars[i][1] - cars[st.top()][1]; //如果会消失，计算消失前能否追上if (dist > cars[st.top()][0] - cars[i][0]) break; //若能，则跳出循环执行计算相遇时间else st.pop(); //若不能，则弹出}if (st.empty()) {ans[i] = -1;} else {//相遇时间点 = 相对距离 / 相对速度double time = double(cars[st.top()][0] - cars[i][0]) / double(cars[i][1] - cars[st.top()][1]);ans[i] = time;}
1793. 好子数组的最大分数
题目链接
/* 单调栈 */
//类似 84. 柱状图最大矩形面积
int maximumScore(vector<int>& nums, int k) {int n = nums.size();vector<int> left(n), right(n);//当前数字左侧最近的第一个比该数字较小元素stack<int> st;for (int i = 0; i < n; i++) {while (!st.empty() && nums[st.top()] >= nums[i])st.pop();left[i] = st.empty() ? -1 : st.top();st.push(i);}//当前数字右侧最近的第一个比该数字较小元素st = stack<int> ();for (int i = n - 1; i >= 0; i--) {while (!st.empty() && nums[st.top()] >= nums[i])st.pop();right[i] = st.empty() ? n : st.top();st.push(i);} int ans = 0;for (int i = 0; i < n; i++) {if (left[i] < k && right[i] > k) ans = max(ans, (right[i] - left[i] - 1) * nums[i]);}return ans;
}
leetcode 栈 II相关推荐
- [LeetCode] Permutations II 全排列之二
Given a collection of numbers that might contain duplicates, return all possible unique permutations ...
- 【Leetcode栈与队列】1047.删除字符串中的所有相邻重复项 6120.数组能形成多少数对（一些题外话和做题经验！！看作对对碰游戏！！）
文章目录 题外话 1.游戏开发可能使用栈结构 2.编程语言的一些功能实现也会使用栈结构 Leetcode 1047.删除字符串中的所有相邻重复项 1.问题描述 2.解决方案 Leetcode 6120 ...
- LeetCode H-Index II(二分法)
问题:给出一个数组,表示论文引用次数.求H-index,即有h篇论文到少引用h次, 思路:c[i]表示第i篇论文的引用次数,总共有n篇论文.其中数组是递增的.则要求c[i] >= n-i 一种方 ...
- LeetCode Permutations II(有重复元素的全排列)
问题:给出一个有重复元素的数组,要求输出全排列 思路:先排序,然后使用next_permutation 具体代码参考: https://github.com/wuli2496/OJ/tree/mast ...
- Leetcode: Permutations II
Given a collection of numbers that might contain duplicates, return all possible unique permutations ...
- [LeetCode] 4Sum II 四数之和之二
Given four lists A, B, C, D of integer values, compute how many tuples (i, j, k, l) there are such t ...
- [leetcode] N-Queens II
N-Queens II Follow up for N-Queens problem. Now, instead outputting board configurations, return the ...
- LeetCode 编辑距离 II（DP）
1. 题目 给你两个单词 s 和 t,请你计算出将 s 转换成 t 所使用的最少操作数. 你可以对一个单词进行如下两种操作: 删除一个字符 替换一个字符 注意: 不允许插入操作 题目保证有解 示例: ...
- LeetCode栈专题-1(go/py3/c++)
每个专题5道,一天一道 232. 用栈实现队列 地址:https://leetcode-cn.com/problems/implement-queue-using-stacks/ 解题思路1 两个数据 ...
最新文章
- IDEA IntelliJ 如何给web项目配置tomcat
- 第八章 Health Check
- PLSQL程序编写杂烦数据表信息编写批量排版
- 见证IBM如何重新定义企业基础架构
- Java垃圾回收（3）
- MATLAB如何用循环分割,利用Matlab进行分割提取浮游生物
- 领域应用 | OMAHA联盟发布“疾病临床表现”、“中毒”知识图谱及OMAHA知识库
- android 高德获取省市,高德地图定位获取当前地址城市街道等详细信息（全部代码）...
- Linux: 举例说明Linux diff 命令
- spring-第十四篇之资源访问Resource接口
- 图算法之k-Core
- 学习数据库系统概念，设计及应用心得
- 详细讲一下delphi里的 IF 语句
- 时间日期插件引用使用方法
- win7安装vmware+ubuntu16.04
- jquery--图片传送带
- Python实现当中秋遇上国庆
- 5月17号，记住这一天
- 通过jstack分析cpu问题
- 一文读懂Jina生态的Dataclass