【NBUOJ刷题笔记】递推_递归+分治策略2

最新推荐文章于 2024-07-13 22:27:25 发布
最新推荐文章于 2024-07-13 22:27:25 发布
阅读量959 收藏 17
点赞数 28
分类专栏： NBUOJ刷题 文章标签： 笔记 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62533201/article/details/136790584
版权

0. 前言

PS：本人并不是集训队的成员，因此代码写的烂轻点喷。。。本专题一方面是巩固自己的算法知识，另一方面是给NBU学弟学妹们参考解题思路（切勿直接搬运抄袭提交作业！！！）最后，该系列博客AC代码均以Java语言提交，C/C++的可以参考思路编写代码

1. 题目详情

1.1 题目一：第K小的数

1.1.1 题目信息

题目描述：
输入n个数，求其中第k小的数。（要求采用分治法完成，不建议采用完整的排序）
输入要求：
第一行包含两个整数n和k；n<1000，1<=K<=n
第二行包含n个整数。
输出要求：
输出第k小的那个整数_。_
输入样例：
15 1
1 3 7 2 4 6 -1 0 9 88 2 5 17 6 1
输出样例：
-1
来源：
NBUOJ

1.1.2 算法思路（分治法）

本题的一般思路有如下几种：

  • 借助堆/优先级队列实现的TopK问题
  • 基于完整的排序算法
  • 分治策略

由于题目限制使用分治思想，因此这里介绍最后一种方法
分治思想：简单来说就是分而治之，化繁为简，将大问题分解成子问题逐一求解
算法步骤（重要）：

  1. 题目要求找到n个数中第k小的元素，我们首先在当前数组中随意选中一个基准元素pivot
  2. 然后使用双指针 区域划分 的思想将数组划分为两部分，其中左半区域的元素比pivot小，右半区域的元素比pivot大
  3. 此时假设pivot基准元素的下标是pivotIndex，pivot元素就是整个数组中第 pivotIndex + 1 小的元素
  4. 此时令左半区域的元素个数为leftNum，如果 k==leftNum + 1 那么直接返回基准元素，如果 k < leftNum + 1 那么就递归左半部分区域继续找到第k小的元素，如果 k > leftNum + 1 ，那么就递归右半部分区域递归找第k - (leftNum + 1)小的元素

PS：如果不清楚数组区域划分算法的小伙伴可以自行搜索或者直接看下面的代码实现部分
示例：我们使用上述给出的测试用例画图讲解：
image.png

1.1.2 AC代码（Java实现）

NBUOJ上面Java带中文注释会报错！因此这里放了两个版本的代码，前面不带注释的可以直接跑OJ通过，后面的方便读者阅读

1.1.2.1 不带注释版本
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(partition(arr, 0, n - 1, k));
    }

    private static int partition(int[] arr, int left, int right, int k) {
        int pivot = arr[right];
        int prev = left - 1; 
        int cur = left;
        while (cur <= right) {
            if (arr[cur] <= pivot) {
                int tmp = arr[prev + 1];
                arr[prev + 1] = arr[cur];
                arr[cur] = tmp;
                cur++;
                prev++;
            } else {
                cur++;
            }
        }
        int leftNum = prev - left; 
        if (leftNum + 1 == k) {
            return pivot;
        } else if (leftNum + 1 > k) {
            return partition(arr, left, prev - 1, k);
        } else {
            return partition(arr, prev + 1, right, k - (leftNum + 1));
        }
    }
}
1.1.2.2 带注释版本
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(partition(arr, 0, n - 1, k));
    }

    /**
     * 在数组arr的[left, right]区域找到第k小的数并返回
     * @return 第k小的数
     */
    private static int partition(int[] arr, int left, int right, int k) {
        // 选基准元素
        int pivot = arr[right];
        int prev = left - 1; // 指向小于pivot的最后元素
        int cur = left; // 遍历数组
        while (cur <= right) {
            if (arr[cur] <= pivot) {
                // 将小于等于pivot的元素移至前面
                int tmp = arr[prev + 1];
                arr[prev + 1] = arr[cur];
                arr[cur] = tmp;
                cur++;
                prev++;
            } else {
                // 大于pivot不用移动
                cur++;
            }
        }
        int leftNum = prev - left; // 左半区域元素个数
        if (leftNum + 1 == k) {
            return pivot;
        } else if (leftNum + 1 > k) {
            // 递归左半区域
            return partition(arr, left, prev - 1, k);
        } else {
            // 递归右半区域
            return partition(arr, prev + 1, right, k - (leftNum + 1));
        }
    }
}

