力扣10题 正则表达式匹配
力扣22题 括号生成
z是代表左括号的数量，y代表右括号的数量，k代表每个括号的最大数量
设置一个temp，存储递归中的字符串
返回条件:左括号和右括号数量均到达k，将temp压入答案中
每次递归先判断左括号有没有到达上限(z>k)没有就可以插入左括号然后递归(z+1,y,k)递归完回溯
然后判断右括号能不能加，如果左括号数量小于等于右括号，就不能加右括号，加入右括号后
同理递归（z,y+1,k）
class Solution {
public:
string temp; //存储中间字符串
vector<string>ans; //答案
void dfs(int z,int y,int k){
if(z==k&&y==k){ //如果括号达到上线 就压入答案
ans.push_back(temp);
return;
}
if(z<k){ //如果还能加入左括号 就加入
temp.push_back('(');
dfs(z+1,y,k);
temp.pop_back();//回溯
}
if(z>y&&y<k){ //只有还有左括号的时候才能压入右括号
temp.push_back(')');
dfs(z,y+1,k);
temp.pop_back();
}
}
vector<string> generateParenthesis(int n) {
dfs(0,0,n);
return ans;
}
};
力扣23题 合并k个升序链表（困难）
先将这些链表两两合并，然后再四四合并，类似于归并排序的思路。
class Solution {
public:
ListNode *mergeTwoLists(ListNode *head1,ListNode *head2){
ListNode dummy(0);
auto cur=&dummy;
while(head1&&head2){
if(head1->val<head2->val){
cur=cur->next=new ListNode(head1->val);
head1=head1->next;
}else{
cur=cur->next=new ListNode(head2->val);
head2=head2->next;
}
}
cur->next=head1?head1:head2;
return dummy.next;
}
ListNode *dfs(vector<ListNode*>&lists,int i,int j){
if(j==i) return nullptr;
if(j==i+1) return lists[i];
int mid=(j-i)/2;
auto left = dfs(lists,i,i+mid);
auto right = dfs(lists,i+mid,j);
return mergeTwoLists(left,right);
}
ListNode* mergeKLists(vector<ListNode*>& lists) {
return dfs(lists,0,lists.size());
}
};
力扣31题 下一个排列
1.将一个左边的较小数与一个右边的较大数交换，以能够让当前排列变大，从而得到下一个排列。
2.同时我们要让这个较小数尽量靠右，而较大数尽可能小。当交换完成后，较大数右边的数需要按照升序重新排列。
这样可以在保证新排列大于原来排列的情况下，使变大的幅度尽可能小。
如果在步骤1找不到顺序对，说明当前序列已经是一个
class Solution {
public:
void nextPermutation(vector<int>& nums) {
int i =nums.size()-2;
while(i>=0 && nums[i]>=nums[i+1]){
i--;
}
if(i>=0){
int j = nums.size()-1;
while(j>=0 && nums[i]>=nums[j]){
j--;
}
swap(nums[i],nums[j]);
}
reverse(nums.begin()+i+1,nums.end());
}
};
力扣238题 除自身以外数组的乘积
根据表格的主对角线，可将表格分为上三角和下三角两部分。分别迭代计算下三角和上三角两部分的乘积，
即可不使用除法就获得结果。
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
int len = nums.size();
if(len==0) return{};
vector<int>ans(len,1);
ans[0] = 1;
int tmp = 1;
for(int i=1;i<len;i++){
ans[i] = ans[i-1]*nums[i-1];
}
for(int i=len-2;i>=0;i--){
tmp *= nums[i+1];
ans[i] *= tmp;
}
return ans;
}
};
力扣240题 搜索二维矩阵II
1.从矩阵 matrix 左下角元素（索引设为 (i, j) ）开始遍历，并与目标值对比：
（1）当 matrix[i][j] > target 时，执行 i-- ，即消去第 i 行元素。
（2）当 matrix[i][j] < target 时，执行 j++ ，即消去第 j 列元素。
（3）当 matrix[i][j] = target 时，返回 true ，代表找到目标值。
2.若行索引或列索引越界，则代表矩阵中无目标值，返回 false 。
每轮i或者j移动后，相当于生成了“消去一行（列）的新矩阵”，索引（i,j）指向新矩阵的左下角元素（标志数），因此
可以重复使用以上性质消去行（列）。
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int i = matrix.size()-1,j=0;
while(i>=0 && j<matrix[0].size()){
if(matrix[i][j]>target) i--;
else if(matrix[i][j]<target) j++;
else return true;
}
return false;
}
};
力扣 621题 任务调度器
设至少有一种任务A出现次数最多，最大出现次数记为cnt_max
设出现次数与cnt_max相等的任务有equal_cnt_max个
1、有cnt_max个A任务，共有（cnt_max-1）个间隔，每个间隔题目要求插入n个不同的任务，凑不够n个不同任务我们用“待命”来填充。
2、最后一个A后面可能还有其他任务，此时的其他任务只能是出现次数等于cnt_max的任务，不然它早就全部用来填充（（cnt_max-1））个间隔了(每个间隔需填充一个)
3、特殊情况是n=0，则题目求出来的答案应该是任务的总数，即代码中的task.size();
4、答案要包括任务A的个数，所以答案 ans = max((cnt_max-1)*n + cnt_max + equal_cnt_max,tasks.size())
class Solution {
public:
int leastInterval(vector<char>& tasks, int n) {
vector<int>cnt(26,0);
for(auto type : tasks){
cnt[type-'A']++;
}
int cnt_max = 0,equal_cnt_max = -1;
for(auto i:cnt) cnt_max = max(i,cnt_max);
for(int i=25;i>=0;--i){
if(cnt_max==cnt[i]){
++equal_cnt_max;
}
}
int ans = max((cnt_max-1)*n+cnt_max+equal_cnt_max,(int)tasks.size());
return ans;
}
};
力扣394题 字符串解码
class Solution {
public:
string decodeString(string s) {
string res = "";
stack <int> nums;
stack <string> strs;
int num = 0;
int len = s.size();
for(int i = 0; i < len; ++ i)
{
if(s[i] >= '0' && s[i] <= '9')
{
num = num * 10 + s[i] - '0';
}
else if((s[i] >= 'a' && s[i] <= 'z') ||(s[i] >= 'A' && s[i] <= 'Z'))
{
res = res + s[i];
}
else if(s[i] == '[') //将‘[’前的数字压入nums栈内， 字母字符串压入strs栈内
{
nums.push(num);
num = 0;
strs.push(res);
res = "";
}
else //遇到‘]’时，操作与之相配的‘[’之间的字符，使用分配律
{
int times = nums.top();
nums.pop();
for(int j = 0; j < times; ++ j)
strs.top() += res;
res = strs.top(); //之后若还是字母，就会直接加到res之后，因为它们是同一级的运算
//若是左括号，res会被压入strs栈，作为上一层的运算
strs.pop();
}
}
return res;
}
};
