我的刷题之旅——栈、堆和队列

我的刷题之旅——栈、堆、队列、并查集



前言

这一部分的题目相当相当重要哦,主要用于一些特殊的场合和某些特定题目的优化,大多数是那种表面很难,其实很套路的题目,经常和其他算法结合在一起,但是也不要担心,我感觉这些题目算是最套路的,永远是哪几个场合会用到。


(一)栈

剑指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存放每个滑动窗口的最大值,
用一个队列作为辅助,队列头存放当前窗口的最大值,每次向后滑动窗口的时候,能影响新窗口最大值取值的元素有

  1. 原来窗口的最大值,看看是否被移出
  2. 原来窗口的次最大值
  3. 当前新元素

我们可以发现,前面窗口的从最大值开始向后面遍历,次最大值、次次最大值、次次次最大值会影响结果。
所以我们可以维护一个单调非严格递减队列,保证队列中的元素是从头到尾的最大值、次最大值、次次最大值……,注意后面出现的元素如果比队列尾部的一些元素小,会覆盖他们变成新的次大元素,他们就没了。

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';
                }
            }
        }
    }
}

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页