1.1.3 扩展题

这里放一些跟本题类似的OJ题（读者可自行尝试解题）：

  1. LeetCode数组中的第K大元素：https://leetcode.cn/problems/xx4gT2/description/
  2. LeetCode最小k个数：https://leetcode.cn/problems/smallest-k-lcci/description/

1.2 题目二：棋盘覆盖

1.2.1 题目信息

题目描述：
在一个2k×2k 个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。
image.png
输入要求：
输入一个整数k，k<=5；
输入特殊格子的坐标x，y。
输出要求：
输出一个由数值表示的二维矩阵。填充规则如下：
（1）用数值填充方格；
（2）特殊方格数值为0；
（3）从中心点开始；然后左上、右上、左下、右下的计数顺序填数；同一块用相同数值表示；
（4）每个数值占4个位置空间；右对齐，左补空格。
输入样例：
3
1 2
输出样例：
image.png
来源：
NBUOJ

1.2.2 算法思路（分治法）

分治策略：首先我们需要明确填充的顺序，根据题目描述填充规则为，从中心点开始，然后按照左上，右上，左下，右下的顺序进行填充
算法步骤：

  1. 首先定义出口条件：只有一个元素时不处理
  2. 找到当前区域的中心点，另四个点位坐标分别是(midRow, midCol)，(midRow, midCol + 1)，(midRow + 1, midCol)，(midRow + 1, midCol + 1)，分别对应四个方位（左上、右上、左下、右下）按照顺序进行处理，**以左上方位举例：**如果说左上存在特殊点，那么特殊点不变继续递归填充dfs(左上, 原特殊点)，但是如果左上方位内部没有特殊点，那么就将当前中心区域的点位作为特殊点继续递归dfs(左上，新特殊点)，此时新特殊点为（midRow, midCol）

示例：也许上面的文字描述有点抽象，还是以画图进行举例：
输入：2 0 3
image.png
image.png
image.png
image.png
image.png
注意：如果我们使用成员变量（或者C++中的全局变量），我们需要先维护好中间位置的填充值，然后在递归四个方位，不然有可能出现在递归完左上角后准备填充中间元素的右上区域值时（填充值已经被改变），不过也可以事先全部填充完中间元素再进行递归（看个人习惯）

1.2.3 AC代码（Java实现）

NBUOJ上面Java带中文注释会报错！因此这里放了两个版本的代码，前面不带注释的可以直接跑OJ通过，后面的方便读者阅读

1.2.3.1 不带注释版本
import java.util.Scanner;

public class Main {

