算法分析期末复习

最新推荐文章于 2024-08-06 20:40:43 发布
最新推荐文章于 2024-08-06 20:40:43 发布
阅读量150 收藏 2
点赞数
分类专栏： 算法 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62260927/article/details/131158780
版权

算法分析期末复习

第一章 算法概述

  • 基本理论知识
  • 课后作业做过的类型
    1. 渐进阶排序，类似课后作业：1-3
    2. 输入规模，类似课后作业： 1-4， 1-5

第二章 递归与分治

  • 基本概念，基本思想

    • 递归：直接或间接的调用自身的算法。
    • 分治：分治法 的子问题间是相互独立的，子问题不包含公共的子问题。

  • 排序(归并，快速)

  • 二分搜索

  • 解决实际问题：

    1. 10个硬币，其中有一个假币，比真币轻，要求用分治法找假币
    2. 求最大值最小值，次大值次小值

归并排序

package review;
public class MergeSort {
    public  void sort(int []a){
        //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        int []temp = new int[a.length];
        mergeSort(a,0, a.length-1, temp);
    }

    public void mergeSort(int[] a, int left, int right, int[] temp){
        if(left < right){
            int mid = left+(right-left)/2;
            mergeSort(a, left, mid, temp); //左边归并排序，使得左子序列有序
            mergeSort(a, mid+1, right, temp); //右边归并排序，使得右子序列有序
            merge(a, left, mid, right, temp); // 并
        }
    }
    /**
     * 归并排序
     * @param a 待排序的数组
     * @param left 排序的左边界
     * @param mid 数组的中间
     * @param right 排序的右边界
     * @param temp 一个长度等于原数组长度的临时数组
     */
    public void merge(int[] a, int left, int mid, int right, int[] temp){
        int i = left, j = mid + 1;
        int t = 0;
        while(i <= mid && j <= right){ // 开始排序，
            if(a[i] <= a[j]){ // 相等也要填，这次会把一个相等的数移到temp，另一个等下次。
                temp[t++] = a[i++];
            }else{
                temp[t++] = a[j++];
            }
        }
        while(i > mid){
            temp[t++] = a[j++];
        }
        while(j > left){
            temp[t++] = a[i++];
        }
        t = 0;
        while(left < right){
            a[left++] = temp[t++];
        }
    }
}

快速排序

package review;

public class QuickSort {
    public static void main(String[] args) {
        int[] a = {6, 10, 32, 8, 19, 20, 2, 14};
        quickSort(a, 0, a.length-1);
        for(int i = 0; i < a.length; i++){
            System.out.println(a[i]);
        }
    }
    public static void quickSort(int[] a, int left, int right){
       if(left < right){
           int i = left;
           int j = right;
           int x = a[i];
           while(i < j){
                while(i < j && a[j] > x){
                    j--;
                }
                if(i < j){
                    a[i++] = a[j];
                }
                while(i < j && a[i] < x){
                    i++;
                }
                if(i < j){
                    a[j--] = a[i];
                }
           }
           a[i] = x;
           quickSort(a,left, i-1);
           quickSort(a, i+1, right);
       }
    }
}

二分搜索

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

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

棋盘覆盖(分治法)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BFKnI7kQ-1686492397351)(算法分析.assets/image-20230605103553176.png)]

找假币

package review;

public class FindFakeCoin {
    public static void main(String[] args) {
        int[] arr = {2,2,2,2,2,1};
        System.out.println(findFakeCoin(arr, 0, arr.length-1));
    }
    public static int findFakeCoin(int[] a, int l, int r){
        int sum1 = 0;
        int sum2 = 0;
        if((r-l+1)% 2 == 0){ // 偶数
            if(l == r-1){
                if(a[l] < a[r]){
                    return l;
                }else{
                    return r;
                }
            }else{ //数组多于两个数
                int mid = l + (r-l+1)/2; // 找中间位置
                for(int i = l; i < mid; i++){
                    sum1 += a[i]; // 中间靠左数组集合总和
                    sum2 += a[i+mid]; // 中间靠右数组集合总和
                }
                if(sum1 < sum2){
                    return findFakeCoin(a, l, mid-1);
                }else{
                    return findFakeCoin(a, mid, r);
                }
            }

        }else{ //奇数
            int mid = l+(r-l)/2;
            for(int i = l; i < mid; i++){
                sum1 += a[i];
                sum2 += a[r-(i-l)];
            }
            if(sum1 < sum2){
                return findFakeCoin(a, l, mid-1);
            }else if(sum1 > sum2){
                return findFakeCoin(a, mid+1, r);
            }else{
                return mid;
            }
        }
    }
}

