第四课 递归、分治

最新推荐文章于 2024-08-29 16:37:54 发布
最新推荐文章于 2024-08-29 16:37:54 发布
阅读量140 收藏 1
点赞数
分类专栏： C++刷题 文章标签： 深度优先 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BH04250909/article/details/133636760
版权

文章目录

第四课 递归、分治

lc78.子集–中等

题目描述

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

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

示例 1：

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

示例 2：

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

提示：

  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10
  • nums 中的所有元素 互不相同

代码展示

class Solution {
public:
    vector<int> t;            // 用于暂存当前子集
    vector<vector<int>> ans;  // 用于存储所有子集的答案

    // DFS 函数，cur 表示当前处理的元素索引，nums 表示原始数组
    void dfs(int cur, vector<int>& nums) {
        if (cur == nums.size()) {  // 如果当前索引等于数组大小，表示处理完了所有元素，将当前子集添加到答案中
            ans.push_back(t);
            return;
        }
        t.push_back(nums[cur]);    // 将当前元素加入子集
        dfs(cur + 1, nums);        // 递归处理下一个元素
        t.pop_back();              // 回溯，将当前元素从子集中移除
        dfs(cur + 1, nums);        // 继续递归处理下一个元素，不加入当前元素的情况
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(0, nums);  // 从第一个元素开始递归生成子集
        return ans;    // 返回生成的所有子集
    }
};

lc77.组合–中等

题目描述

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

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

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

  • 1 <= n <= 20
  • 1 <= k <= n

代码展示

class Solution {
public:
    vector<int> temp;           // 用于暂存当前组合
    vector<vector<int>> ans;    // 用于存储所有组合的答案

    void dfs(int cur, int n, int k) {
        // 剪枝：如果当前已经选择的数字个数加上剩下的数字个数小于 k，就不可能构造出长度为 k 的组合，进行剪枝
        if (temp.size() + (n - cur + 1) < k) {
            return;
        }
        // 如果当前已经选择的数字个数等于 k，将当前组合加入答案中
        if (temp.size() == k) {
            ans.push_back(temp);
            return;
        }
        // 考虑选择当前位置的数字
        temp.push_back(cur);
        dfs(cur + 1, n, k);
        temp.pop_back();  // 回溯，将当前位置的数字移除，考虑不选择当前位置的数字
        dfs(cur + 1, n, k);
    }

    vector<vector<int>> combine(int n, int k) {
        dfs(1, n, k);  // 从第一个数字开始生成组合
        return ans;    // 返回生成的所有组合
    }
};

优化思路：

这个算法的改进之处在于：

  1. 减少了递归的深度：在原来的算法中，即使不选择当前位置的数字，也会递归调用一次 dfs(cur + 1, n, k)，导致递归深度较大。改进后的算法只有在选择当前位置的数字时才会递归调用，减少了递归深度。
  2. 减少了不必要的循环：原来的算法在循环时，遍历了所有可能的组合，包括不可能构成有效组合的情况。改进后的算法在循环时，通过限制 i 的取值范围，避免了生成无效组合的情况。

这个改进后的算法在性能上更优化，尤其是对于较大的输入，因为它减少了不必要的递归和循环操作。

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result;
        vector<int> current;
        backtrack(result, current, n, k, 1);
        return result;
    }

private:
    void backtrack(vector<vector<int>>& result, vector<int>& current, int n, int k, int start) {
        if (k == 0) {
            result.push_back(current);
            return;
        }

        for (int i = start; i <= n - k + 1; ++i) { // 减去 k - 1 个数，保证剩余的数足够构成组合
            current.push_back(i);
            backtrack(result, current, n, k - 1, i + 1);
            current.pop_back();
        }
    }
};

lc46.全排列–中等

题目描述

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

  • 1 <= nums.length <= 6
  • -10 <= nums[i] <= 10
  • nums 中的所有整数 互不相同

代码展示

