【动态规划】独立任务、石子合并

已于 2024-05-17 01:14:45 修改
阅读量752 收藏 24
点赞数 21
文章标签： 动态规划 算法
于 2024-05-17 01:12:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74173134/article/details/138914258
版权

目录

   m处理器

动态规划：

在一般情况下，动态规划通常包括以下几个步骤来实现：

  1. 定义子问题：确定问题的子问题，并将原问题划分为子问题。子问题应该是原问题的较小规模的版本。

  2. 定义状态：确定表示子问题的状态。状态是问题的关键属性，它们的值随着问题的求解而改变。

  3. 定义递推关系：确定子问题之间的递推关系，即如何从较小规模的子问题推导出较大规模的子问题的解。这通常是通过分析问题的特征和限制条件来得到的。

  4. 确定边界条件：确定最小规模的子问题的解，也就是边界条件。边界条件是递归或迭代过程中终止条件的基础。

  5. 确定计算顺序：确定计算子问题的顺序。有些子问题可能依赖于其他子问题的解，因此需要按照一定的顺序进行计算，确保所依赖的子问题已经求解。

  6. 填充表格或数组：使用递推关系和边界条件，填充表格或数组来保存子问题的解。这样可以避免重复计算子问题，提高效率。

  7. 求解原问题：根据填充的表格或数组，从子问题的最优解中得出原问题的解。

  8. 可选的优化步骤：根据具体问题的特点，可以进行一些优化操作，如空间优化、状态压缩等，以减少内存消耗或提高算法效率。

独立任务最优调度问题

#include <stdio.h>
#include <stdlib.h>

#define MAXTIME 500

int p[MAXTIME][MAXTIME];

int Dynamic(int a[], int b[], int n) {
    int aTime = 0; // 作业仅在机器a上运行所需的时间
    for (int k = 1; k <= n; k++) { // 从1开始，到n，方便操作
        aTime += a[k]; // 记录此时a机器单独操作需要的最大时间
        for (int t = 0; t <= aTime; t++) { // 一列一列地更新
            if (t < a[k]) { // 此时时间条件不允许a单独处理k
                p[t][k] = p[t][k - 1] + b[k]; // 此处p元素值直接是b处理完k-1后继续处理k
            } else { // 此时时间条件允许a处理新加入的k，进行比较
                p[t][k] = p[t - a[k]][k - 1] > p[t][k - 1] + b[k] ? p[t][k - 1] + b[k] : p[t - a[k]][k - 1];
            }
        }
    }
    int minTime = 999999;
    for (int t = 0; t < aTime; t++) {
        int maxt = t > p[t][n] ? t : p[t][n]; // 找到每个时间段对应的两者的最大值
        minTime = minTime > maxt ? maxt : minTime; // minTime每次更新，记录最小值
    } // 说白了就是横坐标t就是a单独处理a的用时，p内值就是a、b并行工作后b的最优用时
    // 在考虑到所有作业时，比较最后一列每一行两者的大小就能得到最优用时
    return minTime;
}

int main() {
    int n; // n个作业
    scanf("%d", &n); // 读入作业个数
    int a[n + 1];
    int b[n + 1];
    for (int i = 1; i <= n; i++) // 读入机器A运行时间
        scanf("%d", &a[i]);
    for (int i = 1; i <= n; i++) // 读入机器B运行时间
        scanf("%d", &b[i]);
    int minTime = Dynamic(a, b, n);
    printf("%d", minTime);
    return 0;
}

在这段代码中，递推式和边界条件如下：

递推式：

  1. for (int k = 1; k <= n; k++) {
    aTime += a[k];
    for (int t = 0; t <= aTime; t++) {
        if (t < a[k]) {
            p[t][k] = p[t][k - 1] + b[k];
        } else {
            p[t][k] = p[t - a[k]][k - 1] > p[t][k - 1] + b[k] ? p[t][k - 1] + b[k] : p[t - a[k]][k - 1];
        }
    }
}

边界条件：

int minTime = 999999;
for (int t = 0; t < aTime; t++) {
    int maxt = t > p[t][n] ? t : p[t][n];
    minTime = minTime > maxt ? maxt : minTime;
}

