【每日一题】1月每日刷题总结（并查集）

最新推荐文章于 2024-04-29 02:15:00 发布
最新推荐文章于 2024-04-29 02:15:00 发布
阅读量361 收藏
点赞数
分类专栏： 每日一题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcz5566719/article/details/112710060
版权

文章目录

605. 种花问题 (贪心)

在这里插入图片描述

虽然是贪心，但是这题目处理贪心的思路是我没有想到的。这个题目首先是找到了一个规律，对于没有种花的一段区域，左端点是 l l l， 右端点是 r r r。可以得到在这个区域内部可以种植的是 ( l − r ) / 2 (l-r)/2 (l−r)/2。这个对于奇数和偶数都是适用的。

因此我们需要维护一下之前种花的位置。也就是pre。但是我们需要特殊情况，也就是开头和结尾情况。一般情况下，两个空挡是无法种植的。但是如果是开头和结尾的位置的是可以种在边界上的。
因此我们把初始前一个有花的位置设置为-2，最后有花的位置是m+1。

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int count = 0;
        int m = flowerbed.length;
        int prev = -2;
        for (int i = 0; i < m; i++) {
            if (flowerbed[i] == 1) {
                count += (i - prev - 2) / 2;
                prev = i;
            }    
        }
        count += (m - prev - 1) / 2;
        return count >= n;
    }
}

239. 滑动窗口最大值 模板题 单调栈

在这里插入图片描述

单调栈问题的母题，单调栈内存放的是索引，排序的依据是数组的大小。

  • 操作顺序：四步！！！！
  1. 维护单调性，弹栈
  2. 入栈
  3. 维护区间要求，弹出超出区间的
  4. 取得最大值。
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> queue = new LinkedList<>();
        int n = nums.length;
        
        int[] ans = new int[n-k+1];
        for(int i = 0;i<n ;i++){
            while(!queue.isEmpty() && nums[i]>=nums[queue.peekLast()]){
                queue.pollLast();
            }
            queue.offerLast(i);
            if(i>=k-1){
                while(i - queue.peekFirst()>=k){
                    queue.pollFirst();
                }
                ans[i-k+1] = nums[queue.peekFirst()];
            }
        }
        return ans;
    }
}

86. 分隔链表

在这里插入图片描述

难倒是不难，但是这个链表问题属实不太熟练。

class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode dummysmall = new ListNode();
        ListNode pre = dummysmall;
        ListNode dummylarge = new ListNode();
        ListNode prel = dummylarge;
        while(head!=null){
            if(head.val<x){
                dummysmall.next = head;
                dummysmall = dummysmall.next;
            }else{
                dummylarge.next = head;
                dummylarge = dummylarge.next;
            }
            head = head.next;
        }
        dummylarge.next = null; // 结束的标志!!!!!!这一步一定不能省略。
        dummysmall.next = prel.next;
        return pre.next;

    }
}

399. 除法求值 （模板题 并查集）

在这里插入图片描述

能够想到使用并查集的方法其实并不难。但是这里需要维护并查集的比例关系这个还是比较复杂。当我们进行并查集的父子连接的时候，因为被合并节点的父节点改变了，因此两个父节点直接也存在了比例关系。因此这个被合并节点的其他子节点也需要修改自己与新的根节点的比值关系。

核心两步：

  1. 维护根节点的比例关系。（在合并的时候）
  2. 修改根节点上全部子节点的数值。（在维护路径压缩的时候）
class Solution {
    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
        int n = queries.size();
        double[] ans = new double[n];
        int m = equations.size();
        HashMap<String, Integer> map = new HashMap<>();
        int index = 0;
        UF uf = new UF(100);
        for(int i = 0;i<m;i++){
            List<String> l= equations.get(i);
            String num1 = l.get(0);
            String num2 = l.get(1);
            int n1;
            int n2;
            if(map.containsKey(num1)){
                n1 = map.get(num1);
            }else{
                n1 = index;
                map.put(num1, n1);
                index++;
            }
            if(map.containsKey(num2)){
                n2 = map.get(num2);
            }else{
                n2 = index;
                map.put(num2, n2);
                index++;
            }
            if(!uf.isUnion(n1,n2)){
                uf.union(n1,n2,values[i]);
            }
        }