求最值和次值

package review;

import java.util.Arrays;

public class MaxiMum {
    public static void main(String[] args) {
        int arr[] = { -2, -9, 0, 5, 2 };
        int[] res =  findMinMax(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(res));

    }
    public static int[] findMinMax(int[] a, int l, int r){
        int min = 0, max = 0;
        if(l == r){ // 只剩一个格子
            min = a[l];
            max = a[l];
        }else if(l == r - 1){ // 还有两个格子
            max = a[l] > a[r]?a[l]:a[r];
            min = a[l] < a[r]?a[l]:a[r];
        }else{  // 不止两个格子，分割，结果用数组储存。
            int mid = l + (r-l)/2;
            int[] preHalf = findMinMax(a, l, mid);
            int[] postHalf = findMinMax(a,mid+1, r);
            max = postHalf[0] > preHalf[0]?postHalf[0]:preHalf[0];
            min = postHalf[1] < preHalf[1]?postHalf[1]:preHalf[1];
        }
        return new int[] {max, min};
    }

}

第三章 动态规划

  1. 基本概念，基本思想

  2. 矩阵连乘问题

  3. 最长公共子序列

  4. 01背包

  5. 解决实际问题 ：

    1. 设m是一个n位十进制整数。如果将m划分为x段，则可得到x个整数。这x个整数的乘积称为m的一个x乘积。试设计一个算法，对于给定的m和x,求出m的最大x乘积。要求给出动态规划算法解决该问题的基本思路，并给出该问题的递归公式。

    2. 数字三角形问题（算法实现题3-4）

    3. 石子合并问题

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DhohVUEi-1686492397352)(算法分析.assets/image-20230609174800200.png)]

矩阵连乘

public static int matrixChain(int arrayNum, int[]m, int l, int r){
        int t = 0;
        // dp[i][j]表示第i到j个矩阵的最少计算次数
        int[][] dp = new int[arrayNum+1][arrayNum+1];
        // 第i到i个的计算次数为 0
        for(int i = 1; i <= arrayNum; i++){
            dp[i][i] = 0;
        }
        for(int i = 1; i <= arrayNum; i++){
            for(int j = i+1; j <= arrayNum; j++){ 
                dp[i][j] = dp[i+1][j] + m[i-1]*m[i]*m[j];
                for(int a = 1; a < arrayNum; a++){
                    t = dp[i][a] + dp[a+1][j] + m[i-1]*m[a]*m[j];
                    if(dp[i][j] > t){
                        dp[i][j] = t;
                    }
                }
            }
        }
        return dp[l][r];
    }

最长公共子序列

public int Lcs(String s1, String s2) {
        int[][] dp = new int[s1.length() + 1][s2.length() + 1];
        for (int i = 0; i <= s1.length(); i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= s2.length(); j++) {
            dp[0][j] = 0;
        }
        for (int i = 1; i <= s1.length(); i++) {
            for (int j = 1; j <= s2.length(); j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[s1.length()][s2.length()];
    }

01背包

https://github.com/youngyangyang04/leetcode-master/blob/master/problems/%E8%83%8C%E5%8C%85%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%8001%E8%83%8C%E5%8C%85-1.md

public static void bag01(int bagCapacity, int[] itemWeight, int[] itemValue){
        int[][] dp = new int[itemValue.length+1][bagCapacity+1];
        for(int i = 0; i <= itemValue.length; i++){
            dp[i][0] = 0;
        }
        for(int j = 0; j <= bagCapacity; j++){
            dp[0][j] = 0;
        }
        for(int i = 1; i <= itemValue.length; i++){
            for(int j = 0; j <= bagCapacity; j++) {
                if(j >= itemWeight[i]){
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-itemWeight[i]] + itemValue[i]);
                }else{
                    dp[i][j] = dp[i-1][j];
                }
           }
        }
    }

