算法实验动态规划----矩阵连乘
10计本算法实验矩阵连乘算法
实验报告4课程数据结构与算法实验名称动态规划(一) 第页班级10计本学号105032010111 姓名陈兴灶实验日期：2012年3月20日报告退发(订正、重做)一、实验目的掌握递归及分治策略的原理和应用。
二、实验环境1、微型计算机一台2、WINDOWS操作系统，Java SDK，Eclipse开发环境三、实验内容必做题：1、编程实现矩阵连乘算法，求出最优值及一个最优解。
附加题：1、开车从a到b会经过n个加油站，给定这n个加油站的距离和油价，及汽车耗油量，汽车油箱的容量为v，编程计算从a到b至少需要花费多少油费。
四、实验步骤和结果第一题：矩阵连乘算法package shiyan4;import java.util.Scanner;public class matrixChain {public static int [][]a;public static int [][]b;public static void matrixchain(int []p,int [][]m,int [][]s){int n=p.length-1;for(int i=1;i<n;i++)m[i][i]=0;for(int r=2;r<=n;r++)for(int i=1;i<=n-r+1;i++){int j=i+r-1;m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];s[i][j]=i;for(int k=i+1;k<j;k++){int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];if(t<m[i][j]){m[i][j]=t;s[i][j]=k;}}}}public static void traceback(int [][]s,int i,int j){if(i==j)return ;traceback(s,i,s[i][j]);traceback(s,s[i][j]+1,j);System.out.println("Multiply A"+i+","+s[i][j]+" and A"+(s[i][j]+1)+","+j);}public static void main(String []args){Scanner sc=new Scanner(System.in);System.out.println("输入矩阵个数");int n=sc.nextInt();int []p=new int[n+1];a=new int [n+1][n+1];b=new int [n+1][n+1];System.out.println("输入各矩阵的行数和列数");for(int i=0;i<=n;i++)p[i]=sc.nextInt();matrixchain(p,a,b);System.out.println("最少次数为");System.out.println(a[1][a.length-1]+" ");System.out.println("最优解为");traceback(b,1,n);}}结果：第二题：计算从a到b至少需要花费多少油费package shiyan4;import java.util.Scanner;public class MinPertrolFee {public static float []fee;public static float []distance;public static float v;public static float vh;public static float vs;float money;MinPertrolFee(){Scanner sc=new Scanner(System.in);System.out.println("输入加油站个数");int n=sc.nextInt();fee=new float[n];System.out.println("输入每个加油站油的单价");distance=new float[n];for(int i=1;i<fee.length;i++)fee[i]=sc.nextFloat();System.out.println("输入两两相邻加油站间的距离");for(int i=1;i<distance.length;i++)distance[i]=sc.nextFloat();System.out.println("输入油箱容量");v=sc.nextFloat();System.out.println("输入每公里的耗油量");vh=sc.nextFloat();vs=0;money=0;}public static void minpertrolfee(MinPertrolFee e) {float s=e.v/e.vh,s2;int j,l,k;for(int i=1;i<e.fee.length;i++){float vj=e.distance[i]/e.vh-e.vs;if(vj>0){e.money+=addpertrol(vj,i);e.vs+=vj;}float s1=0;for( j=i;j<e.fee.length&&s>=s1;j++)s1+=e.distance[j];for( l=i,k=i;l<(e.fee.length-1)&&l<=j;l++) {if(e.fee[k]>=e.fee[l+1])break;else continue;}if(l==j&&j!=e.distance.length)s2=e.v/e.vh;else s2=e.distance[l]-e.distance[i];float vj1=s2/e.vh-e.vs;if(vj1>0){e.money+=addpertrol(vj1,i);e.vs+=vj1;}e.vs-=e.distance[i]/e.vh;}System.out.println("所须要最少的钱为"+e.money); }public static float addpertrol(float vj,int i) {return vj*fee[i];}public static void main(String []args){MinPertrolFee e=new MinPertrolFee();minpertrolfee(e);}}结果：五、实验总结1.第二题算法是错的。
动态规划-(矩阵连乘)
12
4、构造最优解
void MatrixChain::Traceback(int i, int j) {
if(i==j) { cout<<'A'<<i; return;} if (i<s[i][j]) cout<<'('; Traceback(i, s[i][j]); if (i<s[i][j])cout<<')'; if(s[i][j]+1<j)cout<<'('; Traceback(s[i][j]+1, j); if(s[i][j]+1<j) cout<<')'; } void MatrixChain::Traceback() { cout<<'('; Traceback(0, n-1); cout<<')'; cout<<endl; }
②当i=j时，A[i:j]=Ai，因此，m[i][i]=0，i=1,2,…,n ③当i<j时，m [ i ] j ] [ m [ i ] k ] [ m [ k 1 ] j ] [ p i 1 p k p j
这里 A i 的维数为 pi1pi
∴可以递归地定义m[i][j]为：
m [i]j] [ m i k j{ m [i]n k [ ] m [k 0 1 ]j] [ p i 1 p kp j}i i j j
根据MatrixChain动态规划算法： ②计算m[i][j]数乘次数
m[2][5]=min m[2][2]+m[3][5]+p1p2p5=13000
矩阵连乘问题（动态规划算法）
矩阵连乘问题（动态规划算法）动态规划算法思想简介：将⼀个问题分解为多个⼦问题，这点和分治法类似，但是每个⼦问题不是独⽴的⽽是相互联系的，所以我们在求解每个⼦问题的时候可能需要重复计算到其他的⼦问题，所以我们将计算过的⼦问题的解放进⼀个表中，这样就能避免了重复计算带来的耗费，这就是动态规划的基本思想；⼀般地，动态规划思想⼀般⽤来解最优化问题，主要分为以下四个步骤：（1）找出最优解的性质，并刻画其结构特征；（2）递归地定义最优值；（3）以⾃底向上的⽅式计算出最优值；（4）根据计算得到的最优值时得到的信息，构造最优解；同时，问题的最优⼦结构性质也是该问题可⽤动态规划算法求解的显著特征，这⾥的最优⼦结构性质即指：问题的最优解也即代表着它的⼦问题有了最优解；问题描述：分析过程如下：（1）分析最优⼦结构的性质：（2）分析递归关系，以及利⽤⾃底向上的⽅式进⾏计算：（3）获取最优值和最优解：代码如下：#ifndef MATRIX_CHAIN_H#define MATRIX_CHAIN_Hvoid matrix_chain(int *p, int n, int **m, int **s);void traceback(int i, int j, int **s);#endif#include <iostream>#include "matrix_chain.h"using namespace std;//利⽤动态规划算法获取最优值void matrix_chain(int *p, int n, int **m, int **s) //p:各个矩阵的列数，n：矩阵个数，m：m[i:j]矩阵i到j的相乘次数，s:对应的分开位置{for (int i = 0; i < n; i++){m[i][i] = 0;}for (int r = 2; r <= n; r++){for (int i = 0; i < n - r + 1; i++){int j = i + r - 1;m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];s[i][j] = i;for (int k = i + 1; k < j; k++){int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];if (t < m[i][j]){m[i][j] = t;s[i][j] = k;}}}}}//利⽤s[i][j]获取最优解void traceback(int i, int j, int **s){if (i == j)return;traceback(i, s[i][j], s);traceback(s[i][j] + 1, j, s);cout << "Multiply A" << i << " , " << s[i][j];cout << "and A" << (s[i][j] + 1) << " , " << j << endl;}#include <iostream>#include "matrix_chain.h"using namespace std;int main(void){int matrix_num = 0; //矩阵个数cout << "请输⼊矩阵个数：" << endl;cin >> matrix_num;int **m = new int *[matrix_num];for (int i = 0; i < matrix_num; i++)m[i] = new int[matrix_num];int **s = new int *[matrix_num];for (int i = 0; i < matrix_num; i++)s[i] = new int[matrix_num];int *p = new int[matrix_num];cout << "请输⼊各矩阵的列数：" << endl;for (int i = 0; i < matrix_num; i++){cin >> p[i];}matrix_chain(p, matrix_num, m, s);traceback(0, matrix_num - 1, s);system("pause");return1;}可结合我的另⼀篇关于贪⼼算法的博客进⾏⽐较，了解这两者的区别；。
算法设计与分析——矩阵连乘问题（动态规划）
算法设计与分析——矩阵连乘问题（动态规划）⼀、问题描述引出问题之前我们先来复习⼀下矩阵乘积的标准算法。
int ra,ca;//矩阵A的⾏数和列数int rb,cb;//矩阵B的⾏数和列数void matrixMultiply(){for(int i=0;i<ra;i++){for(int j=0;j<cb;j++){int sun=0;for(int k=0;k<=ca;k++){sum+=a[i][k]*b[k][j];}c[i][j]=sum;}}}给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1，2…，n-1。
如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。
例如，给定三个连乘矩阵{A1，A2，A3}的维数分别是10*100，100*5和5*50，采⽤（A1A2）A3，乘法次数为10*100*5+10*5*50=7500次，⽽采⽤A1（A2A3），乘法次数为100*5*50+10*100*50=75000次乘法，显然，最好的次序是（A1A2)A3，乘法次数为7500次。
加括号的⽅式对计算量有很⼤的影响，于是⾃然地提出矩阵连乘的最优计算次序问题，即对于给定的相继n个矩阵，如何确定矩阵连乘的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。
⼆、问题分析矩阵连乘也是Catalan数的⼀个常⽤的例⼦，关于时间复杂度的推算需要参考离散数学关于Catalan的内容。
下⾯考虑使⽤动态规划法解矩阵连乘积的最优计算次序问题。
1、分析最优解的结构问题的最优⼦结构性质是该问题可以⽤动态规划求解的显著特征！！！2、建⽴递归关系3、计算最优值public static void matrixChain(int n) {for (int i = 1; i <= n; i++) {m[i][i] = 0;}for (int r = 2; r <= n; r++) {//i与j的差值for (int i = 1; i <= n - r + 1; i++) {int j = i + r - 1;m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];s[i][j] = i;for (int k = i + 1; k < j; k++) {int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];if (t < m[i][j]) {m[i][j] = t;s[i][j] = k;}}}}}4、构造最优解public static void traceback(int i, int j) {if (i == j) {System.out.printf("A%d", i); // 输出是第⼏个数据return;}System.out.printf("(");traceback(i, s[i][j]);// 递归下⼀个数据System.out.printf(" x ");traceback(s[i][j] + 1, j);System.out.printf(")");}三、总结。
矩阵连乘问题实验报告
一、实验目的通过本次实验，加深对动态规划算法的理解和应用，掌握解决矩阵连乘问题的方法，提高算法分析和设计能力。
二、实验原理矩阵连乘问题是指给定n个矩阵，每个矩阵都与它的前一个矩阵可乘，求计算这些矩阵连乘积的最优计算次序，以使计算过程中所需的数乘次数最少。
由于矩阵乘法满足结合律，因此可以通过加括号的方式确定不同的计算次序。
三、实验步骤1. 问题描述：给定n个矩阵A1, A2, ..., An，其中Ai与Ai-1是可乘的。
求计算矩阵连乘积A1A2...An的最优计算次序，使得计算过程中所需的数乘次数最少。
2. 输入数据：矩阵个数n，每个矩阵的规模。
3. 输出结果：计算矩阵连乘积的最优计算次序和最少数乘次数。
4. 算法设计：- 定义一个二维数组m[i][j]，其中m[i][j]表示计算矩阵AiAi-1...Aj的最少数乘次数。
- 初始化m[i][i] = 0，因为单个矩阵无需计算。
- 对于每个子问题A[i:j]，计算m[i][j]的最小值：- 遍历k从i到j-1，将问题分解为A[i:k]和Ak+1:j，计算m[i][k]和m[k+1][j]的和，并加上k个矩阵的维度乘积。
- 取上述和的最小值作为m[i][j]的值。
5. 递归关系：- 当i = j时，m[i][j] = 0。
- 当i < j时，m[i][j] = min(m[i][k] + m[k+1][j] + p[i-1]p[k]p[j])，其中k从i到j-1，p[i-1]表示矩阵Ai-1的行数，p[j]表示矩阵Aj的列数。
6. 自底向上计算：- 从m[1][1]开始，按照递归关系计算m[1][2]，m[1][3]，...，m[1][n]。
- 然后计算m[2][3]，m[2][4]，...，m[2][n]，以此类推，直到计算m[1][n]。
7. 输出最优计算次序：- 从m[1][n]开始，根据递归关系和子问题的最优解，逐步确定每个子问题的最优计算次序，直到得到整个问题的最优计算次序。
矩阵连乘实验报告总结
一、实验背景与目的矩阵连乘问题是一个经典的算法问题，它涉及给定一系列矩阵，确定这些矩阵的最佳乘积顺序，以最小化乘法操作的次数。
本实验旨在通过动态规划算法解决矩阵连乘问题，加深对动态规划方法的理解，并提高算法分析与设计的能力。
二、实验内容与步骤1. 问题描述与理解：- 给定n个矩阵A1, A2, ..., An，其中任意两个相邻矩阵都是可乘的。
- 目标是确定计算这些矩阵连乘积的最佳顺序，以最小化所需的乘法次数。
2. 算法分析：- 使用动态规划方法，通过将问题分解为子问题并存储子问题的解来求解。
- 设定m[i, j]表示矩阵Ai到Aj的最佳乘积顺序的乘法次数。
3. 动态规划过程：- 初始化m[i, i] = 0，因为单个矩阵不需要乘法。
- 对于长度为k的矩阵序列，通过遍历所有可能的分割点，计算m[i, j]的最小值。
- 具体步骤包括：- 对于每个可能的k（1 ≤ k ≤ n-1），- 对于每个起始矩阵i（1 ≤ i ≤ n-k），- 计算m[i, i+k-1]和m[i+k, j]，- 更新m[i, j]为m[i, i+k-1] + m[i+k, j] + p[i-1] p[i] p[i+k]。
4. 代码实现：- 使用C或Java等编程语言实现动态规划算法。
- 编写辅助函数来计算矩阵的乘法次数。
三、实验结果与分析1. 实验结果：- 通过实验，成功实现了矩阵连乘问题的动态规划算法。
- 得到了计算给定矩阵序列连乘积所需的最小乘法次数。
2. 结果分析：- 动态规划方法有效地解决了矩阵连乘问题，避免了穷举法的指数级时间复杂度。
- 通过分析子问题的解，我们可以找到整个问题的最优解。
四、实验总结与反思1. 实验收获：- 加深了对动态规划方法的理解，特别是如何通过子问题的解来构建整个问题的解。
- 学会了如何将实际问题转化为动态规划问题，并使用代码实现算法。
2. 反思与展望：- 实验过程中遇到了一些挑战，如理解子问题的定义和计算最优子结构的策略。
矩阵链乘法（动态规划）
矩阵链乘法（动态规划）
⼀题意描述：
给定由n个要相乘的矩阵构成的序列（链）<A1,A2,A3,····A n>。
由于矩阵满⾜结合律（加括号⽅式表⽰结合⽅式），不同的计算⽅式导致的求出最终计算结果的代价相异，有的花的时间很少，有的⽅式所花时间很多，那么下⾯的任务就是求出算出结果所需要的最少时间及⼀个最优解。
⼆思路分析：
设p(n)表⽰⼀串n个矩阵可能的加全部括号⽅案数。
当n=1时，只有⼀个矩阵，此时p(1)=1。
当n>=2时，⼀个加全部括号的矩阵乘积等于两个加全部括号的⼦矩阵乘积的乘积，⽽且这两个⼦乘积之间的分裂可能发⽣在第k个和第k+1个矩阵之间，其中k=1，2，····，n-1;因此可以求得递归式：
1.找局部最优解：把问题：转化成两个最优⼦问题：及
2.构造递归解：
⾸先定义m[i,j]为解决⼦问题A[i....j]的最⼩计算次数，那么解决整个问题A[1,n]所花的最⼩时间为m[1,n]。
那么递归⽅程可以写成如下形式：
为了跟踪如何构造⼀个最优解我们可以定义s[i,j]为这样的⼀个k值，在该处分裂乘积后可得⼀个最优解。
3.构造函数进⾏求解
输出最优路径的函数⾃⼰编写，经过调⽤数组s[i][j]即可。
动态规划之矩阵链相乘问题（算法导论）
动态规划之矩阵链相乘问题（算法导论）问题描述：给定n个矩阵序列，(A1,A2,A3,A4,...,An). 计算他们的乘积：A1A2A3...An.由于矩阵的乘法运算符合结合律，因⽽可以通过调整计算顺序，从⽽降低计算量。
样例分析：⽐如有三个矩阵分别为：A1: 10*100,A2: 100*5,A3: 5*50假如现在按照(A1A2)A3的顺序计算需要的计算量为：10*100*5+10*5*50=7500次运算。
若按照A1(A2A3)的顺序计算，需要的计算量为：100*5*50+10*100*50=75000次运算。
上⾯两种不同的运算顺序所有的计算量相差⼗倍。
因⽽，⼀种最优的计算顺序将能很⼤程度的减少矩阵连乘的运算量。
问题解析：此问题的⽬的是寻找⼀种最优的括号化⽅案。
下⾯⽤动态规划的思想来进⾏分析：1、动态规划的第⼀步：寻找最优⼦结构。
为⽅便起见，使⽤Ai..j表⽰AiAi+1...Aj的乘积结果矩阵。
对于k(i<=k<j), 计算Ai..j所需要的计算量为：Ai..k 和 Ak+1..j 以及⼆者相乘的代价和。
2、设m[i][j]为Ai..j的最优计算顺序所要花费的代价。
则其求解公式为：if i == j, m[i][j] = 0; //因为只有⼀个矩阵时计算代码为0，即不需要计算。
m[i][j]=min{m[i][k] + m[k+1][j] + Pi-1PkPj} i<=k<j3、为了能够输出求解顺序，需要保存区间中的⼀些分割点。
假如Ai..j中的最优分割点为k，则我们使⽤s[i][j]=k。
即在Ai..j 中，分别计算Ai..k 和 Ak+1..j 所⽤的计算开销最⼩。
4、采⽤⾃底向上的表格法。
依次求解矩阵长度为2,3,...,n的最优计算顺序。
算法思想：1、对m[i][i]全部初始化为0.2、在矩阵链A1..n中，依次计算长度len为2,3,...,n的m[i][j]⼤⼩。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三：动态规划法
【实验目的】
深入理解动态规划算法的算法思想，应用动态规划算法解决实际的算法问题。
【实验性质】
验证性实验。
【实验要求】
对于下列所描述的问题，给出相应的算法描述，并完成程序实现与时间复杂度的分析。
该问题描述为：一般地，考虑矩阵A1，A2，…，An的连乘积，它们的维数分别为d0,d1,…,dn,即Ai的维数为di-1×di (1≤i≤n)。
确定这n个矩阵的乘积结合次序，使所需的总乘法次数最少。
对应于乘法次数最少的乘积结合次序为这n个矩阵的最优连乘积次序。
按给定的一组测试数据对根据算法设计的程序进行调试：6个矩阵连乘积A=A1×A2×A3×A4×A5×A6，各矩阵的维数分别为：A1：10×20，A2：20×25，A3：25×15，A4：15×5，A5：5×10，A6：10×25。
完成测试。
【算法思想及处理过程】
【程序代码】
for (i=0; i<=n-z; i++)
{
j = i + z - 1;
m[i][j] = m[i+1][j] + p[i] * p[i+1] * p[j+1];
s[i][j] = i;
for (k = i+1; k<j; k++)
{
t = m[i][k] + m[k+1][j] + p[i] * p[k+1] * p[j+1];
if (t < m[i][j])
{
m[i][j] = t;
s[i][j] = k;
}
}
}
}
void print1 (int m[][6], int s[][6],int p[])
{
int i, j;
printf ("\n\n程序所给矩阵如下:\n");
printf ("-----------------------------------------------\n");
for (i=0; i<6; i++)
printf ("A%d 矩阵: %2d X %-2d \n",i+1,p[i], p[i+1]);
printf ("\n\n-----------------------------------------------\n");
printf("矩阵的最少计算次数为：%d\n", m[0][5]);
printf ("-----------------------------------------------\n");
printf ("\n\n数乘次数: \n");
printf ("-----------------------------------------------\n");
for (i=0; i<6; i++)
{
for (j=0; j<i; j++)
printf (" ");
for (j=i; j<6; j++)
printf ("%-7d", m[i][j]);
printf ("\n");
}
printf ("-----------------------------------------------\n");
printf ("\n\n中间断点: \n");
printf ("-----------------------------------------------\n");
for (i=0; i<6; i++)
{
for (j=0; j<i; j++)
printf (" ");
for (j=i; j<6; j++)
printf ("%-7d", s[i][j]);
printf ("\n");
}
printf ("-----------------------------------------------\n"); }
void print2(int i, int n, int s[][6])
{
if (i == n)
printf (" A%d ", i);
else if (i+1 == n)
printf ("( A%d A%d )", i, n);
else {
printf (" ( ");
print2 (i, s[i][n], s);
print2 (s[i][n]+1, n, s);
printf (" ) ");
}
}
【运行结果】
【算法分析】
函数MatrixChain( )包含三重循环,循环体内的计算量为O(1) , 所以算法的时间复杂度为O(n3) ,算法的空间时间复杂度为O(n3) .
【实验总结】。