    private static int curValue = 1;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            curValue = 1;
            int k = scanner.nextInt();
            int specialRow = scanner.nextInt();
            int specialCol = scanner.nextInt();
            int edges = (int) Math.pow(2, k);
            int[][] matrix = new int[edges][edges];
            matrix[specialRow][specialCol] = 0;
            partition(matrix, 0, edges - 1, 0, edges - 1, specialRow, specialCol);
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[i].length - 1; j++) {
                    System.out.printf("%4s", matrix[i][j]);
                }
                System.out.printf("%4s\n", matrix[i][matrix[i].length - 1]);
            }
        }
    }

    private static void partition(int[][] matrix, int upRow, int downRow, int leftCol, int rightCol, int specialRow, int specialCol) {
        if (upRow == downRow && leftCol == rightCol) {
            return;
        }
        int midValue = curValue;
        curValue++;
        int midLeftUpRow = (upRow + downRow) / 2;
        int midLeftUpCol = (leftCol + rightCol) / 2;
        if (upRow <= specialRow && specialRow <= midLeftUpRow && leftCol <= specialCol && specialCol <= midLeftUpCol) {
            partition(matrix, upRow, midLeftUpRow, leftCol, midLeftUpCol, specialRow, specialCol);
        } else {
            matrix[midLeftUpRow][midLeftUpCol] = midValue;
            partition(matrix, upRow, midLeftUpRow, leftCol, midLeftUpCol, midLeftUpRow, midLeftUpCol);
        }
        int midRightUpRow = midLeftUpRow;
        int midRightUpCol = midLeftUpCol + 1;
        if (upRow <= specialRow && specialRow <= midRightUpRow && midRightUpCol <= specialCol && specialCol <= rightCol) {
            partition(matrix, upRow, midRightUpRow, midRightUpCol, rightCol, specialRow, specialCol);
        } else {
            matrix[midRightUpRow][midRightUpCol] = midValue;
            partition(matrix, upRow, midRightUpRow, midRightUpCol, rightCol, midRightUpRow, midRightUpCol);
        }
        int midLeftDownRow = midLeftUpRow + 1;
        int midLeftDownCol = midLeftUpCol;
        if (midLeftDownRow <= specialRow && specialRow <= downRow && leftCol <= specialCol && specialCol <= midLeftDownCol) {
            partition(matrix, midLeftDownRow, downRow, leftCol, midLeftDownCol, specialRow, specialCol);
        } else {
            matrix[midLeftDownRow][midLeftDownCol] = midValue;
            partition(matrix, midLeftDownRow, downRow, leftCol, midLeftDownCol, midLeftDownRow, midLeftDownCol);
        }
        int midRightDownRow = midLeftUpRow + 1;
        int midRightDownCol = midLeftUpCol + 1;
        if (midRightDownRow <= specialRow && specialRow <= downRow && midRightDownCol <= specialCol && specialCol <= rightCol) {
            partition(matrix, midRightDownRow, downRow, midRightDownCol, rightCol, specialRow, specialCol);
        } else {
            matrix[midRightDownRow][midRightDownCol] = midValue;
            partition(matrix, midRightDownRow, downRow, midRightDownCol, rightCol, midRightDownRow, midRightDownCol);
        }
    }
}
1.2.3.2 带注释版本
import java.util.Scanner;

public class Main {

