数据结构——动态规划

动态规划：有很多重叠子问题，每一个状态一定是由上一个状态推导出来的

贪心：没有状态推导，而是从局部直接选最优的

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

  • 确定递推公式（容斥原理）

  • dp数组如何初始化

  • 确定遍历顺序

  • 举例推导dp数组（用于检验）

一：递推问题

1.1. 如何求解递推问题

正向递推：（递推：一个算法     递归：程序实现的方式，不是算法） 

正向递推（慢）：n-------》1-------》递归

逆向递推（快）：1-------》n-------》循环  

解决效率过差：

1. 递归过程+记忆化

2. 改成逆向递推求解

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

        dp[n]：第n个月的兔子总数是dp[n]

  • 确定递推公式（容斥原理）

        容斥原理 ：dp[n]全集包括：成年兔 + 幼年兔

        dp[n] = dp[n - 1] + dp[n - 2];

  • dp数组如何初始化

        dp[1] = 1;

        dp[2] = 2;

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现：

#include <stdio.h>
#include <stdlib.h>
//正向递推：递归过程+记忆化（提高运行效率）
#define MAX_N 100
int arr[MAX_N + 1] = {0};
int func1(int n) {if (n <= 2) {return n;}if (arr[n]) {return arr[n];}arr[n] = func1(n - 1) + func1(n - 2);return arr[n];
}//逆向递推
int func2(int n) {int *dp = malloc(sizeof(int) * (n + 1));dp[1] = 1;dp[2] = 2;for (int i = 3; i <= n; i++) {dp[i] = dp[i - 1] + dp[i - 2];}int ret = dp[n];free(dp);return ret;
} int main(int argc, char *argv[]) {int n;scanf("%d", &n);printf("%d\n", func1(n));printf("%d\n", func2(n));return 0;
}

1.2. 容斥原理的基本思想

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

        dp[i][j]：用前 i 种钱币，凑足 j 元钱的方法总数

  • 确定递推公式（容斥原理）

        容斥原理：dp[i][j]全集包括：没有使用第i种钱币 + 使用第i种钱币

        没有使用第i种钱币：dp[i - 1][j]

        使用第i种钱币：dp[i][j - value[i]]

                                  第一部分：给第i种钱币先留出一个空，用前i种钱币凑够(j - value[i])钱 

                                  第二部分：最后一个空用第i种钱币

        dp[i][j] = dp[i - 1][j] + dp[i][j - value[i]];

  • dp数组如何初始化

1）

        

        

//初始化
for (int i = 1; i <= m; i++) {dp[i][0] = 1;
}
for (int j = 1; j <= n; j++) {if (w[1] <= j && (j % w[1] == 0)) {dp[1][j] = 1;} else {dp[1][j] = 0;}
}

2）

//初始化
memset(dp[0], 0, sizeof(int) * n); //将第0行初始化为0
for (int i = 1; i <= m; i++) {dp[i][0] = 1; //初始化第i行第0列为1
}

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现:

//1)动态规划
#include <stdio.h>
#define MAX_N 10000
#define MAX_M 20
int w[MAX_M + 1];
int dp[MAX_M + 1][MAX_N + 1];int main(int argc, char *argv[]) {int m, n; //m种面额的钱币凑足n元钱scanf("%d%d", &m, &n);for (int i = 1; i <= m; i++) {scanf("%d", w + i);}//初始化for (int i = 1; i <= m; i++) {dp[i][0] = 1;}for (int j = 1; j <= n; j++) {if (w[1] <= j && (j % w[1] == 0)) {dp[1][j] = 1;} else {dp[1][j] = 0;}}for (int i = 2; i <= m; i++) {for (int j = 1; j <= n; j++) {dp[i][j] = dp[i - 1][j];if (j < w[i]) {continue;}dp[i][j] += dp[i][j - w[i]];dp[i][j] %= 9973;}}printf("%d\n", dp[m][n]);return 0;
}//2)动态规划
#include <stdio.h>
#include <string.h>#define MAX_N 10000
#define MAX_M 20
int w[MAX_M + 5];
int dp[MAX_M + 5][MAX_N + 5];int main(int argc, char *argv[]) {int m, n; //m种面额的钱币凑足n元钱scanf("%d%d", &m, &n);for (int i = 1; i <= m; i++) {scanf("%d", w + i);}memset(dp[0], 0, sizeof(int) * n); //将第0行初始化为0for (int i = 1; i <= m; i++) {dp[i][0] = 1; //初始化第i行第0列为1for (int j = 1; j <= n; j++) {dp[i][j] = dp[i - 1][j];if (j < w[i]) {continue;}dp[i][j] += dp[i][j - w[i]];dp[i][j] %= 9973;}}printf("%d\n", dp[m][n]);return 0;
}//3)回溯

