我的刷题之旅——栈、堆、队列、并查集
前言
这一部分的题目相当相当重要哦,主要用于一些特殊的场合和某些特定题目的优化，大多数是那种表面很难，其实很套路的题目，经常和其他算法结合在一起，但是也不要担心，我感觉这些题目算是最套路的，永远是哪几个场合会用到。
（一）栈
剑指offer09 用两个栈实现队列
很简单，一个做队列，一个做缓存辅助
入队：队列栈全部放入缓存，将结果放回队列，然后缓存放回栈
出队：直接pop
20 有效的括号——辅助栈法
就是最简单的栈的应用，
如果当前元素是右括号，看看是不是栈不空并且栈顶弹出的是不是对应，不是提前返回false；
如果当前元素是左括号，直接入栈。
最后如果栈空才为真。
class Solution {
public boolean isValid(String s) {
HashMap<Character,Character> map = new HashMap<>();
map.put('(',')');
map.put('[',']');
map.put('{','}');
LinkedList<Character> stack = new LinkedList<>();//注意没有Stack类
for(int i=0;i<s.length();i++){
Character c = s.charAt(i);
if(map.containsKey(c)){
stack.push(c);
}else{
if(stack.isEmpty())
return false;
char top = stack.pop();//栈的方法是push和pop
if(map.get(top)==c)
continue;
else return false;
}
}
return stack.size()==0;
}
}
155 最小栈（单调栈思想——存在和左右比较的关系）
要用O（1）的复杂度求出栈中的最小元素，但是栈同时也在pop，所以我们不可以用一个变量保存当前栈的最小值，那么怎么办呢？——使用局部最小辅助栈，该辅助栈的栈顶存放当前栈状态的最小值。
主栈进新元素a：
如果辅助栈空，a放入；
a>辅助栈顶，辅助栈不变；
a<=辅助栈顶，辅助栈中将a放入；
主栈弹出元素a：
a>辅助栈顶，此时辅助栈顶是min；
a==辅助栈顶，此时辅助栈顶pop；
class MinStack {
private Stack<Integer> stack;
private Stack<Integer> help;
public MinStack() {
stack = new Stack<>();
help = new Stack<>();
}
public void push(int x) {
stack.push(x);
if(help.isEmpty()||x<=help.peek())
help.push(x);
}
public void pop() {
if(stack.pop().equals(help.peek()))//一定要注意集合中装的是对象，比较的时候用equals方法，==是不可以的
help.pop();
}
public int top() {
return stack.peek();
}
public int getMin() {
return help.peek();
}
}
394 字符串解码
如题
输入：s = “3[a2[c]]”
输出：“accaccacc”
我们做的时候发现也是需要括号改变顺序的，使用辅助栈。
预先在栈中push一个new StringBuilder（"")；
如果当前元素是数字，转成数字push入栈；
如果当前元素是[，直接push入栈，并且在栈中push一个new StringBuilder（"")；
如果当前元素是字母，栈顶的StringBuilder串拼接之；
如果当前元素是]，从栈中依次pop出栈顶的StringBuilder串、[、数字，然后该字母串倍增那个数字的次数。然后将倍增后的串追加到栈顶的串后面，回到开始接着遍历；
结束遍历的时候栈顶放着的是结果。
class Solution {
public String decodeString(String s) {
LinkedList stack = new LinkedList();
stack.push(new StringBuilder(""));
for(int i=0;i<s.length();i++){
int digit=0;//
while(s.charAt(i)>='0'&&s.charAt(i)<='9'){
digit=digit*10 +s.charAt(i)-'0';
i++;
}
if(digit!=0)
stack.push(digit);
if(s.charAt(i)=='['){
stack.push('[');
stack.push(new StringBuilder(""));
}
else if(s.charAt(i)==']'){
StringBuilder temp = (StringBuilder)stack.pop();
stack.pop();//pop左括号
Integer count = (Integer)stack.pop();
String ss = temp.toString();
for(int j=0;j<count-1;j++)
temp.append(ss);
StringBuilder sb = (StringBuilder)stack.peek();
sb.append(temp);
}else{
StringBuilder sb = (StringBuilder)stack.peek();
sb.append(s.charAt(i));
}
}
return (String)stack.peek().toString();
}
}
739 每日温度(单调栈——需要和左右比较的时候用)
遍历每日温度，维护一个单调栈——栈中保存着递减的下标，为什么要维持这样一个递减的栈呢？因为每次只有变成递增状态的时候能够找到增温点。
如果当日温度<=栈顶温度，也就是说
如果当日温度>栈顶温度，代表栈顶的那天的升温日找到了，栈元素依次出栈，直到把当日温度放在它合适的位置。
class Solution {
public int[] dailyTemperatures(int[] T) {
LinkedList<Integer> stack = new LinkedList<>();
int[] res = new int[T.length];
for(int i=0;i<T.length;i++)
res[i] = 0;
for(int i=0;i<T.length;i++){
if(stack.isEmpty() || T[i] <= T[stack.peek()])
stack.push(i);
else{
while(!stack.isEmpty() && T[stack.peek()] < T[i]){//注意，使用stack.peek的时候确保不空才行
int index = stack.pop();
res[index] = i-index;
}
stack.push(i);
}
}
return res;
}
}
84 柱状图中的最大矩形
85 最大矩形
42 接雨水——dp 双指针 单调栈
这一题有三种简单解法，每一种都很棒，全部要求掌握。雨水数组是a[]
（1)两遍遍历，用数组保存a[i]的前i个高度中的最大值（可以用动态规划思想）
第二遍遍历，从a最后一个元素向前，每次求出从当前到最后的最大值。此时当前元素左最大值得到，右最大值也得到，得到可积累雨水——最简单通俗容易想，时间复杂度O（n），空间O（n）。
代码如下：
class Solution {
//遍历求左右最大高度
public int trap(int[] height) {
if(height.length==0)
return 0;
int res = 0;
int[] left = new int[height.length];
//第一遍，求每个节点左边最高（含自己）
left[0] = height[0];
for(int i=1;i<height.length;i++){
left[i] = Math.max(left[i-1],height[i]);
}
//第二遍，求右边最高，并且同时比较左右最高，求出可积累雨水量
int rightmx = 0;
for(int i=height.length-1;i>=0;i--){
rightmx = Math.max(rightmx,height[i]);
res += Math.min(left[i],rightmx)-height[i];
}
return res;
}
}
(2)最高效的方法——（双指针），时间O（n），空间O(1)
left指针：从左往右当前下标
right指针：从右向左当前下标
left_max:left指针左边能找的最大值（不含left自己）——这个值一定是当前left的左堤坝
right_max:right指针右边能找到的最大值（不含right）——这个值一定是当前right的优堤坝
对于left而言，左边最大值一定是left_max，右边最大值范围是“大于等于”right_max的，所以，如果当前的left_max < right_max的时候，说明将来右无论怎样移动都不会影响结果，水都会被从右边挡住，左边的left_max一定是短板。当这种情况下，我们可以去除了left指针了，并计算当前left的存水量，left++。
反之，若right_max < left_max,就可以处理右节点了。
class Solution {
public int trap(int[] height) {
if(height.length<=2)
return 0;
int res = 0;
int left = 0,right = height.length-1;
int leftMax = 0,rightMax = 0;
while(left <= right){//注意结束条件，当left==right时，当前节点依然可以和左右最高值计算存雨量
if(leftMax < rightMax){//左指针可计算存储量了
res += Math.max(leftMax-height[left],0);
leftMax = Math.max(leftMax,height[left]);
left += 1;
}else{
res += Math.max(rightMax-height[right],0);
rightMax = Math.max(rightMax,height[right]);
right--;
}
}
return res;
}
}
（3）用单调栈，找到每次发生上升的位置，只有此时才可能出现囤积雨水的现象。
思路：
设置两个栈，一次存放递减高度的下标，一个存放递减的高度（每次囤积雨水时将高度更新为囤积后的高度）
public class Solution{
int trap(int[] height){
int n = height.length;
if(n<=2) return 0;
int res =0;//结果
int curLeftMax=0;//当前节点左边最大的那个高度（不含当前）
LinkedList<Integer> stackHeight = new LinkedList<Integer>();
LinkedList<Integer> stackIndex = new LinkedList<Integer>();
for(int i=0;i<n;i++){
int cur = height[i];
if(cur>=curLeftMax){//如果当前节点是新的制高点
while(!stackHeight.isEmpty()){//更新递减栈，以原来的左边最高为短板，计算雨水
int h = stackHeight.pop();
int index = stackIndex.pop();
if(stackHeight.isEmpty()) break;//最后一个元素，也就是那个原来的左边最高被pop了，可直接退出
res += (index-stackIndex.peek())*(curLeftMax-h);//雨水=长*高，高是和左最高的差，长是递减栈距离自己左边第一个元素的距离。
}
curLeftMax = cur;
stackHeight.push(cur);
stackIndex.push(i);
}else{//当前节点很普通
while(stackHeight.peek()<=cur){
int h = stackHeight.pop();
int index = stackIndex.pop();
res += (index - stackIndex.peek())*(cur-h);
}
stackHeight.push(cur);
stackIndex.push(i);
}
}
return res;
}
}
（二）堆
剑指offer41 数据流中的中位数
思路：
首先能想到的是：维持一个有序的数组，每次数据流新加入一个元素的时候，通过二分查找的方式找到<=该元素的位置，右移插入，这种方法太垃圾了；
由于发现要找中位数，左边从小到大，右边从大到小，这样我们存放数据不再用数组，而是两个堆，左边搞一个大根堆Left，右边搞一个小根堆Right，各自存放一半元素。
- 添加元素x
- Left的大小==Right的大小，将x放入Right，然后Right新的堆顶放回Left
- Left的大小>Right的大小，x放入Left，Left新的堆顶放回Right
- 查找中位数
- Left的大小==Right的大小，中位数是堆顶的算数平均
- Left的大小>Right的大小，中位数是Left的堆顶
时间复杂度：查找中位数是O（1），插入元素是O（logN）
空间复杂度：O（N）
class MedianFinder{
Queue<Integer> Left,Right;
public MedianFinder(){
Left = new PriorityQueue<>((x,y)->y-x);//大顶堆，放小的那一半
Right = new PriorityQueue<>();//小顶堆
}
//添加元素
public void add(int x){
if(Left.size() == Right.size()){
Right.add(x);
Left.add(Right.poll());
}else{
Left.add(x);
Right.add(Left.poll());
}
}
//找到中位数
public double findMedian(){
if(Left.size() == Right.size())
return (Left.peek()+Right.peek())/2;
else
return Left.peek();
}
}
23 合并k个升序链表(三种方法)
方法一：堆选最小，遍历链表
优先队列存放K个链表的当前表头，每次poll()作为结果链表的下一个元素。
时间复杂度：O（KNlogK）KN个元素*堆深度
空间复杂度：O（K）
方法二：依次合并，知道合并完K个，每次用双指针的方法合并
时间复杂度：第一次O（n），第二次O（2N），第三次O（3N）……最后总共O（KKN）
空间复杂度：O（1）只用了双指针
在这里插入代码片
方法三：
分治合并，类似归并，
时间复杂度：第一次K/2组，每小组O（2N），第二次K/4组，每小组O（4N）……，一共O（KNlogK ）
空间复杂度：O(logK),K个链表
在这里插入代码片
215 数组的第K个最大的元素
求第K个大的原素，我们首先本能要知道的是这一题可以用堆排序的方法，毕竟堆排序是一种性能为nlogn的排序算法，性能很棒，找到第k个非常合适。但是我们要知道堆排序不是这种题的最好做法——最好的是快速排序
（1）如何用快排找第k大的元素
先复习一下快排：快排是先从第一个元素出发，交换元素，使得该元素左边都比他小，右边都>=它，这样数组就被划分为左右两部分了，然后左右两部分分别快排。
我们可以利用这种划分+分治的思想找第k大的元素
- 如果划分好后的位置下标是 n-k,返回之
- 如果划分好后的位置下标在n-k前面，也就是说第k大的元素在它后面，递归调用 右边
- 如果划分后的位置下标>n-k,递归调用左边
时间复杂度：O（nlogn）,
空间复杂度：用栈，是logn
class Solution {
public int findKthLargest(int[] nums, int k) {
return quicksort(nums,0,nums.length-1,k);
}
private int quicksort(int[] a,int left,int right,int k){
if(left>right)
return -1;
int base=a[left],i=left,j=right;
while(i<j){
while(a[j]>=base && j>i)
j--;
while(a[i]<=base && j>i)//都是带等号的，否则出错
i++;
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
a[left] = a[i];
a[i] = base;
if(i==a.length-k)
return a[i];
else if(i<a.length-k)
return quicksort(a,i+1,right,k);
else
return quicksort(a,left,i-1,k);
}
}
（2）经典做法——堆
这里也有要注意的地方，求第k个最大元素，建立一个大根堆还是小根堆呢？大跟堆——当堆建立好之后，依次pop出去k-1个元素，此时堆顶就是第k最大元素。
当然我们可以调用java的库函数
PriorityQueue<Integer> heap = new PriorityQueue(n,(a,b)->b-a);//大顶堆要写倒过来
但是面试官一般可能让我们自己建立堆，所以还是老老实实自己实现吧。
堆很简单的，从下到上煎堆，从上到下跟下面的孩子比较交换，最大的最为父亲，如果发生交换，交换后得节点接着和孩子比较更新。
时间复杂度O（nlogn），建立堆O（n），删除k个元素O（klogn）因为k<n,渐进时间复杂度是O（n+klogn）=O(nlogn)
空间O（1）
public class Solution{
public int findKthLargest(int[] nums,int k){
return heapsort(nums,k);
}
public int heapsort(int[] a,int k){
int len = a.length;
for(int i = len/2-1;i>=0;i--)//初始化堆
heapajust(a,i,len);
swap(a,0,--len);//找到最大的元素了
if(k==1)
return a[len];
while(len>0){//当未排序长度>0时
heapajust(a,0,len);
swap(a,0,--len);
if(a.length-k==len)
return a[len];
}
return a[0];
}
private void heapajust(int[] a,int index,int len){
int left = index*2+1;
while(left<len){
int larger = left;
if(left+1<len && a[left+1]>a[left])
larger = left+1;
if(a[index]<a[larger]){//更大和和当前节点交换，并且当前节点变成交换后的位置，注意更新左孩子left
swap(a,index,larger);
index = larger;
left = index*2+1;
}else{
break;
}
}
}
private void swap(int[] s,int a,int b){
int temp = s[a];
s[a] = s[b];
s[b] = temp;
}
}
347 前K个高频元素（hash+快排/堆排）
首先用一个HashMap记录每个元素出现的次数，得到一个次数数组，然后需要找到这个次数数组的第k大的元素，注意要求时间复杂度<nlogn。
找出数组第k大的元素不就是上面那一题嘛。
方法一：hash+快排
quick(a[],left,right)，将a从小道大排序，以a[left]为基准元素，将a[]分成两部分，左边都<a[left],右边都>=a[left]，得到基准元素的位置
如果该位置<n-k ,快排左部分
如果该位置>n-k,快排右部分
如果该位置=n-k，找到，将它和它右边的元素统统放入结果数组。
时间复杂度：原本的快排是O（nlogn），但是我们现在只需要递归其中一个分支，算法复杂度减低到了O（n）；
空间复杂度：O（n）。
class Solution{
public int[] topKeyFrequent(int[] nums ,int k){
//哈希表放着num数组元素出现的次数
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int item:nums)
map.put(item,map.getOrDefault(item,0)+1);
//次数数组,如{[1,3]，[2,1]，[3,2]}代表元素1出现3次，元素2出现1次，元素3出现2次
List<int[]> list = new ArrayList<int[]>();
for(Map.Entry<Integer,Integer> entry : map.entrySet()){
int key = entry.getKey();
int count = entry.getValue();
list.add(new int[]{key,count});
}
int[] res = new int[k];//结果集
quicksort(list,0,list.size()-1,res,0,k);
return res;
}
//快排求出list的出现次数前k做多的元素，放在res中
public void quicksort(List<int[]>,int left,int right,int[] res,int index,int k){
int base = list.get(left)[1];
int i = left,j = right;
while(i<j){
while(i<j && list.get(j)[1] >= base)
j--;
while(i<j && list.get(i)[1] <= base)
i++;
int[] temp = list.get(i);
list.set(i,list.get(j));
list.set(j,temp);
}
int[] temp = list.get(left);
list.set(left,list.get(i));
list.set(i,temp);
if(i==list.size()-k){
while(i<list.size()){
res[index] = list.get(i)[0];
index++;
i++;
}
}else if(i<list.size()-k){
quicksort(list,i+1,right,res,0,k);
}else{
quicksort(list,left,i-1,res,0,k);
}
}
}
方法二：hash+堆排
就是用堆排序，这一题不能完全按照上面的那种搞一个n元素的大顶堆，全部放进堆里面，最后从堆里面pop出k个元素的方法，因为如果那么做的话时间复杂度会达到nlogn
所以我们建立维护一个k个元素的小顶堆，遍历次数数组，当前元素<=堆顶，不管当前元素；当前元素>堆顶，插入堆。
注意——求最大k个用小顶堆，求最小k个用大顶堆
时间复杂度O（nlogk）
空间复杂度：O（N）
class Solution{
public int[] topKFrequent(int[] nums,int k){
//哈希表放着num数组元素出现的次数
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int item:nums)
map.put(item,map.getOrDefault(item,0)+1);
//最小堆
PriorityQueue<int[]> queue = new PriorityQueue<int[]>(new Comparator<int[]>(){
public int compare(int[] m,int[] n){
return m[1]-n[1];
}
});
//遍历维护这个最小跟堆
for(Map.Entry<Integer,Integer> entry : map){
int key = entry.getKey();
int count = entry.getValue();
if(queue.size()==k){
if(queue.peek()[1] < count){
queue.poll();
queue.offer(new int[]{key,count});
}
}else{
queue.offer(new int[]{key,count});
}
}
//从堆中得到返回值
int[] res = new int[k];
for(int i=0;i<k;i++)
res[i] = queue.poll()[0];
return res;
}
}
（三）队列
剑指offer59I 滑动窗口的最大值（单调队列）
题目：给定一个数组和滑动窗口大小为k，求出每次滑动窗口的最大值
思路：
用int[n-k+1] res存放每个滑动窗口的最大值,
用一个队列作为辅助，队列头存放当前窗口的最大值，每次向后滑动窗口的时候，能影响新窗口最大值取值的元素有
- 原来窗口的最大值，看看是否被移出
- 原来窗口的次最大值
- 当前新元素
我们可以发现，前面窗口的从最大值开始向后面遍历，次最大值、次次最大值、次次次最大值会影响结果。
所以我们可以维护一个单调非严格递减队列，保证队列中的元素是从头到尾的最大值、次最大值、次次最大值……，注意后面出现的元素如果比队列尾部的一些元素小，会覆盖他们变成新的次大元素，他们就没了。
class solution{
public int[] maxSlidingWindow(int[] nums,int k){
//边界
if(nums.length == 0 || k==0)
return new int[0];
//我们写队列最好是用Deque这个API
Deque<Integer> deque = new LinkedList<>();
//先构造第一个窗口
for(int i=0;i<k;i++){
//后面出现的元素如果比队列尾部的一些元素小，会覆盖他们变成新的次大元素
while(!deque.isEmpty() && deque.peekLast() < nums[i])
deque.removeLast();
deque.addLast(nums[i]);
}
res[0] = deque.peekFirst();
//下面是滑动窗口阶段
for(int i=k;i<nums.length; i++){
if(deque.peekFirst() == nums[i-k])
deque.removeFirst();
while(!deque.isEmpty() && deque.peekLast() < nums[i])
deque.removeLast();
deque.addLast(nums[i]);
res[i-k+1] = dequeue.peekFirst();
}
return res;
}
}
剑指offer59II 队列的最大值
要求出队 入队 求最大值的函数都是O（1）复杂度
思路：单调队列
搞一个非递增辅助双端队列max
max的对头始终是当前队列的最大值，
- 插入元素时，如果新元素是的东西，不管他，直接放进入，队伍前面有大家伙撑着；如果是大家伙，max就要更新了，将队伍前面新来的小的家伙淘汰掉，再将这个大家伙放进入当升职当长老。
- poll元素的时候，如果和max顶相同也要一起poll，否则不管max
class MaxQueue{
Queue<Integer> queue;
Deque<Integer> max;
public MaxQueue(){
queue = new LinkedList<>();
max = new LinkedList<>();
}
//入队
public void push_back(int value){
queue.add(value);
while(!max.isEmpty() && max.peekLast() < value)
max.removeLast();
max.addFirst(value);
}
//出队
public int pop_front(){
if(!max.isEmpty() && queue.peek().equals(max.peekFirst()))
max.removeFirst();
return queue.size()==0?-1:queue.poll();
}
//最大值
public int max_value(){
return max.size()==0?-1:max.peek();
}
}
621 任务调度器（用优先队列太麻烦了，填桶策略）
冷却n,一个桶子>n+1，桶子里智能放不同的任务,行数由频数最大 的那个元素数量决定。
- 任务种类很少的时候，填不满n+1
- 任务种类很多的时候，桶子放不下，一行放不同可以尽情的放超过n+1都可以执行
- 我们就计算第一种就行了，和任务长度间取一个最大值做返回值
class Solution{
public int leastInterval(char[] tasks,int n){
int[] counts = new int[26];//存放的是每种任务数量
for(char c : tasks)
counts[c-'A']+=1;
int max = 0;
for(int count : counts) max = Math.max(max,count);
int maxCount = 0; //最后一行还剩的元素数量
for(int count:counts)
if(count == max)
maxCount++;
return Math.max(tasks.length, (n+1)*(max-1)+maxCount);
}
}
（四）并查集（一般用于判断图中是否有环，也可以用于求连通分量个数）
求连通分量的个数，比如我们 200和547，其实最好还是用宽搜或者深搜，并查集效率太低了。
这里了解即可。
128最长连续序列——（字节原题，并查集和哈希表法）
（1）哈希表+优化
我们考虑枚举数组中的每个数 x，考虑以其为起点，不断尝试匹配 x+1, x+2, ⋯ 是否存在，假设最长匹配到了 x+y，那么以 x 为起点的最长连续序列即为 x, x+1, x+2,⋯,x+y，其长度为 y+1，我们不断枚举并更新答案即可。
其实更高效的方法是用一个哈希表存储数组中的数，这样查看一个数是否存在即能优化至 O(1) 的时间复杂度。
仅仅是这样我们的算法时间复杂度最坏情况下还是会达到 O(n^2)，无法满足题目的要求。
但仔细分析这个过程，我们会发现其中执行了很多不必要的枚举，如果已知有一个 x, x+1, x+2⋯,x+y 的连续序列，而我们却重新从 x+1，x+2 或者是 x+y 处开始尝试匹配，那么得到的结果肯定不会优于枚举 x为起点的答案，因此我们在外层循环的时候碰到这种情况跳过即可。
那么怎么判断是否跳过呢？由于我们要枚举的数 x 一定是在数组中不存在前驱数 x-1 的，不然按照上面的分析我们会从 x-1开始尝试匹配，因此我们每次在哈希表中检查是否存在 x-1 即能判断是否需要跳过了。
class Solution {
public int longestConsecutive(int[] nums) {
Set<Integer> set = new HashSet<>();
for(int a:nums)
set.add(a);
int maxlen = 0;
for(int a:nums){
if(a==Integer.MIN_VALUE || !set.contains(a-1)){//小心边界
int curlen = 1;
int curnum = a;
while(a != Integer.MAX_VALUE && set.contains(curnum+1)){//小心边界
curnum++;
curlen++;
}
maxlen = Math.max(maxlen,curlen);
}
}
return maxlen;
}
}
方法二：并查集
能够想到使用并查集来解决，关键是将连续的整数视为一个集合，当然最小的集合大小就是1，元素本身。因此在合并时将该数x与x+1合并，（如果x+1也在数组中），并计算集合大小的最大值就好了
class Solution {
//并查集类
class UnionFind{
Map<Integer, Integer> parents;
public UnionFind(int[] arr) {//初始化，map<自己，祖先>
parents = new HashMap<>();
for (int i : arr) {
parents.put(i, i);
}
}
public Integer find(int x) {//查找x的祖宗
if (!parents.containsKey(x)) return null;
int t = parents.get(x);
if(x != t)
parents.put(x, find(t));//如果x的祖先不是自己，更新x的祖先
return parents.get(x);//最后返回x的祖先
}
public boolean union(int x, int y) {//将x和y变成一个集合关系（具有祖先子孙关系）
Integer rootX = find(x), rootY = find(y);
if (rootX == null || rootY == null) return false;
if(rootX.equals(rootY)) return false;
parents.put(rootX, rootY);
return true;
}
}
//-------------------------------------------
//解题
public int longestConsecutive(int[] nums) {
if (nums.length == 0) return 0;
UnionFind u = new UnionFind(nums);
for (int num : nums) {//构造并查集，每次合并num 和 num+1
u.union(num, num + 1);
}
int max = 1;
for (int num : nums) {
max = Math.max(max,u.find(num) - num + 1);
}
return max;
}
}
547 朋友圈——（并查集）
给你二维数组，找出数组中岛屿数量。
int fa[1000];
int find(int x){//查找x的祖先节点
if(fa[x]==x) return x;
return fa[x]=find(fa[x]);
}
//查找连通分量个数
int findCircleNum(int** M, int MSize, int* MColSize){
for(int i=0;i<MSize;i++) fa[i]=i;
int ans=MSize;//连通分量默认有MSize个
for(int i=0;i<MSize;i++)//遍历行
{
for(int j=0;j<i;j++)//遍历列
{
if(M[i][j]==0)
continue;
if(find(fa[i])!=find(fa[j]))//如果该两个点间不同祖先
{
fa[find(i)]=fa[find(j)];//祖先合并为一家
ans--;//连通分量--
}
}
}
return ans;
}
被围绕的区域
找到所有被X包围的O，将这些O改为X
- 将各个坐标映射到一维，范围在[0, mn-1]，同时定义一个超级源点src在最后位置mn，这个源点与所有边缘的’O’相连
- 对于在里边的’O’来说，将其与上下左右四个方向的’O’连接起来
- 最后在遍历一遍矩阵，将没有与src连接在一块的’O’置为’X’
class Solution {
// 定义并查集——很简单，并查集都是这么定义的
class UnionFind{
int[] parents;
public UnionFind(int size){
parents = new int[size];
for(int i = 0; i < size; i++)
parents[i] = i;
}
//找x的祖先
public int find(int x){
if(parents[x] == x)
return x;
return parents[x] = find(parents[x]);
}
//合并x和y
public void union(int x, int y){
int px = find(x);
int py = find(y);
if(px == py)
return ;
parents[px] = py;
}
//x和y是否在同一个连通图里
public boolean isConnect(int x, int y){
return find(x) == find(y);
}
}
int[][] d = new int[][]{{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int m;
int n;
//求解
public void solve(char[][] board) {
m = board.length;
if(m == 0) return;
n = board[0].length;
int size = m * n + 1;
int src = m * n;
UnionFind u = new UnionFind(size);
//遍历这个图，处理并查集
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(board[i][j] == 'X')
continue;
if(i == 0 || i == m-1 || j == 0 || j == n-1)// 是边缘的'O'与超级源点src相连接
u.union(src, i * n + j);
else{//不是边缘的‘O’
for(int k = 0; k < 4; k++){ // 将周围的'O'与(i, j)连接
int x = i + d[k][0];
int y = j + d[k][1];
if(board[x][y] == 'O')
u.union(i * n + j , x * n + y);
}
}
}
}
//最后根据并查集的结果处理图，不和周围的‘O’相联的O都改成“X”
for(int i = 1; i < m-1; i++){
for(int j = 1; j < n-1; j++){
if(board[i][j] == 'O' && !u.isConnect(src, i * n + j)){
board[i][j] = 'X';
}
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