1.

设m是一个n位十进制整数。如果将m划分为x段，则可得到x个整数。这x个整数的乘积称为m的一个x乘积。试设计一个算法，对于给定的m和x,求出m的最大x乘积。要求给出动态规划算法解决该问题的基本思路，并给出该问题的递归公式。

dp[i][j] = max{dp[i][j], dp[m][j-1]*num[m+1][i] }
dp[i][j] 表示这个数前i位切j刀的最大乘积为：前m位切j-1刀的最大乘积乘上num[m+1][i];

第四章 贪心算法

  1. 基本概念，基本思想。

  2. 活动安排问题

  3. 背包问题

  4. 最优装载问题

  5. 单源最短路径

  6. 根据算法思想解决实际问题：

    1. 有n个正整数，将他们连成一排，组成一个最大的多位整数。例如：n = 3时，3个整数13，312，343连成的最大整数为：34331213。又如：n = 4时，4个整数7，13，4，246连接成的最大整数为7424613
    2. 新房需要装修，但是总预算只有20万元，为了更好得满足装修需求，小明按照所需物品的重要程度进行了分类，用1~5表示，第5类最重要，他希望在不超过预算的前提下，求max（Σ每种物品的价格*重要程度）
    3. 设计一个贪心算法，使得对于给定的n位正整数，在删除其中任意k<=n位数字后，剩余的数字按原来的次序排列组成的新的正整数最小。

做题的时候想清楚什么是局部最优，如何用局部最优推全局最优。

活动安排问题

各个活动的起始时间存在数组 s 中，结束时间存储在数组 f 中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VlA1rDK8-1686492397353)(算法分析.assets/image-20230607130459896.png)]

f [ i ] 按照非递减的顺序排序。所以先排结束时间早的，这样可以为后面的活动留下更多的时间。

import java.util.Arrays;

public class GreedySelect {
    public static void main(String[] args) {
        int[] s = {1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12};
        int[] f = {4, 5, 6, 7, 8, 9, 10, 11, 12 ,13 ,14};
        System.out.println(Arrays.toString(greedySelect(s,f)));
    }
    public static boolean[] greedySelect(int[] s, int[] f){
        boolean[] a = new boolean[s.length];
        a[0] = true;
        int t = 0;
        for(int i = 1; i < s.length; i++){ // 后面活动的开始时间要大于前面活动的结束时间。
            if(s[i]>=f[t]){
                t = i;
                a[i]  = true;
            }
            else{
                a[i] = false;
            }
        }
        return a;
    }
}

背包问题

有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。
要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。

最优装载问题

轮船装的货物重量受限，物品重量给出，求怎样装能装的物品数量最多。

package review;

import java.util.Arrays;

public class LoadProblem {
    public static void main(String[] args) {
        int shipWeight = 100;
        int[] itemWeight = {2, 6, 34, 76, 45, 20};
        loadProblem(shipWeight,itemWeight);
    }
    public static void loadProblem(int shipWeight, int[] itemWeight){
        Arrays.sort(itemWeight); // 将物品按重量从轻到重排序
        boolean[] isLoad = new boolean[itemWeight.length];
        for(int i = 0; i < itemWeight.length; i++){
            if(shipWeight < itemWeight[i]){ // 剩余容量装不下itemWeight[i]了
                break;
            }
            shipWeight -= itemWeight[i]; 
            isLoad[i] = true;
        }
        System.out.println(Arrays.toString(isLoad));
    }
}

单源最短路径

import java.util.Arrays;
import java.util.Scanner;
import java.util.Collections;

