matrixchain区块链

1. 矩阵连乘问题，为什么运行不了

不是所有矩阵都可以互相相乘
！大多数矩阵
不可以
相乘。
A
矩阵
X
B
矩阵，
只有
当
A
的列数
等于
B的
行数
才可以
乘，
得出的
C
矩阵
行数
同
A
的行数，
列数
同
B的列数。
A
X
B
可以时，B
X
A
往往不可以，除非是方阵。
你要
矩阵连乘，有一个依次乘的顺序，必需保证
每次乘时
新的前矩阵列数
等于
新的
后矩阵
行数。否则
乘法
不成立。

2. 动态规划矩阵连乘问题

可怜，100分还没人理你，给我吧。
动态规划问题可以有tD/eD的形式，n^t为问题的大小，n^e为问题所依赖的子问题的大小
1D/1D型，最长上升子序列
2D/0D型，最长公共子序列
2D/1D型，多源最短路径
2D/2D型，双背包问题
当然可以有3D/1D或者更高的。

动态规划题目千变万化，主要是要学会思考方法，要能看到题目很快找出题目中的状态，找准状态后就基本没有难度了

3. 指向指针的指针做函数参数

这说明你对指针理解还不够透彻。
int **t;
还没有分配内存能拿来t = b么？
这个先不说，
b[3][2]是2维的数组，所以
int b[3][2]={{1,2},{1,2},{1,3}};
不仅自己方便辨认也对你的代码清晰有好处
至于你函数的传值，我不需要看你的函数就知道不行
因为b[3][2]这样的数组，可以看成3行和2列，也可以看成
3个指向2维数组的指针
但是函数传值的时候编译器可以figure out数组前面的那一维，但是不能知道后面那一组的大小，所以你要明确指明后面的大小，所以prototype里要写
int m[][a],a是一个值

至于内存分配，比如
我写个
int *i, a;
a = 10;
*i = a;
这个对么？明显不对，因为i是指针，没有分配过内存

我不是中文学的，所以表述有点不清，但是malloc和指针是比较有难度的，慢慢来
还有楼上那位兄弟写的挺好，这里提醒一下需要注意int *t[n]和int (*t)[n]相差甚远，所以留心。

今天看了一下发现俺对你的意思理解有点偏差，不好意思，
“指向指针的指针不是可以表示二维数组么？为什么传二维数组给**m 报错?”
指向指针的指针可以表示二维数组，前提是你要先分配内存.
比如
int **t;
t = (int **)malloc(3*sizeof(int *));
这样t就是一个含有3个指针的数组，
然后你再单独对每一个指针分配内存：
int i;
for(i = 0; i < 3; i++){
t[i] = (int *)malloc(2*sizeof(int));
}
这样t才可以看做二维数组，
而单单的int **t仅仅是指向一个指向整数的指针。
所以你可以写
int **t, *ptr, a;
a = 10;
ptr = &a;
t = &ptr;
但是不能直接用作函数原型里作为2维数组传值的形参。
函数原型里要写作
void MatrixChain(int *p,int n,int m[][6],int s[][6]);
这样传值才是对的，原因参见我前面讲的
这个就是解决方法

4. 动态规划算法matrixchain怎么计算

备忘录方法是动态规划方法的变形。与动态规划算法不同的是，备忘录方法的递归方式是自顶向下的，而动态规划算法则是自底向上的。 如： 求LCS的问题： 当xi=yj时，求C[i,j]只需知道C[i-1,j-1]，而无需用到C[i,0]～C[i,j-1]及C[i-1,j]

5. 用动态规划方法求【矩阵连乘】最小次序的程序

您好吗，这样的：
#include<iostream> using namespace std;
const int MAX = 100;
//p用来记录矩阵的行列，main函数中有说明
//m[i][j]用来记录第i个矩阵至第j个矩阵的最优解 //s[][]用来记录从哪里断开的才可得到该最优解 int p[MAX+1],m[MAX][MAX],s[MAX][MAX];
int n;//矩阵个数
int matrixChain() {
for(int i=0;i<=n;i++) m[i][i]=0;
for(int r=2;r<=n;r++)//对角线循环 for(int i=0;i<=n-r;i++)//行循环 {
int j = r+i-1;//列的控制
//找m[i][j]的最小值，先初始化一下，令k=i m[i][j]=m[i+1][j]+p[i+1]*p[i]*p[j +1]; s[i][j]=i;
//k从i+1到j-1循环找m[i][j]的最小值 for(int k = i+1;k<j;k++) {
int temp=m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1];
if(temp<m[i][j]) {
m[i][j]=temp;
//s[][]用来记录在子序列i-j段中，在k位置处 //断开能得到最优解 s[i][j]=k; } } }
return m[0][n-1]; }
//根据s[][]记录的各个子段的最优解，将其输出 void traceback(int i,int j) {
if(i==j) {
cout<<'A'<<i; return
}
if(i<s[i][j]) cout<<'(';
traceback(i,s[i][j]); if(i<s[i][j]) cout<<')'; if(s[i][j]+1<j) cout<<'(';
traceback(s[i][j]+1,j); if(s[i][j]+1<j) cout<<')'; }
void traceback(){ cout<<'(';
traceback(0,n-1); cout<<')'; cout<<endl; }
int main() {
cout<<"请输入矩阵的个数："<<endl; cin>>n;
cout<<"输入矩阵（形如a*b,中间用空格隔开）:"<<endl; for(int i=0;i<=n;i++) cin>>p[i];
//测试数据可以设为六个矩阵分别为
//A1[30*35],A2[35*15],A3[15*5],A4[5*10],A5[10*20],A6[20*25] //则p[0-6]={30,35,15,5,10,20,25} cout<<"输出结果如下："<<endl; matrixChain();
traceback(0,n-1);
//最终解值为m[0][n-1]; cout<<endl; return 0;
}

