矩阵连乘问题

/* description:
 *
 * 动态规划算法之矩阵连乘问题
 * 1)矩阵Ai*Ai+1*...*Aj简记为A[i:j],所需的最小计算次数为m[i][j].
 * 2)当i=j时，m[i][j] = 0
 * 3)当 i<j时，假设使m[i][j]最小的最优次序是在Ak和Ak+1之间断开，
 * 则m[i][j] = m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j],其中k的位置可以是:i, i+1, ..., j-1,
 * 数组p[]存储各个矩阵的维数，s[i][j]标记m[i][j]的断开位置k.
 *
 * auther: cm
 * date: 2010/11/16
 */
public class MatrixChain 
{
	private static final int MAX_VALUE = Integer.MAX_VALUE;

	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] = MAX_VALUE;
				for (int k = i; k < j; k++)
				{
					int temp = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
					if (temp < m[i][j])
					{
						m[i][j] = temp;
						s[i][j] = k;
					}
				}
			}
		}
		System.out.println("The lowest compute times:" + m[1][n]);
	}

	//输出A[i:j]的最优计算次序
	public static void traceback(int[][] s, int i, int j)
	{
		if (i == j)
		{
			System.out.print("A" + i);
		}
		if (i < j)
		{
			System.out.print("(");
			traceback(s,i,s[i][j]);
			traceback(s, s[i][j] + 1, j);
			System.out.print(")");
		}
	}

	//输出矩阵
	public static void printMatrix(int[][] m)
	{
		for (int i = 1, length = m.length; i < length; i++)
		{
			System.out.println();
			for (int j = 1, l = m[i].length; j < l; j++)
			{
				System.out.print(m[i][j] + " ");
			}
		}
	}
	public static void main(String[] args) 
	{
		int[] p = {30, 35, 15, 5, 10, 20, 25};
		int[][] m = new int[7][7];
		int[][] s = new int[7][7];
		MatrixChain.matrixChain(p, m, s);
		//MatrixChain.printMatrix(m);
		//MatrixChain.printMatrix(s);
		MatrixChain.traceback(s, 1, 6);
	}
}

 

共有六个矩阵,维数分别为:

30*35

35*15

15*5

5*`10

10*20

20*25

运行结果为：

The lowest compute times:15125
((A1(A2A3))((A4A5)A6))