    private static int curValue = 1;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            // 读取k值
            curValue = 1;
            int k = scanner.nextInt();
            int specialRow = scanner.nextInt(); // 特殊点横坐标
            int specialCol = scanner.nextInt(); // 特殊点纵坐标
            int edges = (int) Math.pow(2, k);
            int[][] matrix = new int[edges][edges];
            matrix[specialRow][specialCol] = 0;
            partition(matrix, 0, edges - 1, 0, edges - 1, specialRow, specialCol);
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[i].length - 1; j++) {
                    System.out.printf("%4s", matrix[i][j]);
                }
                System.out.printf("%4s\n", matrix[i][matrix[i].length - 1]);
            }
        }
    }

    /**
     *
     * @param matrix 矩阵
     * @param upRow 行的上界
     * @param downRow 行的下界
     * @param leftCol 列的左边界
     * @param rightCol 列的右边界
     * @param specialRow 特殊点横坐标
     * @param specialCol 特殊点纵坐标
     */
    private static void partition(int[][] matrix, int upRow, int downRow, int leftCol, int rightCol, int specialRow, int specialCol) {
        if (upRow == downRow && leftCol == rightCol) {
            // 只有一个元素，直接返回
            return;
        }
        // 计算中心区域
        // 维护中间区域填充值
        int midValue = curValue;
        curValue++;
        int midLeftUpRow = (upRow + downRow) / 2;
        int midLeftUpCol = (leftCol + rightCol) / 2;
        if (upRow <= specialRow && specialRow <= midLeftUpRow && leftCol <= specialCol && specialCol <= midLeftUpCol) {
            // 特殊点在左上区域
            partition(matrix, upRow, midLeftUpRow, leftCol, midLeftUpCol, specialRow, specialCol);
        } else {
            matrix[midLeftUpRow][midLeftUpCol] = midValue;
            partition(matrix, upRow, midLeftUpRow, leftCol, midLeftUpCol, midLeftUpRow, midLeftUpCol);
        }
        int midRightUpRow = midLeftUpRow;
        int midRightUpCol = midLeftUpCol + 1;
        if (upRow <= specialRow && specialRow <= midRightUpRow && midRightUpCol <= specialCol && specialCol <= rightCol) {
            // 特殊点在右上区域
            partition(matrix, upRow, midRightUpRow, midRightUpCol, rightCol, specialRow, specialCol);
        } else {
            matrix[midRightUpRow][midRightUpCol] = midValue;
            partition(matrix, upRow, midRightUpRow, midRightUpCol, rightCol, midRightUpRow, midRightUpCol);
        }
        int midLeftDownRow = midLeftUpRow + 1;
        int midLeftDownCol = midLeftUpCol;
        if (midLeftDownRow <= specialRow && specialRow <= downRow && leftCol <= specialCol && specialCol <= midLeftDownCol) {
            // 特殊点在左下区域
            partition(matrix, midLeftDownRow, downRow, leftCol, midLeftDownCol, specialRow, specialCol);
        } else {
            matrix[midLeftDownRow][midLeftDownCol] = midValue;
            partition(matrix, midLeftDownRow, downRow, leftCol, midLeftDownCol, midLeftDownRow, midLeftDownCol);
        }
        int midRightDownRow = midLeftUpRow + 1;
        int midRightDownCol = midLeftUpCol + 1;
        if (midRightDownRow <= specialRow && specialRow <= downRow && midRightDownCol <= specialCol && specialCol <= rightCol) {
            // 特殊点在右下区域
            partition(matrix, midRightDownRow, downRow, midRightDownCol, rightCol, specialRow, specialCol);
        } else {
            matrix[midRightDownRow][midRightDownCol] = midValue;
            partition(matrix, midRightDownRow, downRow, midRightDownCol, rightCol, midRightDownRow, midRightDownCol);
        }
    }
}

1.3 题目三：求逆序对

1.3.1 题目信息

题目描述：
给定一个序列a1,a2,…,an，如果存在i<j并且ai>aj，那么我们称之为逆序对，求逆序对的数目。
要求用分治法求解。
输入要求：
第一行为n,表示序列长度；
接下来的n行，第i+1行表示序列中的第i个数。/或者第2行有n个数。
输出要求：
所有逆序对总数
输入样例：
4
3
2
3
2
输出样例：
3
来源：
NBUOJ

1.3.2 算法思路（分治法）

这里直接给大家介绍算法思路了：
模板：归并排序
算法步骤（重要）：

  1. 我们设计一个递归函数partition(int[] arr, int left, int right)求解区间内逆序对的个数并且完成排序功能
  2. 然后我们将数组划分为两个区间[left, mid]，[mid + 1, right]
  3. 递归调用partition(arr, left, mid)此时将左半部分区间逆序对统计完毕并且排序完成，递归调用partition(arr, mid + 1, right)此时将右半部分区间逆序对统计完毕并且排序完成
  4. 此时我们只需要统计排序完毕的左区间和排序完毕后右区间之间的逆序对个数了

PS：上述代码基于归并排序的模板实现，下面着重讲解如何统计两个排序完毕区间之间的逆序对个数
示例：测试用例：[1, 5, 2, 7, 4, 3, 0, 6] 画图讲解：
image.png
上图所示是递归与回溯的示意图：下面我们专门讲解两个有序区间内部如何统计逆序对的问题

