矩阵连乘优化-优快云博客

本文链接：https://blog.youkuaiyun.com/cv_yuippe/article/details/21798789

题目描述：给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1,2 ,…,n-1。如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。例如：

　　A1={30x35} ; A2={35x15} ;A3={15x5} ;A4={5x10} ;A5={10x20} ;A6={20x25} ;

最后的结果为：((A1(A2A3))((A4A5)A6)) 最小的乘次为15125。

解题思路：能用动态规划的一个性质就是最优子结构性质，也就是说计算A[i:j]的最优次序所包含的计算矩阵子琏A[i:k]和A[k+1:j]的次序也是最优的。动态规划算法解此问题，可依据其递归式以自底向上的方式进行计算（即先从最小的开始计算）。在计算过程中，保存已解决的子问题答案。每个子问题只计算一次，而在后面需要时只要简单查一下，从而避免大量的重复计算，最终得到多项式时间的算法。我们可以根据下面这个公式来计算结果。其中p[i-1]表示的是第i个矩阵的行数,p[k]表示i:k矩阵合起来后最后得到的列数，p[j]是k+1:j合起来后得到的列数。这个部分的计算方法其实就是计算两个矩阵相乘时总共的乘次数

从连乘矩阵个数为2开始计算每次的最小乘次数m[i][j]: m[0][1] m[1][2] m[2][3] m[3][4] m[4][5] //m[0][1]表示第一个矩阵与第二个矩阵的最小乘次数

然后再计算再依次计算连乘矩阵个数为3:m[0][2] m[1][3] m[2][4] m[3][5]

　　　　　　　　　连乘矩阵个数为4：m[0][3] m[1][4] m[2][5]

　　　　　　　　　　连乘矩阵个数为5：m[0][4] m[1][5]

　　　　　　　　　　连乘矩阵个数为6：m[0][5] //即最后我们要的结果

代码如下：

// ConsoleApplication2.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdlib.h>


int matrix_chain(int* p, int n, int** m, int** s)
{
	//m[][]最小乘次数
	//s[][]最小乘数的断开点

	int i, j, r, k;

	for (i = 0; i < n; i++)    //单一矩阵的最小乘次都置为0
	{
		m[i][i] = 0;
	}

	for( r = 2; r <= n; r++)   //r为连乘矩阵的个数
	{
		for(i = 0; i <= n-r; i++)   //i表示连乘矩阵中的第一个
		{
			j = i + r -1;           //j表示连乘矩阵中的最后一个
			m[i][j] = 99999;

			for (k = i; k <= j - 1; k++)
			{
				int tmp = m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1];
				if (tmp < m[i][j])
				{
					m[i][j] = tmp;
					s[i][j] = k;
				}
			}
		}
	}

	return m[0][n-1];
}


void print_chain(int i, int j, char **a, int **s)
{
	if(i == j)
	{
		printf("%s", a[i]);
	}
	else
	{
		printf("(");
		print_chain(i, s[i][j], a, s);
		print_chain(s[i][j] + 1, j, a, s);
		printf(")");
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int* p, **min_part, **min_point;
	char** a;
	int n = 6, i;
	int ret;

	p = (int *)malloc((n + 1)*sizeof(int));
	a = (char **)malloc(n*sizeof(char *));
	min_part = (int **)malloc(n*sizeof(int *));
	min_point = (int **)malloc(n*sizeof(int *));

	for (i = 0; i < n; i++)
	{
		min_part[i] = (int*)malloc(n*sizeof(int));
		min_point[i] = (int*)malloc(n*sizeof(int));
		a[i] = (char*)malloc(n*sizeof(char));
	}

	p[0] = 30;   //第一个矩阵的行数
	p[1] = 35;     //第二个矩阵的行数
	p[2] = 15;     //……
	p[3] = 5;     //……    
	p[4] = 10;     //……
	p[5] = 20;     //第六个矩阵的行数
	p[6] = 25;     //第六个矩阵的列数

	a[0] = "A1";
	a[1] = "A2";
	a[2] = "A3";
	a[3] = "A4";
	a[4] = "A5";
	a[5] = "A6";


	ret = matrix_chain(p,n,min_part,min_point);
	printf("Minest times:%d.\n",ret);
	print_chain(0,n-1,a,min_point);

	free(p);
	free(min_part);
	free(min_point);
	free(a);

	return 0;
}

效果图:

显示递归过程：

参考链接：http://www.cnblogs.com/Jason-Damon/p/3231547.html

以下也是实现代码，不过是读取txt：

// ConsoleApplication2.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <fstream>

using namespace std;

const int maxSize = 100;



int matrixChain(int p[maxSize],int n,int m[maxSize][maxSize],int s[maxSize][maxSize])//n为矩阵l连乘个数 
{
	int i;
	for(i = 1;i <= n; ++i)   //
	{
		m[i][i] = 0;    
	}
	int d, j, k, temp; 
	for(d = 2; d <= n; ++d)//自底向上,计算2至n个矩阵连乘. 
		for(i = 1;i <= n-d+1; ++i)  //i表示第一个
		{
			j = d+i-1;           //j表示末尾那个 
			m[i][j] = m[i][i] + m[i+1][j] + p[i-1]*p[i]*p[j];
	
			s[i][j] = i;
			for(k = i+1; k < j; ++k)
			{
				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;
				}
			}
		}

		return m[1][n-1];
}
void printMatChain(int p[maxSize],int begin,int last, int s[maxSize][maxSize],ofstream& fout)//begin、last为当前矩阵连乘的起始位置  
{
	if(begin == last)
	{
		cout<<'A'<<begin;
		fout<<'A'<<begin;
	} 
	else
	{
		cout<<'(';
		fout<<'(';
		printMatChain(p,begin,s[begin][last],s,fout);
		printMatChain(p,s[begin][last]+1,last,s,fout);
		cout<<')';
		fout<<')';
	}
} 



