矩阵连乘(备忘录方法:自顶向下递归)

#include<iostream>
#include<vector>
#include<iterator>
#include<algorithm>
using namespace std;

/*
*矩阵连乘(备忘录方法:自顶向下递归)
*/
vector<vector<int>> m;//m[i][j]表示矩阵Ai连乘到Aj的最少运算次数
vector<vector<int>> s;//s[i][j]记录矩阵Ai和矩阵Aj之间的分割点

//计算该连乘式子的最佳结合方式
int MatrixChain(vector<int>& p,int beg, int end)
{
	if(m[beg][end]>0) return m[beg][end];
	if(beg==end) return 0;
	int u = MatrixChain(p,beg,beg)+MatrixChain(p,beg+1,end)+p[beg-1]*p[beg]*p[end];
	s[beg][end] = beg;
	for (int K = beg+1; K <end ; K++)
	{
		int t = MatrixChain(p,beg,K) + MatrixChain(p,K+1,end) + p[beg-1]*p[K]*p[end];
		if (t<u)
		{
			u = t;s[beg][end] = K;
		}
	}
	m[beg][end] = u;
	return u;
}

//输出该连乘式子的最佳结合方式
void PrintMatrixChain(int n,int m)
{
	if(n==m)
	{
		cout<<"A"<<n;
		return;
	}
	int k = s[n][m];
	if(n==k)
		PrintMatrixChain(n,k);
	else
	{
		cout<<"(";
		PrintMatrixChain(n,k);
		cout<<")";
	}
	if(k+1==m)
		PrintMatrixChain(k+1,m);
	else
	{
		cout<<"(";
		PrintMatrixChain(k+1,m);
		cout<<")";
	}
}
int main()
{
	vector<int> vec;
	copy(istream_iterator<int>(cin),istream_iterator<int>(),back_inserter(vec));
	int n = vec.size()-1;//一共有n个矩阵相乘
	m = vector<vector<int>>(n+1,vector<int>(n+1,0));//0行0列空余
	s = vector<vector<int>>(n+1,vector<int>(n+1,0));//0行0列空余
	//初始化m数组
	for(int i = 0;i<=n;i++) m[i][i] = 0;
	int u = MatrixChain(vec,1,n);
	cout<<"最优解为计算"<<u<<"次乘法!"<<endl;
	PrintMatrixChain(1,vec.size()-1);
}

时间: 2024-12-26 05:00:40

矩阵连乘(备忘录方法:自顶向下递归)的相关文章

方法的递归

一.方法递归 方法的递归是指在一个方法的内部调用自身的过程,递归必须要有结束条件,不然就会陷入无限递归的状态,永远无法结束调用. 实例代码: class demo4{ public static void main(String[] args) { int sum=getSum(100);//调用递归方法 System.out.println(sum); } public static int getSum(int n){ if(n==1){ //递归结束条件 return 1; } int t

二叉树前序、中序和后序的遍历方法(递归、用栈和使用线索化)

在2^k*2^k个方格组成的棋盘中,有一个方格被占用,用下图的4种L型骨牌覆盖所有棋盘上的其余所有方格,不能重叠. 代码如下: def chess(tr,tc,pr,pc,size): global mark global table mark+=1 count=mark if size==1: return half=size//2 if pr<tr+half and pc<tc+half: chess(tr,tc,pr,pc,half) else: table[tr+half-1][tc+

JAVA_SE基础——18.方法的递归

方法的递归是指在一个方法的内部调用自身的过程,递归必须要有结束条件,不然就会陷入无限递归的状态,永远无法结束调用,接下来用一个最简单的例子来体现下方法递归,使用递归算法计算自然数之和: public class Example18 { <span style="white-space:pre"> </span>public static void main(String[] args) { <span style="white-space:pre

矩阵连乘(动态规划非递归)

对于矩阵连乘机问题就不概述了,主要是找出最佳的结合方式使得整个式子的运算次数最少. 对于这个问题之所以用动态规划的原因点如下: 第一:由于矩阵连乘机本身可以划分为若干个子矩阵链连乘机,而且若干个子矩阵链的最优解组合起来就是原矩阵链的最优解. 第二:对于原矩阵链的不同划分中个子问题是存在重叠子问题. 所以当此问题用动态规划算法来解决时就会变得很简单,算法的精髓就是从子问题入手.自底向上一步一步的由子问题的最优解去找到更复杂的大问题的最优解, 当循环到原问题时得出即为原为题的最优解:而且在自底向上的

反转一个链表的两种方法:递归和循环

下面是反转一个链表的两种方法: 一.循环算法 //反转一个链表,循环算法 LinkList Reverse(LinkList& head) { // if(!head) // return head; //此时不用判断head是否为空,如是空的话返回的也是空 LinkList cur = head; LinkList hou; LinkList beh = 0; while (cur) { hou = cur->next; cur->next = beh; beh = cur; cur

java中方法的递归调用

方法的递归调用 /* 关于方法的递归调用 1.什么是递归? -方法自身调用自身 a(){ a(){ } } 2.递归是很耗费栈内存的,递归算法可以不用的时候尽量不用 3.一下程序运行的时候发生了这样一个错误[不是异常,是错误Error]: java.lang.StackOverflowErroe 栈内存溢出错误. 错误放生无法挽回,只有一个结果,就是JVM停止工作 4.递归必须有结束条件,没有结束条件一定会发生栈内存溢出错误 5.递归即使有了结束条件,即使结束条件是正确的,也可能会发生栈内存溢出

java 对象的this使用 java方法中参数传递特性 方法的递归

一.this关键字,使用的情形,以及如何使用. 1.使用的情形 类中的方法体中使用this  --初始化该对象 类的构造器中使用this --引用,调用该方法的对象 2.不写this,调用 只要方法或者构造器中  不存在成员变量与局部变量同名的情况,可直接不写this 否则方法中或构造器中使用的就是局部变量 3.static 静态方法不能调用this,不能调用任何非static修饰的成员变量 或者方法 二.java方法中  参数传递特性 1.基本数据类型--实际是新增变量,并赋值而已   不过代

J2SE之基础语法_方法_递归调用

方法 public class TestMethod { public static void main(String[] args) { m(); m2(2); m3('3', 4); m4(4, 6); int i = m4(4, 6); System.out.println(i); } public static void m() { //return;方法返回,结束,后面的不会执行,出错 System.out.println("ok"); System.out.println(

两种方法(递归,非递归)实现单链表的逆转

//普通方法实现链表的逆置 void reverseList(pNode *head) { pNode p, q, r; if (*head == NULL || (*head)->next == NULL) return; q = *head; p = q->next; r = NULL; while (p){ q->next = r; r = q; q = p; p = p->next; } q->next = r; *head = q; } //递归法实现链表的逆置 p