Java 如何生成所有矩阵乘法顺序组合

我找了很多，但找不到任何解决办法

任何编程语言的答案都可以接受。特别是C，Java，C#

不过我更喜欢C#

所以这里是我的问题

例1

假设我有以下矩阵

A1, A2, A3

所以它们可以按以下顺序相乘

A1*A2*A3
A1*(A2*A3)
(A1*A2)*A3

另一个例子

A1, A2, A3, A4, A5

几种可能的乘法顺序如下所示

        (A1*A2)*(A3*A4)*A5

        A1*(A2*A3)*(A4*A5)

        A1*(A2*A3*A4*A5)
               .
               .
               .

那么，有没有办法设计一个算法来找到所有的

---

它可以是递归的，内存有动态的？

为了拥有所有的组合，我使用数组“group”来保留哪个矩阵在哪个括号中。 例如，一组1是“（M）”，一组2是“（M*M）”，一组3是“（M*M*M）”等等

如果我们有5个矩阵，那么

• 分组=[1,1,1,1,1]给出“（M）*（M）*（M）*（M）*（M）*（M）”
• 组=[4,0,0,0,1]给出“（M*M*M*M）*（M）”

我在“组”中使用了如下值： 如果它是一个大于0的数字，那么它就是组中持有的矩阵的数量。 如果为0，则矩阵由第一个值“拥有”=0带有较小的标记

示例：组=[2,0,3,0,0]

指标1中的0表示指标1中的矩阵由指标0中的组“拥有”。 指标4中的0表示指标4中的矩阵由指标2中的集团“拥有”（而非0）

您现在可以使用“组”来了解如何计算实际矩阵（我的只是一个字符串）

现在，算法的核心在于

如何才能拥有下一个“组”

。 为此，我使用以下规则（我从头到尾遍历数组）：

• 找到第二组并增加其大小

为什么是第二组？因为你不可能在没有太多矩阵的情况下增加第一个

如果组=[1,1,1,1,1]，则有5个矩阵。 如果我增加第一组，那么[1,1,1,1,2]将有6个矩阵，这是不可能的

• 将新增加的组中的以下所有矩阵设置为0

• 然后，将以下所有矩阵设置为1的组

这是一个新代码，你能理解吗

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>

#define NB_MAT 3

void MatriceGroupDisplay(int group[NB_MAT])
{
    for (int i = 0; i < NB_MAT; ++i) {
        if (group[i] > 1) {
            printf("(");
        }
        printf("M%d", i + 1);
        if (group[i] == 0 && (i + 1 >= NB_MAT || group[i + 1] != 0)) {
            printf(")");
        }
        if (i != NB_MAT - 1) {
            printf(" * ");
        }
    }
    printf("\n");
}

bool FoundNextMatriceGroup(int group[NB_MAT])
{
    int i;
    int nbGroup = 0;

    // There are one group, so no more combination is possible
    if (group[0] == NB_MAT) {
        return (false);
    }
    // We found the second group ...
    for (i = NB_MAT - 1; nbGroup != 2; --i) {
        if (group[i] != 0) {
            ++nbGroup;
        }
    }
    ++i;
    // ... and increment it's size.
    ++group[i];
    // All the following "matrix" are in the group ...
    for (int j = 1; j < group[i]; ++j) {
        group[i + j] = 0;
    }
    // ... and all the following group have a size of 1
    for (int j = i + group[i]; j < NB_MAT; ++j) {
        group[j] = 1;
    }

    return (true);
}

int main(void)
{
    int group[NB_MAT];

    for (size_t i = 0; i < NB_MAT; ++i) {
        group[i] = 1;
    }

    MatriceGroupDisplay(group);
    while (FoundNextMatriceGroup(group)) {
        MatriceGroupDisplay(group);
    }
    return (EXIT_SUCCESS);
}