public class Dijkstra {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int vectorNum = sc.nextInt();
        int[][] reflect = new int[vectorNum + 1][vectorNum + 1];
        for(int i = 1; i <= vectorNum; i++){
            for(int j = 1; j <= vectorNum; j++){
                reflect[i][j] = sc.nextInt();
            }
        }
        int root = sc.nextInt();
}

/**
 *
 * @param path 记录i到j的路径
 * @param root 源点1
 */
private static void dijkstra(int[][] path, int root){
    boolean identify[]  = new boolean[path.length]; // 判断节点是否找到了最短路径
    int[] rootToVectorPath = new int[path.length]; // 存各点到源点的当前最短路径长度
    int[] prev = new int[path.length]; // 记录前驱节点
    prev[root] = 0; // 源点的前驱节点为 0
    // 初始化 存各点最短路径的数组，
    for(int j = 1; j <= path.length; j++){ // 遍历1~n
        rootToVectorPath[j] = path[root][j]; // 能直达源点的节点的最短路径为她们到源点的路径
        identify[j] = false;
        if(rootToVectorPath[j] != Integer.MAX_VALUE){  // 如果有节点到源点可以直达
            prev[j] = root; // 那么她们的前驱节点就是root
        }else{
            prev[j] = 0; // 不能直达，则前驱节点为0
        }
    }
    identify[root] = true;

    int fulfillVector = 0;
    // refresh circle
    for(int i = 1; i <= path.length; i++) {
        int temp = Integer.MAX_VALUE;
        // 找还没有找到最短路径的点中路径最短的
        for (int j = 1; j <= path.length; j++) {
            if (!identify[j] && rootToVectorPath[j] < temp) {
                fulfillVector = j;
                temp = rootToVectorPath[j];
            }
        }
        identify[fulfillVector] = true;
        // 调整rootToVectorPath
        for (int j = 1; j <= path.length; j++) {
            if(!identify[j] && path[fulfillVector][j] != Integer.MAX_VALUE){
                if(rootToVectorPath[fulfillVector] + path[fulfillVector][j] < rootToVectorPath[j]){
                    rootToVectorPath[j] = rootToVectorPath[fulfillVector] + path[fulfillVector][j];
                    prev[j] = fulfillVector;
                }
            }
        }
    }
}

第五章 回溯法

  1. 基本概念，基本思想
  2. 01背包
  3. 最优装载
  4. N后问题
  5. 会求左右剪枝问题
  6. 利用所学知识解决实际问题
/**
*t为当前拓展节点在解空间树的深度。
*n用来控制递归深度，当t>n时，算法已经搜索到叶子节点。
*/
void backtracking(t) {
    if (终止条件) { // 记录或输出得到的可行解x
        存放结果;
        return;
    }
    for(int i = f(n, t); i <= g(n, t); i++) {
        if(Constraint(t) && Bound(t)){
			处理节点;
            BackTrack(t+1);
         	回溯，撤销处理结果
        }
    }
}

01背包

 public static void backtrack(int t){
        if(t >= itemNum){
            bestValue = Math.max(curValue, bestValue) ;

        }else{
            for(int i = 0; i < 2; i++){
                if(i == 0){
                    backtrack(t+1);
                }else{
                    if(bagCapacity >= curWeight+itemWeight[t]){
                        curWeight += itemWeight[t];
                        curValue += itemValue[t];
                        backtrack(t+1);
                        curWeight -= itemWeight[t];
                        curValue -= itemValue[t];
                    }
                }
            }
        }
    }

最优装载

https://www.cnblogs.com/icodes8238/p/12893640.html
n为集装箱数量 
c为第一艘船的最大容量 
cw为当前已装入第一艘船的重量 
r为剩余未装入第一艘船的重量 
bestw为目前为止最好的装载方案其对应的重量 
w[i]集装箱i的重量 
x[i]集装箱i是否装入第一艘船 