具体思想

  1. 定义问题：这段代码解决的问题是将n个作业分配到两台机器（机器A和机器B）上完成，并使得完成所有作业所需的时间最小化。

  2. 确定状态：在这个问题中，状态可以用二维数组p[t][k]表示。其中，p[t][k]表示在时间为t且前k个作业已被分配的情况下，机器B完成作业所需的最小时间。

  3. 定义递推关系：这段代码使用了递推关系来计算最优解。它通过迭代遍历作业和时间来更新数组p的值。具体的递推关系如下：

    • 当t < a[k]时，表示此时时间条件不允许机器A单独处理作业k。因此，递推式为p[t][k] = p[t][k-1] + b[k]。
    • 当t >= a[k]时，表示时间条件允许机器A处理作业k。此时，递推式为p[t][k] = min(p[t-a[k]][k-1], p[t][k-1] + b[k])。

  4. 确定边界条件：在初始化阶段，将p[0][k]的所有元素设置为0，表示在时间为0时，无论有多少个作业，机器B都不需要运行。将p[t][0]的所有元素设置为0，表示在没有作业时，无论时间是多少，机器B都不需要运行。

  5. 填充表格：通过使用递推关系和边界条件，遍历作业和时间，填充二维数组p。每个格子p[t][k]的值表示在时间t和前k个作业已被分配的情况下，机器B完成作业所需的最小时间。

  6. 求解原问题：在考虑所有作业时，比较最后一列每一行的两个值，即p[t][n]和t，取较大值作为机器B的最优用时。然后通过遍历所有时间段的最优用时，找到最小值作为整体的最优用时。

石子合并问题

#include<stdio.h>
#include<string.h>
#define Ma_x 99999
#define Mi_x 0
#define min(a,b) a<b?a:b
#define max(a,b) a>b?a:b

int n,w[200],dp[200][200],dq[200][200];//n表示堆数，w表示每队的数量，dp[i][j]表示从第i堆开始合并j堆（包括第i堆）后的最小花费 ,dq表示最大

int sum(int i,int t){//从第i堆开始,t个石堆合，最后一次的合并的花费
    int k,s=0,k1;
    for(k=i;k<i+t;k++){
        k1=k%n;
        if(k1==0) k1=n;
        s=s+w[k1];   //这t个石堆最好两堆合并时的花费一定是这t堆石子的总和
    }
    return s;
}

int main(){
    int i,t,k;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d",&w[i]);
        dp[i][1]=0;//表示合并一堆的花费，没有合并则花费为0

    }
    //动态规划
    for(t=2;t<=n;t++){
        for(i=1;i<=n;i++){
            dp[i][t]=Ma_x;
            dq[i][t]=Mi_x;
            for(k=1;k<t;k++){
                dp[i][t]=min(dp[i][t],dp[i][k]+dp[(i+k-1)%n+1][t-k]+sum(i,t));
                dq[i][t]=max(dq[i][t],dq[i][k]+dq[(i+k-1)%n+1][t-k]+sum(i,t));
            }
        }
    }
    int mini=Ma_x;
    int maxi=Mi_x;
    for(i=1;i<=n;i++){//从第几堆石子开始结果最小
        mini=min(mini,dp[i][n]);
        maxi=max(maxi,dq[i][n]);
    }
    printf("%d ",mini);
    printf("%d ",maxi);
}

这段代码是一个用动态规划解决石子合并问题的示例代码。下面解释一下递推式和边界条件的含义：

  • n：表示石堆的数量。
  • w：数组，表示每个石堆的数量。
  • dp：二维数组，dp[i][j]表示从第i堆开始合并j堆（包括第i堆）后的最小花费。
  • dq：二维数组，dq[i][j]表示从第i堆开始合并j堆（包括第i堆）后的最大花费。

递推式：

dp[i][t] = min(dp[i][t], dp[i][k] + dp[(i+k-1)%n+1][t-k] + sum(i, t))
dq[i][t] = max(dq[i][t], dq[i][k] + dq[(i+k-1)%n+1][t-k] + sum(i, t))
  • dp[i][t]的计算表示从第i堆开始合并t堆石子的最小花费。它通过遍历中间位置k，将这k堆和剩余的t-k堆分别合并，并计算合并花费，然后取最小值。
  • dq[i][t]的计算表示从第i堆开始合并t堆石子的最大花费。它也通过遍历中间位置k，将这k堆和剩余的t-k堆分别合并，并计算合并花费，然后取最大值。

边界条件：

dp[i][1] = 0
  • dp[i][1]表示合并一堆石子的花费，由于只有一堆石子，所以花费为0。

