20201030：算法题

最新推荐文章于 2023-03-04 16:37:04 发布
最新推荐文章于 2023-03-04 16:37:04 发布
阅读量361 收藏
点赞数 2
分类专栏： LeetCode题目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45082647/article/details/109383544
版权

文章目录

算法题一：实现strStr()

在这里插入图片描述
自己的解法：

class Solution {
    public int strStr(String haystack, String needle) {
        if (haystack.length() < needle.length()) {
            return -1;
        }
        if (haystack.length() == needle.length()) {
            if (haystack.equals(needle)) {
                return 0;
            } else {
                return -1;
            }
        }
        if (haystack.length() == 0 || needle.length() == 0) {
            return 0;
        }

        char c = needle.charAt(0);

        //mississippi
        // issip
        for (int i = 0; i < haystack.length(); i++) {
            if (haystack.charAt(i) == c) {
                //System.out.println("haystack.charAt(i):" + haystack.charAt(i) + "=====c:" + c);

                if (needle.length() + i <= haystack.length()) {
                    String subString = haystack.substring(i, needle.length() + i);
                    //System.out.println(subString);
                    if (needle.equals(subString)) {
                        return i;
                    } else {
                        continue;
                    }
                } else {
                    return -1;
                }
            }
        }
        return -1;
    }
}

在这里插入图片描述
【思路】：

我的解法时间和空间效率都不是很高，这里和官方解法做个对比，思路是：
1、首先拿到目标字符串的第一个字符c；
2、遍历原始字符串，如果遇到了和字符c一样的字符，就看它的后面是否与目标字符串一样，如果一样返回当前索引i；
3、否则继续遍历；
4、这个想法比较容易理解；

官方的解法：

public int strStr(String haystack, String needle) {
    int L = needle.length();
    int n = haystack.length();

    //逐一比较的次数为：n-L+1
    for (int start = 0; start < n - L + 1; ++start) {
        if (haystack.substring(start, start + L).equals(needle)) {
            return start;
        }
    }
    return -1;
}

在这里插入图片描述

官方的解法相对更简单：
1、遍历次数为原始字符串长度-目标字符串长度+1；
2、直接进行比较原始字符串是否截串之后等于目标字符串；
3、如果相等返回当前索引，否则返回-1；

算法题二：有多少小于当前数字的数字

在这里插入图片描述
自己的做法：

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 0; i < nums.length; i++) {
            list.add(nums[i]);
        }

        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        //System.out.println(list);

        int[] result = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            int index = list.indexOf(nums[i]);
            result[i] = index;
        }
        return result;
    }
}

在这里插入图片描述
【思路】：

1、将数组中的元素装进集合中进行排序；
2、遍历数组找到集合中当前元素所对应的索引，将这个值存放在结果集中；
3、返回结果集；

官方解法：计数排序

注意到数组元素的值域为 [0,100]，所以可以考虑建立一个频次数组 cnt，cnt[i] 表示数字 i 出现的次数。那么对于数字 i 而言，小于它的 i 数目就为 cnt[0...i−1] 的总和。

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        int[] cnt = new int[101];
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            cnt[nums[i]]++;
        }
        for (int i = 1; i <= 100; i++) {
            cnt[i] += cnt[i - 1];
        }
        int[] ret = new int[n];
        for (int i = 0; i < n; i++) {
            ret[i] = nums[i] == 0 ? 0 : cnt[nums[i] - 1];
        }
        return ret;
    }
}

在这里插入图片描述
【思路】：

1、首先定义一个结果数组用于记录每个数字出现的个数；

2、遍历当前数组，记录每个数字出现的个数，将该数字作为索引，出现次数作为值存储在cnt数组中；

3、遍历cnt数组，从索引1开始，每个值都等于自己+前一个索引的值；这样就可以计算出该值前面有多少个值小于他；

4、遍历给定的数组，如果当前值不为0，结果集中存储的小于他的个数等于cnt数组中以该数字-1为索引的值，否则直接等于0；

5、该解法时间上效率很低，时间复杂度： O(N + K)，其中 K为值域大小。需要遍历两次原数组，同时遍历一次频次数组 cnt 找出前缀和。空间复杂度： O(K)。因为要额外开辟一个值域大小的数组。