        for(int i = 0;i<n;i++){
            List<String> l= queries.get(i);
            String num1 = l.get(0);
            String num2 = l.get(1);
            int n1;
            int n2;
            if(map.containsKey(num1)){
                n1 = map.get(num1);
            }else{
                n1 = index;
                index++;
            }
            if(map.containsKey(num2)){
                n2 = map.get(num2);
            }else{
                n2 = index;
                index++;
            }
            if(uf.isUnion(n1,n2)){
                ans[i] = uf.getCount(n1)/uf.getCount(n2);

            }else{
                ans[i] = -1.0;
            }
        }
        return ans;
    }
    class UF{
        int[] size;
        int[] fa;
        double[] count;
        private UF(int N){
            size = new int[N];
            fa = new int[N];
            count = new double[N];
            for(int i = 0;i<N;i++) {
                size[i] = 1;
                fa[i] = i;
                count[i] = 1.0;
            }
        }

        private int findfa(int i){
            if(i == fa[i]) return i;
            int ifa = findfa(fa[i]); // 新的根节点，同时已经维护好了父亲这一支的权值关系。
            count[i] *= count[fa[i]];// 这一步和上一步的顺序是不可调换的。因为前一行维护好了count[fa[i]]。
            fa[i] = ifa;
            return fa[i];
        }

        public boolean isUnion(int i , int j){
            return findfa(i) == findfa(j);
        }

        private void union(int i, int j, double v){
            int ifa = findfa(i);
            int jfa = findfa(j);
            if (jfa == ifa) return; 
            // 不进行压缩了，所有的ifa都合并到jfa上。
            fa[ifa] = jfa;
            //count[ifa] = count[j]*v/count[i]; // 这个其实等价，因为count[jfa]一定是等于1
            count[ifa] = count[j]*count[jfa]*v/count[i];// vali = count[i]*count[ifa]  valj = count[j]*count[jfa]; vali = valj*v
        }

        public double getCount(int i){
            return count[i];
        }
    }
}

1202. 交换字符串中的元素 M （并查集，连通元素有序性）

在这里插入图片描述

并查集的简单升级，除了利用并查集判断连通性，还额外维护了连通块元素的顺序。

为了加快速度，并不是在每次合并的时候维护顺序，而是在完成了全部的连通性以后。借助字典，key是根，value是一个堆。实现维护连通元素的顺序。

这个借助字典的方法很常用。

省略了UF
class Solution {
    String s;
    public String smallestStringWithSwaps(String s, List<List<Integer>> pairs) {
        this.s = s;
        int n = s.length();
        UF uf = new UF(n);
        int m = pairs.size();
        for(int i = 0;i<m;i++){
            uf.union(pairs.get(i).get(0),pairs.get(i).get(1));
        }

        HashMap<Integer, PriorityQueue<Integer>> map = new HashMap<>();
        for(int i = 0;i<n;i++){
            int cur = uf.findfa(i);
            if(!map.containsKey(cur)){
                map.put(cur, new PriorityQueue<>((a,b)->s.charAt(a)-s.charAt(b)));
            }
            map.get(cur).offer(i);
        }
        StringBuffer sb = new StringBuffer();
        for(int i = 0;i<n;i++){
            sb.append(s.charAt(map.get(uf.findfa(i)).poll()));
        }
        return sb.toString();
    }
}

1203. 项目管理 H（多层次拓扑排序）

在这里插入图片描述在这里插入图片描述

比较复杂的一道题目。需要用到两次不同级别的拓扑排序。