PS：与上图示意图有所不一致的是，统计逆序对的问题在归并排序的时候最好使用降序排序，至于为什么，大家下来自己尝试一下嘻嘻！

image.png
此时相比聪明的大家已经可以想明白过程了（事实上就是在二路归并中进行逆序对的统计，并且只有左区间的当前元素大于右区间当前元素时才会统计），当左区间全部遍历完毕后，两个区间之间的逆序对个数就统计完毕了！

1.3.3 AC代码（Java实现）

NBUOJ上面Java带中文注释会报错！因此这里放了两个版本的代码，前面不带注释的可以直接跑OJ通过，后面的方便读者阅读

1.3.3.1 不带注释版本
import java.util.Scanner;

public class Main {
    private static int reversePairCount = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            reversePairCount = 0;
            int n = scanner.nextInt();
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextInt();
            }
            partition(arr, 0, n - 1);
            System.out.println(reversePairCount);
        }
    }

    private static void partition(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = (left + right) / 2;
        partition(arr, left, mid);
        partition(arr, mid + 1, right);
        int[] tmp = new int[right - left + 1];
        int tmpIndex = 0;
        int left1 = left;
        int right1 = mid;
        int left2 = mid + 1;
        int right2 = right;
        while (left1 <= right1 && left2 <= right2) {
            if (arr[left1] > arr[left2]) {
                tmp[tmpIndex++] = arr[left1];
                left1++;
                reversePairCount += (right2 - left2 + 1);
            } else {
                tmp[tmpIndex++] = arr[left2];
                left2++;
            }
        }
        while (left1 <= right1) {
            tmp[tmpIndex++] = arr[left1];
            left1++;
        }
        while (left2 <= right2) {
            tmp[tmpIndex++] = arr[left2];
            left2++;
        }
        for (int i = 0; i < tmpIndex; i++) {
            arr[left + i] = tmp[i];
        }
    }
}
1.3.3.2 带注释版本
import java.util.Scanner;

public class Main {
    private static int reversePairCount = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            reversePairCount = 0;
            int n = scanner.nextInt();
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = scanner.nextInt();
            }
            partition(arr, 0, n - 1);
            System.out.println(reversePairCount);
        }
    }

    /**
     * 统计区间[left, right]内部逆序对的个数
     * @param arr 数组元素
     * @param left 左区间
     * @param right 右区间
     */
    private static void partition(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // 计算中心下标
        int mid = (left + right) / 2;
        partition(arr, left, mid); // 统计左区间逆序对个数并排序
        partition(arr, mid + 1, right); // 统计右区间逆序对个数并排序
        int[] tmp = new int[right - left + 1]; // 临时数组
        int tmpIndex = 0;
        int left1 = left;
        int right1 = mid;
        int left2 = mid + 1;
        int right2 = right;
        while (left1 <= right1 && left2 <= right2) {
            if (arr[left1] > arr[left2]) {
                tmp[tmpIndex++] = arr[left1];
                left1++;
                reversePairCount += (right2 - left2 + 1);
            } else {
                tmp[tmpIndex++] = arr[left2];
                left2++;
            }
        }
        while (left1 <= right1) {
            tmp[tmpIndex++] = arr[left1];
            left1++;
        }
        while (left2 <= right2) {
            tmp[tmpIndex++] = arr[left2];
            left2++;
        }
        // 拷贝回原数组
        for (int i = 0; i < tmpIndex; i++) {
            arr[left + i] = tmp[i];
        }
    }
}

1.3.4 扩展题

这里放一些跟本题类似的OJ题（读者可自行尝试解题）：

  1. LeetCode交易逆序对的总数：https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/description/
  2. LeetCode翻转对：https://leetcode.cn/problems/reverse-pairs/description/