最后，代码通过遍历所有堆的起始位置i，找到合并所有石堆的最小花费mini和最大花费maxi，并输出结果。

具体思想

这段代码解决的问题是给定n个石堆，并给出每个石堆的数量。任务是将这些石堆合并成一堆，合并过程中需要支付一定的花费。代码的目标是找到合并全部石堆的最小花费和最大花费。

具体的实现思路如下：

  1. 读取输入的石堆数量n。
  2. 循环读取每个石堆的数量，并初始化合并一堆的花费dp[i][1]为0。
  3. 动态规划部分：
    • 使用两个嵌套循环，外层循环变量t从2到n，内层循环变量i从1到n。
    • 对于每个t和i，初始化dp[i][t]为较大值Ma_x，dq[i][t]为较小值Mi_x。
    • 使用另一个循环变量k，从1到t-1，遍历中间位置k。
    • 更新dp[i][t]为取所有可能的合并方案中的最小值，更新dq[i][t]为取所有可能的合并方案中的最大值。
  4. 寻找最小和最大花费：
    • 初始化mini为较大值Ma_x，maxi为较小值Mi_x。
    • 使用循环从1到n，找到从每堆石子开始合并的最小花费和最大花费。
  5. 输出最小花费和最大花费。

总体思路是使用动态规划的方法，通过填充二维数组dp和dq，逐步计算合并不同堆数石子的最小和最大花费。最后，通过遍历所有堆的起始位置，找到合并所有石堆的最小花费和最大花费。

最小m段和

//最小m段和问题
#include <stdio.h>
#include <string.h>

#define N 410

int main() {
    int dp[N][N] = {0}; // 初始化为0
    int a[N] = {0};
    int n, m;
    scanf("%d %d", &n, &m); // 使用scanf读取输入

    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]); // 读取序列的每个元素
    }

    // 状态转移方程的初始化
    for (int i = 1; i <= n; i++) {
        dp[i][1] = dp[i - 1][1] + a[i];
    }

    // 动态规划填表过程
    for (int j = 2; j <= m; j++) {
        for (int i = j; i <= n; i++) {
            int min_val = 100005;
            for (int k = 1; k < i; k++) {
                int v = (dp[k][j - 1] > (dp[i][1] - dp[k][1])) ? dp[k][j - 1] : (dp[i][1] - dp[k][1]);
                if (v < min_val) {
                    min_val = v;
                }
            }
            dp[i][j] = min_val;
        }
    }

    // 输出结果
    printf("%d\n", dp[n][m]);

    return 0;
}

递推关系：
在这段代码中，通过以下递推关系来计算dp[i][j]，表示将前i个元素划分为j段的最小段和：

dp[i][j] = min(dp[k][j-1], dp[i][1] - dp[k][1]), 其中 1 <= k < i

边界条件：
 

for (int i = 1; i <= n; i++) {
    dp[i][1] = dp[i - 1][1] + a[i];
}

具体思想

这个递推关系的意思是，要计算dp[i][j]，需要考虑将前k个元素划分为j-1段，并将第k+1到第i个元素作为第j段的情况。然后从这些情况中选择最小的段和。

  1. 输入n和m，表示序列长度和要划分的段数。

  2. 读取序列的元素，保存在数组a中。

  3. 初始化dp数组为0，其中dp[i][j]表示将前i个元素划分为j段的最小段和。

  4. 初始化边界条件：将前缀和存储在dp数组的第一列dp[i][1]中。即dp[i][1] = dp[i-1][1] + a[i]，表示将前i个元素划分为1段时的段和。

  5. 使用动态规划填表，从2段到m段进行递推。外层循环遍历划分的段数j，内层循环遍历位置i。

    • 对于每个位置i和划分段数j，通过遍历划分点k（1 <= k < i），计算划分为j-1段的最小段和dp[k][j-1]和第j段的和dp[i][1] - dp[k][1]。选择其中较大的值作为当前位置i划分为j段的最小段和，即dp[i][j] = max(dp[k][j-1], dp[i][1] - dp[k][1])。

  6. 最终结果存储在dp[n][m]中，表示将前n个元素划分为m段的最小段和。

  7. 输出最小段和：printf("%d\n", dp[n][m])。

最大k乘积

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_DIGITS 11