class Solution {
    /**
     * groupGraph 组间的拓扑图，组之间的依赖
     * itemGraph 组内项目之间的拓扑图，组内项目之间的依赖
     * groupItem 每个小组负责的项目
     * groupTopSort 组间的拓扑排序
     * @param n           项目数量
     * @param m           组的数量
     * @param group       the group
     * @param beforeItems the before items
     * @return the int [ ]
     *
     * 首先我们可以按照已经完成分配的任务进行分组，没有进行分配的任务是单独的一系列。我们要先建立这些小组之间的依赖性。也就是首先完成
     * 在小组之间的拓扑排序，这里需要维护小组之间的入度。这需要我们建立从项目映射到小组的标记，也就是group。
     *
     * 在完成小组之间的拓扑排序之后，我们继续建立小组内部的拓扑排序。这里我们需要从小组映射到任务，利用任务之间的依赖也就是彼此的入度，完成拓扑排序。
     */
    public int[] sortItems(int n, int m, int[] group, List<List<Integer>> beforeItems) {
    	// 组间的依赖关系。
        List<List<Integer>> groupGraph = new ArrayList<>();
        // 组内的依赖关系。
        List<List<Integer>> itemGraph = new ArrayList<>();
        for(int i = 0;i<m+n;i++){
            groupGraph.add(new ArrayList<Integer>());
        }
        for(int i = 0; i<n;i++){
            itemGraph.add(new ArrayList<Integer>());
        }
        int[] groupDegree = new int[m+n+1];
        int[] itemDegree = new int[n+1];

        List<Integer> id = new ArrayList<>();
        for(int i = 0;i<n+m;i++){
            id.add(i);
        }
        // 每个小组的项目。
        List<List<Integer>> graphItem = new ArrayList<>();
        for(int i = 0;i<n+m;i++){
            graphItem.add(new ArrayList<Integer>());
        }
        // 没有小组的任务，都是单独编号给一个小组
        int leftItem = m;
        for (int i = 0; i<n;i++){
            if (group[i] == -1) {
                group[i] = leftItem;
                leftItem++;
            }
            graphItem.get(group[i]).add(i);
        }
      
        for(int i = 0 ;i<n;i++){
            int curGroupId = group[i];
            for(int before:beforeItems.get(i)){ // before 想执行当前任务需要的先前任务
                int needGroupId = group[before];
                 // 如果是同一个小组，维护组内的任务拓扑
                if(curGroupId == needGroupId){
                    itemGraph.get(before).add(i); // 钥匙交给before
                    itemDegree[i]++; // 加上一把锁
                }else{
                // 不是一个小组，维护组间的拓扑
                    groupGraph.get(needGroupId).add(curGroupId);
                    groupDegree[curGroupId]++;
                }
            }
        }
        // 首先进行组间的拓扑排序。
        List<Integer> groupTop = graphTopSort(groupDegree, groupGraph, id);
        if(groupTop.size() == 0)return new int[0];
        int[] ans = new int[n];
        int index = -1;
		// 依据组间拓扑的排序，维护组内的任务排序。
        for(int curGroup:groupTop){
            if(graphItem.get(curGroup).size() == 0)continue;
            List<Integer> itemTop = graphTopSort(itemDegree, itemGraph, graphItem.get(curGroup));

            if (itemTop.size() == 0)return new int[0];

            for(int i:itemTop){
                ans[++index] = i;
            }
        }
        return ans;

    }

======================!!!!!!!!!!!!!拓扑排序的板子!!!!!!!!!!!!!!!=========================
    /**
     * @param degree      节点的入度表
     * @param graph       节点的邻接表， 依赖关系
     * @param id		  全体节点表
     * @return  List<Integer> 拓扑排序的结果
     *
     */
    public List<Integer> graphTopSort(int[] degree, List<List<Integer>> graph, List<Integer> id){
        Queue<Integer> queue = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        for(int i:id){
            if(degree[i] == 0){
                queue.offer(i);
                res.add(i);
            }
        }
        while(!queue.isEmpty()){
            int cur = queue.poll();
            for(int next:graph.get(cur)){
                degree[next]--;
                if(degree[next] == 0){
                    queue.offer(next);
                    res.add(next);
                }
            }
        }
        return res.size() == id.size() ? res : new ArrayList<Integer>();
    }
}

803. 打砖块 H (反向并查集)

在这里插入图片描述在这里插入图片描述

引用官方解答的解析。当时在第一次做这个题目的时候，可以想到类似并查集，但是总觉着那里很别扭。因为并查集起到了合并的作用，但是这里是分解连通量。
在这里插入图片描述

逆向的思路关键在于，拆分开连通量。并且倒序连接起来全部的量，等价于每次连接多少砖头被连接起来。

class Solution {
    // 逆向思维，反向利用并查集。
    // 并查集的特点是讲两个连通量合并为成为一个连通量。而我们的问题是讲一个连通量拆分为两个连通量。
    public int[] hitBricks(int[][] grid, int[][] hits) {
        int n = grid.length;
        int m = grid[0].length;
        int[][] copy = new int[n][m];
        int[][] dis = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};

