关于动态规划算法的总结

 

动态规划算法，在T大某位老师的书中说就是递推+重复子问题。

动态规划算法的效率主要与重复子问题的处理有关。

 

典型的题目有 陪审团，最大公共子串问题

 

1，最大公共子串问题

 

这个是动态规划的基础题目。动态规划就是递推和重复子结构。

确定了递推关系后。找到一个能极大地减少重复运算的子结构至关重要。选的好了，时间效率会很好。

这个问题，不妨设第一个串为a，长度为n，第二个串为b，长度m。那么最长的子序列长度为f（n,m）

当a[n]=a[m]时

f(n,m)=1+f(n-1,m-1)

否则f(n,m)=max(f(n-1),f(m-1))

同时建立一个存储计算过的f（x,y)的矩阵，如果计算过了就直接使用

程序如下所示

 

#include #define MAXLen 1000 char seq1[MAXLen]; char seq2[MAXLen]; int maxLen[MAXLen][MAXLen]; int MaxCommonMain() { while(scanf("%s%s",seq1+1,seq2+1)>0) { int length1=strlen(seq1+1); int length2=strlen(seq2+1); for(int i=0;i<=length1;i++) maxLen[i][0]=0; for(int j=0;j<=length2;j++) maxLen[0][j]=0; for(int i=1;i<=length1;i++) { for(int j=1;j<=length2;j++) { if(seq1[i]==seq2[j]) maxLen[i][j]=maxLen[i-1][j-1]+1; else maxLen[i][j]=maxLen[i-1][j]>maxLen[i][j-1]?maxLen[i-1][j]:maxLen[i][j-1]; } } printf("%d/n",maxLen[length1][length2]); // printf("%d",maxLen[length2-1][length1-1]); } return 0; }  

 

2，陪审团问题

问题描述：

问题描述
在遥远的国家佛罗布尼亚，嫌犯是否有罪，须由陪审团决定。陪审团是由法官从公众中
挑选的。先随机挑选n 个人作为陪审团的候选人，然后再从这n 个人中选m 人组成陪审团。
选m 人的办法是：
控方和辩方会根据对候选人的喜欢程度，给所有候选人打分，分值从0 到20。为了公
平起见，法官选出陪审团的原则是：选出的m 个人，必须满足辩方总分和控方总分的差的
绝对值最小。如果有多种选择方案的辩方总分和控方总分的之差的绝对值相同，那么选辩控
双方总分之和最大的方案即可。最终选出的方案称为陪审团方案。
输入数据
输入包含多组数据。每组数据的第一行是两个整数n 和m，n 是候选人数目，m 是陪审
团人数。注意，1<=n<=200, 1<=m<=20 而且 m<=n。接下来的n 行，每行表示一个候选人
的信息，它包含2 个整数，先后是控方和辩方对该候选人的打分。候选人按出现的先后从1
开始编号。两组有效数据之间以空行分隔。最后一组数据n=m=0
输出要求
对每组数据，先输出一行，表示答案所属的组号, 如 'Jury #1', 'Jury #2', 等。接下来的
一行要象例子那样输出陪审团的控方总分和辩方总分。再下来一行要以升序输出陪审团里每
个成员的编号，两个成员编号之间用空格分隔。每组输出数据须以一个空行结束。
输入样例
4 2
1 2
2 3
4 1
6 2
0 0
输出样例
Jury #1
Best jury has value 6 for prosecution and value 4 for defence:
2 3

 

用动态规划来解

动态规划可以看成是重复子问题+递归

设p为控方向量，d为辩方向量

评分从-400到400
f（j，k）为选取第j个人，评分差为k的辩控总分
对于任意的i，i大于0小于n，则有
f(j,k)=f(j-1+1,x+p[i]-d[i])
则就有
f(j,k)=f(j-1,x)+p[i]+d[i];

如果新的f（j,k)大于旧的，则替换旧的，否则不替换

初始值为k=0，在程序中或许是某个值，以免避免序号k出现负值。
那么初始的f（0,0）=0；
在第一轮的时候只有辩控差为0的合理
对所有的候选人做
f（1，p[i]-d[i])=max(f(1,p[i]-d[i]),f(0,0)+p[i]+d[i]);
这样就可以完成选一个人的操作。
做完之后离k=0最近的非负的就是我们要的最大的辩控和。下标就是辩控差。
同理，如果选两个的话，第二轮
k=-400~400
如果f（1，k）合理（此时，只有在第一轮中算出来的合理）
f(2，k+p[i]-d[i])=max(f(2,k+p[i]-d[i]),f(1,k)+p[i]+d[i]);

