解密编程的八大法宝（一）（附暴力枚举、贪心算法、分治法和动态规划详解）

空青726

已于 2024-08-02 10:16:16 修改

阅读量1k

点赞数 22

文章标签：贪心算法动态规划算法 java 后端深度学习面试

于 2024-08-01 17:25:43 首次发布

本文链接：https://blog.csdn.net/weixin_55745942/article/details/140853041

版权

算法题中常见的几大解题方法有以下几种：

暴力枚举法（Brute Force）：这是最基本的解题方法，直接尝试所有可能的组合或排列来找到答案。这种方法适用于问题规模较小的情况，但在大多数情况下效率不高。
贪心算法（Greedy Algorithm）：贪心算法在每一步都选择当前看起来最优的解，希望最终能得到全局最优解。这种方法适用于一些特定类型的问题，如背包问题、最小生成树等。
分治法（Divide and Conquer）：将问题分解为更小的子问题，递归解决这些子问题，然后将结果合并以得到原问题的解。经典的例子包括快速排序和归并排序。
动态规划（Dynamic Programming）：动态规划通过将问题分解为相互重叠的子问题，并使用记忆化技术来避免重复计算，来解决问题。这种方法适用于有重叠子问题和最优子结构性质的问题。
回溯法（Backtracking）：回溯法是一种试错的算法，通过不断尝试和撤销来搜索所有可能的解。这种方法适用于需要探索所有可能解的组合问题。
二分查找（Binary Search）：二分查找是一种在有序数组中查找特定元素的高效算法。每次比较中间元素，根据大小关系缩小查找范围。
图论算法：图论算法用于解决图相关的问题，包括最短路径、最小生成树、拓扑排序等。常见的图论算法有Dijkstra算法、Bellman-Ford算法、Floyd-Warshall算法等。
字符串匹配算法：字符串匹配算法用于在一个文本中查找一个模式串的出现位置。经典的算法有KMP算法、Boyer-Moore算法和Rabin-Karp算法等。

本文主要详细介绍一下前四种解法：

1. 暴力枚举法（Brute Force）

概念：暴力枚举法是最基本的解题方法，它通过尝试所有可能的组合或排列来找到问题的解。

适用场景：暴力枚举法适用于问题规模较小的情况，或者当其他高效算法难以应用时。

优缺点：

优点：简单易懂，适用于多种问题。
缺点：效率低下，时间复杂度高，对大规模数据不适用。

时间和空间复杂度：时间复杂度通常为O(n^k)，其中n是数据规模，k是枚举的维度。空间复杂度取决于具体实现。

代码举例：假设我们要找一个数组中两个数的和等于目标值的所有组合，可以使用暴力枚举法：

public List<List<Integer>> twoSum(int[] nums, int target) {
    List<List<Integer>> result = new ArrayList<>();
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                List<Integer> pair = new ArrayList<>();
                pair.add(nums[i]);
                pair.add(nums[j]);
                result.add(pair);
            }
        }
    }
    return result;
}

2. 贪心算法（Greedy Algorithm）

概念：贪心算法在每一步都选择当前看起来最优的解，希望最终能得到全局最优解。

适用场景：贪心算法适用于一些特定类型的问题，如背包问题、最小生成树等，且问题具有贪心选择性质。

优缺点：

优点：简单高效，适用于特定类型的问题。
缺点：不一定能得到全局最优解，需要问题满足贪心选择性质。

时间和空间复杂度：通常取决于具体问题，可能是线性或多项式时间复杂度。

代码举例：假设我们要找一个数组中可以选取的连续子数组使得和最大，可以使用贪心算法：

public int maxSubArray(int[] nums) {
    int maxSum = nums[0];
    int currentSum = maxSum;
    for (int i = 1; i < nums.length; i++) {
        currentSum = Math.max(currentSum + nums[i], nums[i]);
        maxSum = Math.max(maxSum, currentSum);
    }
    return maxSum;
}

3. 分治法（Divide and Conquer）

概念：分治法将问题分解为更小的子问题，递归解决这些子问题，然后将结果合并以得到原问题的解。

适用场景：分治法适用于问题可以被分解为相互独立的子问题，且子问题是原问题的缩小版本。

优缺点：

优点：可以简化复杂问题的解决，常常可以用递归实现。
缺点：可能会产生大量的重复计算，需要使用记忆化或动态规划技术来优化。

时间和空间复杂度：通常取决于具体问题，可能是对数级别或多项式时间复杂度。

代码举例：假设我们要对一个数组进行快速排序，可以使用分治法：

public void quickSort(int[] nums, int left, int right) {
    if (left < right) {
        int pivotIndex = partition(nums, left, right);
        quickSort(nums, left, pivotIndex - 1);
        quickSort(nums, pivotIndex + 1, right);
    }
}

private int partition(int[] nums, int left, int right) {
    int pivot = nums[left];
    int i = left + 1;
    int j = right;
    while (true) {
        while (i <= j && nums[i] < pivot) i++;
        while (i <= j && nums[j] > pivot) j--;
        if (i > j) break;
        swap(nums, i, j);
    }
    swap(nums, left, j);
    return j;
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

4. 动态规划（Dynamic Programming）

概念：动态规划通过将问题分解为相互重叠的子问题，并使用记忆化技术来避免重复计算，来解决问题。

适用场景：动态规划适用于问题具有重叠子问题和最优子结构性质的情况。

优缺点：

优点：可以解决许多复杂问题，避免了暴力枚举的低效性。
缺点：需要额外的空间来存储中间结果，可能会出现空间复杂度问题。

时间和空间复杂度：通常取决于具体问题，可能是多项式时间复杂度和空间复杂度。

代码举例：假设我们要计算一个数组中最长递增子序列的长度，可以使用动态规划：

public int lengthOfLIS(int[] nums) {
    if (nums.length == 0) return 0;
    int[] dp = new int[nums.length];
    Arrays.fill(dp, 1);
    int maxLen = 1;
    for (int i = 1; i < nums.length; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
        maxLen = Math.max(maxLen, dp[i]);
    }
    return maxLen;
}