1.3. 随堂练习1：爬楼梯

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

        dp[n]：走到第n阶台阶的方法总数

  • 确定递推公式（容斥原理）

        容斥原理：dp[n]全集包括：最后跨2步到达第n阶台阶 + 最后跨3步到达第n阶台阶

        dp[n] = dp[n - 2] + dp[n - 3];

  • dp数组如何初始化

        dp[1] = 0;

        dp[2] = 1;

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现：

#include <stdio.h>#define MAX_N 500
int dp[MAX_N + 1];int func(int n) {dp[0] = 1;dp[1] = 0;dp[2] = 1;for (int i = 3; i <= n; i++) {dp[i] = dp[i - 2] + dp[i - 3];}return dp[n];
}int main(int argc, char *argv[]) {int n;scanf("%d", &n);printf("%d\n", func(n));return 0;
}

💖1.4. 随堂练习1：墙壁涂色

   

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

       dp[n][i][j]代表前n块墙壁，在不考虑头尾成环的前提下，第1块涂颜色i，第n块涂颜色j的方法总数

        此时 i 可以等于 j ,最后统计答案时去除相等的情况

  • 确定递推公式（容斥原理）

        容斥原理：dp[n][i][j]全集包括：第1块涂颜色i，第n-1块涂颜色k(k != j)，第n块涂颜色j

        dp[n][i][j] = dp[n-1][i][k]（k != j）的累加

  • dp数组如何初始化

        

        

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

     

二：递推-课后实战题

2.1. 数的划分

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

        dp[i][j]：将数字 i 分成 j 份的方法总数

  • 确定递推公式（容斥原理）

        容斥原理：dp[i][j]全集包括：拆分方案中有1 + 拆分方案中没有1

        拆分方案中有1：留下最后一个位置放1，dp[i - 1][j - 1]

        拆分方案中没有1：将所有方案中的 j 个数都减1，得到另外一个数（i - j）分成 j                                        份的结果，将i - j的所有方案列出来，每个数都加上1，就是拆分方                                         案中没有1的结果，所以拆分方案中没有1的方法总数 == 将数字 i  -                                         j分成 j 份的方法总数 ，即dp[i - j][j]

        dp[i][j] = dp[i - 1][j - 1] + dp[i - j][j];        

  • dp数组如何初始化

        

        

int dp[MAX_N + 1][MAX_K + 1] = {0};
for (int i = 1; i <= n; i++) {dp[i][1] = 1;
}

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现：

//动态规划
#include <stdio.h>#define MAX_N 200
#define MAX_K 6
#define min(a, b) ((a) > (b) ? (b) : (a))int dp[MAX_N + 1][MAX_K + 1] = {0};int main(int argc, char *argv[]) {int n, k;scanf("%d%d", &n, &k);dp[0][0] = 1;for (int i = 1; i <= n; i++) {dp[i][1] = 1;for (int j = 2; j <= min(i, k); j++) {dp[i][j] = dp[i - 1][j - 1] + dp[i - j][j];}}printf("%d\n", dp[n][k]);return 0;
}//回溯

2.2. 数的计算

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

       dp[i]：以i作为开头的合法的数列个数

  • 确定递推公式（容斥原理）

        容斥原理：dp[i]全集包括：

                          以i作为结尾（不扩展）+ i后面接i/2 + i后面接i/2-1 ...... + i后面接1

                                    1                             dp[i/2]          dp[i/2-1]                dp[1]

        dp[i] = dp[j]的累加（j <= i/2）+ 1                                     

  • dp数组如何初始化

        

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现：

#include <stdio.h>#define MAX_N 1000
int dp[MAX_N + 1] = {0};int main(int argc, char *argv[]) {int n;scanf("%d", &n);for (int i = 1; i <= n; i++) {dp[i] = 1;for (int j = 1; j <= i / 2; j++) {dp[i] += dp[j];}}printf("%d\n", dp[n]);return 0;
}

2.3. 神经网络

2.4. 栈