int maxProduct(char *num, int k) {
    int n = strlen(num);
    if (k == 1) {
        // 如果只需要一个段，那么最大乘积就是整数本身
        return atoi(num);
    }

    // 创建一个二维数组来存储中间结果
    // dp[i][j] 表示将前 j 个数字分成 i 段的最大乘积
    int dp[k][n + 1];
    memset(dp, 0, sizeof(dp));

    for (int i = 1; i <= k; ++i) {
        for (int j = i; j <= n; ++j) {
            int maxProd = 0;
            int currentProd = 1;
            for (int end = j - 1; end >= i - 1; --end) {
                currentProd *= num[end] - '0';
                maxProd = currentProd > maxProd ? currentProd : maxProd;
                currentProd /= num[end - i + 1] - '0';
                dp[i][j] = maxProd > dp[i][j] ? maxProd : dp[i][j];
            }
        }
    }

    return dp[k][n];
}

int main() {
    FILE *inputFile = fopen("input.txt", "r");
    FILE *outputFile = fopen("output.txt", "w");
    if (inputFile == NULL || outputFile == NULL) {
        perror("File opening failed");
        return EXIT_FAILURE;
    }

    int n, k;
    fscanf(inputFile, "%d %d", &n, &k);
    char num[MAX_DIGITS];
    fscanf(inputFile, "%s", num);

    int result = maxProduct(num, k);
    fprintf(outputFile, "%d\n", result);

    fclose(inputFile);
    fclose(outputFile);
    return EXIT_SUCCESS;
}

递推关系

for (int i = 1; i <= k; ++i) {
    for (int j = i; j <= n; ++j) {
        int maxProd = 0;
        int currentProd = 1;
        for (int end = j - 1; end >= i - 1; --end) {
            currentProd *= num[end] - '0';
            maxProd = currentProd > maxProd ? currentProd : maxProd;
            currentProd /= num[end - i + 1] - '0';
            dp[i][j] = maxProd > dp[i][j] ? maxProd : dp[i][j];
        }
    }
}

边界条件

  • 当 k 等于 1 时，直接返回整数本身作为最大乘积。
  • 通过创建大小为 kx(n + 1) 的二维数组来存储中间结果，并将所有元素初始化为 0，确保在递推过程中可以正确记录最大乘积。
if (k == 1) {
    // 如果只需要一个段，那么最大乘积就是整数本身
    return atoi(num);
}
//
int dp[k][n + 1];
memset(dp, 0, sizeof(dp));

具体思想

  1. 首先，我们定义了一个二维数组 dp，其中 dp[i][j] 表示将前 j 个数字分成 i 段的最大乘积。

  2. 然后，我们通过遍历不同的段数 i 和数字范围 j，来计算出 dp[i][j] 的值。

  3. 当只需要选择一个段时（即 k 等于 1），最大乘积就是整数本身，因此直接返回整数的值。

  4. 对于其他情况，我们使用三层循环来计算 dp 数组的值。

  5. 外层循环遍历不同的段数 i，从 1 到 k。

  6. 内层循环遍历不同的数字范围 j，从 i 到整数的长度 n。

  7. 在内层循环中，我们使用一个更小的循环来遍历当前数字范围内的所有可能的分段方式。

  8. 我们使用变量 maxProd 来记录当前分段内的最大乘积，初始值为 0。

  9. 我们使用变量 currentProd 来记录当前正在计算的分段的乘积，初始值为 1。

  10. 通过遍历当前数字范围内的所有可能的结束位置，我们逐步计算出不同分段的乘积，并更新 maxProd 为当前的最大乘积。

  11. 为了计算下一个起始位置的乘积，我们将 currentProd 除以当前分段的第一个数字。

  12. 将当前的最大乘积 maxProd 更新到 dp[i][j] 中。

  13. 最终，返回 dp[k][n] 即为将整数分成 k 段的最大乘积。

通过使用动态规划思想，我们通过从小到大的段数和数字范围，逐步计算出最大乘积，并将中间结果存储在 dp 数组中。这样可以避免重复计算，并且可以通过查表的方式获取最终的最大乘积值。

字符串比较

//字符串比较
#include <stdio.h>
#include <string.h>

const int N = 505;

int f[N][N]; // 声明一个二维数组
char a[N], b[N];
int k;

// 自定义 min 函数
int min(int a, int b) {
    return a < b ? a : b;
}

// 自定义 abs 函数，用于字符
int char_abs(char a, char b) {
    return a > b ? a - b : b - a;
}