class Solution {
public:
    void backtrack(vector<vector<int>>& res, vector<int>& output, int first, int len){
        // 所有数都填完了
        if (first == len) {
            res.emplace_back(output); // 当前排列已完成，将其添加到结果集中
            return;
        }
        for (int i = first; i < len; ++i) {
            // 动态维护数组
            swap(output[i], output[first]); // 交换当前位置与第一个位置的数字
            // 继续递归填下一个数
            backtrack(res, output, first + 1, len); // 递归填充下一个位置的数字
            // 撤销操作，即还原数组
            swap(output[i], output[first]); // 恢复交换前的数组状态，进行回溯
        }
    }
    
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        backtrack(res, nums, 0, (int)nums.size()); // 调用回溯函数开始生成全排列
        return res; // 返回所有全排列结果
    }
};

这段代码使用了递归和回溯的方法来生成全排列。具体解释如下：

  • backtrack 函数是回溯的核心部分。它接受以下参数：
    • res：存储结果的二维向量。
    • output：当前正在生成的排列。
    • first：表示当前正在处理的位置。
    • len：数组的长度，用于确定何时完成排列。
  • 在 backtrack 函数中，首先检查是否已经生成了一个完整的排列（即 first == len）。如果是，将当前排列添加到结果集 res 中。
  • 接下来，使用一个 for 循环，从当前位置 first 开始遍历数组。对于每个位置 i，它进行了以下操作：
    • 交换 output[i] 和 output[first]，这是为了将当前位置的数字放到第一个位置，相当于固定了第一个位置的数字。
    • 然后递归调用 backtrack，处理下一个位置，即 first + 1。
    • 最后，进行回溯，恢复数组状态，即再次交换 output[i] 和 output[first]，以便尝试其他数字排列。
  • 最后，在 permute 函数中，它调用了 backtrack 函数，从数组的第一个位置开始生成全排列。最终返回所有生成的全排列。

这段代码是一个经典的全排列生成算法，使用了回溯技巧，通过交换数组中的元素来生成所有可能的排列。

lc47.全排列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 {
    vector<int> vis; // 用于标记元素是否已经被使用

public:
    void backtrack(vector<int>& nums, vector<vector<int>>& ans, int idx, vector<int>& perm) {
        if (idx == nums.size()) {
            ans.emplace_back(perm); // 当前排列已完成，将其添加到结果集中
            return;
        }
        for (int i = 0; i < (int)nums.size(); ++i) {
            if (vis[i] || (i > 0 && nums[i] == nums[i - 1] && !vis[i - 1])) {
                // 跳过已使用的元素或者处理重复元素时，跳过非第一个重复元素
                continue;
            }
            perm.emplace_back(nums[i]); // 将当前元素加入当前排列
            vis[i] = 1; // 标记当前元素已使用
            backtrack(nums, ans, idx + 1, perm); // 递归处理下一个位置
            vis[i] = 0; // 回溯，标记当前元素未使用
            perm.pop_back(); // 移除当前元素，以便尝试其他可能的排列
        }
    }

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> ans;
        vector<int> perm;
        vis.resize(nums.size()); // 初始化标记数组
        sort(nums.begin(), nums.end()); // 对输入数组进行排序，以方便处理重复元素
        backtrack(nums, ans, 0, perm); // 调用回溯函数开始生成全排列
        return ans; // 返回所有生成的不重复全排列
    }
};

lc226.翻转二叉树–简单

题目描述

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

img

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

img

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

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目范围在 [0, 100] 内
  • -100 <= Node.val <= 100

代码展示

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return nullptr;
        }
        TreeNode* left = invertTree(root->left);
        TreeNode* right = invertTree(root->right);
        root->left = right;
        root->right = left;
        return root;
    }
};

lc98.验证二叉搜索树–中等

题目描述

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

  • 节点的左子树只包含 小于 当前节点的数。
  • 节点的右子树只包含 大于 当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

img

输入：root = [2,1,3]
输出：true

示例 2：

img

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：

  • 树中节点数目范围在[1, 104] 内
  • -231 <= Node.val <= 231 - 1

