从字节面试题中学回溯

已于 2024-09-04 17:04:33 修改
阅读量564 收藏 11
点赞数 7
分类专栏： 算法与数据结构 文章标签： 算法 回溯
于 2024-09-04 17:02:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45942644/article/details/141896440
版权

131. 分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

  • 1 <= s.length <= 16
  • s 仅由小写英文字母组成

回溯

class Solution {
    List<List<String>> res = new LinkedList<>();
    List<String> track = new LinkedList<>();

    public List<List<String>> partition(String s) {
        backtrack(s, 0);
        return res;
    }

    void backtrack(String s, int start) {
        if (start == s.length()) {
            // base case
            // 越界，即整个 s 被成功分割为若干个回文子串，记下答案
            res.add(new ArrayList<String>(track));
        }
        
        // for 和 if 是用来检查字符串是否应该被放到track列表里的
        for (int i = start; i < s.length(); i++) {
            if (!isPalindrome(s, start, i)) {
                // s[start..i] 不是回文串，不能分割，继续检查s[start, i+1]
                continue;
            }
            
            // s[start..i] 是一个回文串，可以进行分割
            // 做选择，把 s[start..i] 放入路径列表中
            track.addLast(s.substring(start, i + 1));
            // 进入回溯树的下一层，继续切分 s[i+1..]
            backtrack(s, i + 1);
            // 撤销选择
            track.removeLast();
        }
    }

    // 用双指针技巧判断 s[lo..hi] 是否是一个回文串
    boolean isPalindrome(String s, int lo, int hi) {
        while (lo < hi) {
            if (s.charAt(lo) != s.charAt(hi)) {
                return false;
            }
            lo++;
            hi--;
        }
        return true;
    }
}
  • 时间复杂度：O(N*2^N)；这里 N 为输入字符串的长度，每一个位置可拆分，也可不拆分，尝试是否可以拆分的时间复杂度为 O(2^N)，判断每一个子串是否是回文子串，时间复杂度为 O(N)；
  • 空间复杂度：
    • 如果不计算保存结果的空间，空间复杂度为 O(N)，递归调用栈的高度为 N；
    • 如果计算保存答案需要空间 2^N*N，这里 2^N 为保守估计，实际情况不会这么多。空间复杂度为 O(2^N*N)。

90. 子集 II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10

回溯

class Solution {
    List<List<Integer>> res = new LinkedList<>();
    List<Integer> track = new LinkedList<>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        // 先排序，让相同的元素靠在一起
        Arrays.sort(nums);
        backtrack(nums, 0);
        return res;
    }

    void backtrack(int[] nums, int start) {
        // 前序位置，每个节点的值都是一个子集。重点。
        res.add(new LinkedList<>(track));

        for (int i = start; i < nums.length; i++) {
            // 剪枝，值相同的相邻树枝，只遍历第一条。重点。
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }
            
            track.addLast(nums[i]);
            backtrack(nums, i + 1);
            track.removeLast();
        }
    }
}
  • 可能的子集数量为 2^n，对于每一个子集，程序都会执行一系列操作，其中包括子集的构造和检查，平均情况下，每个子集的长度是 O(n)。回溯搜索的总复杂度可以近似表示为 O(n*2^n)，这是因为回溯会对每个可能的子集进行构建和复制。
  • new LinkedList<>(track) 这行代码会创建一个新的 LinkedList 实例，并将当前 track 中的所有元素复制到新列表中。复制 track 的所有元素的时间复杂度是 O(k)，其中 k 是当前 track 的长度。res.add(...) 是将新子集加入到结果列表 res 中，这个操作本身是常数时间 O(1)，因为 LinkedList 的尾插入操作时间复杂度为 O(1)。在回溯生成子集的过程中，track 的长度会随着递归的深度变化。最坏情况下，track 可以达到最大长度，即 n（输入数组的长度）。因此，复制 track 的操作在最坏情况下是 O(n)。因此如果不考虑结果链表res，空间复杂度是 O(n)。res的空间复杂度是O(n*2^n)。