算法题三：搜索插入位置

在这里插入图片描述
自己的解法：

class Solution {
    public int searchInsert(int[] nums, int target) {
        ArrayList<Integer> list = new ArrayList<>();
        int result = 0;
        for (int i = 0; i < nums.length; i++) {
            list.add(nums[i]);
        }
        //System.out.println(list);

        if (list.contains(target)) {
            result = list.indexOf(target);
        } else {
            if (target <= list.get(0)) {
                return 0;
            }
            if (target >= list.get(list.size() - 1)) {
                return list.size();
            }
            for (int i = 0; i < list.size() - 1; i++) {
                if (list.get(i) <= target && list.get(i + 1) >= target) {
                    result = i + 1;
                    break;
                }
            }
        }

        return result;
    }
}

在这里插入图片描述
【思路】

1、首先定义一个集合用于存储指定排序数组的所有值，我自己在做题的时候，很喜欢使用集合，因为觉得集合存储数据很方便，调用其中的方法很快的帮助我们达到一定的效果；
2、首先判断如果集合中存在给定的目标值，返回该目标值的索引；
3、如果不存在目标值，首先将目标值与集合中首尾元素大小进行比较，如果小于最小值或者大于最大值返回0或者list.size()；
4、如果不符合上面的情况，从索引0开始遍历集合，如果当前元素小于等于目标值并且目标值小于等于下一个元素（其实不可能等于，因为前面已经做过了判断），设置结果为当前索引+1，然后循环终止；
5、最终返回结果；
6、这个解法的时间复杂度很完美，空间复杂度较低；

官方的解法：二分查找

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int left = 0, right = n - 1, ans = n;
        while (left <= right) {
            int mid = ((right - left) >> 1) + left;
            if (target <= nums[mid]) {
                ans = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

在这里插入图片描述

1、官方使用了二分法来解决这个题目，首先定义了左右可以看作是指针，左指针等于数组最开始的索引0，右指针指向最末端的索引nums.length；
2、执行while循环，循环条件为左索引<=右索引，定义一个中间索引，这里使用了位运算符，它等于（右索引-左索引）+ 左索引；
3、如果目标值小于等于中间索引对应的值，将右索引的值改变为中间索引-1，并将结果改为mid；
4、否则将左索引改变为中间索引+1；
5、最终就是依靠一次一次的逼近结果索引找到这个最中结果返回；
6、这样做的好处就是循环次数显然少于for循环，效率更高；

算法题四：独一无二的出现次数

在这里插入图片描述
自己的解法：

class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        Map<Integer, Integer> hashMap = new HashMap();
        for (int i = 0; i < arr.length; i++) {
            if (hashMap.containsKey(arr[i])) {
                Integer count = hashMap.get(arr[i]);
                hashMap.put(arr[i], ++count);
            } else {
                hashMap.put(arr[i], 1);
            }
        }

        Set<Integer> keySet = hashMap.keySet();
        HashSet<Integer> hashSet = new HashSet<>();
        Iterator<Integer> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            hashSet.add(hashMap.get(iterator.next()));
        }

        return hashMap.size() == hashSet.size();
    }
}

在这里插入图片描述
【思路】：

1、还是比较好理解的做法，首先定义一个hashMap，将给定数组中的元素及其出现的次数作为键值对存储起来；
2、使用集合自带的迭代器遍历集合，并定义一个不允许重复元素的hashSet；
3、将集合中的值存储在hashSet中，集合中存储的值都是不重复的；
4、最终返回两个集合的长度是否相等；
5、这个解法与官方给出的哈希表解法思路一样；

评论区的解法：

class Solution {
        public boolean uniqueOccurrences(int[] arr) {
        Set<Integer> set = new HashSet<>();
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            int counts = 1;
            while (i < arr.length - 1) {
                if(arr[i+1] == arr[i]) {
                    counts++;
                    i++;
                }else {
                    break;
                }
            }
            if(set.contains(counts)) {
                return false;
            } else {
                set.add(counts);
            }
        }
        return true;
    }
}

在这里插入图片描述

