目录
3、合并K个升序链表 - 暴力合并两个链表升级版 / 最小堆(优先队列)
1、合并两个有序链表 - 链表 + 暴力 / 递归
(1)暴力
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy=new ListNode();
ListNode cur=dummy;
while(l1!=null&&l2!=null)
{
if(l1.val<=l2.val)
{
cur.next=l1;
l1=l1.next;
}else{
cur.next=l2;
l2=l2.next;
}
cur=cur.next;
}
cur.next= l1==null? l2:l1;
return dummy.next;
}
}
(2)递归
思路:
力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if(l1==NULL) return l2;
if(l2==NULL) return l1;
if(l1->val<=l2->val)
{
l1->next=mergeTwoLists(l1->next,l2);
return l1;
}
else {
l2->next=mergeTwoLists(l1,l2->next);
return l2;
}
}
};
2、括号生成 - dfs + 剪枝
先求所有括号组合情况,我们发现可以用dfs列出(画出dfs树)
然后我们发现可以进行剪枝:
- 当左括号数>n时,像 (()( 、((()这种肯定不行
- 当dfs过程中右括号数>左括号数时,再深入括号也定然不匹配(先左括号再右括号才能组成完整的)
排除上述两种情况,则剩下的就是匹配的括号情况
class Solution {
public:
vector<string> res;
vector<string> generateParenthesis(int n) {
string str;
dfs("",0,0,n);
return res;
}
void dfs(string cur,int left,int right,int n)
{
if(left > n || left < right) return; // 如果左括号超了,或右括号比左括号多,该分支肯定不行
if(cur.size() == n*2)
{
res.push_back(cur);
return;
}
dfs(cur+"(",left+1,right,n);
dfs(cur+")",left,right+1,n);
}
};
3、合并K个升序链表 - 暴力合并两个链表升级版 / 最小堆(优先队列)
(1)暴力 - 合并两链表升级版
思路:
把K个链表合并转换为每次合并两个链表
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
int n=lists.length;
ListNode res=null;
for(int i=0;i<n;i++)
res=vmerge(lists[i],res);
return res;
}
public ListNode vmerge(ListNode a,ListNode b)
{
ListNode dummy=new ListNode(0);
ListNode cur=dummy,l1=a,l2=b;
while(l1!=null&&l2!=null)
{
if(l1.val<=l2.val)
{
cur.next=l1;
l1=l1.next;
}else{
cur.next=l2;
l2=l2.next;
}
cur=cur.next;
}
cur.next= l1!=null? l1:l2;
return dummy.next;
}
}
(2)最小堆(优先队列)
思路:
最小堆性质是:每次取出的堆顶元素都保证是最小值
我们可以利用这个性质,先把所有链表的头结点存进最小堆中
然后不断取堆顶元素,并存入取出元素的下一个元素
循环取出堆顶直至堆空,也就成功获取一条从小到大的顺序链表
// c++
class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
auto cmp=[](ListNode* a,ListNode* b) {return a->val > b->val;};
priority_queue<ListNode*,vector<ListNode*>,decltype(cmp)> pq;
for(ListNode* x:lists)
if(x) pq.push(x);
ListNode* dummy=new ListNode();
ListNode* cur=dummy;
while(!pq.empty())
{
ListNode* t=pq.top();
pq.pop();
if(t->next) pq.push(t->next);
cur->next=t;
cur=cur->next;
}
return dummy->next;
}
};
// java
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);
for (ListNode head : lists)
if (head != null) pq.offer(head);
ListNode dummy = new ListNode();
ListNode cur = dummy;
while (!pq.isEmpty())
{
ListNode node = pq.poll();
if (node.next != null) pq.offer(node.next);
cur.next = node;
cur = cur.next;
}
return dummy.next;
}
}
4、下一个排列 - 思维+排序
思路:
题目要求寻找比当前序列大,且最接近当前序列值的新序列,即就是求向左逼近该数的新数
为了保证新序列在比原序列大的情况下尽可能小,所以我们从后向前寻找一个大值与前面进行交换(从后向前是因为尽量改变低位的值以保证值最小)
怎么寻找交换的位置呢?其实应该从后向前找第一个升序对(i,j),因为只有升序交换后,值才可能变大
解决了值变大的问题,再而要控制数尽可能小。也就是在交换位置之后寻找一个比交换位置的数大的最小数,与之交换
从后向前找第一个升序对(i,j),所以说 [j,end] 区间必定是降序的,记录i的下标为k。
在[j,end]区间内从后向前找第一个比nums[k]大的数,交换它与nums[k]的位置(改变低位的值保证整体值最小)
交换后的[j,end]区间必定是降序的,将[j,end]翻转(k位置的值变大了,为了保证值尽可能小,后面必须是升序)
class Solution {
public void nextPermutation(int[] nums) {
int n=nums.length;
int k=-1;
//step1:先从后往前找第一个升序对(i,j),记录i的坐标为k
for(int i=n-2;i>=0;i--)
{
int j=i+1;
if(nums[i]<nums[j])
{
k=i;
break;
}
}
//如果这个序列是降序,则需要翻转
if(k==-1)
{
swap(0,n-1,nums);
return;
}
//step2:从后向前找[j,end]中找第一个比nums[k]大的数nums[i],交换两者位置
for(int i=n-1;i>k;i--)
{
if(nums[i]>nums[k])
{
int t=nums[i];
nums[i]=nums[k];
nums[k]=t;
break;
}
}
for(int i=0;i<n;i++)
System.out.print(nums[i]+" ");
//step3:此时[j,end]绝对是升序的,翻转成降序
swap(k+1,n-1,nums);
}
public void swap(int a,int b,int[] nums)
{
int n=nums.length;
for(int i=a,j=b;i<j;i++,j--)
{
int t=nums[i];
nums[i]=nums[j];
nums[j]=t;
}
}
}
5、在排序数组中查找元素的第一个和最后一个位置 - 二分
二分模板:
- l + r >> 1 —— 先 r = mid 后 l = mid+1 —— 寻找左边界 —— 找大于某个数的最小值
- l+r+1>>1 —— 先 l = mid 后 r = mid-1 —— 寻找右边界 —— 找小于某个数的最大值
思路:
由于数组有序,因此先二分出第一个出现的位置st,然后再二分出比target大的数(target+1)的位置ed,返回答案【st,ed】
class Solution {
public int[] searchRange(int[] nums, int target) {
int st=find(nums,target);
int ed=find(nums,target+1);
if(st==nums.length||nums[st]!=target) return new int[]{-1,-1};
return new int[] {st,ed-1};
}
public int find(int[] nums,int target)
{
int l=0,r=nums.length;
while(l<r)
{
int mid=l+r>>1;
if(nums[mid]>=target) r=mid;
else l=mid+1;
}
return l;
}
}
6、组合总和 - dfs + 剪枝优化
思路:
这题看数据范围知道是跟全排列类似的dfs暴力枚举+剪枝
但是我不太擅长dfs,感觉回溯的思路有点反人类,因此根据题解学习的该题
首先我的思路是,像树形dfs一样枚举所有情况,然后如果之和>target则进行剪枝
我们发现这样会出现重复的子集,比如说在3这个分支下出现过【3,4……】,而4这个分支下会出现【4,3……】出现了重复,因此我们需要去重
因此我们规定只需要升序的序列,因为其他顺序肯定被之前升序的序列枚举过,只是顺序不一样,进行去重剪枝。这里我们先对choice数组排序,再按顺序枚举choice的元素,每次找组合只往它及之后找,我们规定一个当前枚举位置st,每次dfs时循环st后面的数(for(i=st;;i++))
class Solution {
List<List<Integer>> res=new ArrayList<>();
public List<List<Integer>> combinationSum(int[] c, int target) {
Arrays.sort(c);
List<Integer> cur=new ArrayList<>(); //用于记录每一个方案
int st=0; //设置遍历起点
dfs(c,target,cur,st);
return res;
}
public void dfs(int[] c,int target,List<Integer> cur,int st)
{
if(target==0) //子集和==target时记录方案
{
res.add(new ArrayList<>(cur));
return;
}
//从st开始遍历 避免生成重复子集
for(int i=st;i<c.length;i++)
{
if(target-c[i]<0) break;
cur.add(c[i]);
dfs(c,target-c[i],cur,i);
cur.remove(cur.size()-1); //撤销选择,回到之前的状态
}
}
}
7、接雨水 - 单调栈
思路:
刚开始我写的时候用的模拟,思路大概是先预处理出最低点和最高点,然后再遍历最低点逐个计算,但是这种遇到样例二这种就算不了,看了题解之后,发现单调栈这个方法更具有普遍性,而我做的模拟只能不断测试数据进行修改
单调栈是思路是保持栈内单调递减,当遇到当前柱子高度cur比栈顶高时,cur可以作为右边界,和前方的柱子进行雨水结算,cur依次与栈内比它小的柱子进行结算
具体做法是,如果遇到cur比栈顶高,则将栈顶出栈作为bottom(注意栈顶元素抛出),然后依次将栈内的元素作为左边界,计算接雨水体积,循环出栈,直至保持栈内单调,然后入栈(比较抽象,配上图会比较好理解)
class Solution {
public int trap(int[] h) {
Deque<Integer> stk=new LinkedList<>();
int sum=0;
for(int r=0;r<h.length;r++)
{
while(!stk.isEmpty()&&h[stk.peek()]<h[r])
{
int bottom=stk.pop();
if(stk.isEmpty()) break; //如果没有左边界 则盛不了水
int l=stk.peek();
int H=Math.min(h[r],h[l])-h[bottom];
sum+=H*(r-l-1);
}
stk.push(r);
}
return sum;
}
}