void backtrack(int i){
    if(i > n){ //reach the leaves
        if(cw > bestw) bestw = cw;
        return ;
    }
    r -= w[i]; // 剩余的箱子不包含第i个箱子
    if(cw + w[i] <= c){//constraint function for searching left
        x[i] = 1;
        cw += w[i];
        backtrack(i+1);
        cw -= w[i];
    }
    if(cw + r > bestw){ //bounding function for searching right
        x[i] = 0;
        backtrack(i+1);
    }
    r += w[i]; //剩余的箱子包含第i个箱子
}
    /*-------- 
    关键在于理解下面这个限界函数，目的是剪去得不到最优解的子树。
    这个时候我们正在处理树的第i层，即正在决定第i个集装箱是否装入
    如果说上面的约束函数是对左子树（装入i）的情况剪枝，那么该函数就是对右子树剪枝。 
    
    对该函数的理解：如果我把集装箱i抛弃掉，这个时候
    如果已经装入的重量+未装入的重量比目前的最优解bestw还要差，
    那么说明这种情况不可能得到最优解 
    也就是说如果把不装入集装箱i，肯定的不到最优解，后面的情况不用考虑了
    
    而如果当前载重量cw + 剩余集装箱的重量r>当前最优载重量 best，
    那么我们就要去尝试不装入它，因为有可能得到最优解 
    */

N后问题

/**
     * 递归实现回溯，从第row行开始找放Q的位置
     * @param n 棋盘大小
     * @param row 当前所在行
     * @param chessboard
     */
    public void backTracing(int n, int row, char[][] chessboard){
        if(row >= n){
            res.add(Array2List(chessboard));
            return;
        }

        for(int col = 0; col < n; col++){ // 遍历row层的各种情况col
            if(isValid(chessboard, row, col, n)){ // (row, col)可以放Q
                chessboard[row][col] = 'Q'; // 放Q
                backTracing(n, row + 1, chessboard); // 继续递归
                chessboard[row][col] = '.'; // 回溯，撤回处理结果
            }
        }
    }

第六章 分支限界法（考理论）

  1. 基本概念，基本思想
  2. 与其他方法的比较
  3. 01背包问题
  4. 最优装载问题
  5. 分析实际问题