如果要保存搜索得到的路径
设路径path保存路径向量
path（j,k）保存推荐第j个陪审员时候，辩控差为k的候选人。
对应上面的f函数，初始值都设为0。
如果只找一个候选人
则本身path中没有任何的值，即没有推荐任何的人。也就是说，推荐第一个人的时候，谁都可以（若推荐第二个人，则以前推荐过的不能再次推荐）
在推荐第一个候选人的时候，只管保存path[0][p[i]-d[i]]=i ;

当选取多个候选人的时候，在更新f(j,k)的同时更新path，因为更新f（j,k）的同时，意味着选了新的候选人，所以需要更新路径

当以上都做完之后，
定义一个数组result来取路径
对i:1~m
 result[i]=path[m-i+1][k];
 k=k-p[result[i]]+d[result[i]];
这样就都解决了。

#include #include #include int p[300]; int d[300]; int path[30][1000]; int f[30][1000]; int result[30]; int compareInt(const void *el, const void *e2) { return *((int *)el)-*((int *)e2); } int jurymain() { int n,m; scanf("%d%d",&n,&m); int no=0; int i=0; while(n+m)//n=0,m=0结束条件 { no++; for(i=1;i<=n;i++) scanf("%d%d",&p[i],&d[i]); memset(f,-1,sizeof(f)); memset(path,0,sizeof(path)); int minD=20*m; f[0][minD]=0; for(int j=0;j=0) { i=1; int temp1; int temp2; for(;i<=n;i++) { if(f[j][k]+p[i]+d[i]>f[j+1][k+p[i]-d[i]]) { temp1=j; temp2=k; while(temp1>0&&path[temp1][temp2]!=i) { temp2=temp2-p[path[temp1][temp2]]+d[path[temp1][temp2]]; temp1--; } if(temp1==0) { f[j+1][k+p[i]-d[i]]=f[j][k]+p[i]+d[i]; path[j+1][k+p[i]-d[i]]=i; } } } } } } i=minD; int j=0; int k=0; while(f[m][i+j]<0&&f[m][i-j]<0) j++; if(f[m][i+j]>f[m][i-j]) k=i+j; else k=i-j; printf("Jury #%d/n",no); printf("Best jury has value %d for prosecution and value %d for defence:/n",(k-minD+f[m][k])/2,(minD-k+f[m][k])/2); for(i=1;i<=m;i++) { result[i]=path[m-i+1][k]; k-=p[result[i]]-d[result[i]]; // std::cout<<"result "<

3，小花店问题

F束花从左到右放在V个花瓶里面（1<=F<=V<=100)，花要按照花的标志数从小到大排列。不同的花在不同的花瓶能够产生不同的美学价值。v[i,j]来表示第i朵花在第j个花瓶产生的美学价值。求把n朵花放在m个花瓶能够产生的最大的美学价值。

这个题和最大公共子串的思考角度相似。由于花必须要小于等于瓶子。而且花的编号由小到大，不能乱序。例如就不能把出现【2，4】 【1，5】这种现象。也就是说插在花瓶中的花按照花瓶的顺序，序号升序排列。

  不妨用f(i,j)来表示把前i朵花插入前个瓶子中。当i=j时，f(i,j)=v[1,1]+v[2,2]+...+v[i,i];

当i=0时，f(0,j)=0; 当i!=j, 且i!=0时f(i,j)=max(f(i,j-1),f(i-1,j-1)+v[i,j]) ,i<=j-1.

#include #include void getMaxValue(int **f,int **v,int m,int n) { for(int j=1;j<=m;j++) { for(int i=1;i<=j-1;i++) { if(f[i-1][j-1]+v[i][j]>f[i][j-1]) f[i][j]=f[i-1][j-1]+v[i][j]; else f[i][j]=f[i][j-1]; } } } int main() { int n,m; scanf("%d%d",&n,&m); int **v=new int[n+1][m+1]; int **f=new int[n+1][m+1]; v[0][0]=0; for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("$d",v[i][j]); for(int j=0;j<=m;j++) v[0][j]=0; int tempSum=0; for(int i=0;i<=n;i++) { sum+=v[i][i]; f[i][i]=sum; } getMaxValue(f,v,m,n); delete(v); return 0; }

 

 4,最佳旅行线问题