代码展示

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:    //递归
    bool helper(TreeNode* root, long long lower, long long upper) {
        if (root == nullptr) {
            return true;
        }
        if (root -> val <= lower || root -> val >= upper) {
            return false;
        }
        return helper(root -> left, lower, root -> val) && helper(root -> right, root -> val, upper);
    }
    bool isValidBST(TreeNode* root) {
        return helper(root, LONG_MIN, LONG_MAX);
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:     //中序遍历
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> stack;
        long long inorder = (long long)INT_MIN - 1;

        while (!stack.empty() || root != nullptr) {
            while (root != nullptr) {
                stack.push(root);
                root = root -> left;
            }
            root = stack.top();
            stack.pop();
            // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root -> val <= inorder) {
                return false;
            }
            inorder = root -> val;
            root = root -> right;
        }
        return true;
    }
};

lc104.二叉树的最大深度–简单

题目描述

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

img

输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

输入：root = [1,null,2]
输出：2

提示：

  • 树中节点的数量在 [0, 104] 区间内。
  • -100 <= Node.val <= 100

代码展示

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:     // 深度优先搜索
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        queue<TreeNode*> Q;
        Q.push(root);
        int ans = 0;
        while (!Q.empty()) {
            int sz = Q.size();
            while (sz > 0) {
                TreeNode* node = Q.front();Q.pop();
                if (node->left) Q.push(node->left);
                if (node->right) Q.push(node->right);
                sz -= 1;
            }
            ans += 1;
        } 
        return ans;
    }
};

lc104.二叉树的最小深度–简单

题目描述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。

示例 1：

img

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

  • 树中节点数的范围在 [0, 105] 内
  • -1000 <= Node.val <= 1000

代码展示

首先可以想到使用深度优先搜索的方法，遍历整棵树，记录最小深度。

对于每一个非叶子节点，我们只需要分别计算其左右子树的最小叶子节点深度。这样就将一个大问题转化为了小问题，可以递归地解决该问题。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:    //深度优先搜索
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        if (root->left == nullptr && root->right == nullptr) {
            return 1;
        }

        int min_depth = INT_MAX;
        if (root->left != nullptr) {
            min_depth = min(minDepth(root->left), min_depth);
        }
        if (root->right != nullptr) {
            min_depth = min(minDepth(root->right), min_depth);
        }

        return min_depth + 1;
    }
};

同样，我们可以想到使用广度优先搜索的方法，遍历整棵树。

当我们找到一个叶子节点时，直接返回这个叶子节点的深度。广度优先搜索的性质保证了最先搜索到的叶子节点的深度一定最小。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:    //广度优先搜索
    int minDepth(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }

        queue<pair<TreeNode *, int> > que;
        que.emplace(root, 1);
        while (!que.empty()) {
            TreeNode *node = que.front().first;
            int depth = que.front().second;
            que.pop();
            if (node->left == nullptr && node->right == nullptr) {
                return depth;
            }
            if (node->left != nullptr) {
                que.emplace(node->left, depth + 1);
            }
            if (node->right != nullptr) {
                que.emplace(node->right, depth + 1);
            }
        }

        return 0;
    }
};

lc50.Pow(x,n)–中等

题目描述

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

  • -100.0 < x < 100.0
  • -231 <= n <= 231-1
  • n 是一个整数
  • 要么 x 不为零，要么 n > 0 。
  • -104 <= xn <= 104

代码展示

class Solution {
public:
    double myPow(double x, long long n) {
        if (n < 0) return 1 / myPow(x, -n); // 如果 n 是负数，先计算 x 的 -n 次幂，然后取其倒数
        if (n == 0) return 1; // 如果 n 等于 0，返回 1，任何数的 0 次幂都是 1
        double temp = myPow(x, n / 2); // 递归计算 x 的 n/2 次幂
        if (n % 2 == 0)
            return temp * temp; // 如果 n 是偶数，x 的 n 次幂等于 x 的 n/2 次幂的平方
        else
            return temp * temp * x; // 如果 n 是奇数，x 的 n 次幂等于 x 的 n/2 次幂的平方再乘以 x
    }
};

lc22.括号生成–中等

题目描述

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1
输出：["()"]

提示：

  • 1 <= n <= 8

代码展示

image-20231007124235318