491. 非递减子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

提示：

  • 1 <= nums.length <= 15
  • -100 <= nums[i] <= 100

回溯

class Solution {
    public List<List<Integer>> findSubsequences(int[] nums) {
        if (nums.length == 0) {
            return res;
        }
        
        backtrack(nums, 0);
        return res;
    }

    List<List<Integer>> res = new LinkedList<>();
    // 记录回溯的路径
    List<Integer> track = new LinkedList<>();

    // 回溯算法主函数
    void backtrack(int[] nums, int start) {
        if (track.size() >= 2) {
            // 找到一个合法答案，不能返回，还要继续找。重点。
            res.add(new LinkedList<>(track));
        }
        
        // 用哈希集合防止重复选择相同元素，横向作用
        Set<Integer> used = new HashSet<>();
        // 回溯算法标准框架
        for (int i = start; i < nums.length; i++) {
            // 剪枝，保证集合中元素都是递增顺序。重点。
            if (!track.isEmpty() && track.getLast() > nums[i]) {
                continue;
            }
            // 剪枝，确保递增，即不要重复使用相同的元素，
            if (used.contains(nums[i])) {
                continue;
            }
            
            // 选择 nums[i]
            used.add(nums[i]);
            track.add(nums[i]);
            // 递归遍历下一层回溯树
            backtrack(nums, i + 1);
            // 撤销选择 nums[i]
            track.removeLast();
            // 这里不能写used.remove(nums[i])，因为used是当前递归层的状态，不是全局状态。
        }
    }
}
  • 时间复杂度为 O(n*2^n)。这里 n 是用于每一层循环的复杂度估算，2^n 是由于每个元素都有加入或不加入子序列的选择。HashSet 的操作（add 和 contains）都是 O(1) 的时间复杂度。
  • 递归的深度最多为 n，因此递归栈的空间复杂度是 O(n)。存储结果的空间复杂度取决于生成的子序列数量和长度，这在最坏情况下接近 O(2^n*n)。

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

回溯

class Solution {
    List<List<Integer>> res = new LinkedList<>(); // 结果列表
    List<Integer> track = new LinkedList<>(); // 用于存储当前的排列内容
    boolean[] used; // 标记数组，用来记录nums中的元素是否已经被使用

    public List<List<Integer>> permuteUnique(int[] nums) {
        // 先对数组进行排序，这样相同的数字就会被排列在一起，便于后续剪枝
        Arrays.sort(nums);
        used = new boolean[nums.length];
        
        backtrack(nums);
        return res;
    }

    void backtrack(int[] nums) {
        // 如果当前排列的长度等于nums的长度，说明找到了一个完整的排列。排列的长度是一样的。
        if (track.size() == nums.length) {
            res.add(new LinkedList(track)); // 将当前排列添加到结果列表中
            return;
        }

        // 从头开始遍历
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) { // 纵向比较进行剪枝
                continue; // 如果nums[i]已经在本路径中被使用过，则跳过
            }
            // 因为数组中有重复元素，所以需要横向比较进行剪枝，以避免产生重复的排列。used是纵向的，即跨递归的，方法二中的prevNum是横向的。
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                // 如果当前数字和前一个数字相同，且前一个数字还未被使用过，则跳过
                // 这是因为这种情况会产生和前一个数字相同的排列，导致产生相同的排列
                continue;
            }
            
            track.add(nums[i]); // 将nums[i]添加到当前排列中
            used[i] = true; // 标记nums[i]已经被使用
            backtrack(nums); // 递归调用，继续填充排列的下一个数字
            track.removeLast(); // 回溯，从当前排列中移除nums[i]
            used[i] = false; // 取消对nums[i]的使用标记
        }
    }
}
  • 总共有n!种排列，每个排列都需要被复制到res中，这个操作的时间复杂度是O(n)，因此总的时间复杂度是O(n*n!)
  • 记忆数组O(n)，递归栈O(n)。

回溯