简单描述：某航空公司给的奖品，一张免费的机票。可以从最西边的一个城市出发，必须到达最东边的一个城市，然后返回起点城市。每个城市职能经过一次，起点被访问2次。问最多能够访问多少个城市。

这个题可以使用动态规划的方法。这个题目也使我想起了《算法导论》中装配线的问题，其实基本是一致的。

在很多的书或者是解法中，都用了这样的方法：从起点开始，两条路一起走f[i,j]表示两条不相交的路线分别到达i和j时，所需乘坐航线的最大值

f(1,1)=0;

f(i,j)= max{f(k,j)}+1,i>j ;k是i的前驱节点。

         max{f(i,k)}+1,i

f(i,i)无意义

该算法是没有错的。很多地方也用这个算法做了一些程序版本。但是这个算法有一个限制，就是前驱节点。在t大某位老师的书中，他枚举所有的点对，然后对f矩阵进行更新（传统的动态规划方法）。但是他这个有一个前提，那就是所有节点的序号符合拓扑序列。但是题目中并没有说城市符合拓扑序列。假如说序号比较随意，t大的这本书中的就错了。但是他并没有在代码中说明，算是对读者的一个误导。

#ifndef TICKETAWARD_H #define TICKETAWARD_H class TicketAward { int *b;//度数 int **g;//g(i,j)表示第i个点的第j个孩子 int **f;//函数f int n;//总共有n个节点 public: TicketAward(); int max(int x,int y); }; #endif  

#include "stdafx.h" #include #include "TicketAward.h" TicketAward::TicketAward() { std::cin>>n; g=new int *[n+1]; b=new int[n+1]; f=new int*[n+1]; for(int i=1;i<=n;i++) { g[i]=new int[n+1]; f[i]=new int[n+1]; b[i]=0; for(int j=1;j<=n;j++) { } } int temp=0; for(int i=1;i<=n;i++) { std::cin>>temp;//输入i的第一个孩子，如果不为0，即就是存在孩子节点，则继续 while(temp!=0) { b[i]++; g[i][b[i]]=temp; std::cin>>temp; } } f[1][1]=0; for(int i=1;i<=n;i++) { for(int j=1;j<=b[i];j++) { if(i==j==1) continue; if(ij) for(int k=1;k<=b[j];k++) { f[i][j]=max(f[i][j],(f[g[j][k]][j]+1)); } } } std::cout<<(f[n][n]-2); } int TicketAward::max(int x, int y) { return x>y?x:y; }  

 

 

5, 最长词链问题

给定一个仅仅包含小写字母的英文单词表，其中每个单词至少包含一个字母，最多包含75个字母，且按照字典序排列。所有单词包含的单词个数之和不超过200w

     如果在一张由一个单词或者多个单词组成的表中，每个单词都被其后的一个单词所包含，则成此表为一个链。

     现在要求从单词表中找到一个包含单词书最多的最长词链。

该问题可以由动态规划解。这让我想起了一个题：在一个连续的长字符串中，找出匹配次数最多的一个词组，不能有重叠。相同的方法。

令F（k）表示第k个单词的时候的最长的链。则F（k）=maxF（i）+1，i从1，到k-1，并且第i个单词是第k个的前缀。这儿问题就解了。

但是，对于这道题还有其他的解法。由于字典序并非乱序。每个单词的前一个单词所包含的前缀很可能就是这个单词的前缀，并且前一个单词也可能就是该单词的前缀。因为前缀的特殊性。所以只用检查前一个单词的前缀（包括该单词本身）就能找出该前缀链

代码为非动态规划算法

#include "stdafx.h" #ifndef MOSTLENGTHLETTER_H #define MOSTLENGTHLETTER_H #include #include struct Pnode { int len; Pnode *next[26]; }; struct MostLengthLetters { public: MostLengthLetters() { for(int i=0;i<=25;i++) { root.next[i]=NULL; } ans=0; std::cout<<"please input the num of words"<>wordsNum; this->getWords(); } void getWords(); void update(std::string temp); int wordsNum; Pnode root; int ans; }; void MostLengthLetters::getWords() { std::string temp; for(int i=0;iwordsNum;i++) { std::cin>>temp; this->update(temp); } } void MostLengthLetters::update(std::string temp) { int len=temp.length(); Pnode p=root; int max=0; int i=1; int tempInt=0; while(ilen=0; for(int j=0;j<=25;j++) { node->next[j]=NULL; } } if(maxans=p.len; return; } #endif

