51nod 1021 石子归并 (动态规划 简单代码)

题目:

思路:动态规划,递推式子 dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1]);

      dp[i][j]表示合并第i到第j个石子需要的最少代价。sum[i]表示前i个石子的价值,sum[j] - sum[i-1]即合成两堆石子((第i到第k合并出的石子),(第k+1到第j合并出的石子))。

   

但是考虑要求1-4,

需要先求出(1-1,2-4),(1-2,3-4),(1-3,4-4)。

所以我们不能直接按横纵坐标遍历。

需要换一种遍历方式,在纸上画一画就可以知道有哪些可行的遍历方式了。

我的遍历方式是

从左往右看,对角线全是0,表示合并(i,i)的代价是0。

这种遍历方式能够保证遍历是按照逻辑上的顺序的。

代码:

#include <iostream>
using namespace std;
typedef long long ll;
#define INF 2147483647

//输入
int n;
int a[110];            

int dp[110][110];//dp[i][j]表示第i到第j堆石子合成所需的最小代价
int sum[110];    //前缀和 

int main(){
    cin >> n;
    for(int i = 1;i <= n; i++) cin >> a[i], sum[i] = sum[i-1] + a[i];
    int ans = 0;

    for(int i = 1;i <= n-1; i++){
        //(x,y)表示图上每一个箭头的起点
        int x = i;int y = i+1;
        //开始往上走(箭头方向)
        while(x >= 1){
            dp[x][y] = 2000000000;

            for(int j = x;j <= y-1; j++){
                dp[x][y] = min(dp[x][y],dp[x][j] + dp[j+1][y] + sum[y] - sum[x-1]);
            }
            x--;
        }
    }
    cout << dp[1][n] << endl;
    return 0;
} 
时间: 2024-10-02 23:23:15

51nod 1021 石子归并 (动态规划 简单代码)的相关文章

51Nod - 1021 石子归并

51Nod -  1021 石子归并 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

51nod 1021 石子归并(dp)

51nod 1021 石子归并 题解:从i到j合并的最小值:dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1]); 最后dp[1][n]即为所求结果. 1 #include<cstdio> 2 #include<algorithm> 3 #include<cstring> 4 #define CLR(a,b) memset((a),(b),sizeof((a))) 5 using name

51Nod - 1021 石子归并(区间DP)

[题目描述] 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) => 1

51nod 1021 石头归并

1021 石子归并 基准时间限制:1 秒 空间限制:131072 KB 分值: 20 难度:3级算法题  收藏  关注 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) =>

[51nod 1022] 石子归并v2 [dp+四边形不等式优化]

题面: 传送门 思路: 加强版的石子归并,现在朴素的区间dp无法解决问题了 首先我们破环成链,复制一条一样的链并粘贴到原来的链后面,变成一个2n长度的序列,在它上面dp,效率O(8n^3) 显然是过不了的,需要优化 注意:dp的转移如下:dp[i][j]=min(dp[i][k]+dp[k+1][j]+sum(i,j)),其中sum(i,j)表示i到j的价值和,满足区间单调性 因此dp[i][j]也满足区间单调性,可以用四边形不等式优化 我们令s[i][j]等于让dp[i][j]取最小值的那个K

51Nod 1022 石子归并 V2(区间DP+四边形优化)

题目链接:http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1022 题目大意: 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)

51nod 1022 石子归并 V2(四边形不等式)

分析:记dp[i][j]为从i到j合并的最小代价(顺时针,i可以大于j),sum[i][j]为从i到j的和,则dp[i][j]=min{dp[i][k-1]+dp[k][j]}+sum[i][j],(i<k<=j),直接求的话复杂度为O(n^3),会T. 四边形不等式优化:记s[i][j]为dp[i][j]取得最小值时对应的k值,则有dp[i][j]=min{dp[i][k-1]+dp[k][j]}+sum[i][j],(s[i][j-1]<=k<=s[i+1][j]),可以证明,

AC日记——石子归并 51nod 1021

石子归并 思路: 经典动态规划——归并类问题: 我们把状态划为n个,即1-n的n个长度为n个状态: 那么,每个长度为i的状态都可以由i-1个长度为i-1的状态推出: 所以,dp转移方程: dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]); 来,上代码: #include <cstdio> #include <cstring> #include <iostream> #include <algori

动态规划中的石子归并问题

一.有N堆石子,每堆的重量是w[i],可以任意选两堆合并,每次合并的花费为w[i]+w[j],问把所有石子合并成为一堆后的最小花费是多少.因为是可以任意合并,所以每次合并的时候选最小的两堆合并,贪心即可. 二.有N堆石子,每堆的重量是a[i],排成一条直线,每次只能合并相邻的两堆,直到合成一堆为止,问最后的最小花费是多少.分析:因为规定了只能合并相邻的两堆,显然不能使用贪心法.分成子问题来考虑,定义dp[i][j]表示从第i的石子合并到第j个石子的最小花费,那么dp[1][N]就是问题的解.可以