这个是在评论区找到的一个比较相对不同的解法，思路大概是：
1、首先给数组排序，并定义一个不允许重复值出现的结果集hashSet；
2、遍历数组，如果当前元素不是最后一个元素，进行一个while循环；
3、如果他后面的元素等于他，使得该元素的个数count++，并使得for循环的变量i++；
4、如果不相等了，也就是这个元素在数组中的个数已经统计完了，就可以跳出while循环，也就是说，while循环就是为了计算该元素在数组中的个数；
5、接下来在集合hashSet中查找，如果存在count，就返回false，否则添加count；

在这里插入图片描述

官方给出的哈希表算法中提到了一个方法：getOrDefault(给定键，默认值)，这个方法指的是如果集合中存在该键，就返回它的值，否则将该键存储到集合中，并返回给定的默认值作为它的值；

算法题五：数组中重复的数字

在这里插入图片描述
自己的解法：

class Solution {
    public int findRepeatNumber(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int ele : nums) {
            map.put(ele, map.getOrDefault(ele, 0) + 1);

            if (map.get(ele) > 1) {
                return ele;
            }
        }

        return nums[0];
    }
}

在这里插入图片描述

自己的做法很简单，使用集合存储元素以及他出现的次数，如果遇到了次数大于1的，直接返回该元素；

评论区解法：

class Solution {
    public int findRepeatNumber(int[] nums) {
        int temp;
        for(int i=0;i<nums.length;i++){
            while (nums[i]!=i){
                if(nums[i]==nums[nums[i]]){
                    return nums[i];
                }
                temp=nums[i];
                nums[i]=nums[temp];
                nums[temp]=temp;
            }
        }
        return -1;
    }
}

在这里插入图片描述
【思路】：

1、如果没有重复数字，那么正常排序后，数字i应该在下标为i的位置；

2、所以思路是重头扫描数组，遇到下标为i的数字如果不是i的话，（假设为m)，那么我们就拿与下标m的数字交换；

3、在交换过程中，如果有重复的数字发生，那么终止返回true；(如果遇到重复的数字，表示之前也存在过该元素，该元素交换到了对应的位置或者是恰好该元素就在这个位置)；

4、这个算法整体非常简洁高效；

算法题六：求根节点到叶子节点之和

在这里插入图片描述

这个题目按照自己的思路做了之后没有通过题解，在看了官方的解法之后，还是觉得自己的算法有缺陷，这里讨论一下官方的解法：

class Solution {
    public int sumNumbers(TreeNode root) {
        return dfs(root, 0);
    }

    public int dfs(TreeNode root, int prevSum) {
        if (root == null) {
            return 0;
        }
        int sum = prevSum * 10 + root.val;
        if (root.left == null && root.right == null) {
            return sum;
        } else {
            return dfs(root.left, sum) + dfs(root.right, sum);
        }
    }
}

在这里插入图片描述
【思路】：

1、官方给出深度优先的算法，很好理解。深度优先搜索是很直观的做法。从根节点开始，遍历每个节点，如果遇到叶子节点，则将叶子节点对应的数字加到数字之和。如果当前节点不是叶子节点，则计算其子节点对应的数字，然后对子节点递归遍历。

2、首先定义一个方法，这个方法需要参数是当前的根节点以及这个根节点之前的数字之和；

3、方法的内部首先判断如果根节点为null，返回0；

4、否则让之前的和*10+当前根节点.val，记录下这个sum值；

5、如果该根节点是一个叶子节点，直接返回这个sum值作为结果；

6、如果该根节点还有左或者右子树，将他们的左右子树作为下一个递归的根节点，当前的sum值作为preSum值，进行递归调用；

算法题七：岛屿的周长

在这里插入图片描述
自己的做法：

class Solution {
    public int islandPerimeter(int[][] grid) {
        int sum = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (grid[i][j] == 1) {
                    sum += getGrith(grid, i, j);
                }
            }
        }

        return sum;
    }

    //                             		 0       1
    private int getGrith(int[][] grid, int i, int j) {
        //判断上下左右有没有1，如果有的话就给整个周长（初始值位4）-1
        int width = grid[i].length - 1;
        int height = grid.length - 1;
        int sum = 4;

        //左边
        if (j - 1 >= 0 && grid[i][j - 1] == 1) {
            sum--;
        }

        //右边
        if (j + 1 <= width && grid[i][j + 1] == 1) {
            sum--;
        }

        //上边
        if (i - 1 >= 0 && grid[i - 1][j] == 1) {
            sum--;
        }

        //下边
        if (i + 1 <= height && grid[i + 1][j] == 1) {
            sum--;
        }

        return sum;
    }
}