class Solution {
    List<List<Integer>> res = new LinkedList<>(); // 结果列表
    LinkedList<Integer> track = new LinkedList<>(); // 用于存储当前的排列内容
    boolean[] used; // 标记数组，用来记录nums中的元素是否已经被使用

    public List<List<Integer>> permuteUnique(int[] nums) {
        // 先对数组进行排序，这样相同的数字就会被排列在一起，便于后续剪枝
        Arrays.sort(nums);
        used = new boolean[nums.length];
        backtrack(nums, track);
        return res;
    }

    void backtrack(int[] nums, LinkedList<Integer> track) {
        if (track.size() == nums.length) {
            res.add(new LinkedList(track));
            return;
        }

        // 利用prevNum变量记录之前树枝上元素的值
        // 题目说 -10 <= nums[i] <= 10，所以初始化为特殊值
        // used是全局记忆数组，prevNum是每层递归中的记忆变量
        int prevNum = -666;
        for (int i = 0; i < nums.length; i++) {
            // 排除不合法的选择
            if (used[i]) {
                continue;
            }
            // 注意prevNum是每层递归中的变量，不会跨递归，因此prevNum是本轮递归中的前一个数，即横向的数，不是track中的上一个选择。
            if (nums[i] == prevNum) {
                continue;
            }

            track.add(nums[i]);
            used[i] = true;
            // 记录这条树枝上的值
            prevNum = nums[i];

            backtrack(nums, track);

            track.removeLast();
            used[i] = false;
        }
    }
}

37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

在这里插入图片描述

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

提示：

  • board.length == 9
  • board[i].length == 9
  • board[i][j] 是一位数字或者 '.'
  • 题目数据 保证 输入数独仅有一个解

回溯

class Solution {
    public void solveSudoku(char[][] board) {
        backtrack(board, 0, 0); // 开始从 (0, 0) 位置开始进行回溯
    }

    boolean backtrack(char[][] board, int i, int j) {
        int m = 9, n = 9; // 数独的大小固定为 9x9
        if (j == n) {
            // 如果穷举到最后一列的话，就换到下一行重新开始。重点。
            return backtrack(board, i + 1, 0);
        }
        if (i == m) {
            // 如果穷举到最后一行，说明找到一个可行解。重点。
            return true;
        }

        if (board[i][j] != '.') {
            // 如果当前位置有预设数字，不用我们穷举，直接跳到下一个位置。重点。
            return backtrack(board, i, j + 1);
        }

        // 尝试填入数字 1 到 9
        for (char ch = '1'; ch <= '9'; ch++) {
            // 如果遇到不合法的数字，跳过
            if (!isValid(board, i, j, ch))
                continue;

            board[i][j] = ch; // 做选择：填入数字 ch
            // 判断 3x3 方框是否存在重复。重点。r/3是从上往下数第几个方块，每一个方块都有三行，所以r/3就是第几行。
            if (backtrack(board, i, j + 1)) {
                return true;
            }
            board[i][j] = '.'; // 撤销选择：恢复为空格
        }
        
        // 穷举完 1 到 9，依然没有找到可行解，返回 false 表示此路不通
        return false;
    }

    // 判断 board[r][c] 是否可以填入字符 n
    boolean isValid(char[][] board, int r, int c, char n) {
        for (int i = 0; i < 9; i++) {
            // 判断行是否存在重复
            if (board[r][i] == n) return false;
            // 判断列是否存在重复
            if (board[i][c] == n) return false;
            // 判断 3x3 方框是否存在重复。重点。
            if (board[(r / 3) * 3 + i / 3][(c / 3) * 3 + i % 3] == n)
                return false;
        }
        return true; // 如果以上条件都不满足，说明可以填入字符 n
    }
}
  • 在最坏情况下，每个空格都需要穷举 9 个数字。因此最差情况下，时间复杂度是 O(9^N)。
  • 空间复杂度主要由递归调用栈的深度决定：在最坏情况下，递归的最大深度为 N，即数独中所有空格的数量。每次递归调用会使用常数级别的空间（例如局部变量和参数），所以空间复杂度为 O(N)。