6, 整数划分问题

给定一个自然数，分成k部分，A1，A2..的数的和，要求A1<=A2...求有多少种？

 

 

原理：整数n拆分成最多不超过m个数的和的拆分数，和n 拆分成最大不超过m的拆分数相等。

根据这个原理，原问题就转化成了求最大拆分为k的拆分个数与最大拆分为k-1的拆分个数的差

f(n,k)=f(n,k-1)+f(n-k,k)。

#include "stdafx.h" #ifndef SPLITTOKNUM_H #define SPLITTOKNUM_H #include #include #define MaxN 100 class SplitToKNum { public: SplitToKNum() { std::cin>>n; std::cin>>k; memset(f,0,sizeof(f)); for(int i=1;i<=k;i++) { f[MaxN][i]=1; } for(int j=1;j<=k;j++) for(int i=MaxN+1;i<=MaxN+n;i++) f[i][j]=f[i][j-1]+f[i-j][j]; std::cout<

同时附上ferrer图的几个原理：

a，整数n拆分成k个数的和的拆分数，和数n拆分最大数位k的拆分数相等

b，整数n拆分成最多不超过m个数的和的拆分数，和n拆分成最大不超过m的拆分数相等。

c，整数n拆分成互不相同的若干奇数的和的的拆分数,和n拆分成自共轭的Ferrers图像的拆分数相等.

7,青蛙的烦恼

池塘里面有n片荷花，正好形成一个凸多边形，按照顺时针方向将这n片和也顺次编号为1，2，3，4，5...，n。一只青蛙想要跳过这些荷叶，每个只能跳过一次，希望跳过的距离最短。

输入荷叶数n，每片荷叶的坐标xy，输出最短距离。

分析：凸多边形，首先不能出现交叉路，否则，由两边之和大于第三边可以知道，这样实际上是路程变长了。

其次，直接按照凸多边形也不正确，可以参考平行四边形，其中一个角为30度，请自行画图查明。

 

方法：每次每个顶点只能到与自己相邻的两个中的一个（到其他顶点边会出现交叉），剩下的n-1个顶点也遵从这一规则。则可以使用动态规划的方法。

 

从s到L

则如果从s出发，则f(s,L,0)=min{dis(s，s+1)+f(s+1,L-1,0),f(s+1,L-1,1)+dis(s+L-1,s)}

如果从s+L-1出发则f(s,L,1)=min{dis(s,s+L-1)+f(s+L-1,L-1,0),f(s+L-1,L-1,0)+dis(s+L-1,s)}

#include #include #include #define MAXN 1000 double x[MAXN];// x radix double y[MAXN]; double dis[MAXN][MAXN]; int n;// the num of double f[MAXN][2][2]; double min(double a,double b) { return a>n; for(int i=0;i>x[i]>>y[i]; } for(int i=0;i=0;i--) { if(j==1) { f[i][sign][0]=0; f[i][sign][1]=0; } else { f[i][sign][1]=min(f[(i+1)%n][1-sign][1]+dis[i][(i+1)%n],f[(i+1)%n][1-sign][0]+dis[i][(i+j-1)%n]); f[i][sign][0]=min(f[i][1-sign][1]+dis[(i+j-1)%n][i],f[i][1-sign][0]+dis[(i+j-1)%n][(i+j-2)%n]); } if(j==n) ans=min(ans,f[i][sign][1]); } } //std::cout<

 

8排列问题

 

在整数1，2，。。。，n中，有些排列满足下面的性质：该排列中除了最后一个数字以外，每个整数后面都跟有一个同它相差为1的整数。例如：N=4，排列1432满足上述性质。求，如果 任意指定p个位置的值，求最多有几个排列满足如上性质

 

这种排列满足一下两条性质

a，任何一个排列的后k位是若干连续整数的集合

b,如果一个排列的后k位（1<=k<=n)是软干连续整数组成的集合，则这个排列满足题目所述的性质。

 

动态规划的方法即可。设s为起始的数的大小，r为连续的多少数的个数

则

 

g(s,r)=g(s+1,j-1),若第1个位置为s，即倒数第j个位置为s

   g(s,j-1),若第1个位置为s+r-1，即倒数的第j个位置为s+r-1

   不确定则为上述两个之和

 

代码如下