题目描述：1 <= n <=18 的合法出栈序列一共有多少种

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

        dp[n]：1—n的合法出栈序列方案数

  • 确定递推公式（容斥原理）

        容斥原理：dp[n]全集包括：出栈序列末尾是1的方案数 + 出栈序列末尾是2的方案数 + 出栈序列末尾是3的方案数 + ...... + 出栈序列末尾是n的方案数

        小于x的数不断入栈出栈---》x入栈---》大于x的数不断入栈出栈---》x出栈

        第一部分：小于x的数   第二部分：大于x的数   第三部分：x

        所以出栈序列末尾是x的方案数 = dp[x - 1] * dp[n - x]

        dp[n] = dp[x - 1] * dp[n - x]的累加（x == 1; x <= n; x++）

  • dp数组如何初始化

        int dp[MAX_N + 1] = {0};

        dp[0] = 1;

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现：

#include <stdio.h>#define MAX_N 18
int dp[MAX_N + 1] = {0};int main(int argc, char *argv[]) {int n;scanf("%d", &n);dp[0] = 1;for (int i = 1; i <= n; i++) {for (int j = 1; j <= i; j++) {dp[i] += dp[j - 1] * dp[i - j];}}printf("%d\n", dp[n]);return 0;
}

2.5. 循环

2.6. 传球游戏

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

        dp[j][i]：传了j轮球，球在第i个人手里的方法总数

  • 确定递推公式（容斥原理）

        容斥原理：dp[j][i]全集包括：

                                      倒数第二轮时球在第i-1个人手里 + 倒数第二轮时球在第 i+1个人手里

                                                    dp[j - 1][i - 1]                              dp[j - 1][i + 1]

        dp[j][i] = dp[j - 1][i - 1] + dp[j - 1][i + 1]

  • dp数组如何初始化

        

  • 确定遍历顺序

        从前往后

  • 举例推导dp数组（用于检验）

代码实现：

#include <stdio.h>#define MAX_N 30
#define MAX_M 30
int dp[MAX_N + 1][MAX_N + 1] = {0};int main(int argc, char *argv[]) {int n, m;scanf("%d%d", &n, &m);dp[0][1] = 1;for (int j = 1; j <= m; j++) {for (int i = 2; i <= n - 1; i++) {dp[j][i] = dp[j - 1][i + 1] + dp[j - 1][i - 1];}//单独处理边界dp[j][1] = dp[j - 1][2] + dp[j - 1][n];dp[j][n] = dp[j - 1][1] + dp[j - 1][n - 1];}printf("%d\n", dp[m][1]);return 0;
}

2.7. Hanoi 双塔问题

动规五步曲：

  • 确定dp数组（dp table）以及下标的含义

  • 确定递推公式（容斥原理）

  • dp数组如何初始化

  • 确定遍历顺序

  • 举例推导dp数组（用于检验）

三：动态规划

3.1. 全面剖析：数字三角形问题

1. 斐波那契数

动规五部曲：

1. 确定dp数组以及下标的含义        

         一维dp数组保存递归的结果

        dp[i]的定义为：第i个数的斐波那契数值是dp[i]

2. 确定递推公式

        状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];

3. dp数组如何初始化

        dp[0] = 0;
        dp[1] = 1;

4. 确定遍历顺序

        从递归公式dp[i] = dp[i - 1] + dp[i - 2]中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的

5. 举例推导dp数组

        按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当n为10的时候，dp数组应该是如下的数列：   0 1 1 2 3 5 8 13 21 34 55

代码实现：

//1) 动归第一种解法 时间复杂度：O(n)  空间复杂度：O(n)
int fib(int n) {if (n <= 1) {return n;}int *dp = malloc(sizeof(int) * (n + 1));dp[0] = 0;dp[1] = 1;for (int i = 2; i <= n; i++) {dp[i] = dp[i - 1] + dp[i - 2];}int ret = dp[n]; //防止内存泄漏free(dp);return ret;
}//2) 动规第二种解法  时间复杂度：O(n)  空间复杂度：O(1)
int fib(int n) {if (n <= 1) {return n;}int dp[2];dp[0] = 0;dp[1] = 1;for (int i = 2; i <= n; i++) {int sum = dp[0] + dp[1];dp[0] = dp[1];dp[1] = sum;}return dp[1];
}//3) 递归+记忆化解法
#define MAX_N 30
int arr[MAX_N + 1] = {0}; //优化：记忆化(防止大量重复运算，加快运行效率)
int fib(int n) {if (n <= 1) {return n;}if (arr[n]) {return arr[n];}arr[n] = fib(n - 1) + fib(n - 2);return arr[n];
}