解释一下判断 3x3 方框是否存在重复的代码。

假设我们在一个数独棋盘上操作，当前的位置是 (r, c)，比如说位置 (4, 4)，我们要检查数字 5 是否可以放在这个位置。

首先，我们需要找到 (4, 4) 所在的 3x3 小方框：

+-------+-------+-------+
| . . . | . . . | . . . |
| . . . | . . . | . . . |
| . . . | . . . | . . . |
+-------+-------+-------+
| . . . | . . . | . . . |
| . . . | . 5 . | . . . |
| . . . | . . . | . . . |
+-------+-------+-------+
| . . . | . . . | . . . |
| . . . | . . . | . . . |
| . . . | . . . | . . . |
+-------+-------+-------+

我们看到 (4, 4) 在棋盘的中心，位于中间的 3x3 小方框中。

  • (r / 3) 表示当前行 r 所在的 3x3 小方框的行索引。对于 r = 4，计算 (4 / 3) = 1，表示当前行位于第二个 3x3 小方框的行。
  • (c / 3) 表示当前列 c 所在的 3x3 小方框的列索引。对于 c = 4，计算 (4 / 3) = 1，表示当前列位于第二个 3x3 小方框的列。

所以，当前 3x3 小方框的左上角坐标是 (1 * 3, 1 * 3)，即 (3, 3)。

我们需要遍历这个 3x3 小方框的所有位置，检查是否有重复数字 n。遍历的索引用 i 从 0 到 8，每个 i 对应小方框中的一个位置。

  • i / 3 是当前元素在 3x3 小方框中的行索引。例如，当 i 取 0, 1, 2 时，对应 3x3 小方框的第一行，i / 3 = 0；当 i 取 3, 4, 5 时，对应 3x3 小方框的第二行，i / 3 = 1；当 i 取 6, 7, 8 时，对应 3x3 小方框的第三行，i / 3 = 2。
  • i % 3 是当前元素在 3x3 小方框中的列索引。例如，当 i 取 0, 3, 6 时，对应 3x3 小方框的第一列，i % 3 = 0；当 i 取 1, 4, 7 时，对应 3x3 小方框的第二列，i % 3 = 1；当 i 取 2, 5, 8 时，对应 3x3 小方框的第三列，i % 3 = 2。