        // 第 1 步：把 grid 中的砖头全部击碎，通常算法问题不能修改输入数据，这一步非必需，可以认为是一种答题规范
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                copy[i][j] = grid[i][j];
            }
        }

        for (int[] h:hits){
            copy[h[0]][h[1]] = 0;
        }

        int size = n*m;
        // size表示屋顶 !!!!! 很经典的思路，利用一个特殊的量表示某种安全岛。
        UnionFind uf = new UnionFind(size+1); 
        // 横坐标是0的砖全部与屋顶连接
        for(int i = 0;i<m;i++){
            if(copy[0][i] == 1){
                uf.union(size, i);
            }
        }

        // 连接剩余的连通量   单侧合并，保证不重不漏 只看左侧和上侧
        for(int i = 1; i < n; i++){
            for (int j = 0; j < m; j++) {
                if(copy[i][j] == 1){
                    if(copy[i-1][j] == 1){
                        uf.union((i-1)*m+j, i*m+j);
                    }
                    if(j>0 && copy[i][j-1] == 1){
                        uf.union(i*m+j, i*m+j-1);
                    }
                }
            }
        }

        int k = hits.length;
        int[] ans = new int[k];
        // 需要按照逆序添加hits !!!! 这一步是关键，反应了我们的算法其实是一个逆向的并查集思路
        for (int i = k-1; i >= 0; i--) {
            int res = uf.getSize(size);
            int x = hits[i][0];
            int y = hits[i][1];
            if(grid[x][y] == 0)continue;

            // 如果是0，需要与屋顶连接
            if(x == 0){
                uf.union(y, size);
            }

            for(int[] d:dis){
                int nx = x+d[0];
                int ny = y+d[1];
                if(nx>=0 && nx<n && ny>=0 && ny<m && copy[nx][ny] == 1){
                    uf.union(nx*m+ny, x*m+y);
                }
            }
            int cur = uf.getSize(size); // 添加砖头之后，连接屋顶的数量的

            ans[i] = Math.max(0, cur-res-1);
            // 最后记着补上
            copy[x][y] = 1;
        }
        return ans;

    }

947. 移除最多的同行或同列石头 H (二维并查集合并)

在这里插入图片描述

对于二维的并查集的合并问题，两个思路：一个是合并点，一个是合并边。

合并点的思路是，维护了两个字典，一个是横轴，一个是纵轴。分别记录了首次出现横纵坐标时候的索引。以后再出现一样的索引时候就可以直接合并。这里有一个APIrow.computeIfAbsent(stones[i][0], val->tem); 当字典不存在时候，令val为tem，否则返回值。

合并边的思路复杂度会稍微低。我们把二维左边变成一位的形式，也就是展开。x->x,y->y+10000。这样的话，每次把点的横纵坐标都进行合并。

但是无论怎么样，我们最后都需要统计连通块的数量。这个方法就是计算根节点的数量。这个是无法简化的。

class Solution {
    public int removeStones(int[][] stones) {
        int n = stones.length;

        /*
        UF uf = new UF(n);
        // 按照点连接，维护两个哈希表，分别是首次出现横纵坐标时候的索引。
        // 并查集进行合并的时候，会两次检查，首先看横坐标上能不能合并，然后看纵坐标能不能合并。
        HashMap<Integer, Integer> row = new HashMap<>();
        HashMap<Integer, Integer> col = new HashMap<>();

        for(int i = 0;i<n;i++){
            int tem = i;
            row.computeIfAbsent(stones[i][0], key->tem);
            col.computeIfAbsent(stones[i][1], key->tem);
            uf.union(i,row.get(stones[i][0])); // 如果横坐标相等，可以合并
            uf.union(i,col.get(stones[i][1])); // 如果纵坐标相等，可以合并
        }
        */

        // 按照边进行合并
        UF uf = new UF(20000);
        for(int i = 0;i<n;i++){
            uf.union(stones[i][0], stones[i][1]+10000);
        }


        HashSet<Integer> set = new HashSet<>();
        for (int[] s:stones){
            set.add(uf.findfa(s[0]));
        }
        return n-set.size();
    }
}

其他题目主要是思路

189. 旋转数组
在这里插入图片描述

主要就是三步旋转解决。首先反转整个数组，然后反转0，k-1的数组。最后反转k到末尾的数组。具体的反转通过头尾双指针交换。