2. 爬楼梯

动规五步曲：

1. 确定dp数组以及下标的含义

一维dp数组保存递归的结果

dp[i]：爬到第i层楼梯，有dp[i]种方法

2. 确定递推公式

从dp[i]的定义可以看出，dp[i] 可以有两个方向推出来

首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶就是dp[i]了

还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶就是dp[i]了

那么dp[i]就是 dp[i - 1]与dp[i - 2]之和！

所以dp[i] = dp[i - 1] + dp[i - 2] 

3. dp数组如何初始化

dp[1] = 1

dp[2] = 2

4. 确定遍历顺序

从递推公式dp[i] = dp[i - 1] + dp[i - 2]中可以看出，遍历顺序一定是从前向后遍历的

5. 举例推导dp数组

举例当n为5的时候，dp table（dp数组）应该是这样的

代码实现：

//动规
int climbStairs(int n) {if (n <= 2) {return n;}int dp[3];dp[1] = 1; //上一层台阶dp[2] = 2; //上两层台阶for (int i = 3; i <= n; i++) {int sum = dp[1] + dp[2];dp[1] = dp[2];dp[2] = sum;}return dp[2];
}//递归
#include <stdio.h>
#define MAX_N 45
int arr[MAX_N + 1] = {0}; //记忆化优化
int climbStairs(int n) {if (n <= 2) {return n;}if (arr[n])return arr[n];arr[n] = climbStairs(n - 1) + climbStairs(n - 2);return arr[n];
}

3. 使用最小花费爬楼梯

动规五步曲：

1. 确定dp数组以及下标的含义

使用动态规划，就要有一个数组来记录状态，本题只需要一个一维数组dp[i]就可以了

dp[i]的定义：第i个台阶所花费的最少体力为dp[i]

2. 确定递推公式

可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]

那么究竟是选dp[i-1]还是dp[i-2]呢？

一定是选最小的，所以dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];

3. dp数组如何初始化

dp[0] = cost[0];
dp[1] = cost[1];

4. 确定遍历顺序

因为是模拟台阶，而且dp[i]又dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组就可以了

5. 举例推导dp数组

拿示例2：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] ，来模拟一下dp数组的状态变化，如下：

代码实现：

#define min(a, b)  ((a) > (b) ? (b) : (a))
int minCostClimbingStairs(int* cost, int costSize) {int *dp = malloc(sizeof(int) * (costSize + 1));dp[0] = dp[1] = 0;for (int i = 2; i <= costSize; i++) {dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);}return dp[costSize];
}

4. 不同路径

动规五步曲：

1. 确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径

2. 确定递推公式

想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]

此时在回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理

那么很自然，dp[i][j] =  dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来

3. dp数组的初始化