ap tree
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
算法设计与分析（期末复习重点）更新中
weixin_49199200的博客
06-12 6245
第一章 算法的五大特性：输入、输出、可行性、有穷性、确定性 （1）输入：一个算法有零个或多个输入。 （2）输出：一个算法有一个或多个输出。 （3）可行性：算法描述的操作可以通过已经实现的基本操作执行有限次来实现（每步可执行）。 （4）有穷性：一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成。算法的有穷性 意味着不是所有的计算机程序都是算法。 （5）确定性：算法中的每一条指令必须有确切的含义，对于相同的输入只能得到相同的输出。 算法的复杂性：时间复杂性和空间复杂性 第二章 大O符号：
算法分析与设计期末复习
qq_44376244的博客
07-10 3040
第一章 算法概述 1.算法：解决问题的一种方法或过程；由若干条指令组成的有穷指令。 2.算法的性质： 输入：有零个或多个输入 输出：有至少一个输出 确定性：每条指令是清晰的、无歧义的 有限性：每条指令的执行次数和时间都是有限的 3.算法与程序的区别 程序是算法用某种程序设计语言的具体实现 程序可以不满足算法的有限性 4.算法复杂性分析 算法的复杂性是算法运行所需要的计算机资源的量，需要时间资源的量称为时间复杂性，需要空间资源的量称为空间复杂性 三种时间复杂性：最坏情况、最好情况、平均情.
算法设计与分析期末复习
m0_69095728的博客
06-28 926
算法是对特定问题求解步骤的一种描述，是指令的有限序列。输入 输出 有穷性 确定性 可行性⑴ 输入：一个算法有零个或多个输入。⑵ 输出：一个算法有一个或多个输出。⑶ 有穷性：一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成。⑷ 确定性：算法中的每一条指令必须有确切的含义，对于相同的输入只能得到相同的输出。⑸ 可行性：算法描述的操作可以通过已经实现的基本操作执行有限次来实现。正确性 健壮性 可理解性 抽象分级 高效性自然语言 程序流程图 伪代码 程序设计语言。
算法设计与分析期末复习题
SXXYNHHXX的博客
06-18 1143
答案：假设我们有一个由 6 个会议组成的数组 SE，每个会议有一个开始时间 start_time 和一个结束时间 end_time。我们需要选择尽可能多的会议，而这些会议之间不会相互冲突。假设会议时间如下：会议 1：开始时间 = 9:00, 结束时间 = 10:00会议 2：开始时间 = 10:15, 结束时间 = 11:15会议 3：开始时间 = 10:30, 结束时间 = 11:30会议 4：开始时间 = 11:20, 结束时间 = 12:20。
算法设计与分析期末复习题（史上最详细）
热门推荐
weixin_43474701的博客
06-07 8万+
算法设计与分析期末复习题（一） 1、二分搜索算法是利用（ A ）实现的算法。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 2、下列不是动态规划算法基本步骤的是（ A ）。 A、找出最优解的性质 B、构造最优解 C、算出最优解 D、定义最优解 3、最大效益优先是（ A ）的一搜索方式。 A、分支界限法 B、动态规划法 C、贪心法 D、回溯法 4、最长公共子序列算法利用的算法是（ B ）。 A、
算法分析与设计期末考试复习GDPU
CH3CH2CH4的博客
06-08 1262
重点内容+习题 绪论 分治 动态规划 贪心 回溯 分支限界
算法分析与设计 期末复习
qq_39162937的博客
12-18 850
算法分析与设计 期末复习 目录算法分析与设计 期末复习第一章 时间复杂度第二章 递归与分治策略三级目录第二章 递归与分治策略第三章 动态规划 第一章 时间复杂度 第二章 递归与分治策略 三级目录 第二章 递归与分治策略 1.分治法的基本思想： 分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题互相独立且与原问题相同。递归地解这些子问题，然后将各子问题的解合并得到原问题的解。 2.二分搜索技术——C语言实现 //用函数封装 #include <stdio.h> bina
高级算法设计与分析期末复习
qq_52686989的博客
02-22 3207
研究生期末算法设计与分析复习
计算机算法设计与分析 期末复习笔记
TGA麻辣香锅的博客
07-02 1597
1.算法复杂度的求解与分析： https://blog.csdn.net/weixin_43510131/article/details/84237929?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162519159816780265479319%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=16251915
南京林业大学算法分析期末复习
06-10
《南京林业大学算法分析期末复习》 算法分析是计算机科学中的关键领域，它涉及研究算法的时间和空间复杂性，以及如何有效地设计、实现和优化算法。对于即将进行期末复习的南京林业大学学生们来说，理解并掌握这些...
川农大算法分析期末复习1
08-03
算法分析与设计是计算机科学中的核心概念，主要关注如何高效地解决问题。以下是根据提供的题目内容解析的相关知识点： 1. **算法定义**：算法是一组明确的、有限的指令，用于解决特定问题或完成特定任务。它应该有...
川农大算法分析期末复习.docx
05-18
- 在算法分析中，我们主要关注算法的时间复杂度和空间复杂度。 - **时间复杂度**：衡量算法执行时间随着输入规模的增长而增长的速度。 - **空间复杂度**：衡量算法执行过程中所需要的额外空间。 2. **常见时间...
算法分析期末复习资料 整理
12-31
算法分析期末复习资料 本资源摘要信息涵盖算法分析的基本概念、描述方法、非递归算法分析、递归算法分析、分治策略设计思想、非递归算法分析步骤、递归算法分析步骤、二分搜索算法及时间复杂度分析等内容。 算法的...
P1145 约瑟夫
zty20120913的博客
08-06 423
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 933
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day021二叉树最后章节
最新发布
m0_62956971的博客
08-06 573
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 187
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
算法设计与分析期末复习：关键概念与复杂性分析
"《算法设计与分析》课程的期末复习资料包含了课程的重点和难点，主要关注算法的正确性、时间复杂性和空间复杂性分析。复习资料中还提到了时间复杂度函数的具体化方法以及四种渐近意义下的符号，如O、Ω、θ和o，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ap tree

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值