#包括
#包括
#包括
#定义NB_材料3
无效矩阵组显示（整数组[NB_MAT]）
{
对于（int i=0；i1）{
printf（“（”）；
}
printf（“M%d”，i+1）；
if（组[i]==0&（i+1>=NB|MAT | |组[i+1]！=0））{
printf（“）”；
}
如果（i！=NB_MAT-1）{
printf（“*”）；
}
}
printf（“\n”）；
}
布尔FoundNextMatriceGroup（内部组[NB_MAT]）
{
int i；
int-nbGroup=0；
//只有一个组，因此不可能再进行组合
if（组[0]==NB\U MAT）{
返回（假）；
}
//我们找到了第二组。。。
对于（i=NB_MAT-1；nbGroup！=2；--i）{
如果（组[i]！=0）{
++NB组；
}
}
++一,；
//…并增加它的大小。
++第[i]组；
//以下所有“矩阵”都在组中。。。
对于（int j=1；j<组[i]；++j）{
组[i+j]=0；
}
//…以下所有组的大小均为1
对于（int j=i+群[i]；j

---

---

旧代码（递归无用，矩阵数组无用，查找下一组算法更复杂）

#包括
#定义NB_材料5
void matDisplay（字符*矩阵[NB_MAT]，整数组[NB_MAT]）
{
对于（int i=0；i1）{
printf（“（”）；
}
printf（“%s”，矩阵[i]）；
if（组[i]==0&（i+1>=NB|MAT | |组[i+1]！=0））{
printf（“）”；
}
如果（i！=NB_MAT-1）{
printf（“*”）；
}
}
printf（“\n”）；
}
void rec（字符*矩阵[NB_MAT]，整数组[NB_MAT]）
{
matDisplay（矩阵，组）；
int i=NB_MAT-1；
//我们发现了第一个可以扩大规模的“群体”
而（i>=0）{
如果（组[i]！=0和组[i]+1如果您标记了一种以上的语言，那么您的问题在99%的情况下都是广义的。因此，请花一些时间重新阅读，并且。自然递归：对
n
元素的分组与第一组
k
元素+对其余
n-k
元素的分组相同，对于每个
k
从
1
到
n
。对于2个矩阵，只有一个解决方案，对于3个矩阵，有两个解决方案（示例的第一行和第三行是相同的），对于4个矩阵，有？个解决方案…试着从这一点开始了解一下。对于n个矩阵，可以这样做的方法有（n-1）！=（n-1）·（n-2）·（n-3）···2·1。算法的关键是只考虑乘法运算（其中有n-1）。。如果你把乘法运算从1数到N-1，那么问题就在于生成这些数字的所有排列。这不需要递归，可以迭代完成。所以，从查找开始。是的，这是正确的答案。你能详细解释一下吗？我已经编辑了，但我很难解释清楚，所以如果有不清楚的地方，请不要犹豫提问。
#include <stdio.h>

#define NB_MAT 5

void matDisplay(char *matrices[NB_MAT], int group[NB_MAT])
{
    for (int i = 0; i < NB_MAT; ++i) {
        if (group[i] > 1) {
            printf("(");
        }
        printf("%s", matrices[i]);

        if (group[i] == 0 && (i + 1 >= NB_MAT || group[i + 1] != 0)) {
            printf(")");
        }
        if (i != NB_MAT - 1) {
            printf(" * ");
        }

    }

    printf("\n");
}

void rec(char *matrices[NB_MAT], int group[NB_MAT])
{
    matDisplay(matrices, group);

    int i = NB_MAT - 1;

    // We found the first "group" that we can increase in size
    while (i >= 0) {
        if (group[i] != 0 && group[i] + 1 <= NB_MAT - i) {
            ++group[i];
            break;
        }
        --i;
    }
    if (i < 0) {
        return ;
    }

    // The following matrice are in the "group"
    int nbInGroup = group[i];
    for (int j = 1; j < nbInGroup; ++j) {
        group[i + j] = 0;
    }

    // All the other group is 1
    for (int j = i + nbInGroup; j < NB_MAT; ++j) {
        group[j] = 1;
    }

    rec(matrices, group);
}

int main(void)
{
    char *matrices[NB_MAT] = {"M1", "M2", "M3", "M4", "M5"};
    int  group[NB_MAT]     = {1, 1, 1, 1, 1};

    rec(matrices, group);

    /*
    11111 (a)*(b)*(c)*(d)*(e)
    1112. (a)*(b)*(c)*(d*e)
    112.1 (a)*(b)*(c*d)*(e)
    113.. (a)*(b)*(c*d*e)
    12.11 (a)*(b*c)*(d)*(e)
    12.2. (a)*(b*c)*(d*e)
    13..1 (a)*(b*c*d)*(e)
    14... (a)*(b*c*d*e)
    2.111 (a*b)*(c)*(d)*(e)
    2.12. (a*b)*(c)*(d*e)
    2.2.1 (a*b)*(c*d)*(e)
    2.3.. (a*b)*(c*d*e)
    3..11 (a*b*c)*(d)*(e)
    3..2. (a*b*c)*(d*e)
    4...1 (a*b*c*d)*(e)
    5.... (a*b*c*d*e)
    */

}