p[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理。

for (int i = 0; i < m; i++) {dp[i][0] = 1;
}
for (int j = 0; j < n; j++) {dp[0][j] = 1;
}

4. 确定遍历顺序

递归公式dp[i][j] =  dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

5. 举例推导dp数组

代码实现：

int uniquePaths(int m, int n) {//动态创建一个二维路径答案表int **dp = (int **)malloc(sizeof(int *) * m);for (int i = 0; i < m; i++) {dp[i] = (int *)malloc(sizeof(int) * n);}//最左一行for (int i = 0; i < m; i++) { dp[i][0] = 1;}//最上一行for (int j = 0; j < n; j++) {dp[0][j] = 1;}for (int i = 1; i < m; i++) {for (int j = 1; j < n; j++) {dp[i][j] = dp[i - 1][j] + dp[i][j - 1];}}return dp[m - 1][n - 1];
}

5. 不同路径 II

​

​

动规五步曲：

1. 确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径

2. 确定递推公式

dp[i][j] =  dp[i - 1][j] + dp[i][j - 1]

(i, j)如果就是障碍的话应该就保持初始状态（初始状态为0）

//当(i, j)没有障碍的时候，再推导dp[i][j]
if (obstacleGrid[i][j] == 0) {dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}

3. dp数组如何初始化

​

for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {dp[i][0] = 1;
}
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {dp[0][j] = 1;
}

4. 确定遍历顺序

从左到右一层一层遍历

5. 举例推导dp数组

拿示例1来举例如题：

​
对应的dp table 如图：

​

代码实现：

6. 整数拆分

​

动规五步曲：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/173369.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

STM32-SPI1控制AD7705（Sigma-Delta-ADC芯片）

STM32-SPI1控制AD7705（Sigma-Delta-ADC芯片）

STM32-SPI1控制AD7705&#xff08;Sigma-Delta-ADC芯片&#xff09; 原理图手册说明功能方框图引脚功能 片内寄存器通信寄存器&#xff08;RS2、RS1、RS00、0、0&#xff09;设置寄存器时钟寄存器数据寄存器&#xff08;RS2、RS1、RS00、1、1&#xff09;测试寄存器&#xff08…
阅读更多...
SAP Smartforms设计

SAP Smartforms设计

第八章 SMART FORMS设计 要点列表 概览&#xff1b; Form&#xff08;表格&#xff09;&#xff1b; Smart Styles&#xff08;样式&#xff09;&#xff1b; Text Module&#xff08;文本模块&#xff09;&#xff1b; 使用标准表方式打印&#xff1b; 使用模板方式打印…
阅读更多...
淼一科技为互联网企业销毁硬盘数据 拆除机房设备

淼一科技为互联网企业销毁硬盘数据 拆除机房设备

在上海这座繁华的大都市&#xff0c;淼一科技以其专业的服务和卓越的技术&#xff0c;为众多互联网企业提供硬盘数据销毁和机房设备拆除服务。作为业界领先的数据安全解决方案提供商&#xff0c;淼一科技致力于保障客户数据的安全与隐私&#xff0c;为客户创造更高的商业价值。…
阅读更多...
uni-app：心跳机制基础逻辑（定时器方法解决）

uni-app：心跳机制基础逻辑（定时器方法解决）

思路 1、在登录的时候&#xff0c;定义一个存储当前时间的全局变量&#xff0c;并且开始心跳请求 2、在全局中定义一个定时器&#xff0c;该定时器每秒都会执行一次&#xff0c;并获取当前的时间 3、将定时器每秒的获取的当前时间和全局变量获取的时间进行比较 4、指定一个…
阅读更多...
网络运维与网络安全 学习笔记2023.11.27

网络运维与网络安全 学习笔记2023.11.27

网络运维与网络安全 学习笔记 第二十八天 今日目标 OSPF基本原理、OSPF单区域配置、OSPF多区域配置 特殊区域之Stub、特殊区域之NSSA OSPF基本原理 项目背景 随着企业的发展&#xff0c;网络的规模越来越大&#xff0c;网段的数量越来越多&#xff0c;公司内部的路由器的…
阅读更多...
Windows系统下搭建PXE Server

Windows系统下搭建PXE Server

在给一台服务器初始安装OS时一般有以下几种方式&#xff1a; 1、通过BMC挂载iso镜像来安装&#xff1b; 2、通过U盘启动来安装&#xff1b; 3、通过网络启动来安装&#xff1b; 方式1和方式2只能一台一台地进行&#xff0c;且需要有键盘和显示器&#xff0c;效率低下&#xff…
阅读更多...
在vue页面中添加组件到底有多方便

在vue页面中添加组件到底有多方便

修改vue写的前端页面到底有多方便&#xff1f;如果熟练的话&#xff0c;出乎你想象的快。 原来的页面&#xff1a;/admin/stock 原来的文件地址&#xff1a;src\views\admin\stock\Stock.vue 另一个页面有个入库功能&#xff0c;需要转移到上面的页面中&#xff1a; 路径&…
阅读更多...
基于C#实现块状链表

基于C#实现块状链表

在数据结构的世界里&#xff0c;我们会认识各种各样的数据结构&#xff0c;每一种数据结构都能解决相应领域的问题&#xff0c;当然每个数据结构&#xff0c;有他的优点&#xff0c;必然就有它的缺点&#xff0c;那么如何创造一种数据结构来将某两种数据结构进行扬长避短&#…
阅读更多...
Java代码生成器，一键在线生成，支持自定义模板

Java代码生成器，一键在线生成，支持自定义模板

【Java代码生成神器】自动化生成Java实体类、代码、增删改查功能&#xff01;点击访问 推荐一个自己每天都在用的Java代码生成器&#xff01;这个网站支持在线生成Java代码&#xff0c;包含完整的Controller\Service\Entity\Dao代码&#xff0c;完整的增删改查功能&#xff01…
阅读更多...
金鸣表格文字识别客户端输出项该如何选择？

金鸣表格文字识别客户端输出项该如何选择？

智能布局&#xff1a;根据提交的图片自动设置输出的打印纸张大小和方向&#xff0c;其中表格识别默认为A4纵向&#xff0c;勾选“合并”可将N张图片批量识别成一个文件、一个表。 表格识别&#xff1a; excel&#xff1a;输出可编辑的excel。 word&#xff1a;输出可编辑的w…
阅读更多...
稳定扩散模型的隐空间探索

稳定扩散模型的隐空间探索

生成图像模型学习视觉世界的“潜在流形”&#xff1a;每个点映射到图像的低维向量空间。 从流形上的这样一个点回到可显示的图像称为“解码”—在稳定扩散模型中&#xff0c;这是由“解码器”模型处理的。 在线工具推荐&#xff1a; Three.js AI纹理开发包 - YOLO合成数据生成器…
阅读更多...
为什么MES管理系统实施效果会很差

为什么MES管理系统实施效果会很差

随着制造业的快速发展&#xff0c;MES生产管理系统越来越受到企业的关注。MES管理系统是一种面向车间生产的管理系统&#xff0c;用于在产品从工单发出到成品完工的过程中传递信息&#xff0c;以优化生产活动并提高操作及流程的效率。然而&#xff0c;很多公司在使用MES管理系统…
阅读更多...
林业无人机如何提升巡山护林效率？

林业无人机如何提升巡山护林效率？

在郁郁森林之上&#xff0c;一架无人机正盘旋在上空时刻观察着林区的情况。凭借复亚智能的全自动巡检系统&#xff0c;无人机巡山护林的巡视范围和反馈实时性得到了显著提升。 一、林业无人机&#xff1a;科技赋能森林防火 秋季林区时常发生火灾&#xff0c;林业无人机在森林防…
阅读更多...
WordPress最廉价优化整站的加载速度

WordPress最廉价优化整站的加载速度

为什么说一个站不优化就等于一个人做整个团队的事务导致项目进展慢&#xff0c;网站也是如此 图片、静态文件、php分离加速&#xff0c;加载速度并不是很快但是很协调比单个网站加载速度快许多 一、图片单域名加载设置上传文件路径和域名 以下代码添加在主题目录&#xff1a;fu…
阅读更多...
C语言每日一题（37）两数相加

C语言每日一题（37）两数相加

力扣网 2 两数相加 题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&a…
阅读更多...
5.前端--CSS-基本概念【2023.11.26】

5.前端--CSS-基本概念【2023.11.26】

1. CSS 语法规范 CSS 规则由两个主要的部分构成&#xff1a;选择器以及一条或多条声明。 属性和属性值之间用英文“:”分开 多个“键值对”之间用英文“;”进行区分 选择器 : 简单来说&#xff0c;就是选择标签用的。 声明 &#xff1a;就是改变样式 2.CSS引入方式 按照 CSS 样…
阅读更多...
Ansible的重用（include和import）

Ansible的重用（include和import）

环境 管理节点&#xff1a;Ubuntu 22.04控制节点&#xff1a;CentOS 8Ansible&#xff1a;2.15.6 重用 Ansible提供四种可重用的工件&#xff1a; variable文件&#xff1a;只包含变量的文件task文件&#xff1a;只包含task的文件playbook&#xff1a;可包含play、变量、ta…
阅读更多...
牛客 算法题 【HJ102 字符统计】 golang实现

牛客 算法题 【HJ102 字符统计】 golang实现

题目 HJ102 字符统计 golang代码实现 package mainimport ("bufio""fmt""os""sort" )func main() {// str_arry :make([]string, 0)str_map : make(map[rune]int)result_map : make(map[int][]string)scanner : bufio.NewScanner(os…
阅读更多...
SAP创建ODATA服务-Structure

SAP创建ODATA服务-Structure

SAP创建ODATA服务-Structure 1、创建数据字典 进入se11创建透明表ZRICO_USR,并创建对应字段 2、创建OData service 首先创建Gateway service project&#xff0c;事务码&#xff1a;SEGW&#xff0c;点击Create Project 按钮 Gateway service Project分四个部分&#xff1a…
阅读更多...
JVS-rules规则引擎导出与导入，确保业务连续性的关键

JVS-rules规则引擎导出与导入，确保业务连续性的关键

在复杂的系统环境中&#xff0c;规则和配置的迁移、备份及共享成为了确保业务连续性和一致性的关键过程。不同的环境可能需要相同的规则和配置数据&#xff0c;或者我们可能需要备份这些数据以防万一。JVS规则引擎提供了规则的导出与导入功能&#xff0c;使用户能够在多个环境间…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023