iygvh
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字节面试必须拿下的十道算法题，你会几道？
bigsai
12-29 6381
最近不少小伙伴跟我交流刷题肿么刷，我给的建议就是先剑指offer和力扣hot100，在这些题中还有些重要程度和出现频率是非常非常高的，今天给大家分享当今出现频率最高的10道算法题，学到就是赚到。 0X01翻转链表 力扣206和剑指offer24原题，题意为： 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 分析： 翻转链表，本意是不创建新的链表节点然后在原链表上实现翻转，.
字节前端二面react面试题（边面边更）
beifeng11996的博客
03-13 450
类似的业务需求也有很多，如一个可以横向滑动的列表，当前高亮的 Tab 显然隶属于列表自身的时，根据传入的某个值，直接定位到某个 Tab。它能保证性能下限，在真实DOM操作的时候进行针对性的优化时，还是更快的。在react的componentWillReceiveProps(nextProps)生命周期中，可以在子组件的render函数执行前，通过this.props获取旧的属性，通过nextProps获取新的props，对比两次props是否相同，从而更新子组件自己的state。否则新建实例时会报错；
字节面试题 数组元素的组合 回溯
口袋里的星星的博客
07-07 146
字节跳动一面算法题 求数组中所有元素的组合（比如[1,2,2]，组合有[[], [1],[2], [1,2],[2,2],[1,2,2]]） 很明显使用回溯算法可以解决 nums = [1,2,2] nums.sort() res = [[]] def backtrack(nums, temp): # res.append(temp) for i in range(len(nums)): if i>0 and nums[i-1]==nums[i]:
字节面试算法题
weixin_49849351的博客
01-01 351
剑指 Offer 35. 复杂链表的复制 题目描述 思路 哈希表+回溯 具体代码 class Solution { Map<Node, Node> cachedNode = new HashMap<Node, Node>(); public Node copyRandomList(Node head) { if (head == null) { return null; } ..
字节算法面试为什么这么难？字节三面算法面试真题分享！(1)
VIP129370的博客
04-21 964
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友[外链图片转存中…(img-M2xEp9Vb-1713638364451)]《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
字节面试题-小于N的最大数字
qq_36282995的博客
07-30 8400
首先将arr数组排序，之后使用深搜+贪心的思想，从第一位开始，尽量使用与对应位置相等的数字。如果有任意一位没有使用相等的数字，那在后面的所有位中都直接使用最大的数字即可。给定一个数组arr=[2,3,4,5],N=2345,求使用arr中的数字，组成一个不大于N的最大的数字。2.如果在找第一位时，就发现都不相等，那不要立刻返回-1，而是应该放弃第一位，将后面的位都选择最大值。深受启发，但原文仍有瑕疵，最终的答案可以等于N，而且有不必要的搜索。2.在之前选择的基础上，此位置没有满足条件的选择，应当返回-1。.
字节面试题 小于n的最大数
muke0318的博客
04-26 1110
②第二种情况为找到这个最大数，且最大数小于当前位的数，则将数压入结果栈，并且后续的位应全部用所给数组nums中的最大元素来作为选择，然后退出最外层循环，返回结果。①出栈回溯前面的位，找到最大且小于当前回溯位数字的元素（而不包括等于当前回溯位数字），如果找到这样的元素，压入结果栈，后续位全部用最大元素填充。对目标数进行遍历，以贪心的方式在所给数组nums中找出小于等于当前位并且最大的数。①第一种情况为找到这个最大数，且最大数等于当前位的数，则将数压入结果栈中。II.不能找到这样的数。
字节前端面试题（第一期）.pdf
09-24
以下是一些面试题及其相关知识点的详细解答： 1. **在列表组件中写 key 的原因**：在 React 或 Vue 中，为列表项设置 `key` 是为了帮助虚拟 DOM 更高效地识别和更新元素，避免不必要的重新渲染，提高性能。每个 `...
2021最新面试经验，包括百度、阿里、美团、字节跳动算法面试题总结经验
10-13
字节跳动以其强大的个性化推荐系统闻名，因此面试题往往涉及机器学习、数据挖掘以及推荐算法。例如，可能会要求设计一个新闻或视频的推荐系统，或者讨论如何通过协同过滤、深度学习模型来提升用户体验。同时，字节...
Just Code ! 针对面试训练算法题， 目前包括字节跳动面试题、 LeetCode 和剑指 offer.zip
05-01
本资料集合了针对字节跳动面试题、LeetCode 以及《剑指 Offer》中的经典算法题目，旨在帮助你提升编程思维和解决问题的能力。 一、字节跳动面试题 字节跳动作为全球领先的科技公司，其面试过程中对算法的考察深入且...
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 464
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3702
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 386
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 680
动态规划
递归、搜索与回溯算法
无聊_人的博客
08-29 7803
所谓的递归其实就是函数自己调用自己的情况。
第四讲：拟合算法
PGeorge6的博客
09-03 944
与插值问题不同，在拟合问题中不需要曲线一定经过给定的点。拟合问题的目标是寻求一个函数(曲线)使得该曲线在某种准则下与所有的数据点最为接近，即曲线拟合的最好(最小化损失函数)。插值算法中，得到的多项式f(x)要经过所有样本点。但是如果样本点太多，那么这个多项式次数过高，会造成龙格现象。尽管我们可以选择分段的方法避免这种现象，但是更多时候我们更倾向于得到-个确定的曲线，尽管这条曲线不能经过每一个样本点，但只要保证误差足够小即可，这就是拟合的思想。(拟合的结果是得到一个确定的曲线)
力扣（无重叠区间）
yyssas的博客
08-29 8562
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1326
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
P7492 [传智杯 #3 决赛] 序列
最新发布
summ1ts的博客
09-03 213
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值