class Solution {
public:
    // 计数（统计）类的分治问题
    vector<string> generateParenthesis(int n) {
        if (n == 0) return {""};
        // if h.contains(n)
        // 记忆化，避免计算重复的generateParenthesis(n)
        if (h.find(n) != h.end()) return h[n];
        // 划分子问题标准：第一个子问题，作为不可分割的整体
        // 分段方法：(a)b
        // (a)： k对括号，子问题a是k-1对括号
        // b： n-k对括号
        vector<string> result;
        // 不同的k之间：加法原理
        for (int k = 1; k <= n; k++) {
            vector<string> result_a = generateParenthesis(k - 1);
            vector<string> result_b = generateParenthesis(n - k);
            // 左右两个子问题：乘法原理
            for (string& a : result_a)
                for (string& b : result_b)
                    result.push_back("(" + a + ")" + b);
        }
        h[n] = result;
        return result;
    }

private:
    unordered_map<int, vector<string>> h;

    // (a)b
    // ((())) 拆为 a=(())  b=""
    // (())() 拆为 a=()  b=()
    // ()()() 拆为 a=""  b=()()
};

lc23.合并k个升序链表–困难

题目描述

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

  • k == lists.length
  • 0 <= k <= 10^4
  • 0 <= lists[i].length <= 500
  • -10^4 <= lists[i][j] <= 10^4
  • lists[i] 按 升序 排列
  • lists[i].length 的总和不超过 10^4