zcz5566719
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode题库-LeetCode:刷题集-每日一题
06-29
俺现在研一，不论是研三出去找工作还是研二出去找实习，都需要强大的算法功底，所以现在基本上强制自己每天刷一两道算法题 马上整理一下，现在是按照标签刷的注意包名。 这个仓库记录俺的刷题的过程以及部分题目的...
【每日一练】PMP试题七.pdf
12-09
PMP（项目管理专业人士）认证是一项国际认可的项目管理资质，备考过程中，刷题和每日一练是非常重要的学习环节。以下是对题目中涉及知识点的详细解释： 1. 相关方管理：项目经理在项目计划获得批准前进行相关方分析...
并查集（合并与查找）
weixin_45746505的博客
07-31 1080
并查集
数据结构：并查集——合并集合
lichengyang的博客
09-01 274
一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。
基础_并查集_合并集合
最新发布
Rockivy的博客
04-29 751
并查集(保姆级讲解)
leetcode每日刷题
JJR_YZ的博客
10-04 1244
leetcode今日刷题
C++ 并查集 || 模版题：合并集合
fucheng的博客
01-07 412
C++ 并查集 || 模版题：合并集合
【每日一题】2020.11月每日刷题总结
遍地跑小鸡的博客
12-07 264
文章目录140.单词拆分II （dfs，dp）57.插入区间（判断区间重叠的标准） 本专栏主要的针对每日一题的更新，会总结一些比较好的每日一题。 140.单词拆分II （dfs，dp） class Solution { public List<String> wordBreak(String s, List<String> wordDict) { // 在整体的思路上，需要首先维护一个dp[i]表示第i位之前的内容全部都是可以在字典中的。这里不包括第i位。
刷题集训+每日一题解析.zip
03-29
《刷题集训+每日一题解析》是一个压缩文件，其中包含了丰富的编程题目与解析，旨在帮助学习者提升编程技能，尤其是对于准备参加各种技术面试或者编程竞赛的人来说，这是一个宝贵的资源。下面，我们将深入探讨这个...
LeetCode:每日至少一题的 LeetCode 刷题日常开始了
04-11
"每日至少一题的 LeetCode 刷题日常开始了" 这个标题暗示了一个持续的学习计划，通过每天解决 LeetCode 上的一道问题来提升编程技能，特别是 Java 语言的应用。 在 LeetCode 上，你可以找到从简单到困难的各种算法...
[宫水三叶的刷题日记]：并查集1
08-03
2. 从侧边栏的类别目录找到「并查集」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检索
并查集的C++实现，并查集的建立，合并和查找
10-21
使用C++实现了并查集的建立，合并和查找功能，并附简单的测试用例。
算法学习系列（十四）：并查集
weixin_60033897的博客
12-28 786
这个并查集以代码短小并且精悍的特点，在算法竞赛和面试中特别容易出，对于面试而言，肯定不会让你去写一两百行的代码，一般出的都是那种比较短的，而且还不好想考验思维的那种题，那并查集就将这两点全占了，所以重要性很大，而且竞赛的话也就是将多个知识点合并起来考察，这个也很可能成为一个点，所以话不多说就开始吧。
【高阶数据结构】并查集详解
Josvin
01-14 411
并查集并查集概述并查集功能分析数组实现并查集并查集——森林实现并查集——查找算法并查集——合并算法整体代码 并查集概述 并查集(Union Find)，又称不相交集合(Disjiont Set)，它应用于N个元素的集合求并与查询问题，在该应用场景中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。虽然该问题并不复杂，但面对极大的数据量时，普通的数据结构往往无法解决，并查集就是解决该种问题最为优秀的算法。 算法过程示例：
合并集合（并查集）
m0_70392867的博客
08-05 92
（2）路径压缩: 在找祖宗过程中直接认祖宗为父亲，这样查询时只用查询1层即可。（4）find函数：分为是祖宗直接返回，不是祖宗递归查询两种情况。（3）预处理：将元素分为n个集合。（1）有合并与查询两个操作，
并查集-查询与合并
RUN
09-20 1140
并查集是用来查询两个元素是否属于同一个集合，并且快速合并两个元素所在的集合。 通过集合中的一个元素来代表这个集合，转化为树的结构就是树的根节点。所以集合中每个节点都有一个父亲节点，根节点的父亲节点是他自己。 f = {} f.setfault(key, value) 字典的setdefault()，如果字典中已经有这个key了，那么是无效的。只有没有这个键的情况下生效。 dict.setdefault(key, default=None) 参数 key – 查找的键值。 default – 键不存在时，设置
第一个leetcode月度打卡勋章
Hunter_Kevin的博客
10-31 485
2022年10月31日 01:56:54。
LeetCode刷题指南
airhaohan 的博客
09-08 6744
力扣，作为一个国内外的程序员都用作准备面试的刷题网站，对想要阅读这篇指南的你应该都不陌生。当你想要借助力扣刷题，提升代码能力、在面试中脱颖而出，却不知从何入手，这篇文章可以作为你的入门指南。
并查集快速查找,快速合并
qq_59974657的博客
04-08 375
并查集基础 一、概念及其介绍 并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。 并查集的思想是用一个数组表示了整片森林（parent），树的根节点唯一标识了一个集合，我们只要找到了某个元素的的树根，就能确定它在哪个集合里。 二、适用说明 并查集用在一些有 N 个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这个过程看似并不复杂，但数据量极大，若用其他的数据结构来描述的话

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值