#include #include #include class RankProgram { public: RankProgram() { std::cout<<"please input the testing data"<>n>>p; s=new int[n+2]; g=new int* [n+2]; for(int i=0;i<=n+1;i++) { g[i]=new int[n+2]; memset(g[i],0,sizeof(int)*(n+2)); g[i][1]=1; } memset(s,0,sizeof(int)*(n+2)); int tempData; int tempP; for(int i=1;i<=p;i++) { std::cin>>tempP>>tempData; s[n-tempP+1]=tempData; } for(int i=n;i>=1;i--) { for(int j=2;j<=n-i+1;j++) { if(s[j]==i) g[i][j]=g[i+1][j-1]; else if(s[j]==(i+j-1)) g[i][j]=g[i][j-1]; else g[i][j]=g[i+1][j-1]+g[i][j-1]; } } std::cout<

9，画室问题

 

实际上该题可以描述为，给定一个尺寸为N的矩阵，行和列宽度为2^N,将该矩阵分为4分，左上角不为零，其他三部分都包含零。递归定义这三部分，直到最小单位，即矩阵只有一个数，为0；

求如果让该矩阵移动一个尺寸(x，y)，两个矩阵重复部分的0的个数。

 

思考：实际上就是判断移动前和移动后对应的位置是否都为0，如果都为0，则总0个数+1。

如果移动到了左上角的位置则不加，其他三部分因为是一样的，该部分递归定义的上层+1

 

在下面的程序中，k1,k2 表示的位置，在当前区域的哪一块

a,b表示三个区域，其中左上的直接被忽略了。

kk1，kk2，表示移动到的了哪一个区域

if(!((a+p[i-1]+k1)%2==0&&(b+q[i-1]+k2)%2==1))表示移动到的区域的哪一块，如果是左上直接忽略

 

 

#ifndef MATRIXMOVE_H #define MATRIXMOVE_H #include #include #define MAXN 101 class MatrixMove { public: MatrixMove() { std::cin>>n; memset(f,0,sizeof(f)); f[n+1][0][0]=1; f[n+1][0][1]=f[n+1][1][0]=f[n+1][1][1]=0; std::cin>>x>>y; for(int i=1;i<=n;i++) { p[n-i+1]=x%2; q[n-i+1]=y%2; x=x/2; y=y/2; } for(int i=n+1;i>=2;i--) { for(int k1=0;k1<=1;k1++) for(int k2=0;k2<=1;k2++) for(int a=0;a<=1;a++) for(int b=0;b<=1;b++) { if(!(a==0&&b==1)) { int kk1=(a+p[i-1]+k1)/2; int kk2=(b+q[i-1]+k2)/2; if(!((a+p[i-1]+k1)%2==0&&(b+q[i-1]+k2)%2==1)) { f[i-1][kk1][kk2]+=f[i][k1][k2]; } } } } std::cout<

 

10, 中世纪剑士

n个人决斗，两两之间有强弱关系，强弱关系不传递，例如a>b,b>c,c>a。n个剑士围成一个圈，一次抽签，抽中的人和他右边的人决斗，输了的人出圈。现在问是否存在一种决斗方式让第k个人生出，计算可能胜出的的人数和方案。

 

这个题目让我想起了围成一个圈的猴子的题目，那个题目是约瑟夫问题。

 

和这个不一样。

 

这个题目：一个人要胜出，则要胜了所有右边的人，同时也要胜出左边的人。因为是围成一个圈，所以该人胜出的话，最终肯定是自己跟自己相遇。那么，这种情况下，把圈展开成一个链，将该链延长一倍，如果i和i+n可以相遇，则说明i可以胜出。i人向右决斗，i+n向左决斗

 

如果两个人可以相遇，用meet[i,j]来表示

meet[i,j]= true if meet[i,k] and meet[k,j] and (e[i,k] or e[j,k])=true

false

#ifndef ACIENTSOLDIER_H #define ACIENTSOLDIER_H #include #include class AcientSoldier { public: AcientSoldier() { std::cin>>n; a=new int*[n+1]; meet=new bool*[2*n+1]; for(int i=1;i<=n;i++) { a[i]=new int[n+1]; meet[i]=new bool[2*n+1]; meet[i+n]=new bool[2*n+1]; memset(meet[i],0,sizeof(bool)*(2*n+1)); memset(meet[i+n],0,sizeof(bool)*(2*n+1)); meet[i][i+1]=true; meet[i+1][i]=true; meet[i+n][(i+n)%2+1]=true; meet[(i+n)%2+1][i+n]=true; for(int j=1;j<=n;j++) std::cin>>a[i][j]; } for(int k=1;k<=2*n;k++) for(int i=1;i<=2*n;i++) for(int j=1;j<=2*n;j++) { if((ik)&&meet[i][k]&&meet[k][j]&&a[(i-1)%n+1][(k-1)%n+1]&&a[(j-1)%n+1][(k-1)%n+1]) { meet[i][j]=true; meet[j][i]=true; } } ans=0; for(int i=1;i<=n;i++) { if(meet[i][i+n]) ans++; } std::cout<