在这里插入图片描述
【思路】：

1、遍历给定的二维数组，如果该元素=1，计算该方块的周长；

  • 为计算方块的周长，抽取一个方法；
  • 该方法需要参数是当前的数组以及该元素的两个下标值；
  • 判断该方块的上下左右是否存在为1的方法
  • 如果存在，则这一边的边长就不计入该方块的周长了
  • 最终返回该方块的周长【0~4】；

2、最终加总求和；

评论区的解法：

  • 网格问题是这样一类搜索问题：有 m×n 个小方格，组成一个网格，每个小方格与其上下左右四个方格认为是相邻的，要在这样的网格上进行某种搜索。这种题目乍一看可能有点麻烦，实际上非常简单，尤其是用 DFS 的方法。题目没有限制的话，我们尽量用 DFS 来写代码。

  • 下面我们一步步地构造出方格类 DFS 的代码。

  • 首先，每个方格与其上下左右的四个方格相邻，则 DFS 每次要分出四个岔：

// 基本的 DFS 框架：每次搜索四个相邻方格
void dfs(int[][] grid, int r, int c) {
    dfs(grid, r - 1, c); // 上边相邻
    dfs(grid, r + 1, c); // 下边相邻
    dfs(grid, r, c - 1); // 左边相邻
    dfs(grid, r, c + 1); // 右边相邻
}
  • 但是，对于网格边缘的方格，上下左右并不都有邻居。一种做法是在递归调用之前判断方格的位置，例如位于左边缘，则不访问其左邻居。但这样一个一个判断写起来比较麻烦，我们可以用“先污染后治理”的方法，先做递归调用，再在每个 DFS 函数的开头判断坐标是否合法，不合法的直接返回。同样地，我们还需要判断该方格是否有岛屿（值是否为 1），否则也需要返回。
// 处理方格位于网格边缘的情况
void dfs(int[][] grid, int r, int c) {
    // 若坐标不合法，直接返回
    if (!(0 <= r && r < grid.length && 0 <= c && c < grid[0].length)) {
        return;
    }
    // 若该方格不是岛屿，直接返回
    if (grid[r][c] != 1) {
        return;
    }
    dfs(grid, r - 1, c);
    dfs(grid, r + 1, c);
    dfs(grid, r, c - 1);
    dfs(grid, r, c + 1);
}
  • 但是这样还有一个问题：DFS 可能会不停地“兜圈子”，永远停不下来，如下图所示：

在这里插入图片描述

  • 那么我们需要标记遍历过的方格，保证方格不进行重复遍历。标记遍历过的方格并不需要使用额外的空间，只需要改变方格中存储的值就可以。在这道题中，值为 0 表示非岛屿（不可遍历），值为 1 表示岛屿（可遍历），我们用 2 表示已遍历过的岛屿。

在这里插入图片描述

这样，我们就得到了网格 DFS 遍历的框架代码：

// 标记已遍历过的岛屿，不做重复遍历
void dfs(int[][] grid, int r, int c) {
    if (!(0 <= r && r < grid.length && 0 <= c && c < grid[0].length)) {
        return;
    }
    // 已遍历过（值为2）的岛屿在这里会直接返回，不会重复遍历
    if (grid[r][c] != 1) {
        return;
    }
    grid[r][c] = 2; // 将方格标记为"已遍历"
    dfs(grid, r - 1, c); 
    dfs(grid, r + 1, c);
    dfs(grid, r, c - 1);
    dfs(grid, r, c + 1);
}
  • 如何在 DFS 遍历时求岛屿的周长

求岛屿的周长其实有很多种方法，如果用 DFS 遍历来求的话，有一种很简单的思路：岛屿的周长就是岛屿方格和非岛屿方格相邻的边的数量。注意，这里的非岛屿方格，既包括水域方格，也包括网格的边界。我们可以画一张图，看得更清晰：