int main(void) {
    scanf("%s %s %d", a, b, &k);
    int len_a = strlen(a);
    int len_b = strlen(b);

    // 初始化二维数组 f
    for (int i = 0; i <= len_a; i++) {
        for (int j = 0; j <= len_b; j++) {
            f[i][j] = k * (i + j);
        }
    }

    // 动态规划填表
    for (int i = 1; i <= len_a; i++) {
        for (int j = 1; j <= len_b; j++) {
            f[i][j] = min(min(f[i - 1][j], f[i][j - 1]) + k, f[i - 1][j - 1] + char_abs(a[i - 1], b[j - 1]));
        }
    }

    printf("%d\n", f[len_a][len_b]);

    return 0;
}

递推关系

// 动态规划填表
for (int i = 1; i <= len_a; i++) {
    for (int j = 1; j <= len_b; j++) {
        f[i][j] = min(min(f[i - 1][j], f[i][j - 1]) + k, f[i - 1][j - 1] + char_abs(a[i - 1], b[j - 1]));
    }
}

边界条件

// 初始化二维数组 f
for (int i = 0; i <= len_a; i++) {
    for (int j = 0; j <= len_b; j++) {
        f[i][j] = k * (i + j);
    }
}

数字三角形

#include <stdio.h>

#define MAXN 100

int n;
int D[MAXN][MAXN];
int maxSum[MAXN][MAXN];
int id = 1;

int fun(int i, int j) {
    int x, y;
    if (maxSum[i][j] != -1) { // 如果之前有计算过，直接取记录好的数，避免进行多次计算
        return maxSum[i][j];
    }

    if (i == n) { // 如果i到数组的底部最后一行，那么最大和就是它本身那个数
        maxSum[i][j] = D[i][j];
    } else {
        x = fun(i + 1, j);
        y = fun(i + 1, j + 1);
        maxSum[i][j] = (x > y) ? x + D[i][j] : y + D[i][j];
    }
    return maxSum[i][j];
}

int main() {
    int i, j;
    while (scanf("%d", &n) == 1) { // 读取n，直到输入失败
        for (i = 0; i < n; i++) {
            for (j = 0; j < i + 1; j++) {
                scanf("%d", &D[i][j]);
                maxSum[i][j] = -1; // 标记每个数的最大值为-1
            }
        }
        printf("Triangle #%d: %d\n", id++, fun(0, 0));
    }
    return 0;
}

递推

int fun(int i, int j) {
    int x, y;
    if (maxSum[i][j] != -1) {
        return maxSum[i][j];
    }

    if (i == n) {
        maxSum[i][j] = D[i][j];
    } else {
        x = fun(i + 1, j);
        y = fun(i + 1, j + 1);
        maxSum[i][j] = (x > y) ? x + D[i][j] : y + D[i][j];
    }
    return maxSum[i][j];
}

边界条件

if (i == n) {
    maxSum[i][j] = D[i][j];
}

乘法表

#include <stdio.h>
#include <string.h>

#define MAXN 50

int result[MAXN][MAXN][3];

// 自定义最小值函数
int min(int a, int b) {
    return a < b ? a : b;
}

int main() {
    char str[MAXN];
    int n;

    scanf("%s", str); // 读取字符串
    n = strlen(str);

    // 初始化整个三维数组为0
    memset(result, 0, sizeof(result));

    // 相当于是求边界的值
    for (int i = 0; i < n; ++i) {
        if (str[i] == 'a') result[i + 1][i + 1][0] = 1;
        if (str[i] == 'b') result[i + 1][i + 1][1] = 1;
        if (str[i] == 'c') result[i + 1][i + 1][2] = 1;
    }

    // 区间长度
    for (int r = 2; r <= n; ++r) {
        // 区间起始
        for (int i = 0; i <= n - r; ++i) {
            int j = i + r - 1;
            for (int k = i; k < j; k++) { // k表示分割的位置
                result[i + 1][j + 1][0] += result[i + 1][k + 1][0] * result[k + 2][j + 1][2] + result[i + 1][k + 1][1] * result[k + 2][j + 1][2] + result[i + 1][k + 1][2] * result[k + 2][j + 1][0];
                result[i + 1][j + 1][1] += result[i + 1][k + 1][0] * result[k + 2][j + 1][0] + result[i + 1][k + 1][0] * result[k + 2][j + 1][1] + result[i + 1][k + 1][1] * result[k + 2][j + 1][1];
                result[i + 1][j + 1][2] += result[i + 1][k + 1][1] * result[k + 2][j + 1][0] + result[i + 1][k + 1][2] * result[k + 2][j + 1][1] + result[i + 1][k + 1][2] * result[k + 2][j + 1][2];
            }
        }
    }

    printf("%d\n", result[1][n][0]);
    return 0;
}

 递推