11, 科学家实验陨石

 

总共获得了n1块A星的和n2块B星的，每次实验需要各一块，实验完了后不能回收。

总共实验min（n1,n2）；

 

求每次试验的绝对值和的最小值

 

先证明一下两个递增序列，a1

 

------a1----------------b1-------------

         - -

-

- O -

------a2----------------b2--------------

由上图根据两条边之和大于第三边可以直接证明上面的式子

 

所以就可以放心的使用动态规划了

对两列数据由小到大排序，少的用i表示，多的用j表示

F[i,j]=min(F[i,j-1],F[i-1][j-1]+dis(i,j))      j>i

  F[i-1][j-1]+dis(i,j)     j=i

 

编程暂时省略，因为这个题目比较简单

12,理想收入问题

只有一元的本金，知道每天的股价为v[i], 求M天之后的理想收入，能够获得的最大的收入

 

假设第i天的理想收入为F[i]

则有F[i]=max(F[j]/v[k])*v[i]; j<=k

令M[i]=max(F[j]/v[k])=max(M[i-1],MF[i-1]/v[i]);M[i]表示在第i天可以得到的最多股票数，MF[i-1]表示前i-1天可以取得的最大收入

MF[i]=Max(MF(i-1),F(i-1))

 

13. 一般的RMQ问题 (Range Minimum/Maximum Query)

 

对于给定的N与N个整数A[1...N]，M与M对下标(x,y)（x<=y)，对于每对下标(x,y)求出A[x...y]中最小数的下标

        解法：

                预处理，对于区间中每一个点A，设计以A为左端点的floor(logN)+1个区间

                [A,A+2^0-1], [A,A+2^1-1],...,[A, A+2^floor(logN)-1]

在求解的过程中，按照区间长度依次求解。[A,A+2^(i+1)-1]，可以通过两个等长的子区间[A,A+2^i-1]和[A+2^i,A+2^(i+1)-1];

       取用方法：

A，当区间的重叠对结果无影响的时候，例如求最大最小值（本题所述，则根据区间[A,A+2^k-1]与[B-2^k+1,B]来计算

B，当区间的重叠对结果有影响的时候，例如统计数字的多少等等，将[A,B]划分为[A,A+2^k-1],

[A+2^K,A+2^k+2^(floor(log(B-(A+2^k)+1)))-1],每次使用对数直接获得划分点。所以至多分成了floor(log(B-A+1))+1个区间。

所以这样处理的时间复杂度为logN

本题中，所述的所有对数，均是以2为底。

  本题中，开一个数组，行下标表示区间开始端A，列坐标表示区间结束端B

 

#include "stdafx.h" #include #include using namespace std; class RMQProblem { int N; int M; int *data; int **b; public: RMQProblem() { cin>>N>>M; data=new int[N+1]; b=new int*[N+1]; int tempRankNum=int(floor(log2(double(N))))+1; for(int i=1;i<=N;i++) { cin>>data[i]; b[i]=new int[tempRankNum]; b[i][0]=data[i]; } for(int j=1;j<=tempRankNum;j++) { int k=1<>tempX>>tempY; tempZ=int(floor(log2(tempY-tempX))); cout<

14, 关于分石子问题的动态规划解法

有n个石头，k个框子。把n个石头按顺序放入k个框子，比如1~3放入1，4~6放入2，要求最大重量的框子的重量最小的放法。

设石子的重量分别为Q1，Q2，...

g(i,j)=Qi+,...,+Qj;

f(i,j)表示把i个石子放到j个框的最大重量框的重量。

则f(i,j)=min_{j-1<=p (f(i,j),max(f(p,j-1),g(p+1,i)));}

g(i,i)=Q_i ,f(1,1)=g(1,1),f(i,1)=g(1,i);

1<=i<=n;

1<=j<=k;

如果提前把S_i =Q1+,..,+Qi 计算出来，g(j,k)=S_k -S_j-1 则时间复杂度为O(N² )