在这里插入图片描述

  • 将这个“相邻关系”对应到 DFS 遍历中，就是：每当在 DFS 遍历中，从一个岛屿方格走向一个非岛屿方格，就将周长加 1。代码如下：
int dfs(int[][] grid, int r, int c) {
    // 从一个岛屿方格走向网格边界，周长加 1
    if (!(0 <= r && r < grid.length && 0 <= c && c < grid[0].length)) {
        return 1;
    }
    // 从一个岛屿方格走向水域方格，周长加 1
    if (grid[r][c] == 0) {
        return 1;
    }
    if (grid[r][c] != 1) {
        return 0;
    }
    grid[r][c] = 2;
    return dfs(grid, r - 1, c)
        + dfs(grid, r + 1, c)
        + dfs(grid, r, c - 1)
        + dfs(grid, r, c + 1);
}
  • 最终，我们得到完整的题解代码：
public int islandPerimeter(int[][] grid) {
    for (int r = 0; r < grid.length; r++) {
        for (int c = 0; c < grid[0].length; c++) {
            if (grid[r][c] == 1) {
                // 题目限制只有一个岛屿，计算一个即可
                return dfs(grid, r, c);
            }
        }
    }
    return 0;
}

int dfs(int[][] grid, int r, int c) {
    if (!(0 <= r && r < grid.length && 0 <= c && c < grid[0].length)) {
        return 1;
    }
    if (grid[r][c] == 0) {
        return 1;
    }
    if (grid[r][c] != 1) {
        return 0;
    }
    grid[r][c] = 2;
    return dfs(grid, r - 1, c)
        + dfs(grid, r + 1, c)
        + dfs(grid, r, c - 1)
        + dfs(grid, r, c + 1);
}

作者：nettee
链接：https://leetcode-cn.com/problems/island-perimeter/solution/tu-jie-jian-ji-er-qiao-miao-de-dfs-fang-fa-java-by/
来源：力扣（LeetCode）

