打印矩阵链乘法（空间优化解决方案）

矩阵链乘法是一种非常常见的问题，在很多领域都有应用，比如计算机图形学和数值分析等。它的本质就是把一个矩阵链相乘，使得每个矩阵的乘积都能正确地计算出来，同时尽量减少计算量。

在这个问题中，我们有一些矩阵（$A_1, A_2, ..., A_n$），这些矩阵的维度分别为 $p_0 \times p_1, p_1 \times p_2, ..., p_{n-1} \times p_n$。我们要找出一种最优的计算方式，使得最终结果的计算量最小。计算量的定义可以是矩阵乘法所需的标量乘法次数、浮点数加减法次数等等。

在这个问题中，有一个非常重要的概念，就是矩阵链的结合律。它指的是，对于任意一组矩阵链 $A_1 \cdot A_2 \cdot ... \cdot A_n$，它们的乘积顺序是固定的，但是我们可以在任意位置添加括号，从而改变计算顺序，例如 $(A_1 \cdot A_2) \cdot (A_3 \cdot A_4 \cdot A_5)$ 和 $A_1 \cdot (A_2 \cdot A_3 \cdot A_4) \cdot A_5$ 都是合法的。因此，我们需要考虑的问题就是，对于任意一组矩阵链，如何添加括号才能使得计算量最小。

有很多种解决方案可以解决这个问题，其中一种非常优美的解法就是动态规划。我们可以定义一个二维数组 $M$，其中 $M_{i,j}$ 表示从第 $i$ 个矩阵到第 $j$ 个矩阵的最小计算量。然后，我们可以考虑每一种可能的括号方式，计算出其中最优的一种。

在这个过程中，需要进行一些中间计算，比如计算每个子问题的最优括号方式、计算矩阵乘积等等。具体实现可以参考下面的伪代码：

def matrix_chain_order(p):
    n = len(p) - 1
    m = [[0] * n for _ in range(n)]
    s = [[0] * n for _ in range(n)]

    for l in range(2, n+1):
        for i in range(n-l+1):
            j = i + l - 1
            m[i][j] = float('inf')
            for k in range(i, j):
                q = m[i][k] + m[k+1][j] + p[i] * p[k+1] * p[j+1]
                if q < m[i][j]:
                    m[i][j] = q
                    s[i][j] = k

    return m, s


def print_optimal_parens(s, i, j):
    if i == j:
        print(f'A{i}', end='')
    else:
        print('(', end='')
        print_optimal_parens(s, i, s[i][j])
        print_optimal_parens(s, s[i][j]+1, j)
        print(')', end='')

其中，matrix_chain_order() 函数用来计算最优计算量及其对应的最优括号方式，print_optimal_parens() 函数用来打印最优括号方式。这两个函数的执行结果如下：

p = [30, 35, 15, 5, 10, 20, 25]
m, s = matrix_chain_order(p)
print_optimal_parens(s, 0, len(p)-2)

((A0(A1A2))((A3A4)A5))

注意，这个算法的时间复杂度是 $O(n^3)$，空间复杂度也是 $O(n^2)$，这可能会在一些规模更大的问题中导致性能问题。因此，我们可以考虑使用一些优化技巧，比如空间优化。

具体来说，我们可以发现在算法的过程中，每次只用到上一层的结果，而不需要保留整个 $M$ 数组。因此，我们可以仅仅保留上一层的结果，来计算下一层的结果，从而将空间复杂度降到 $O(n)$。具体实现可以参考下面的代码：

def matrix_chain_order(p):
    n = len(p) - 1
    m = [0] * n
    s = [0] * n

    for l in range(2, n+1):
        for i in range(n-l+1):
            j = i + l - 1
            m[i] = float('inf')
            for k in range(i, j):
                q = m[k] + m[k+1] + p[i] * p[k+1] * p[j+1]
                if q < m[i]:
                    m[i] = q
                    s[i] = k

    return m, s


def print_optimal_parens(s, i, j):
    if i == j:
        print(f'A{i}', end='')
    else:
        print('(', end='')
        print_optimal_parens(s, i, s[i])
        print_optimal_parens(s, s[i]+1, j)
        print(')', end='')

与之前的代码比较，我们可以发现，这个版本的代码只保留了一个一维数组 m。因此，它的空间复杂度是 $O(n)$。

以上就是关于矩阵链乘法的一个简单介绍，以及一个空间优化的解决方案。如果你想深入研究这个问题，还可以尝试其他的解决方案，比如递归、记忆化搜索等等。