米饭好好吃.
关注
  • 28
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python递推和递归_递归递推区别分析与例题总结
weixin_36149538的博客
01-14 1196
递归与递推特点递归(recursive)运行过程中自我调用，求解过程分为回溯和递推两个过程，占用内存多(栈数先积累后收缩，有可能爆栈)，代码简洁但低效。尾递归和递归区别⬇function story() {从前有座山，山上有座庙，庙里有个老和尚，一天老和尚对小和尚讲故事：story() // 尾递归，进入下一个函数不再需要上一个函数的环境了，得出结果以后直接返回。}function story()...
递归与分治java策略实验报告_【算法设计与分析】递归与分治策略（一）
weixin_42445810的博客
02-24 1042
凡治众如治寡，分数是也。孙子兵法【递归与分治】直接或间接地调用自身的算法称为递归算法。用函数自身给出定义的函数称为递归函数。分治与递归由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟，经常同时应用在算法设计...
nbuoj题解
qq_51056901的博客
01-25 7280
nbuoj题解（2021-1-23版） /* 这一个博客是用来记录我们学校的题解的，顺便对自己之前的代码做一下优化； 还有一件事，我为了方便而采取cpp与C语言混用的方式编写; 还有一件事，现在设计的是每篇博客上写20个题解； 还有一件事，目前的版本是2021-1-23，后续题库更新可能导致题目改变可以私信我; 还有一件事，目前在nbuoj上一共ac了400左右道，这个系列做完前三页（大概300道）就不写了； 还有一件事， 这个写完后会写洛谷题单的题解，作为升级版； */ /* T1000 #inclu
NBU OJ魔方阵
Hu_Linson的博客
02-04 381
输出魔方阵，所谓魔方阵就是指这样的方阵，它的每一行每一列和对角线之和都相等，例如，三阶魔方阵为 8 1 6 3 5 7 4 9 2 要求输出由1—n^2之间的自然数构成的魔方阵。 输入该方阵的阶数n(n<=15且n为奇数)。 输出该n阶魔方阵，两个数字之间用空格间隔 输入 3 输出 8 1 6 3 5 7 4 9 2 思路： 由于魔方阵的填法有很多种，这里给出一种填法： 1.将1放在第一行的最中央。 2.接下来的每个数字都放在前一个数字的右上方。如果右上方被占，则放在前一个数字的下面。 #includ
算法实验一 递归与分治策略
weixin_45816954的博客
05-24 3306
递推/递归与分治策略1 实验题目：王老师爬楼梯 题目描述： 王老师爬楼梯，他可以每次走1级或者2级或者3级楼梯，输入楼梯的级数，求不同的走法数。（要求递推求解）如果N很大，需要高精度计算。 输入要求： 一个整数N，N<=1000。 输出要求： 共有多少种走法。 实验代码 #include <bits/stdc++.h> using namespace std; class DividedByZeroException {}; class BigInteger { private:
递推最小二乘法实现及推广.rar_最小二乘 递推_最小二乘法_最小二乘递归_递归最小二乘_递推
07-14
2. **预测**：当新的数据点到达时，根据当前的参数估计和前一时刻的逆协方差矩阵，预测新数据点的响应。 3. **更新**：然后，计算预测响应与实际响应之间的偏差，并使用该偏差来更新参数估计。更新规则通常涉及P、...
递推-递归-分治-回溯.docx
11-11
递推、递归、分治和回溯是计算机科学中解决复杂问题的四种常用策略，它们在算法设计中扮演着重要角色。 递推算法是一种基于已知数据推导后续数据的计算方法。例如，整数阶乘、斐波那契数列等经典问题都可以用递推...
C++函数、递推、递归.ppt
11-17
"C++函数、递推、递归" 在本节中，我们将讨论C++语言中的函数、递推和递归三个关键概念。 一、函数 在C++语言中，函数是一种可以重复使用的代码块，用于执行特定的任务。函数可以将复杂的运算分解成简单易于管理...
LSM.rar_LSM_最小二乘 递推_最小二乘法_递推最小二乘法
09-24
2. **递推更新**：当新的观测数据到来时，使用先前的参数估计和新数据来更新参数。RLS算法使用一个称为“遗忘因子”（forgetting factor）的参数，它决定了旧数据对当前参数估计的影响程度。遗忘因子通常取值在0到1...
算法与数据结构之递推与递归
10-05
算法与数据结构之递推与递归
mysql笔记1
m0_62975692的博客
07-11 318
首先查看systemctl status mysqld，如果是关闭的可以进入的配置文件打开mysql，我的mysql配置文件就是在/usr/local/mysql/support-filess/下，在此目录下执行./mysql.server start,打开mysql服务，也可以通过systmectl start mysqld，如果你嫌麻烦的话可以systemctl enable mysqld 一直打开mysql的服务;重新给字段添加约束的时候不可以添加not null约束的！
计算机网络复习笔记【面向考纲整理】
最新发布
无
07-13 285
计算机网络（简称网络）由若干结点（node，节点）和连接这些结点的链路（link）组成。
AJAX学习笔记完（学习自用）
yayaye717的博客
07-09 550
AJAX学习笔记完（学习自用）
Hugging Face使用笔记
人无远虑，必有近忧
07-09 1531
Hugging Face Hub和 Github 类似，都是Hub(社区)。Hugging Face可以说的上是机器学习界的Github。hugging face在NLP领域最出名，其提供的模型大多都是基于Transformer的。
HTML CSS 基础复习笔记 - 框架、装饰、弹性盒子
forevercui的博客
07-09 1213
弹性盒子 - 学习 Web 开发 | MDN (mozilla.org)flex-flow：flex-flow属性是flex-direction属性和flex-wrap属性的简写形式align-items：flex-start | flex-end | center | baseline | stretch （单行）
javascript高级部分笔记
喵喵的博客
07-09 1273
javascript高级部分 Function方法 与 函数式编程 call 语法：call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 定义：调用一个对象的一个方法，以另一个对象替换当前对象。 说明：call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。 如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。 let myName = 'goudan
Redis学习笔记(个人向)
ozawacai的博客
07-12 511
从个人使用角度总结了我对Redis的理解
java Web学习笔记（二）
qq_62678419的博客
07-10 793
1. Ajax响应请求方式概述 2. 前端工程化概述 3. ES6语法详解 4. nodejs和npm软件安装及其命令行使用
群晖NAS配置WebDav服务结合内网穿透实现跨平台云同步思源笔记
m0_73879806的博客
07-09 783
本教程主要分享如何将思源笔记、cpolar内网穿透和群晖WebDav三者相结合，实现思源笔记的云同步功能。具体而言，我们利用cpolar将群晖NAS上的WebDav服务暴露到公网上，然后在思源笔记中配置该公网地址作为同步目标。这样，无论用户身处何地，只要能够访问互联网，就可以实现思源笔记的实时同步和共享。当下，信息的同步与共享变得尤为重要，传统的文件同步方案往往受限于网络环境和设备限制，使得文件同步变得复杂且不稳定。
nbuoj+角谷猜想
10-24
nbuoj是一个在线的OJ（Online Judge）平台，可以用来练习算法和编程技能。它提供了大量的题目，包括算法竞赛、ACM、OI等方面的题目，可以帮助学生提高编程能力和算法水平。 角谷猜想是一个数学问题，它是指对于任意正整数n，如果n是偶数，则将n除以2；如果n是奇数，则将n乘以3再加1。得到的新数再按照同样的规则进行处理，直到最终结果为1。据说无论初始值是多少，经过有限次处理后总能得到1。但是至今还没有人能够证明这个猜想的正确性。 在nbuoj上，有一些与角谷猜想相关的题目，例如求解角谷猜想中某个数的迭代次数、求解角谷猜想中最大的迭代次数等等。这些题目可以帮助学生更好地理解和掌握角谷猜想，并提高编程能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值