明天，你好呀
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【入门】靶心数
edu1119836008的博客
12-31 638
James同学发现了在二维数组中有这样一类数，这个数正好比自己上下左右四个方向的数都大（由于需要比四个方向的数都大，因此这个数不可能在第一行、最后一行、第一列、最后一列），James把它们称为靶心数，请你编程求出一个二维数组的靶心数有哪些，输出他们。
【剑指Offer面试编程题】题目1384：二维数组中的查找--九度OJ
一路向前
12-04 1204
【思路】深入挖掘题目愿意，巧妙利用题目的意图，只需要用要查找的元素与输入的数组每一个元素进行比较即可得到要查找的元素是否在输入的数组里面，数组也不用保存。比较简单的思路，但却是比较巧的解法。 AC code：
回文数问题
MarcoLimuzhou的博客
03-04 437
找回文数
leetcode题解-9.回文数
qianji_little_boy的博客
07-20 562
回文数:link 1.题目分析 1.首先按照题意，负数是不可能是回文数的。 2.反转一个数字可能会出现的是溢出，在本题中有三种方法处理溢出； 法一：将数字转化为字符串tostr()函数。 法二：使用long long类型作为转化后的数可以避免溢出。 法三：只转化数的一半，reference 2.示例代码 class Solution { public: bool isPalindrom...
C语言：二维数组
yingcanye的博客
02-18 1267
简单介绍了二维数组并附加了几道题。
AlgProblems:算法题合集
03-18
【标题】"AlgProblems:算法题合集" 指的是一份包含大量算法问题的资源库，可能是一个项目或者课程，旨在帮助学习者提升算法设计和分析能力。在这个集合中，用户可以找到各种类型的算法题目，涵盖数据结构、排序、...
algorithm：算法题测试
02-14
本话题将深入探讨与“algorithm：算法题测试”相关的知识，特别是与Java编程语言的结合。 Java是一种广泛使用的面向对象的编程语言，它具有丰富的类库，强大的性能和跨平台兼容性，这使得Java成为实现算法的理想...
AlgorithmDemo:算法题上传
03-31
《算法题上传——Python编程实践解析》 在编程领域，算法是解决问题的核心工具，而Python作为一门易学且功能强大的编程语言，常被用于编写算法。"AlgorithmDemo:算法题上传"这一项目，旨在帮助开发者通过Python实现...
leetcode题库-Algorithm:算法
06-29
支持10+种语言（包括C#，Python，Ruby，Nodejs等流行的语言），判题一次跑所有test，出现了错误可以查看输入输出数据，从而反思是哪里没有想对，还有QQ群让大家讨论（251587768），群里高手众多。 可视化的数据结构...
算法笔试题：（Python实现）—— 算法面试题汇总
01-21
算法笔试题：（Python实现）—— 算法面试题汇总算法笔试题：（Python实现）—— 算法面试题汇总开始之前Python实现只出现一次的数字多数元素搜索二维矩阵 II合并两个有序数组鸡蛋掉落字符串Python实现验证回文串...
16-7 靶心数
Harry_Zhao123的博客
05-09 1601
#include <bits/stdc++.h> using namespace std; int main(){ int a[200][200]; int i,j,n,m,t; cin >> n >> m; for(i = 0;i < n;i++){ for(j = 0;j < m;j++){ cin >> a[i][j]; } ...
蓝桥杯 Python 练习题 数字游戏
qq_57844679的博客
02-10 5693
试题 算法训练 数字游戏 提交此题评测记录 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 　　给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。 　　例如: 　　3 1 2 4 　　4 3 6 　　7 9 　　16 　　现在如果知道N和最后得到的数字sum，请求出最初序列a[i]，为1～N的一个排列。若有多种答案，则输出字典序最小的那一个。数据保证有解。 输入格...
黑马程序员——java编程那些事儿____java基础（三） 数组
wang_zhi_的专栏
03-17 613
-------android培训、java培训、期待与您交流！ ----------     一 数组的定义             数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。             其实我觉得数组就是一个容器。 二 数组的好处            可以自动给数组中的
用二维数组表示图中的上下左右偏移，然后进行移动遍历
qq_31424423的博客
12-05 4235
我们在遍历图时往往会涉及到点的上下左右移动，使用二维数组对移动的方向做个记录，将变得简洁方便，下面给出了一个栗子（）： #include struct Point{ int px; int py; }; int DIRECTION[4][2] = { {0,-1}, {0,1}, {-1,0}, {1,0} }; int main() { Point pt =Point{ 3,
获取图片颜色相同的最大块，获取二维数组中值上下左右连续相同的最大块
北海的博客
08-21 2415
问题：查找一块图片中区域颜色相同的最大的一块，以二维数组模拟图片，共有1、2、3、4四种颜色。 输入：一个二维数组，每个值为1、2、3、4中的一个。 输出：最大块颜色值及最大块总数值。 主要思路： 参数设置： int a[10][10]，作为被查找最大块的原始数据，数组里用1、2、3、4表示4种不同的颜色。为方便验证正确性，此处使用10*10的二位数组。 int k，记录当前颜色。
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数
qq_38087131的博客
03-14 649
题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 1.使用最暴力的方法，将数组通过两次for循环进行遍历，判断其是否有该数字 public class Solution { public boolean Find(int targe...
leetcode刷题笔记
qq_39412355的博客
09-22 1733
2020年9月22日 1.监控二叉树 hard 属于递归和动态规划的结合，将节点分为三种状态，一种是自身有摄像头，一种是自身没有摄像头但是自己可以被看到，还有一种就是自身不能被看到 每个节点只要管好自身还有自己的子节点即可，最上层的根节点单独处理 主要是对于递归的掌握还是不够好，还需要多刷题，今天学了一下大佬的解法，争取下次自己能做出来 ...
每日一练——矩阵中的最大递增路径
千里之行，始于足下
07-11 2647
题目描述： Given an integer matrix, find the length of the longest increasing path. From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move
剑指67题解
ni_new_sm_new的博客
03-03 4102
剑指offer 需要md私信 1 二维数组中的查找 二维数组中的查找 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路：从右上角开始往左下角塞选 public class select2DArry { public boolean Fi...
字节面试算法题总结大全
最新发布
06-01
"字节跳动面试中的算法题总结主要关注于求职者在面试过程中的技术评估，特别是与编程和逻辑思维紧密相关的算法题目。两道核心题目分别是： 1. 买卖股票的最佳时机： - 这是一个经典的动态规划问题，面试者需要设计...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值