for (int r = 2; r <= n; ++r) {
    for (int i = 0; i <= n - r; ++i) {
        int j = i + r - 1;
        for (int k = i; k < j; k++) {
            result[i + 1][j + 1][0] += result[i + 1][k + 1][0] * result[k + 2][j + 1][2] + result[i + 1][k + 1][1] * result[k + 2][j + 1][2] + result[i + 1][k + 1][2] * result[k + 2][j + 1][0];
            result[i + 1][j + 1][1] += result[i + 1][k + 1][0] * result[k + 2][j + 1][0] + result[i + 1][k + 1][0] * result[k + 2][j + 1][1] + result[i + 1][k + 1][1] * result[k + 2][j + 1][1];
            result[i + 1][j + 1][2] += result[i + 1][k + 1][1] * result[k + 2][j + 1][0] + result[i + 1][k + 1][2] * result[k + 2][j + 1][1] + result[i + 1][k + 1][2] * result[k + 2][j + 1][2];
        }
    }
}

边界条件

for (int i = 0; i < n; ++i) {
    if (str[i] == 'a') result[i + 1][i + 1][0] = 1;
    if (str[i] == 'b') result[i + 1][i + 1][1] = 1;
    if (str[i] == 'c') result[i + 1][i + 1][2] = 1;
}

租用游艇

#include <stdio.h>
#include <math.h>

#define MAXN 100

int r[MAXN][MAXN]; // r[i][j] 是第 i 站到第 j 站的费用
int n; // n 站
int cost[MAXN][MAXN]; // cost[i][j] 是第 i 站到第 j 站的最小费用
int costt[MAXN]; // costt[i] 是第 1 站到第 i 站的最小费用

// 自定义 min 函数
int min(int a, int b) {
    return a < b ? a : b;
}

int dp1() {
    int i, j, k, t;
    for (i = 1; i < n; i++) {
        for (j = i + 2; j <= n; j++) {
            t = 99999;
            for (k = i + 1; k < j; k++) {
                t = min(t, cost[i][k] + cost[k][j]);
            }
            cost[i][j] = min(t, r[i][j]);
        }
    }
    printf("方法：%d\n", cost[1][n]);
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            scanf("%d", &r[i][j]);
            cost[i][j] = r[i][j];
        }
    }
    dp1();

    return 0;
}

递推

for (i = 1; i < n; i++) {
    for (j = i + 2; j <= n; j++) {
        t = 99999;
        for (k = i + 1; k < j; k++) {
            t = min(t, cost[i][k] + cost[k][j]);
        }
        cost[i][j] = min(t, r[i][j]);
    }
}

边界条件

for (int i = 1; i < n; i++) {
    for (int j = i + 1; j <= n; j++) {
        scanf("%d", &r[i][j]);
        cost[i][j] = r[i][j];
    }
}

m处理器

#include <stdio.h>
#include <math.h>

#define N 10010

int n, m;
double ans;
int a[N], sum[N];
double dp[N][N]; // dp[i][j] 表示前i个数据包被划分成j段的max{f(rm,rm+1)} 0<=m<=j-1
double f[N][N];

// 自定义 min 函数
double min(double a, double b) {
    return a < b ? a : b;
}

// 自定义 max 函数
double max(double a, double b) {
    return a > b ? a : b;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        sum[i] = sum[i - 1] + pow(a[i], 2);
    }
    for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            f[i][j] = sqrt(sum[j] - sum[i - 1]);
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            dp[i][j] = 9999;
        }
    }
    for (int i = 1; i <= n; i++) {
        dp[i][1] = f[1][i];
        for (int j = 2; j <= min(m, i); j++) {
            for (int k = j - 1; k < i; k++) {
                dp[i][j] = min(dp[i][j], max(dp[k][j - 1], f[k + 1][i]));
            }
        }
    }
    printf("%.3f", dp[n][m]);
    return 0;
}

 递推关系