6. c++的动态规划 关于二维数组的问题

#include "stdafx.h"
#include "conio.h"
#include <iostream>
using namespace std;

void MatrixChain(int* p, int n, int m[7][7],int s[7][7])
{
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]=m[i+1][j]+p[i-1]*p[i]*p[j];
s[i][j]=i;
for(int k=i+1;k<j;k++)
{
int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if(t<m[i][j]){m[i][j]=t;s[i][j]=k;}
}
}
}

void Traceback(int i,int j,int s[7][7])
{
if(i==j)return;
Traceback(i,s[i][j],s);
Traceback(s[i][j]+1,j,s);
cout<<"Multiply A"<<i<<","<<s[i][j];
cout<<"and A"<<(s[i][j]+1)<<","<<j<<endl;
}
int main()
{
int p[7]={5,4,7,8,3,6,9};
int n=6;
int m[7][7];
int s[7][7];
MatrixChain(p,n,m,s);
Traceback(1,6,s);
getchar();
return 0;
}

你的**c指针不能用 new *c 指针可以new 所以出错 直接用数组就可以了
上面代码我编译过了 绝对可以通过啊。

7. Matrix交易所是DFG孵化区块链企业吗

是的，将在一个真正的全球化平台上为用户提供数字资产的交易和托管服务

8. Matrix交易所是DFG孵化的区块链企业吗

是的，这是受阿布扎比全球市场（ADGM）金融服务监管局（FSRA）许可的

9. 二维数组指针

int **m;可以分步骤来理解
**m意思是引用这个整型数,*m代表指向这个整型数的指针,m代表指向*m的指针,也就是传说中指向指针的指针
一般情况下形参为指针类型时,可以传送数组名作为实参,也即数组的起始地址,二维数组的可以看成是多个一维数组组成的

10. c++ 矩阵连乘算法返回值问题

#include<stdio.h>
#include<stdafx.h>

voidMatrix_ABC(double*a,double*b,double*c,double*result,intm,intn,intp,intq);

voidmain()
{
	intm=3,n=2,p=2,q=4;
	doublea[]={1,0,1,0,1,0};
	doubleb[]={2,3,2,3};
	doublec[]={3,1,3,1,0,0,0,0};

	double*result;

	result=newdouble[m*q];

inti,j;

printf("A
");
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
			printf("%f	",a[i*n+j]);
		printf("
");
	}

	printf("B
");
	
	for(i=0;i<n;i++)
	{
		for(j=0;j<p;j++)
			printf("%f	",b[i*p+j]);
		printf("
");
	}
	printf("C
");

	for(i=0;i<p;i++)
	{
		for(j=0;j<q;j++)
			printf("%f	",c[i*q+j]);
		printf("
");
	}
	printf("
");
	Matrix_ABC(a,b,c,result,m,n,p,q);
	printf("A*B*C
");

for(i=0;i<m;i++)
	{
		for(j=0;j<q;j++)
			printf("%f	",result[i*q+j]);
		printf("
");
	}

delete[]result;

}

voidMatrix_ABC(double*a,double*b,double*c,double*result,intm,intn,intp,intq)
{
	inti,j,k;

	double*temp;

	temp=newdouble[m*p];

	for(i=0;i<m;i++)
		for(j=0;j<p;j++)
		{
			temp[i*p+j]=0;
			for(k=0;k<n;k++)
				temp[i*p+j]+=a[i*n+k]*b[n*k+j];
		
		}

	for(i=0;i<m;i++)
		for(j=0;j<q;j++)
		{
			result[i*q+j]=0;
			for(k=0;k<p;k++)
				result[i*q+j]+=temp[i*p+k]*c[q*k+j];
		
		}

delete[]temp;
}