代码展示

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:      //顺序合并
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *ans = nullptr;
        for (size_t i = 0; i < lists.size(); ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:       //分治合并
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }
};
BH04250909
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分治与递归
weixin_46105280的博客
11-22 3091
分治与递归 递归是一种方法； 分治是一种思想； 分治可以用递归来实现，也可以不用递归 普通分治：分治的各个层次的各解决方案不同 递归分治：分治的各个层次的解决方案相同 分治 分治的基本思想 分治算法是将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。 如果原问题可分割成k个子问题，1<k≤n，且这些子问题都可解并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。 由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。 在这种情况下，
第2章 递归与分治策略.ppt
11-19
该资源为算法设计与分析这门课程的，第二章课件。王晓东 编著 计算机算法设计与分析（第四版） 北京：电子工业出版社， 2012.2
第三章 递归与分治
weixin_51775250的博客
11-21 1362
分治是一种算法思想，递归是实现这种思想的一种手段。递归策略只需要少量的代码就可以描述出解决过程所需的多次重复计算，大大减少了代码量。
第二章 递归与分治策略知识总结
ice123s的博客
10-13 553
递归与分治策略知识汇总。
递归和分治（基础）
m0_63783532的博客
01-16 3757
在数学及程序设计方法学中为递归下的定义是这样的：若一个对象部分包含地包含它自己，或用它自己来定义它自己，则称这个对象是递归的；若一个过程直接或间接的调用自己，则称这个过程为递归的过程。简而言之，递归方法就是直接或间接地调用其自身1、什么时候会用到递归的方法以数学上常用的阶乘函数为例，其定义和计算都是递归的定义：return 1;递归过程在实现时，需要自己调用自己层层向下递归，退出次序正好相反主程序第一次递归调用自己为内部调用它们返回调用它的过程的地址不同。
第四课：递归、分治【C++】
SuperJayzz1的博客
07-25 146
递归recursion（实现形式） 函数自身调用自身 通过函数体来进行循环 以相似的方法重复进行的过程 例子： def factorial(n): # 要注意边界 if n <= 1: return 1 return n * factorial(n - 1) 递归的三个关键 定义需要递归的问题（重叠子问题）——数学归纳法 确定递归边界 保护与还原现场 全局变量要还原，局部变量不用 分治（算法） 把原问题划分为若干个子问题，分别解决后，再把结果合并 关键
分治与递归习题整理
qq_41571459的博客
05-18 1947
文章目录求解n的阶乘注意:递归解法非递归解法求解 Fibonacci 数列题目：递归解法代码复杂度分析递归调用图优化时间复杂度非递归解法二分查询步骤思考递归实现非递归实现全排列分析代码PermMain子集问题分析代码get_SubsetMain输出结果 求解n的阶乘 注意: cpu代表的是时间方向 可以耗损的时间是无穷的，所以可以无限循环 内存代表的是空间方向 内存是有限的，所以不能无限递归 阶乘结果 超出int范围(4字节)怎么办？ n是有符号数时，限制n不能大于12，或者 令溢出时为负数时为-
递归分治 --- 例题5.线性时间选择
PG13okc的博客
11-28 1020
递归分治 — 例题5. 线性时间选择 一.问题描述 给定线性序列集中的n个元素和正整数k, 1≤ k≤ n, 求第k小元素的位置. 二.解题思路 该篇文章中我们讨论与排序问题类似的元素选择问题,元素选择问题的一般提法是:给定线性序集合中n个元素和一个整数k(1 <= k <= n),要求找出这n个元素中第k小的元素,即如果将这n个元素依其线性排列数时,排在第k个位置的元素即为要找的元素. ①最直观的解题方法: 先排序,然后找到第k小的元素即可.这样时间复杂度至少是: O(n), 平均: O(n
递归与分治
阁下的小窝
07-20 1480
分治；及分而治之，就是把一个较为复杂的问题分成多个规模较小但结构和原问题相同的或相似的子问题，然后在分别解决这些子问题，最后再将这些子问题合并即可得到原问题的解。在计算机中分治是一种很重要的算法思路，如快速排序、归并排序……都是建立在分治的思路上。分治分解出的的问题应该是相互独立的、没有交叉的，如果分解的问题有相交的地方，那么改题则不能使用分治解决。一般来说作为一种算法思想既可以使用的手段来实现，也可以通过的方式来实现，不过一般来说使用>01的的情况成为）...
《算法设计与分析》第二章 递归与分治策略
Concise200的博客
01-18 1784
第二章 递归与分治策略1. 递归阶乘函数(O(n))Fibonacci数列（O(2^n)）排列问题Hanoi塔问题2.分治法二分搜索技术（O(logn)） 1. 递归 阶乘函数(O(n)) int factorial(int n) { if(n==0) return 1; return n*factorial(n-1); } Fibonacci数列（O(2^n)） int fibonacci(int n) { if(n<=1) return 1; return f
递归和分治法
Eternal嘉的博客
03-04 1845
递归和分治法 将问题分解，通过求解局部性的小问题来解开原来的问题，这种技巧称为分治法。 同时分治法需要用到递归。 递归 递归函数是指自己调用自己的函数，是设计算法时的一种编程技巧。 但是注意，递归函数必须有一个终点，否则程序会一直运行下去。 分治法 利用递归的技巧，将问题分成多个局部问题，使用递归函数求出每个局部问题的解，再将结果整合，最终解决原问题，这种编程手法称为分治法。 1.将问题分割成多个局部问题。 2.递归求出局部问题。 3.将局部问题...
fenzhifa2.rar_矩阵相乘_递归 分治
07-14
在提供的压缩包中，有两个MATLAB文件，"fenzhifa2.m"和"fenzhifa1.m"，很可能是实现这种递归分治矩阵相乘算法的源代码。通过阅读和理解这些代码，你可以进一步了解如何在实践中应用分治法和递归来优化矩阵相乘。需要...
算法设计与分析学习提纲，第四章 递归和分治.doc
05-06
第四章 递归和分治在算法设计与分析中占据着重要的地位，它们是解决复杂问题的有效手段。递归是一种自包含的解决问题的方法，而分治则是将大问题分解为小问题来解决的策略。 4.1 基于归纳的递归算法 递归算法的核心...
算法与分析实验一：分治与递归
02-10
实验报告——分治与递归 实验目标是深入理解分治法的核心概念，以及如何将这一方法应用于实际的算法问题中。在这个实验中，我们关注的是如何为具有2的幂次方个选手的网球循环赛制定比赛日程表。实验性质为验证性，...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5147
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
递归、搜索与回溯算法
最新发布
无聊_人的博客
08-29 1163
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 1215
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 1078
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 1319
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
递归与分治：优化算法实例
本资源主要介绍时间复杂度分析中的递归与分治策略在几个具体问题上的应用，由刘汝佳讲解。...理解这些概念有助于提升算法设计和分析的技能，特别是在处理大规模数据时，递归分治策略能够显著降低时间复杂度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值