for (int i = 1; i <= n; i++) {
    dp[i][1] = f[1][i];
    for (int j = 2; j <= min(m, i); j++) {
        for (int k = j - 1; k < i; k++) {
            dp[i][j] = min(dp[i][j], max(dp[k][j - 1], f[k + 1][i]));
        }
    }
}

 边界条件

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

 活动安排

背包问题

最优装载问题

哈夫曼编码

空

空

多机调度问题

秦淮的小迷妹
关注
算法学习——3.动态规划（缓慢更新
weixin_47787789的博客
11-01 218
最长递增子序列 设计思想： O（n2）：暴力 状态转移方程： d[i]= max(d[i],d[j]+1) s[j]<s[i] 1 else 物理意义：d[i]代表截止位置到i的最长递增子序列 O（nlogn）：二分（查找位置）+贪心，指另需要一个O(n)大小的数组来存储它的递增子序列，并保证这个数组是严格递增的，最后这个数组的大小就是最长递增子序列。（此方法只能求长度） 石子合并 设计思想：将圆环还原成链，数组扩充至两倍大小，实现首尾相连。 状...
第13期：动态规划-dp题集
qq_57351574的博客
03-23 1367
1 P7972 [KSN2021] Self Permutation
动态规划 解决石子合并问题
04-29
动态规划 解决石子合并问题 在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。规定每次只 能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。 编程任务： 对于给定n堆石子, 编程计算合并成一堆的最小得分和最大得分。
石子合并问题（动态规划）
热门推荐
m0_52124992的博客
03-29 1万+
动态规划 石子合并问题
动态规划——石子合并问题
最新发布
有时候，想要一块二向箔
10-22 1184
但不同的是，动态规划是自底向上分解，并且会保存子问题的解，在需要时可直接拿过来使用，这一点是区别于分治的。这类问题存在大量重叠子问题，即子问题的解可以被多次重复利用，而这些子问题的结果依赖于更小的子问题结果。子问题划分： 为了找到最优的合并顺序，我们需要考虑如何将区间 [i, j] 划分为更小的子区间 [i, k] 和 [k+1, j]，并递归地计算它们的最优解。例如，如果我们有三堆石子 [4, 4, 5]，不同的合并顺序会导致不同的得分，总共有两种合并顺序，分别为21和22。
石子合并（动态规划）
qq_56866469的博客
01-10 845
题目描述  N堆石子摆成一条线。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将N堆石子合并成一堆的最小代价。  例如： 1 2 3 4，有不少合并方法  1 2 3 4 => 3 3 4(3) => 6 4(9) => 10(19)  1 2 3 4 => 1 5 4(5) => 1 9(14) => 10(24)  1 2 3 4 => 1 2 7(7) => 3 7(10) =>
动态规划--石子合并
计算机科学与技术专业学生的成长之路
01-15 525
假期 2020.01.15 题目描述 沿着一条直线，摆放N堆石子，每一堆的石子的数目不一，规定每次只能移动相邻的两堆石子合并，合并花费为新合成的一堆石子的数量，求将这N堆石子合并成一堆的总花费的最大值以及最小值。 问题分析 这个问题考虑后，可以有两种方法解决，一种是采用贪心算法解决问题，一种是采取动态规划的问题解决问题，但是经过验证可知，贪心算法并不能准确计算出最大值与最小值，因此，此处采用...
第3章动态规划实验.zip
04-12
在本实验中，我们将深入探讨动态规划这一重要的算法思想，主要涵盖了五个具体的问题：最大k乘积问题、独立任务最优调度问题、最小m段和问题、字符串比较问题以及石子合并问题。动态规划是一种用于解决最优化问题的...
动态规划：关键状态转移方程解析与实例
4. **石子合并与多边形剖分** (Polygon Partitioning): 分别涉及F[i,j]:= min(f[i,k]+f[k+1,j]+sum[i,j]) 和 F[I,j]:= min(f[i,k]+f[k,j]+a[k]*a[j]*a[i])，目的是找到最小代价或最优分割方案。 5. **乘积最大值...
动态规划石子合并问题
10-25
在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。源代码
石子合并问题的 动态规划解法
12-05
王晓东版 //--石子合并问题 /*问题描述：在一个圆形操场的四周摆放着n堆石子，先要将石子有序的合并为一堆。规定每次只能选相邻的石子合并成一堆，并将新一堆的石子数 记录为该次合并的得分。试设计一个算法，记录n堆石子合并的最大和最小得分。 数据输入：由文件input.txt输入，第一行是正整数n，表示有n堆石子。第二行有n个正整数，分别表示每堆石子的个数， 结果输出：将计算结果输出到文件output.txt中，文件中第一行是最小得分，第二行是最大得分 解题思路：类似于矩阵连乘问题，可以用动态规划的方法来解决： （1）定义一个n*n的数组A来存储合并石子的最小合并方式，由一开始的只有两堆石子要合并慢慢向上递归得到n堆石子合并的最小得分。 （2)定义另一个于A同秩的矩阵B来存储各个合并中间的剖分 */
C语言实现的算法实验：递归、回溯、搜索与动态规划
实验内容包括经典算法如二分查找、合并排序、快速排序，以及各种应用问题如0-1背包问题、8皇后问题、动态规划的石子合并等。" 实验一：递归与分治 递归算法是一种自顶向下的解决问题方法，它将大问题分解为小问题...
【动态规划】石子合并问题
Coco416的博客
12-07 1125
1、算法总体思路类似于矩阵连乘问题，可以用dp[i][j]表示：合并第i堆到第j堆的最少得分2、但它们之间最大的区别是：此题为一个圆形操场——首尾相接，第一堆和最后一堆也是相邻的。故需要增加一维数据分别记录两种合并情况，如下图：3.最后枚举最后两堆的合并情况得到最小得分 4.生成测试数据 5.不同规模数据实验的时间对比 计时方式: 6.时间复杂度分析 最多三层循环O(n3)
动态规划专题之石子合并
QiaoRuoZhuo的专栏
06-27 522
动态规划专题讲义 专题九：合并石子问题 /* Name: 动态规划专题之石子合并 Author: 巧若拙 Description: 在一个操场上摆放着一排N堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。 试设计一个算法，计算出将N堆石子合并成一堆的最小得分。 输入描述 Input Description 第一行是...
合并石子----动态规划
weixin_60360239的博客
12-13 308
Description 在操场上沿一直线排列着 n堆石子。现要将石子有次序地合并成一堆。规定每次只能选相邻的两堆石子合并成新的一堆， 并将新的一堆石子数记为该次合并的得分。允许在第一次合并前对调一次相邻两堆石子的次序。 计算在上述条件下将n堆石子合并成一堆的最小得分。 Input 输入数据共有二行，其中，第1行是石子堆数n≤100； 第2行是顺序排列的各堆石子数（≤20），每两个数之间用空格分隔。 Output 输出合并的最小得分。 Sample Input 3 2 5 1 Sample
动态规划-石子合并
HeBizhi1997的博客
07-02 357
动态规划比递归要复杂很多，为了让自己不忘记，还是决定在这个程序中将思考过程写一下，因为发现动态规划类的思考过程其实大同小异。问题分析操场玩法情况下  假设有6堆石子，数量分为3，4，6，5，4，2最初想到用贪心算法思想去看2+3=55+4=95+4=99+6=1515+9=24总计算量=5+9+9+15+24=62看上去挺完美的，哈哈接下来就是神奇的地方：3+4=77+6=134+2=65+6=1...
【动态规划】石子合并
xuhaoran1的博客
01-14 711
【动态规划】石子合并
石子合并问题动态规划
08-13
石子合并问题是一个经典的动态规划问题。假设有n堆石子，每堆石子的数量为a1, a2, ..., an。每次可以选择相邻的两堆石子合并，并的代价为两堆石子的数量之和。目标是通过一系列合并操作，使得最终只剩下一堆石子，并且合并的总代价最小。 我们可以使用动态规划来解决这个问题。我们定义一个二维数组dp，其中dp[i][j]表示合并第i堆到第j堆石子所需要的最小代价。初始时，所有的dp[i][i]都为0，因为一堆石子无需合并。 然后，我们可以通过填充dp数组的方式，自底向上地计算出最小代价。假设我们要计算dp[i][j]，我们可以枚举中间分割点k，将石子分成两部分：第i堆到第k堆和第k+1堆到第j堆。这样，我们可以得到两部分的最小代价，即dp[i][k]和dp[k+1][j]。然后，我们再加上将这两部分合并的代价，即a[i]+a[i+1]+...+a[j]。最后，我们选择使得总代价最小的分割点k，即可得到dp[i][j]的最小代价。 最终，我们可以得到dp[1][n]，即合并所有石子所需的最小代价。 这就是石子合并问题的动态规划解法。希望可以帮到你！如果有任何问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值