【每日一题】 959. 由斜杠划分区域

【每日一题】 959. 由斜杠划分区域

避免每日太过咸鱼,一天搞定一道LeetCode算法题

一、题目描述

在由 1 x 1 方格组成的 N x N 网格 grid 中,每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。(请注意,反斜杠字符是转义的,因此 \ 用 “\” 表示。)。

返回区域的数目。

提示:

  • 1 <= grid.length == grid[0].length <= 30
  • grid[i][j]'/''\'、或 ' '

示例 1:

输入:
[
  " /",
  "/ "
]
输出:2
解释:2x2 网格如下:

在这里插入图片描述

示例 2:

输入:
[
  " /",
  "  "
]
输出:1
解释:2x2 网格如下:

在这里插入图片描述

示例 3:

输入:
[
  "\\/",
  "/\\"
]
输出:4
解释:(回想一下,因为 \ 字符是转义的,所以 "\\/" 表示 \/,而 "/\\" 表示 /\。)
2x2 网格如下:

在这里插入图片描述

示例 4:

输入:
[
  "/\\",
  "\\/"
]
输出:5
解释:(回想一下,因为 \ 字符是转义的,所以 "/\\" 表示 /\,而 "\\/" 表示 \/。)
2x2 网格如下:

在这里插入图片描述

示例 5:

输入:
[
  "//",
  "/ "
]
输出:3
解释:2x2 网格如下:

在这里插入图片描述

二、题解

1. 解法

解题思路:

这是一个关于连通性的问题,让我们求解连通分量的个数,解决这个问题没有特别的技巧,根据题意 画图分析、稍微细心一点就可以通过系统测评。

可以用深度优先遍历(Depth First Search)、广度优先遍历(Breadth First Search)和并查集(Disjoint Sets),由于只要求计算结果,不要求给出具体的连通信息,可以使用并查集。

1. 并查集

「斜杠」、「反斜杠」把单元格拆分成的 2 个三角形的形态,在做合并的时候需要分类讨论。根据「斜杠」、「反斜杠」分割的特点,我们把一个单元格分割成逻辑上的 4 个部分。如下图所示:

在这里插入图片描述

我们须要遍历一次输入的二维网格 grid,在 单元格内 和 单元格间 进行合并。

单元格内:

如果是空格:合并 0、1、2、3;
如果是斜杠:合并 0、3,合并 1、2;
如果是反斜杠:合并 0、1,合并 2、3。
单元格间:

把每一个单元格拆分成 4 个小三角形以后,相邻的单元格须要合并,无须分类讨论。我们选择在遍历 grid 的每一个单元格的时候,分别「向右、向下」尝试合并。

在这里插入图片描述

向右:合并 1 (当前单元格)和 3(当前单元格右边 1 列的单元格),上图中红色部分;
向下:合并 2 (当前单元格)和 0(当前单元格下边 1 列的单元格),上图中蓝色部分。
事实上,大家选择在遍历 grid 的每一个单元格的时候,分别「向左、向上」、「向左、向下」、「向右、向上」、「向右、向下」中的任何一种都可以。

合并完成以后,并查集里连通分量的个数就是题目要求的区域的个数。

java代码实现如下:

 public static int regionsBySlashes(String[] grid) {
     int n = grid.length;
     int size = 4 * n * n;
     UnionFind unionFind = new UnionFind(size);
     for (int i = 0; i < n; i++) {
         char[] chars = grid[i].toCharArray();
         for (int j = 0; j < chars.length; j++) {
             // 二维网格转换为一维表格
             int index = 4 * (i * n + j);
             char c = chars[j];
             // 单元格内合并
             if (c == '/') {
                 // 合并 0、3,合并 1、2
                 unionFind.union(index, index + 3);
                 unionFind.union(index + 1, index + 2);
             } else if (c == '\\') {
                 // 合并 0、1,合并 2、3
                 unionFind.union(index, index + 1);
                 unionFind.union(index + 2, index + 3);
             } else {
                 unionFind.union(index, index + 1);
                 unionFind.union(index + 1, index + 2);
                 unionFind.union(index + 2, index + 3);
             }

             // 单元格间合并
             // 向右合并:1(当前)、3(右一列)
             if (j + 1 < n) {
                 unionFind.union(index + 1, 4 * (i * n + j + 1) + 3);
             }
             // 向下合并:2(当前)、0(下一行)
             if (i + 1 < n) {
                 unionFind.union(index + 2, 4 * ((i + 1) * n + j));
             }

         }


     }
     return unionFind.getCount();
 }

private static class UnionFind {

    private int[] parent;

    private int count;

    public int getCount() {
        return count;
    }

    public UnionFind(int n) {
        this.count = n;
        this.parent = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    public int find(int x) {
        return parent[x] == x ? x : (parent[x] = find(parent[x]));
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);

        if (rootX == rootY) {
            return;
        }
        parent[rootX] = rootY;
        count--;
    }
}

复杂度分析

  • 时间复杂度:O(m⋅α(n)),其中 mm 是数组 connections 的长度,α 是阿克曼函数的反函数。

  • 空间复杂度:O(n),即为并查集需要使用的空间。

2. 解法二

做题不是目的,毕竟这道题用并查集做出来也是比较ok的了,但是为了学习更多的算法思想,所以看看大佬们其他的解决方案,了解到了 深度优先搜索 ,接下来我们就是这个试一下吧。使用深度优先搜索来得到图中的连通分量数。

具体地,初始时所有节点的状态均为「待搜索」。我们每次选择一个「待搜索」的节点,从该节点开始进行深度优先搜索,并将所有搜索到的节点的状态更改为「已搜索」,这样我们就找到了一个连通分量。

List<Integer>[] edges;
boolean[] used;

public  int makeConnected2(int n, int[][] connections) {
    if (connections.length < n - 1) {
        return -1;
    }

    edges = new List[n];
    for (int i = 0; i < n; ++i) {
        edges[i] = new ArrayList<Integer>();
    }
    for (int[] conn : connections) {
        edges[conn[0]].add(conn[1]);
        edges[conn[1]].add(conn[0]);
    }

    used = new boolean[n];
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        if (!used[i]) {
            dfs(i);
            ++ans;
        }
    }

    return ans - 1;
}

public  void dfs(int u) {
    used[u] = true;
    for (int v : edges[u]) {
        if (!used[v]) {
            dfs(v);
        }
    }
}

复杂度分析

  • 时间复杂度:O(n+m),其中 m 是数组 connections 的长度。

  • 空间复杂度:O(n+m),其中 O(m) 为存储所有边需要的空间,O(n) 为深度优先搜索中使用的栈空间。

题目来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/distance-between-bus-stops

--------------最后感谢大家的阅读,愿大家技术越来越流弊!--------------

在这里插入图片描述

--------------也希望大家给我点支持,谢谢各位大佬了!!!--------------

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值