石子合并问题(矩阵连乘求解)
《算法设计与分析》实验报告实验一...
《算法设计与分析》实验报告实验一递归与分治策略应用基础学号：**************姓名：*************班级：*************日期：2014-2015学年第1学期第九周一、实验目的1、理解递归的概念和分治法的基本思想2、了解适用递归与分治策略的问题类型，并能设计相应的分治策略算法3、掌握递归与分治算法时间空间复杂度分析，以及问题复杂性分析方法二、实验内容任务：以下题目要求应用递归与分治策略设计解决方案，本次实验成绩按百分制计，完成各小题的得分如下，每小题要求算法描述准确且程序运行正确。
1、求n个元素的全排。
（30分）2、解决一个2k*2k的特殊棋牌上的L型骨牌覆盖问题。
（30分）3、设有n=2k个运动员要进行网球循环赛。
设计一个满足要求的比赛日程表。
（40分）提交结果：算法设计分析思路、源代码及其分析说明和测试运行报告。
三、设计分析四、算法描述及程序五、测试与分析六、实验总结与体会#include "iostream"using namespace std;#define N 100void Perm(int* list, int k, int m){if (k == m){for (int i=0; i<m; i++)cout << list[i] << " ";cout << endl;return;}else{for (int i=m; i<k; i++){swap(list[m], list[i]);Perm(list, k, m+1);swap(list[m], list[i]);}}}void swap(int a,int b){int temp;temp=a;a=b;b=temp;}int main(){int i,n;int a[N];cout<<"请输入排列数据总个数：";cin>>n;cout<<"请输入数据：";for(i=0;i<n;i++){cin>>a[i];}cout<<"该数据的全排列："<<endl;Perm(a,n,0);return 0;}《算法设计与分析》实验报告实验二递归与分治策略应用提高学号：**************姓名：*************班级：*************日期：2014-2015学年第1学期一、实验目的1、深入理解递归的概念和分治法的基本思想2、正确使用递归与分治策略设计相应的问题的算法3、掌握递归与分治算法时间空间复杂度分析，以及问题复杂性分析方法二、实验内容任务：从以下题目中任选一题完成，要求应用递归与分治策略设计解决方案。
动态规划-石子合并问题
动态规划-⽯⼦合并问题（1）问题描述 在⼀个圆形操场的四周摆放着 num 堆⽯⼦。
先要将⽯⼦有次序地合并成⼀堆。
规定每次只能选相邻的 2 堆⽯⼦合并成新的⼀堆，并将新的⼀堆⽯⼦数记为该次合并的耗费⼒⽓。
试设计⼀个算法，计算将 n 堆⽯⼦合并成⼀堆的最省⼒⽓数。
（2）算法思想 对于给定的 n 堆⽯⼦，当只有⼀堆时，不⽤搬，进⽽不耗费⼒⽓，然后依次计算出从 2 堆 ~ num 堆⽯⼦的最优解，并且堆数递增求最优解，依赖于上⼀步的解进⾏计算所得；（3）算法思路 此解法和矩阵连乘类似，我们知道矩阵连乘也是每次合并相邻的两个矩阵，那么⽯⼦合并可以⽤矩阵连乘的⽅式来解决。
设 dp[i][j] 表⽰第 i 到第 j 堆⽯⼦合并的最优值，sum[i][j] 表⽰第 i 到第 j 堆⽯⼦的所耗费的⼒⽓总数。
动规⽅程如下：（4）代码展⽰public class StoneMerge {/*** 记录⽯⼦堆的数量*/private static int num;/*** 记录每堆⽯⼦的重量*/private static int[] weight;/*** 记录⽯⼦堆断开的位置【便于计算局部最优解】*/private static int[][] location;/*** 记录⽯⼦堆局部最优解，以⾄于求得最终最优解【动规⽅程】*/private static int[][] dp;/*** 初始化数据*/private static void initData() {Scanner input = new Scanner(System.in);System.out.println("请输⼊⽯⼦堆数量:");num = input.nextInt();weight = new int[num];System.out.println("请输⼊每堆⽯⼦的重量:");for (int i = 0; i < weight.length; i++) {weight[i] = input.nextInt();}// 定义成 int 类型的⼆维数组，创建完每个元素直接初始化为 0dp = new int[num][num];location = new int[num][num];}/*** 计算最省最费⼒⽓值*/private static void dpFindMinStrength() {// 初始化 dp 数组for (int m = 0; m < num; m++) {dp[m][m] = 0; // ⼀堆⽯⼦，不⽤搬，耗费⼒⽓为 0}for (int r = 2; r <= num; r++) { // 从 2 堆依次到 num 堆，分别计算最优值for (int i = 0; i < num - r + 1; i++) { // 起始⽯⼦堆取值范围int j = i + r - 1; // 根据每次选取⽯⼦堆 r 和起始⽯⼦堆 i ，计算终⽌⽯⼦堆int sum = 0;for (int x = i; x <= j; x++) { // 计算从⽯⼦堆 i 到⽯⼦堆 j 合并时，最后两堆使⽤的⼒⽓总和 sumsum += weight[x];}// 根据动规⽅程，从局部最优解中计算当前从⽯⼦堆 i 到⽯⼦堆 j 合并所使⽤的的⼒⽓总和dp[i][j] = dp[i + 1][j] + sum; // 计算从 i ⽯⼦堆分开时，使⽤的⼒⽓总和location[i][j] = i; // 标记从第 i ⽯⼦堆分开位置for (int k = i + 1; k < j; k++) { // 需要统计从 k 【k ∈ (i, j)】⽯⼦堆分开，使⽤的⼒⽓总和int temp = dp[i][k] + dp[k + 1][j] + sum; // 计算从 k ⽯⼦堆分开时，使⽤的⼒⽓总和if (temp < dp[i][j]) {dp[i][j] = temp;location[i][j] = k;}}}}}/*** 输出*/private static void print() {System.out.println("动规数组【不同堆数合并⽯⼦所费⼒⽓】:");for (int i = 0; i < num; i++) {for (int j = 0; j < num; j++) {System.out.print(dp[i][j] + " ");}System.out.println();}System.out.println("不同堆数合并⽯⼦最省⼒⽓断开位置最优解:");for (int i = 0; i < num; i++) {for (int j = 0; j < num; j++) {System.out.print(location[i][j] + " ");}System.out.println();}}public static void main(String[] args) {// 初始化数据initData();// 计算最省最费⼒⽓值dpFindMinStrength();// 输出print();}}⽯⼦合并核⼼代码（5）输⼊输出请输⼊⽯⼦堆数量:4请输⼊每堆⽯⼦的重量:4 45 9动规数组【不同堆数合并⽯⼦所费⼒⽓】:0 8 21 430 0 9 270 0 0 140 0 0 0不同堆数合并⽯⼦最省⼒⽓分开位置最优解【下标从数组 0 开始分开】:0 0 1 20 0 1 20 0 0 20 0 0 0输⼊输出（6）总结 ⽯⼦合并问题完全提现了动态规划的核⼼思想，先求解⼦问题的解【⼦问题求解不相互独⽴，相互依赖】，然后从这些⼦问题的解中得到原问题的解，进⽽得到该问题的最优解。
石子合并问题
石子合并问题
石子合并问题是最经典的DP问题。
首先它有如下3种题型：
(1)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。
求将这N堆石子合并成一堆的总花费最小（或最大）。
分析：当然这种情况是最简单的情况，合并的是任意两堆，直接贪心即可，每次选择最小的两堆合并。
本问题实际上就是哈夫曼的变形。
(2)有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量。
求将这N堆石子合并成一堆的总花费最小（或最大）。
分析：我们熟悉矩阵连乘，知道矩阵连乘也是每次合并相邻的两个矩阵，那么石子合并可以用矩阵连乘的方式来解决。
设dp[i][j]表示第i到第j堆石子合并的最优值，sum[i][j]表示第i到第j 堆石子的总数量。
那么就有状态转移公式：
代码如下：（直线）
return 0;
}
(3)问题(2)的是在石子排列是直线情况下的解法，如果把石子改为环形排列，又怎么做呢？
分析：状态转移方程为：
其中有：
代码如下：（环形）
#include <stdio.h>
#include <string.h>
#define INF 10000
#define N 205
int mins[N][N];
int maxs[N][N];
int sum[N],a[N];
int minval,maxval;
int n;
int min(int a,int b)
{
return a<b?a:b;。
石子合并问题
石子合并问题在一个圆形操场的四周摆放着n堆石子。
现要将石子有次序地合并成一堆。
规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。
试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。
分析：假设有n堆石子需要合并,可以设计一个2*n-1个元素的数组来存储每堆石子的个数。
分析最优解的结构：假设有石头AiAi+1……Aj需要合并,简记为A[i,j].如果设最后一次合并发生在Ak与Ak+1之间(i<=k<j),则最后一个合并的得分为Ai……Aj堆石头的个数的总和记为totalValue(i,j).(不管你最后一次合并发生在哪个位置,totalValue(i,j)的值都是一样的)因此总的得分等于A[i,k]的得分加上A[k+1,j]的得分再加上totalValue(i,j).可以假设计算A[0,n-1]的一个最优次序所包含的计算子链A[0,k]和A[K+1,n-1]的次序也是最优的.证明:假设存在一个比计算A[0,k]的次序得分更少的次序,则用此次序来替换原来计算A[0,k]的次序,那么此时计算A[0,n-1]次序的得分就会比最优次序所得到的分数更少,这与假设相矛盾;同理可证明:计算A[0,n-1]的一个最优次序所包含的另一个计算子链A[k+1,n-1]的次序也是最优的!综上所述,此题满足最优子结构性质,因此可以用动态规划算法来求解.建立递归关系设m[i][j]表示A[i,j]的计算结果.当i=j时,表示只有一堆石头,不能合并,因此得分为零,所以m[i,j]=0;当i<j时,可利用最优子结构性质来计算m[i][j],m[i,j]=m[i,k]+m[k+1,j]+totalValue(i,j)(i<=k<j)可用矩阵连乘的最优计算次序问题来求解这题.可选用自顶向下的备忘录算法或是自底向上的动态规划算法.以下代码使用动态规划算法:[cpp]view plaincopy1.void MatrixChain(int *p,int n,int **m,int flag) //矩阵连乘算法2.{3.for(int i=0;i<n;i++)4.m[i][i]=0;5.for(int r=2;r<n;r++)6.for(int i=0;i<n-r+1;i++)7.{8.int j=i+r-1;9.int temp=totalValue(i,j,p);10.m[i][j]=m[i+1][j]+temp;11.for(int k=i+1;k<j;k++)12.{13.int t=m[i][k]+m[k+1][j]+temp;14.if(!flag) //求最小得分15.{16.if(t<m[i][j])17. m[i][j]=t;18.}19.else//求最大得分20.if(t>m[i][j])21.m[i][j]=t;22.}23.}24.}25.MatrixChain(inputNum,2*n-1,m,0); //计算最小得分26.int resultMin=m[0][n-1];27.for(i=1;i<=n-1;i++)28.if(resultMin>m[i][n-1+i])29.resultMin=m[i][n-1+i];30.31.MatrixChain(inputNum,2*n-1,m,1); //计算最大得分32.int resultMax=m[0][n-1];33.for(i=1;i<=n-1;i++)34.if(resultMax<m[i][n-1+i])35.resultMax=m[i][n-1+i];。
动态规划思想：石子合并问题
动态规划思想：⽯⼦合并问题描述：在⼀个圆形操场的四周摆放着n 堆⽯⼦。
现要将⽯⼦有次序地合并成⼀堆。
规定每次只能选相邻的2 堆⽯⼦合并成新的⼀堆，并将新的⼀堆⽯⼦数记为该次合并的得分。
试设计⼀个算法，计算出将n堆⽯⼦合并成⼀堆的最⼩得分和最⼤得分。
开始以为通过贪⼼算法可能很快解决问题，可是是⾏不通的。
⾸先我们可以把这么堆⽯⼦看成⼀列我们假如5堆的⽯⼦，其中⽯⼦数分别为7，6，5，7，100•按照贪⼼法，合并的过程如下：每次合并得分第⼀次合并 7 6 5 7 100 =11 第⼆次合并 7 11 7 100=18 第三次合并 18 7 100 =25第四次合并 25 100 =125总得分＝11＋18＋25+125＝179•另⼀种合并⽅案每次合并得分 第⼀次合并 7 6 5 7 100 ->13第⼆次合并 13 5 7 100->12第三次合并 13 12 100 ->25第四次合并 25 100 ->125总得分＝13＋12＋25+125＝175显然利⽤贪⼼来做是错误的，贪⼼算法在⼦过程中得出的解只是局部最优,⽽不能保证使得全局的值最优。
如果N－1次合并的全局最优解包含了每⼀次合并的⼦问题的最优解，那么经这样的N－1次合并后的得分总和必然是最优的。
因此我们需要通过动态规划算法来求出最优解。
在此我们假设有n堆⽯⼦，⼀字排开，合并相邻两堆的⽯⼦，每合并两堆⽯⼦得到⼀个分数，最终合并后总分数最少的。
我们设m(i,j)定义为第i堆⽯⼦到第j堆⽯⼦合并后的最少总分数。
a(i)为第i堆⽯⼦得⽯⼦数量。
当合并的⽯⼦堆为1堆时，很明显m(i,i)的分数为0; 当合并的⽯⼦堆为2堆时，m(i,i+1)的分数为a(i)+a(i+1); 当合并的⽯⼦堆为3堆时，m(i,i+2)的分数为MIN((m(i,i)+m(i+1,i+2)+sum(i,i+2)),(m(i,i+1)+m(i+2,i+2)+sum(i,i+2)); 当合并的⽯⼦堆为4堆时......代码实现如下：1 #include<stdio.h>2#define N 1003/*4 *求合并过程中5 *最少合并堆数⽬6 **/7int MatrixChain_min(int p[N],int n)8 {9//定义⼆维数组m[i][j]来记录i到j的合并过成中最少⽯⼦数⽬10 //此处赋值为-11112int m[N][N];13for(int x=1;x<=n;x++)14for(int z=1;z<=n;z++)15 {16 m[x][z]=-1;17 }1819int min=0;2021//当⼀个单独合并时，m[i][i]设为0，表⽰没有⽯⼦22for(int g = 1;g<=n;g++) m[g][g]=0;2324//当相邻的两堆⽯⼦合并时，此时的m很容易可以看出是两者之和25for(int i=1;i<=n-1;i++)26 {27int j=i+1;28 m[i][j]=p[i]+p[j];29 }3031//当相邻的3堆以及到最后的n堆时，执⾏以下循环32for(int r=3; r<=n;r++)33for(int i=1;i<=n-r+1;i++)34 {35int j = i+r-1; //j总是距离i r-1的距离36int sum=0;37//当i到j堆⽯⼦合并时最后⾥⾯的⽯⼦数求和得sum38for(int b=i;b<=j;b++)39 sum+=p[b];4041// 此时m[i][j]为i~j堆⽯⼦间以m[i][i]+m[i+1][j]+sum结果，这是其中⼀种可能，不⼀定是最优42 //要与下⾯的情况相⽐较，唉，太详细了4344 m[i][j] = m[i+1][j]+sum;4546//除上⾯⼀种组合情况外的其他组合情况47for(int k=i+1;k<j;k++)48 {49int t=m[i][k]+m[k+1][j]+sum;50if(t<m[i][j])51 m[i][j] = t;5253 }54 }55//最终得到最优解56 min=m[1][n];57return min;585960 }6162/*63 *求合并过程中64 *最多合并堆数⽬65 **/6667int MatrixChain_max(int p[N],int n)68 {69int m[N][N];70for(int x=1;x<=n;x++)71for(int z=1;z<=n;z++)72 {73 m[x][z]=-1;74 }757677int max=0;78//⼀个独⾃组合时79for(int g = 1;g<=n;g++) m[g][g]=0;80//两个两两组合时81for(int i=1;i<=n-1;i++)82 {83int j=i+1;84 m[i][j]=p[i]+p[j];85 }8687for(int r=3; r<=n;r++)88for(int i=1;i<=n-r+1;i++)89 {90int j = i+r-1;91int sum=0;92for(int b=i;b<=j;b++)93 sum+=p[b];94 m[i][j] = m[i+1][j]+sum;9596for(int k=i+1;k<j;k++)97 {98int t=m[i][k]+m[k+1][j]+sum;99if(t>m[i][j])100 m[i][j] = t;101102 }103 }104105 max=m[1][n];106return max;107108109 }110int main()111 {112int stone[N];113int min=0;114int max=0;115int n;116 scanf("%d",&n);117for(int i=1;i<=n;i++)118 scanf("%d",&stone[i]);119120 min= MatrixChain_min(stone,n);121 max= MatrixChain_max(stone,n);122123//因为题⽬要求圆的原因，要把所有情况都要考虑到，总共有n种情况。
算法设计与分析 期末试卷 A卷(完整含答案)
4、操场上摆放一行共n堆石头，呈直线排列。n堆石子从左到右方向编号为1~n，每堆石子 个数分别为a[1],…,a[n]，现在要将石子有次序的合并为一堆，规定每次只能选相邻的2堆合 并为新的一堆，并将新的一堆的石子数记为该次合并的得分，经过n-1次合并，最终合并为 一堆，总得分为n-1次合并得分之和。现要设计一个算法，计算出将一行的n堆石子合并为一 堆的最小得分。这里假设m[i,j]为合并石子Ai…Aj, 1≤i≤j≤n，所得到的最小得分。请写出 m[i,j]的递推公式。 （5分）
3
m[1][3] min{m[1][1] m[2][3] p0 p1 p3 , m[1][2] m[3][3] p0 p2 p3} 7500; m[2][4] min{m[2][2] m[3][4] p1 p2 p4 , m[2][3] m[4][4] p1 p3 p4 } 5000;
则 O( f 2 (n)) O(_____________) 则 O( f 3 (n)) O(_____________) 则 O( f 4 (n)) O(_____________) 则 O( f 5 (n)) O(_____________)
n
f 4 (n) 2log n ，
参考解答：设 n 堆石子从左到右方向编号为 1,2,…,n，每堆石子个数分别为 a[1],…,a[n]。n 堆石子的合并有许多不同 的方式，每种合并方式对应于 n 个矩阵连乘的一种完全加括弧方式。显然，这里合并是满足最优子结构性质的，用 A1…An 来代表每堆的石子，则最后一次合并在 Ak 和 Ak+1 之间，则 A1…An 的最优合并为((A1…Ak)(Ak+1…An))，可以看出最优 解左边部分(A1…Ak)和右边部分(Ak+1…An)的合并也分别是最优的。 假设 m[i,j]为合并石子 Ai…Aj, 1≤i≤j≤n，所得到的最小得分，若没有“合并”这个动作，则为 0。原问题所求 的最优值即为 m[1,n]。
石子合并问题DP
⽯⼦合并问题DPSTART:2021-08-1014:29:041.问题描述：有N堆⽯⼦排成⼀排，每堆⽯⼦有⼀定的数量。
现要将N堆⽯⼦并成为⼀堆。
合并的过程只能每次将相邻的两堆⽯⼦堆成⼀堆，每次合并花费的代价为这两堆⽯⼦的和，经过N-1次合并后成为⼀堆。
求出总的代价最⼩值。
2. 输⼊输出⽰例输⼊有多组测试数据，输⼊到⽂件结束。
每组测试数据第⼀⾏有⼀个整数n，表⽰有n堆⽯⼦。
接下来的⼀⾏有n（0< n <200）个数，分别表⽰这n堆⽯⼦的数⽬，⽤空格隔开输出输出总代价的最⼩值，占单独的⼀⾏样例输⼊231 2 3713 7 8 16 21 4 18样例输出92393.分析：由题⽬我们可知，题⽬将给我们测试数据的组数，我们定义⼀个变量t来储存，⽤while(t--)来处理了这t组数据。
对于每组数据，我们⾸先会得到有n堆的⽯⼦，然后得到这n堆⽯⼦每堆⽯⼦的数⽬。
处理完数据，我们得设计算法来解题了：对于不同的顺序，我们合并⽯⼦的代价不同。
我们举个栗⼦，给定4个⽯堆，分别有1个，2个，3个，4个⽯堆，我们先全部遍历⼀遍，⽐如，先只遍历长度为2的合并，看看有什么规律：我们可以看到，有四个⽯堆，分别有1个，2个，3个, 4个⽯头，我们先执⾏长度为2的合并：我们⽤sum[i][j]表⽰从i合并到j需要多少代价，dp[i][j]表⽰合并区间[ i , j ]的⽯堆累计的代价第⼀种：1∪2==>sum[1][2]=1+2=3,dp[1][2]=3第⼆种：2∪3==>sum[2][3]=2+3=5,dp[2][3]=5第三种：3∪4==>sum[3][4]=3+4=7,dp[3][4]=7我们只有四个⽯堆，所以合并长度为2的⽅案只有这三个，然后接着我们合并长度为3的：合并区间[ 1 , 3 ]有以下两种⽅案：第⼀种：合并{1∪2,3}，所以（1∪2）∪3：sum[1][3]=sum[1][2]+sum[3][3]=3+3=6dp[1][3]=sum[1][2]+sum[1][3]=3+6=9第⼆种：合并{1,2∪3}，所以1∪（2∪3）：sum[1][3]=sum[1][1]+sum[2][3]=1+5=6dp[1][3]=sum[2][3]+sum[1][3]=5+6=11所以合并区间[1,3]的最优⽅案是先合并1,2再合并3。
矩阵连乘问题的算法
矩阵连乘问题的算法介绍矩阵连乘问题是一个经典的数学问题，它涉及到如何寻找一组矩阵相乘的最优顺序，使得计算所需的乘法操作总数最小化。
这个问题在计算机科学和算法设计中有着重要的应用。
本文将介绍矩阵连乘问题的算法及其相关概念和应用。
问题描述给定一组矩阵{A1, A2, A3, …, An}，其中Ai的维度为pi-1 × pi（1 ≤ i ≤ n），我们希望找到一种矩阵相乘的顺序，使得计算这些矩阵相乘所需的乘法操作总数最小化。
动态规划算法动态规划算法是解决矩阵连乘问题的经典方法。
它通过存储中间结果来避免重复计算，从而提高计算效率。
下面将介绍动态规划算法的具体实现步骤。
定义子问题假设我们要计算矩阵Ai × Ai+1 × … × Aj的最优顺序和乘法操作总数，其中i ≤ j。
确定状态转移方程设m[i][j]表示计算矩阵Ai × Ai+1 × … × Aj的最优顺序和乘法操作总数。
根据定义，我们有以下状态转移方程： - 当i = j时，m[i][j] = 0，因为只有一个矩阵无需进行乘法操作； - 当i < j时，m[i][j] = min{m[i][k] + m[k+1][j] + pi-1 × pk × pj}，其中i ≤ k < j。
填表计算最优值根据状态转移方程，我们可以使用动态规划的方法逐步填充表格m。
具体步骤如下：1. 初始化所有m[i][i]为0（0 ≤ i ≤ n）； 2. 对于每个子问题(i, j)，从i= 1递增到j = n-1，按照递增的长度进行计算： - 对于每个i和j，根据状态转移方程计算m[i][j]； 3. 最终，m[1][n-1]即为所求的计算矩阵Ai × Ai+1× … × An的最优顺序和乘法操作总数。
重构最优解为了得到最优顺序下的具体计算过程，我们可以使用一个辅助表格s来记录最优划分点。
石子合并问题实验报告
一、实验目的1. 了解石子合并问题的背景和意义；2. 掌握石子合并问题的解决方法；3. 提高实验操作能力和数据分析能力。
二、实验原理石子合并问题是一个经典的数学问题，主要研究如何将若干个石子合并成若干个尽可能大的石子堆。
该问题在现实生活中具有广泛的应用，如城市规划、资源分配等。
实验通过模拟石子合并过程，寻找最优的合并策略。
三、实验材料1. 石子若干；2. 纸和笔；3. 计算器。
四、实验步骤1. 准备实验材料，将石子随机分成若干堆；2. 记录每堆石子的数量；3. 按照一定的合并策略进行合并，如从数量最少的一堆开始合并；4. 记录每次合并后的石子堆数量和数量；5. 重复步骤3和4，直到所有石子合并成若干个石子堆；6. 分析实验结果，总结最优合并策略。
五、实验结果与分析1. 实验结果通过多次实验，发现以下几种合并策略：（1）从数量最少的一堆开始合并；（2）从数量最多的一堆开始合并；（3）从数量相差最小的一堆开始合并。
2. 实验分析（1）从数量最少的一堆开始合并：该策略在合并过程中可以逐渐减少石子堆的数量，但可能导致石子堆的体积差异较大。
（2）从数量最多的一堆开始合并：该策略在合并过程中可以保持石子堆的体积相对稳定，但可能导致石子堆的数量较多。
（3）从数量相差最小的一堆开始合并：该策略在合并过程中可以平衡石子堆的数量和体积，但需要花费更多的时间进行筛选。
综上所述，从数量相差最小的一堆开始合并是一种较为合理的合并策略。
六、实验结论1. 通过石子合并问题实验，了解了石子合并问题的背景和意义；2. 掌握了石子合并问题的解决方法，即从数量相差最小的一堆开始合并；3. 提高了实验操作能力和数据分析能力。
七、实验心得1. 在实验过程中，要注重观察和分析，以便找到最优的合并策略；2. 要善于总结经验，提高实验效率；3. 要注重团队合作，共同完成实验任务。
八、实验展望石子合并问题在现实生活中具有广泛的应用，未来可以从以下几个方面进行深入研究：1. 探讨不同合并策略的优缺点，寻找更优的合并策略；2. 将石子合并问题与其他实际问题相结合，如城市规划、资源分配等；3. 利用计算机技术，模拟石子合并过程，提高实验效率。
经典算法
但有些却不能 改进算法－贪心 一般情况下这类问题没有绝对正确的贪 心算法 动态规划求解－这类问题不能用平常的 动规求解，因为无法划分阶段
最优排列匹配问题
推荐算法1－遗传算法 由于是求一种排列情况，那么，假设当前有排
列a1,a2,a3 …… an 假设交换ai,aj可以使得整个排列所能达到的一 个期望值，也就是我们需要得到的一个值更加 优秀的话，那么就应该交换ai,aj。如此交换， 直到找不出这样的ai,aj为止 这显然是一种贪心的思想
时间是2nn2，空间是2nn 只能承受到n=17 所以需要注意优化，比如说判断s的第i位 是不是1，用下面这个语句： OK:=(s xor (s-1 shl (i-1)))=1 shl (i-1) 还有一些优化措施是做一些预处理
最优排列匹配问题
推荐算法3－KM算法 只适用于二分图匹配问题
导弹拦截
Noip的导弹拦截问题其实是求一个最长
不上升序列。 如果将序列反过来，则是一个最长不下 降子序列问题，称为LST。 先来看看一般的解法： For i:=2 to n do for j:=i-1 downto 1 do if high[i]>high[j] then f[i]:=max(f[i],f[j]+1);
最优排列匹配问题
推荐算法2－状态压缩型动态规划 某些特殊情况下，即使n较小，例如只有
20，但对于某些特殊的问题仍然不能够 在短时间内得出最优解 在n较小，遗传算法效果不理想的情况下， 用状态压缩型动态规划求解 所谓的状态压缩，是指将状态用2进制数 表示
最优排列匹配问题
具体实例：求harmilton回路 状态的表示－f[s,i]
导弹拦截
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
石子合并问题 (2011-11-14 21:06:38)
描述：在一条直线上摆着N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为将的一堆石子的数量。
设计一个算法，将这N堆石子合并成一堆的总花费最小
解析：
采用动态递归，运用矩阵连乘思想即可解答此类题目
源程序：
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
#define MAXN 100
int sum[MAXN][MAXN];
int m[MAXN][MAXN];
int t[MAXN][MAXN];
int n, stone[MAXN];
int MatrixChain_min( )
{
int min=0;
for(int g =01;g<n;g++)
m[g][g]=0;
for(int i=0;i<n-1;i++)
{
int j=i+1;
m[i][j]=sum[i][j];
}
for(int r=3; r<=n;r++)
for(int i=0;i<n-r+1;i++)
{
int j = i+r-1;
m[i][j] = m[i+1][j]+sum[i][j];
t[i][j] = i;
for(int k=i+1;k<j;k++)
{
int l=m[i][k]+m[k+1][j]+sum[i][j];
if(l < m[i][j])
{ m[i][j] = l;
t[i][j] = k;
}
}
}
min=m[0][n-1];
return min;
}
int main()
{ int i,j,q;
scanf("%d", &n);
for(i = 0; i < n; i++)
scanf("%d", &stone[i]); for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
int temp=0;
for(q=i;q<=j;q++)
temp=temp+stone[q];
sum[i][j]=temp;
}
}
int Best=MatrixChain_min(); printf("%d\n",Best);
return 0;
}。