算法分析实验三报告

《算法设计与分析》实验报告
目录
一、实验内容描述和功能分析.
二、算法过程设计.
三、程序调试及结果（附截图）.
四、源代码（附源代码）.
一、实验内容描述和功能分析.
1.矩阵连乘问题
内容描述：给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1,2 ,…,n-1。

如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。

功能分析：输入包含多组测试数据。

第一行为一个整数C，表示有C 组测试数据，接下来有2*C行数据，每组测试数据占2行，每组测试数据第一行是1个整数n，表示有n个矩阵连乘,接下来一行有n+1
个数,表示是n个矩阵的行及第n个矩阵的列,它们之间用空格隔开。

输出应该有C行，即每组测试数据的输出占一行，它是计算出的矩阵最少连乘积次数。

例如：输入：1输出：7500
3
10 100 5 50
2.Pebble Merging
内容描述：在一个圆形操场的四周摆放着n 堆石子。

现要将石子有次序地合并成一堆。

规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。

试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。

编程任务：
对于给定n堆石子,编程计算合并成一堆的最小得分和最大得分。

功能分析：输入由多组测试数据组成。

每组测试数据输入的第1 行是正整数n，1≤n≤100，表示有n堆石子。

第二行有n个数，分别表示每堆石子的个数。

对应每组输入，输出的第1 行中的数是最小得分；第2 行中的数是最大得分。

例如：输入：4 输出：43
4 4
5 9 54
二、算法过程设计.
1.矩阵连乘问题
矩阵连乘问题是通过设置数组，利用数组的横竖坐标来进行矩阵对应行与列的计算。

2.Pebble Merging
这个问题也是跟数组相关，通过寻找数组中的最大和最小值来进行计算。

三、程序调试及结果（附截图）.
1.矩阵连乘问题
2.Pebble Merging
四、源代码（附源代码）.
1.矩阵连乘问题
#include <stdio.h>
int main()
{ int a[ 50 ] , b[ 50 ][ 50 ] , c[ 50 ][50 ] , z , n;
int i , r , j , k , t;
scanf("%d",&z);
while (z --)
{ scanf("%d",&n);
for (i = 0 ; i <= n ; ++ i) scanf("%d",& a[ i ]);
for (i = 1 ; i <= n ; ++ i) b[ i ][ i ] = 0;
for (r = 2 ; r <= n ; ++ r)
for (i = 1 ; i <= n - r + 1 ; ++ i)
{ j = i + r - 1;
b[ i ][ j ] = b[i + 1][ j ] + a[i - 1] * a[ i ] * a[ j ];
c[ i ][ j ] = i;
for (k = i + 1 ; k < j ; ++ k)
{ t = b[ i ][ k ] + b[k + 1][ j ] + a[i - 1] * a[ k ] * a[ j ];
if (t < b[ i ][ j ])
b[ i ][ j ] = t , c[ i ][ j ] = k;
}
}
printf ("%d\n" , b[ 1 ][ n ]);
}
return 0;
}
2.Pebble Merging
#include <stdio.h>
int main()
{ int dpmin[ 200 ][ 200 ] , min[ 200 ][ 200 ] , mins;
int dpmax[ 200 ][ 200 ] , max[ 200 ][ 200 ] , maxs;
int a[ 200 ] , i , n , j , k , temp , l;
while (scanf ("%d" , & n) != EOF)
{ for (i = 1 ; i <= n ; ++ i) scanf ("%d" , & a[ i ]);
for (i = 1 ; i < n ; ++ i) a[i + n] = a[ i ];
for (i = 1 ; i < 2 * n ; ++ i)
{ min[ i ][ i ] = max[ i ][ i ] = 0;
dpmax[ i ][ i ] = dpmin[ i ][ i ] = a[ i ];
dpmax[ i ][i + 1] = dpmin[ i ][i + 1] = a[ i ] + a[i + 1];
min[ i ][i + 1] = max[ i ][i + 1] = a[ i ] + a[i + 1];
}
for (i = 1 ; i < n - 1; ++ i)
for (l = 1 , j = 2 + i ; j < 2 * n ; ++ j , ++ l)
{ for (k = l + 1 ; k <= j ; ++ k)
{ if (k == l + 1)
{ dpmin[ l ][ j ] = dpmin[ l ][k - 1] + dpmin[ k ][ j ] + min[ l ][k - 1] + min[ k ][ j ];
if ( l == k - 1 && k != j)
min[ l ][ j ] = a[ l ] + min[ k ][ j ];
else
if (l != k - 1 && k == j)
min[ l ][ j ] = min[ l ][k - 1] + a[ k ];
else
min[ l ][ j ] = min[ l ][k - 1] + min[ k ][ j ]; dpmax[ l ][ j ] = dpmax[ l ][k - 1] + dpmax[ k ][ j ] + max[ l ][k - 1] + max[ k ][ j ];
if ( l == k - 1 && k != j)
max[ l ][ j ] = a[ l ] + max[ k ][ j ];
else
if (l != k - 1 && k == j)
max[ l ][ j ] = max[ l ][k - 1] + a[ k ];
else
max[ l ][ j ] = max[ l ][k - 1] + max[ k ][ j ];
continue ;
}
temp = dpmin[ l ][k - 1] + dpmin[ k ][ j ] + min[ l ][k - 1] + min[ k ][ j ];
if (temp < dpmin[ l ][ j ])
{ dpmin[ l ][ j ] = temp;
if ( l == k - 1 && k != j)
min[ l ][ j ] = a[ l ] + min[ k ][ j ];
else
if (l != k - 1 && k == j)
min[ l ][ j ] = min[ l ][k - 1] + a[ k ];
else
min[ l ][ j ] = min[ l ][k - 1] + min[ k ][ j ];
}
temp = dpmax[ l ][k - 1] + dpmax[ k ][ j ] + max[ l ][k - 1] + max[ k ][ j ];
if (temp > dpmax[ l ][ j ])
{ dpmax[ l ][ j ] = temp;
if ( l == k - 1 && k != j)
max[ l ][ j ] = a[ l ] + max[ k ][ j ];
else
if (l != k - 1 && k == j)
max[ l ][ j ] = max[ l ][k - 1] + a[ k ];
else
max[ l ][ j ] = max[ l ][k - 1] + max[ k ][ j ];
} } }
mins = dpmin[ 1 ][ n ]; maxs = dpmax[ 1 ][ n ];
for (i = 2 ; i <= n ; ++ i)
{ if (mins > dpmin[ i ][i + n - 1])
mins = dpmin[ i ][i + n - 1];
if (maxs < dpmax[ i ][i + n - 1])
maxs = dpmax[ i ][i + n - 1];
}
printf ("%d\n%d\n" , mins , maxs);
}
return 23;
}。