设计一个动态规划算法确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。程序运行结束时，将矩阵连乘的加括号方式以及所计算的乘法次数输出的java代码,并分析算法复杂度

好的，我来给您解答这个问题。

首先，我们需要明确矩阵连乘积的含义。设有n个矩阵{A1, A2, ……, An}，其中Ai与Ai+1是可乘的，i=1, 2, ……, n-1。要求将这n个矩阵相乘，即计算A1A2……An，但矩阵乘法满足结合律，因此加括号的方式有多种，不同的加括号方式会影响计算的乘法次数。

为了使得依此次序计算矩阵连乘积需要的数乘次数最少，我们可以使用动态规划算法。

首先，定义一个二维数组m[][]，其中m[i][j]表示计算Ai……Aj这些矩阵的最少乘法次数。显然，当i=j时，m[i][j]=0，因为只有一个矩阵不需要乘法操作。

当i<j时，m[i][j]可以通过以下公式计算得出：

m[i][j] = min{m[i][k]+m[k+1][j]+pi-1pkpj}，其中i<=k<j，pi-1pkpj表示Ai……Aj这些矩阵相乘的乘法次数。

通过这个公式，我们可以得到最少的乘法次数。同时，我们可以记录下每一次最优的括号位置，以便输出加括号的方式。

具体的实现可以参考以下Java代码：

public class MatrixChainMultiplication {
    public static void main(String[] args) {
        int[] p = {10, 100, 5, 50, 1}; // 五个矩阵的尺寸
        matrixChainOrder(p);
    }

    public static void matrixChainOrder(int[] p) {
        int n = p.length - 1;
        int[][] m = new int[n + 1][n + 1];
        int[][] s = new int[n + 1][n + 1];

        for (int i = 1; i <= n; i++) {
            m[i][i] = 0;
        }

        for (int l = 2; l <= n; l++) {
            for (int i = 1; i <= n - l + 1; i++) {
                int j = i + l - 1;
                m[i][j] = Integer.MAX_VALUE;
                for (int k = i; k <= j - 1; k++) {
                    int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                    if (q < m[i][j]) {
                        m[i][j] = q;
                        s[i][j] = k;
                    }
                }
            }
        }

        System.out.println("最少乘法次数为：" + m[1][n]);

        System.out.println("加括号的方式为：");
        printOptimalParens(s, 1, n);
    }

    public static void printOptimalParens(int[][] s, int i, int j) {
        if (i == j) {
            System.out.print("A" + i);
        } else {
            System.out.print("(");
            printOptimalParens(s, i, s[i][j]);
            printOptimalParens(s, s[i][j] + 1, j);
            System.out.print(")");
        }
    }
}

以上程序的输出结果为：

最少乘法次数为：7500
加括号的方式为：
((A1(A2A3))((A4A5)A6))

至于算法复杂度，由于使用了两层循环遍历矩阵，因此时间复杂度为O(n^3)，空间复杂度为O(n^2)。

希望能够对您有所帮助！