int _tmain(int argc, _TCHAR* argv[])
{

	int p[maxSize], m[maxSize][maxSize], s[maxSize][maxSize];

	ifstream fin;
	ofstream fout;

	fin.open("C:\\Users\\sony\\Desktop\\in.txt", std::ios::in);
	fout.open("out.txt",std::ios::app);

	int temp, n, i=0;

	while (fin>>temp)
	{
		p[i] = temp;
		++i;
	}

	n = i - 1;  //n是矩阵连乘数目
	i = 0;
	
	cout<<"计算以下"<<n<<"个矩阵连乘"<<endl;
	fout<<"计算以下"<<n<<"个矩阵连乘"<<endl;  
	while(i < n)
	{
		cout<<"A"<<i+1<<":"<<p[i]<<"x"<<p[i+1]<<" "; 
		fout<<"A"<<i+1<<":"<<p[i]<<"x"<<p[i+1]<<" "; 
		++i; 
	}
	cout<<endl<<endl;
	fout<<endl<<endl;
	matrixChain(p,n,m,s);
	cout<<"矩阵连乘方案:\n";
	fout<<"矩阵连乘方案:\n";
	printMatChain(p,1,n,s,fout);
	cout<<"\n矩阵连乘所需最少乘法次数为\n"<<m[1][n]<<endl<<endl; 
	fout<<"\n矩阵连乘所需最少乘法次数为\n"<<m[1][n]<<endl<<endl; 
	fin.close();
	fout.close();
	cout<<"txt文档输出在当前文件夹的out.txt中"<<endl; 
	cout<<"\n回车退出\n"; 
	cin.get(); 
	return 0;
}

效果图如下：

转载链接：http://www.cnblogs.com/zhengyuhong/p/3375217.html

do myself:

// multiplication.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;


const int maxSize = 100;
const int n = 3;//矩阵连乘的个数


int calc_MinStep(int p[maxSize], int m[maxSize][maxSize], int s[maxSize][maxSize], int n) //n表示矩阵连乘个数
{

	int r; //表示r个矩阵相乘
	int i, j;
	int k;
	int temp;
	for (i = 1; i <= 3; i++ )  //将单个矩阵相乘至零
	{
		m[i][i] = 0;
	}

	for (r = 2; r <= n; r++)  //计算2至n个矩阵相乘
	{
		for (i = 1; i <= n-r+1; i++)  //i表示第一个
		{
			j = i + r - 1;  //j表示末尾

			m[i][j] = m[i][i] + m[i+1][j] + p[i-1]*p[i]*p[j]; //初始化

			s[i][j] = i;

			for (k = i; k < j; k++)  //k表示分割点
			{
				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;
				}
			}

		}
	}

	return m[1][n];

}


void print_chain(int p[maxSize], int i, int j, int s[maxSize][maxSize])
{
	if (i == j )
	{
		cout << "A" << i;
	}
	else
	{
		cout << "(";
		print_chain(p, i, s[i][j], s);
		print_chain(p,s[i][j] + 1, j, s);
		cout<<")";
	}
}


int _tmain(int argc, _TCHAR* argv[])
{
	int m[maxSize][maxSize], s[maxSize][maxSize],p[ maxSize];

	int i;

	p[0] = 30;
	p[1] = 35;
	p[2] = 15;
	p[3] = 5;

	int number = calc_MinStep(p, m, s, n);

	cout << number << endl;

	print_chain(p, 1, n, s);

	return 0;
}

矩阵连乘之动态规划