精华内容
下载资源
问答
  • 最大 目录1080. 最大描述样例 1:样例 2:题解鸣谢 1080. 最大 描述 给定一个由0和1组成的非空二维数组grid,一个由一组四联通(上下左右四方向)的1(表示陆地)组成。假定grid的四周都是水。 返回...

    领扣LintCode算法问题答案-1080. 最大的岛

    1080. 最大的岛

    描述

    给定一个由0和1组成的非空二维数组grid,一个岛由一组四联通(上下左右四方向)的1(表示陆地)组成。假定grid的四周都是水。

    返回最大的岛。(没有岛则返回0)

    • grid中的每一维度长度都不超过50。

    样例 1:

    输入:
    [[0,0,1,0,0,0,0,1,0,0,0,0,0],
     [0,0,0,0,0,0,0,1,1,1,0,0,0],
     [0,1,1,0,1,0,0,0,0,0,0,0,0],
     [0,1,0,0,1,1,0,0,1,0,1,0,0],
     [0,1,0,0,1,1,0,0,1,1,1,0,0],
     [0,0,0,0,0,0,0,0,0,0,1,0,0],
     [0,0,0,0,0,0,0,1,1,1,0,0,0],
     [0,0,0,0,0,0,0,1,1,0,0,0,0]]
    输出:6。
    解释:注意不是11!因为是4方向联通。
    

    样例 2:

    输入:[[0,0,0,0,0,0,0,0]]
    输出:0
    

    题解

    public class Solution {
        /**
         * @param grid: a 2D array
         * @return: the maximum area of an island in the given 2D array
         */
        public int maxAreaOfIsland(int[][] grid) {
            // Write your code here
            if (grid == null) {
                return 0;
            }
            int maxR = grid.length;
            if (maxR == 0) {
                return 0;
            }
            int maxC = grid[0].length;
            if (maxC == 0) {
                return 0;
            }
    
            Queue<Point> pointQueue = new LinkedList<>();
            Set<Point> visitedPoint = new HashSet<>();
            int maxCount = 0;
    
            for (int r = 0; r < maxR; r++) {
                for (int c = 0; c < maxC; c++) {
                    if (grid[r][c] == 1) {
                        Point p = new Point(r, c);
                        if (!visitedPoint.contains(p)) {
                            visitedPoint.add(p);
                            pointQueue.offer(p);
                            int count = 0;
                            while (!pointQueue.isEmpty()) {
                                p = pointQueue.poll();
                                count++;
                                if (p.r > 0) {
                                    Point tp = new Point(p.r - 1, p.c);
                                    if (grid[tp.r][tp.c] == 1) {
                                        if (!visitedPoint.contains(tp)) {
                                            visitedPoint.add(tp);
                                            pointQueue.offer(tp);
                                        }
                                    }
                                }
                                if (p.c > 0) {
                                    Point tp = new Point(p.r, p.c - 1);
                                    if (grid[tp.r][tp.c] == 1) {
                                        if (!visitedPoint.contains(tp)) {
                                            visitedPoint.add(tp);
                                            pointQueue.offer(tp);
                                        }
                                    }
                                }
                                if (p.r + 1 < maxR) {
                                    Point tp = new Point(p.r + 1, p.c);
                                    if (grid[tp.r][tp.c] == 1) {
                                        if (!visitedPoint.contains(tp)) {
                                            visitedPoint.add(tp);
                                            pointQueue.offer(tp);
                                        }
                                    }
                                }
                                if (p.c + 1 < maxC) {
                                    Point tp = new Point(p.r, p.c + 1);
                                    if (grid[tp.r][tp.c] == 1) {
                                        if (!visitedPoint.contains(tp)) {
                                            visitedPoint.add(tp);
                                            pointQueue.offer(tp);
                                        }
                                    }
                                }
                            }
                            if (count > maxCount) {
                                maxCount = count;
                            }
                        }
                    }
                }
            }
    
            return maxCount;
        }
        
         class Point {
            private final int r;
            private final int c;
    
            public Point(int r, int c) {
                this.r = r;
                this.c = c;
            }
    
            public int getR() {
                return r;
            }
    
            public int getC() {
                return c;
            }
    
            @Override
            public boolean equals(Object o) {
                if (this == o)
                    return true;
                if (o == null || getClass() != o.getClass())
                    return false;
                Point point = (Point) o;
                return r == point.r && c == point.c;
            }
    
            @Override
            public int hashCode() {
                return Objects.hash(r, c);
            }
        }
    }
    

    原题链接点这里

    鸣谢

    非常感谢你愿意花时间阅读本文章,本人水平有限,如果有什么说的不对的地方,请指正。
    欢迎各位留言讨论,希望小伙伴们都能每天进步一点点。

    展开全文
  • 最大面积问题(JAVA+DFS算法) 问题描述 问题描述:给定一个二维矩阵,用0表示水域,1-9表示陆地,现给定一个岛屿上的坐标点,求解所在岛屿的面积。 假设条件为:二维矩阵 M<=50;N<=50;给定的坐标...

    求岛的最大面积问题(JAVA+DFS算法)

    问题描述

    问题描述:给定一个二维矩阵,用0表示水域,1-9表示陆地,现给定一个岛屿上的坐标点,求解所在岛屿的面积。

    假设条件为:二维矩阵 M<=50;N<=50;给定的坐标点的值不为0值(即为岛屿)

    样例数据如下:

    第一行输入两个整数,表示矩阵的N行和M列的值;

    之后,输入N行数据,每行M个整数值,来构造N行M列的矩阵;

    之后,再输入两个整数,表示岛上的坐标点,求这个坐标点所在的岛屿的面积。


    10 10 
    1 2 1 0 0 0 0 0 2 3 
    3 0 2 0 1 2 1 0 1 2 
    4 0 1 0 1 2 3 2 0 1 
    3 2 0 0 0 1 2 4 0 0 
    0 0 0 0 0 0 1 5 3 0 
    0 1 2 1 0 1 5 4 3 0 
    0 1 2 3 1 3 6 2 1 0 
    0 0 3 4 8 9 7 5 0 0 
    0 0 0 3 7 8 6 0 1 2 
    0 0 0 0 0 0 0 0 1 0 
    6 8

    输出结果为:

    38
     


    算法实现

    package com.bean.algorithm.dfsbfs;
    
    import java.util.Scanner;
    
    /*
     * 测试数据
     * 输入数据
     * 1 2 1 0 0 0 0 0 2 3 
     * 3 0 2 0 1 2 1 0 1 2 
     * 4 0 1 0 1 2 3 2 0 1 
     * 3 2 0 0 0 1 2 4 0 0 
     * 0 0 0 0 0 0 1 5 3 0 
     * 0 1 2 1 0 1 5 4 3 0 
     * 0 1 2 3 1 3 6 2 1 0 
     * 0 0 3 4 8 9 7 5 0 0 
     * 0 0 0 3 7 8 6 0 1 2 
     * 0 0 0 0 0 0 0 0 1 0 
     * 6 8
     * 输出数据
     * 38
     * */
    public class MaxAreaofIsland22 {
    	
    	//定义一个不超过50行50列的数组nums
    	static int[][] nums = new int[50][50];
    	//定义一个不超过50行50列的辅助数组aux
        static int[][] aux = new int[50][50];
        /*
         * area用来表示岛屿的面积
         * 初始值为1,因为输入的坐标点表示陆地。如果其四周都为水域,即值为0时,其面积为1.
         * */
        static int area = 1;
        static int n, m;
        static Scanner input = new Scanner(System.in);
    
        public static void main(String[] args) {
        	//接收输入值,确定矩阵是N行和M列的矩阵
            n = input.nextInt();
            m = input.nextInt();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                	//为N行M列的矩阵元素赋值
                	nums[i][j] = input.nextInt();
                }
            }
            //输入岛的坐标
            int startX = input.nextInt();
            int startY = input.nextInt();
            //根据输入坐标的位置,标记aux[startX][startY]的值为1,即陆地
            aux[startX][startY] = 1;
            //从startX,startY的位置开始,调用dfs搜索算法
            dfs(startX, startY);
            //输出计算结果,获得岛屿的面积
            System.out.println(area);
        }
        
        /*
         * DFS搜索算法
         * 输入参数:搜索位置的X,Y坐标
         * 计算逻辑:
         * 从X,Y位置开始,向4个方向进行搜索,定义一个方向数组
         * */
        public static void dfs(int x, int y) {
            int[][] next = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
            int tx, ty;
            for (int i = 0; i < 4; i++) {
                tx = x + next[i][0];
                ty = y + next[i][1];
                if(tx < 0 || tx > n - 1 || ty < 0 || ty > n - 1) {
                    continue;
                }
                if (nums[tx][ty] > 0 && aux[tx][ty] == 0) {
                	area ++;
                	aux[tx][ty] = 1;
                    dfs(tx, ty);
                }
            }
            return;
        }
    
    }
    

    程序运行结果:

    [输入信息]

    [输出结果]

    38

    展开全文
  • 题目描述 在二维地图上, 0 代表海洋, 1 代表... 进行填海之后,地图上最大的岛屿面积是多少?(上、下、左、右四个方向相连的 1 可形成岛屿) 示例1 输入: [[1, 0], [0, 1]] 输出: 3 解释: 将一...
      

    题目描述

    在二维地图上, 0 代表海洋, 1 代表陆地,我们最多只能将一格 0 海洋变成 1 变成陆地。

    进行填海之后,地图上最大的岛屿面积是多少?(上、下、左、右四个方向相连的 1 可形成岛屿)

    示例1

            输入:
    [[1, 0], [0, 1]]
    输出:
    3
    解释:
    将一格 0 变成 1 ,最终连通两个小岛得到面积为 3 的岛屿。
          

    示例2

            输入:
    [[1, 1], [1, 0]]
    输出:
    4
    解释:
    将一格 0 变成 1 ,岛屿的面积扩大为 4 。
          

    示例3

            输入:
    [[1, 1], [1, 1]]
    输出:
    4
    解释:
    没有 0 可以让我们变成 1 ,面积依然为 4 。
          

    提示

    • 1 <= grid.length = grid[0].length <= 50
    • 0 <= grid[i][j] <= 1

    题解

    没有做过这种类型题目的强烈建议自己动手实现一遍,对提升代码能力有很大帮助。

    这题虽然是 hard 难度,但其实没有什么算法,只用到了 dfs 求连通块而已。我们只需要知道填充了一个 0 之后,它上下左右跟它相邻的 4 块连通块是多大。

    首先普及一下什么是连通块,就是一块由 1 组成的区域,其中任意两块 1 都可以由一条 1 组成的路径走过去(只能上下左右走)。那么这题我们遍历所有的 0 ,把它四周的连通块大小加起来就是填充了这块 0 之后的连通块大小了。那么问题是怎么知道它周围连通块的大小呢?

    首先我们得求出所有连通块的大小,然后存下来,这就得用到 dfs 了。

    用二维数组 index (初始化为 -1)记录方块是否被搜索过。然后遍历所有的方块,如果是 1 ,并且 index 为 -1 (也就是没被搜索过),那么它的 index 设为 1 ,表示被搜索过了。然后从它开始向四周进行 dfs ,直到跟它相连的所有 1 的连通块都被搜索完毕。这时候整块连通块里面的 1 方块的 index 都被设成了 1 ,就算以后被遍历到了也不会被搜索了。那么大小怎么记录呢?只需要设置一个变量 cnt 初始为 1 ,然后 dfs 的时候遇到一个未被搜索的块就加 1 ,最后 cnt 就是当前连通块的大小了。

    光知道了每个连通块的大小还不行,对于一个 0 块,四周的 1 方块万一属于同一个连通块怎么办?得区分它们,不然就会被重复计算。所以在上面的 dfs 之前,给那块连通块一个唯一的编号(从 0 开始),遇到下一个连通块就加 1 。这样 index 数组就可以用来存连通块的编号了,同时还能表示方块是否被搜索过。

    具体的细节还得看代码,有很多实现的技巧,当然我写的还有一些优化余地。

    代码

    c++

            class Solution {
    public:
        static const int N = 55;
        int dx[4] = {0, 0, 1, -1};
        int dy[4] = {1, -1, 0, 0};
        int index[N][N], area[N*N], flag[N*N];
        int m, n;
    
        int largestIsland(vector<vector<int>>& grid) {
            m = grid.size();
            n = grid[0].size();
            memset(index, -1, sizeof index);
            memset(area, 0, sizeof area);
            memset(flag, 0, sizeof flag);
            
            int res = 0, idx = -1;
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    if (grid[i][j] == 1 && index[i][j] == -1) {
                        int cnt = 1;
                        index[i][j] = ++idx;
                        dfs(i, j, idx, cnt, grid);
                        area[idx] = cnt;
                        res = max(res, cnt);
                    }
                }
            }
            
            for (int x = 0; x < m; ++x) {
                for (int y = 0; y < n; ++y) {
                    if (grid[x][y] == 0) {
                        int tmp = 1;
                        for (int i = 0; i < 4; ++i) {
                            int nx = x + dx[i], ny = y + dy[i];
                            if (inside(nx, ny) && grid[nx][ny] == 1 && !flag[index[nx][ny]]) {
                                flag[index[nx][ny]] = 1;
                                tmp += area[index[nx][ny]];
                            }
                        }
                        for (int i = 0; i < 4; ++i) {
                            int nx = x + dx[i], ny = y + dy[i];
                            if (inside(nx, ny) && grid[nx][ny] == 1 && flag[index[nx][ny]]) {
                                flag[index[nx][ny]] = 0;
                            }
                        }
                        res = max(res, tmp);
                    }
                }
            }
            return res;
        }
    
        bool inside(int x, int y) {
            return 0 <= x && x < m && 0 <= y && y < n;
        }
    
        void dfs(int x, int y, int idx, int& cnt, vector<vector<int>>& grid) {
            for (int i = 0; i < 4; ++i) {
                int nx = x + dx[i], ny = y + dy[i];
                if (inside(nx, ny) && grid[nx][ny] == 1 && index[nx][ny] == -1) {
                    index[nx][ny] = idx;
                    dfs(nx, ny, idx, ++cnt, grid);
                }
            }
        }
    };
    
          

    后记

    dfs 求连通块是常规操作,必须要学会,很考验代码功底,要细心,不然很容易写错。

    展开全文
  • LC-695 最大区域的

    2018-10-29 16:11:00
    输入一个二维数组,0和边界代表大海,1代表岛屿的面积,的连接仅由上下左右四个方向相连,试找出最大岛屿的面积。 思路: 使用深搜算法,便利二位数组,当找到一个值为1的pixel,开始进行深搜,搜索与其相连的...

    目标:

    输入一个二维数组,0和边界代表大海,1代表岛屿的面积,岛的连接仅由上下左右四个方向相连,试找出最大岛屿的面积。

     

    思路:

    使用深搜算法,便利二位数组,当找到一个值为1的pixel,开始进行深搜,搜索与其相连的岛屿面积,对添加进栈的pixel标记为0,代表已搜索。最后比较留下最大岛屿的面积。

     

    代码:

     1 class Solution {
     2 public:
     3     int maxAreaOfIsland(vector<vector<int>>& grid) {
     4         int direction[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
     5         int height = grid.size();
     6         int width = grid[0].size();
     7         int max = 0;
     8         for (int i = 0; i < height; i++) {
     9             for (int j = 0; j < width; j++) {
    10                 // 找到岛屿的一个pixel
    11                 if (grid[i][j] == 1) {
    12                     // 为dfs进行初始化
    13                     int count = 0;
    14                     vector<int*> stack;
    15                     int* init = new int[2];
    16                     init[0] = i;
    17                     init[1] = j;
    18                     stack.push_back(init);
    19                     // 标记该点已搜索
    20                     grid[i][j] = 0;
    21                     // 开始dfs
    22                     while (!stack.empty()) {
    23                         // 出栈
    24                         count++;
    25                         int* current = stack.back();
    26                         int x = current[0];
    27                         int y = current[1];
    28                         delete current;
    29                         stack.pop_back();
    30                         // 遍历该pixel的四个方向
    31                         for (int k = 0; k < 4; k++) {
    32                             int new_x = x + direction[k][0];
    33                             int new_y = y + direction[k][1];
    34                             if (new_x >= 0 && new_x < height && new_y >= 0 && new_y < width) {
    35                                 if (grid[new_x][new_y] == 1) {
    36                                     int* v = new int[2];
    37                                     v[0] = new_x;
    38                                     v[1] = new_y;
    39                                     stack.push_back(v);
    40                                     // 对已入栈的pixel标记为已搜索
    41                                     grid[new_x][new_y] = 0;
    42                                 }
    43                             }
    44                         }
    45                     }
    46                     
    47                     if (count > max)
    48                         max = count;
    49                 }
    50             }
    51         }
    52         return max;
    53     }
    54 };

     

    转载于:https://www.cnblogs.com/leo-lzj/p/9871219.html

    展开全文
  • 题意: 求从最左边的到最右边的最大容量 这道题还学会了手动开栈 #include #include #include #include #include #include #pragma comment(linker, "/STACK:1024000000,1024000000")//外挂开栈 using ...
  • 中文分词的python实现-基于FMM算法

    千次阅读 2016-09-28 19:44:05
    正向最大匹配算法(FMM)正向最大匹配算法(FMM)是一种基于词典的分词方法,思想很简单就是从左向右扫描寻找词的最大匹配,比如词典中同时含有“钓鱼”和“钓鱼”,那“钓鱼属于中国”就会被分词成“钓鱼/...
  • c++贪心算法总结

    2021-03-20 23:03:27
    c++贪心算法第一周末总结 总体来说,这周的贪心...一开始,我总是从一个出发试着去求建设雷达所能覆盖的最大岛屿数量,并对此进行降序排序。但很快我就发现,这种思路可谓错误至极。一方面,计算一座岛屿的周围可覆
  • 算法-岛屿问题专辑

    2020-04-19 22:05:17
    算法-岛屿问题专辑1、岛屿数量2、被围绕的区域3、岛屿最大面积4、岛屿周长 遇到岛屿问题,基本上就是一种算法:深搜+记忆化搜索。 1、岛屿数量 List item 200. 岛屿数量 给定一个由 '1'(陆地)和 '0'(水)组成的...
  • 算法——海岛问题

    千次阅读 2019-07-29 15:55:55
    题目:海岛面积计算题,给一个矩阵,0表示还睡,相连的1表示海岛,上下左右表示相连。...(0)求有几座 (1)求最大海岛的面积 (2)求最大海岛的面积和对应海岛的所有坐标 (3)求所有海岛的所有坐标,按海岛分。
  • 左神算法基础班总结

    千次阅读 2019-07-17 21:59:24
    以及morris遍历8、二叉树的序列化和反序列化9、求一棵完全二叉树的节点个数10、LRU算法11、并查集12、DFS(问题)13、前缀树(字典树)14、求项目的最大收益(贪心算法)15、海量数据和空间限制问题(1)布隆过滤...
  • Java算法:最小生成树

    2020-10-12 22:19:43
    航海家们在太平洋上发现了几座新岛屿,其中最大的一个已经连接到Internet,但是其它和主之间没有电缆连接,所以无法入网。我们的目的是让所有岛上的居民都能上网,即每个和主之间都有直接或间接的电缆连接...
  • 【问题描述】一家互联网服务商(简称PIN)在太平洋上发现了几座新岛屿,其中最大的一个(称为主)已经连接到Internet,但是其他和主之间没有光缆连接,所以无法上网。为了让所有岛上的居民都能上网,每个...
  • 算法--最短的桥DFS+BFS

    2021-04-18 17:43:23
    是由四面相连的 0 形成的一个最大组。) 现在,我们可以将0变为1,以使两座连接起来,变成一座。 返回必须翻转的0 的最小数目。 首先找到这两座,随后选择一座,将它不断向外延伸一圈,直到到达了另一...
  • NOI 1797:金银(C++)

    千次阅读 2017-03-27 09:28:14
    典型的贪心算法,思路是:计算每个金属的性价比,然后根据性价比进行排序,从高到低尽可能塞入背包,背包满则得到最大值。 #include "iostream" #include "iomanip" #include "algorithm" using namespace std; ...
  • 最优生成树(kruskal算法

    千次阅读 2016-07-12 16:42:37
    【问题描述】 给出N个顶点、E条边的连通无向简单图,请你完成下列任务:任务1、求边权和最小的生成树(最小生成树) 任务2、求边权和最大的生成树(最大生成树) 任务3、求最大边最小的生成树(瓶颈生成树) 任务4、...
  • 培养每个问题30分钟内解决所有算法问题的能力 轻松解决Kakao或Naver的编码测试问题 截止日期:2020/7/27〜结束是看不见的 问题 主题 问题 等等 数学 蛮力 最大差异 旅行推销员 乐透 :dollar_banknote: 运算符嵌入 ...
  • 题目大意: 海上有很多p 现在要在x轴上放置雷达,给出雷达范围...贪心的想法是把雷达侦查范围尽量的铺开,侦查的范围不要重叠,这样的话就最大化的利用了雷达的侦查范围,没有浪费~这很贪心。#include #include<cma
  • 贪心--金银

    千次阅读 2017-10-22 20:30:46
     典型的贪心算法,思路是:计算每个金属的性价比,然后根据性价比进行排序,从高到低尽可能塞入背包,背包满则得到最大值。 二、参考代码 #include "iostream" #include "iomanip" #include ...
  • 鲁滨逊第 111 天在 111 上,第 iii 天发现了 iii ,并建立了一条到 XiX_iXi​ 的航线,(这里 XiX_iXi​ 为已经发现的,故 Xi<iX_i<iXi​<i ),长度为 111 。现在鲁滨逊想知道,在第 iii 天他的...
  • 4.9 本章小结 4.10 练习题 习题4-1:斐波那契数列(POJ 2753) 习题4-2:求最大公约数问题(POJ 3248) 习题4-3:分解因数(POJ 2749) 习题4-4:逆波兰表达式(POJ 2694) 习题4-5:括号匹配问题(POJ 3704)第5章 二分查找 ...
  • 问题C:确认关于黄蜂的传言2019年9月,在加拿大不列颠哥伦比亚省的温哥华上发现了胡蜂(Vespa mandarinia,又称亚洲大黄蜂)的殖民地。鸟巢很快被摧毁,但这一事件的消息迅速传遍了整个地区。从那时起,在邻近的...
  • 1.Max Area of island 题目描述: 给定一个二维的 0-1 矩阵,其中 0 表示海洋,1 表示陆地。单独的或相邻的陆地可以形成岛屿,每个格子只与其上下左右四个格子相邻。求最大的岛屿面积。...用栈对相连的进行搜索
  • 要你从这些宝石中选取一些宝石,保证总重量不超过 W(W≤230)W(W\le 2^{30})W(W≤230),输出最大的总价值。保证每颗宝石的重量符合 a×2b(a≤10,b≤30)a\times 2^b(a\le 10,b\le30)a×2b(a≤10,b≤30)。 算法分析 设 ...
  • 简单重述一下,James Bond被困在直径15的湖心上,整个湖可以模拟成一个100*100的矩阵,湖上有可供跳跃的陆地点(其实是鳄鱼背),每次007有一个最大的跳跃半径maxdist,问007能否成功逃脱跳到岸上。 这道题实际上...
  • 最多能将多少游客从最西边的送至最东边的岛屿上。 思路: 网络流求最大流的裸题。先通过坐标找到最西边的岛屿和最东边的岛屿,记录并标记为源点和汇点。然后 用链式前向星来存储图,将M条双向边加入到图中。然后...
  • 很多面试算法题都涉及0 ,1矩阵相关知识,下面主要讲一下寻找0 ,1矩阵中含有连续全1块的个数(的个数)和0, 1矩阵中最大连续的全1块。 定义 0 ,1矩阵中含有连续全1块的个数 一个矩阵中只有0和1两种值, 每...
  • 血管的三维重建,本文分析了每张切片与营道曲面的交线是一族圆的包络缱.且这族圆中半径最大者即为最大内切圆这一...建立了相应的算法,将中轴鳍拟合成B;er曲线.并用两种算法耐模垂进行了检验.方法有一定特色。
  • poj2485

    2015-02-06 21:12:30
    /*题意:Flatopia要修路,这个岛上有n个城市,要求修完路后, ...算法:prim 输出最小生成树的最大权值*/ #include #include #define INF 70000 using namespace std; int main() {  int a[51
  •   印度尼西亚领先数字资产交易所 INDODAX 宣布上线 QTUM/IDR 交易对。 QTUM 充值与交易通道已于2月18日-19日开放。   ...INDODAX 是印度尼西亚规模最大的合规数字资产...算力智库专访|钟文斌:新型算法仍需时...

空空如也

空空如也

1 2
收藏数 33
精华内容 13
关键字:

最大岛算法