今天开始整hard题,果然费时。
1249.移除无效的括号
题目链接:1249.minimum-remove-to-make-valid-parentheses
解法:
这个题用栈来处理,用栈来记录左括号的位置,同时用一个向量来记录左括号和右括号是否有效(有效则不需要删除)。
如果遇到左括号,那么栈中弹入,同时该位置为无效(需要删除),待后面遇到右括号再置为有效。
如果遇到右括号,那么如果栈为空(前面没有左括号可以匹配),那么该位置无效;如果栈不为空,那么该位置有效,且把前面左括号(栈顶元素)改为有效。
最后把有效的元素取出来即可。
还有一种做法是直接在遍历字符的过程中,记录左括号,并且即时删除无效的右括号,最后遍历结束再删除左括号。这种即时删除的写法会在遍历过程中就改变字符串s,感觉还是容易出错,所以推荐遍历结束后,再同一删除。
参考题解:栈
边界条件:无
时间复杂度:O(n)
空间复杂度:O(n)
class Solution {
public:
string minRemoveToMakeValid(string s) {
stack<int> leftStack;
// 如果是有效的,那么值为true
vector<bool> validIdx(s.size(), true);
for (int i=0; i<s.size(); i++) {
if (s[i]=='(') {
leftStack.push(i);
// 暂时没匹配到右括号,所以目前是无效
validIdx[i] = false;
} else if (s[i]==')') {
if (leftStack.empty()) {
// 没有左括号,所以右括号无效
validIdx[i] = false;
} else {
// 前面的左括号改为有效
// 右括号初始化为有效,所以不用改
validIdx[leftStack.top()] = true;
leftStack.pop();
}
}
}
string res;
for (int i=0; i<s.size(); i++) {
if (validIdx[i]) {
res += s[i];
}
}
return res;
}
};
23.合并K个升序链表
解法:
(1)第一种方法是优先队列,即构造小根堆(队首元素最小),然后把所有链表添加到优先队列中,那么从队首到队尾是根据val进行升序排列的。
建立一个虚拟头节点,每次都把val最小的node添加作为next,同时把该node的next添加到优先队列中。最近返回虚拟头节点的next即可。
优先队列的思路比较好理解。
(2)第二种方法是分治合并。将 k个链表两两配对并将同一对中的链表合并;不断重复这个过程,直到剩下一个链表。
参考题解:优先队列
边界条件:
优先队列的复杂度:
分治合并的复杂度:
/**
* Definition for singly-linked list.
* 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:
struct Status {
int val;
ListNode *ptr;
// 重载小于操作符,val大的反而认为是小的
// 因为优先队列默认是最大堆,即队首的元素是最大的,但是我们这里需要最小堆,所以把比较的逻辑反向
bool operator < (const Status& sta) const {
return val > sta.val;
}
};
// 注意元素是Status而不是Status*,所以取属性是通过 s.val 而不是 s->val
priority_queue<Status> q;
ListNode* mergeKLists(vector<ListNode*>& lists) {
for (auto& node: lists) {
if (node) {
q.push({node->val, node});
}
}
ListNode head, *tail = &head;
while (!q.empty()) {
auto s = q.top();
q.pop();
tail->next = s.ptr;
tail = tail->next;
if (s.ptr->next) {
q.push({s.ptr->next->val, s.ptr->next});
}
}
// 注意head不是指针,而是一个真正的对象,所以使用.而不是->来获取
return head.next;
}
};
/**
* Definition for singly-linked list.
* 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:
ListNode* mergeTwoLists(ListNode* a, ListNode* b) {
if ((!a) || (!b)) return a? a:b;
// 为啥不直接用 a和b 这俩指针呢
ListNode head, *tail=&head, *aPtr=a, *bPtr=b;
while (aPtr && bPtr) {
if (aPtr->val < bPtr->val) {
tail->next = aPtr;
aPtr = aPtr->next;
} else {
tail->next = bPtr;
bPtr = bPtr->next;
}
tail = tail->next;
}
tail->next = (aPtr ? aPtr:bPtr);
return head.next;
}
ListNode* merge(vector<ListNode*>& lists, int l, int r) {
if (l==r) return lists[l];
if (l > r) return nullptr;
int mid = l + (r - l) / 2;
return mergeTwoLists(merge(lists, l, mid),merge(lists, mid+1, r));
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
return merge(lists, 0, lists.size()-1);
}
};
773.滑动谜题
题目链接:773.sliding-puzzle
解法:
这个题实名表扬labuladong同志,题解写得很详细很通俗易懂,从0开始讲解,不需要前置知识。
这个题用BFS来处理,一次 移动 定义为选择 0
与一个相邻的数字(上下左右)进行交换,所以每次搜索的过程如下图所示:
一直搜下去,直到第一次出现了目标矩阵,那返回交换次数即可。
其他的看题解吧,题解写得不错。参考题解:labuladong的BFS
边界条件:
class Solution {
public:
int slidingPuzzle(vector<vector<int>>& board) {
int m = 2, n = 3;
string start;
string target = "123450";
// 将矩阵转为行优先的字符串
for (int i=0; i<m; i++) {
for (int j=0; j<n; j++) {
start += board[i][j] +'0';
}
}
// 记录一维字符串中i位置的相邻索引
vector<vector<int>> neighbor = {
{1,3},
{0,4,2},
{1,5},
{0,4},
{3,1,5},
{4,2}
};
queue<string> q;
unordered_set<string> visited;
q.push(start);
visited.insert(start);
int step = 0;
while (!q.empty()) {
int size = q.size();
for (int i=0; i<size; i++) {
string cur = q.front();
q.pop();
// 如果已经调整为目标矩阵,则返回结果
if (cur == target) return step;
// 找到数字0的索引
int idx = 0;
while (cur[idx]!='0') {
idx++;
}
// 将数字0与相邻数字交换位置
for (int adj: neighbor[idx]) {
string newBorad = cur;
swap(newBorad[adj], newBorad[idx]);
if (!visited.count(newBorad)) {
q.push(newBorad);
visited.insert(newBorad);
}
}
}
step++;
}
return -1;
}
};