Algorithm 求数组元素乘积和和的最大值的动态规划

您好，我有以下问题要解决：

给定整数数组：

127512

我想找到最大相邻乘积和，即

1+2+（5*7）+1+2=41

给定整数数组：1 2 4 2 我想找到最大相邻乘积和，即

1+（2*4）+（2*4）+2=19

乘法的限制条件是只有一个相邻元素可以用于乘法。 i、 e.如果数组中有

242

，我们将其计算为

2+（4*2）或（2*4）+2

我是动态规划的初学者。 我无法找出以下问题的递归关系

---

有人能提出一些建议吗？

逐步解决方案如下：

• 考虑第一个元素，当没有其他元素时，它是最大值
• 当您的所有元素都不存在时，请继续
• 添加第i个元素：
  • F（i）=最大值{F（i-1）+ei，F（i-2）+ei-1*ei）

其中F（i）是第一个i元素的最大值，ei是第i个元素

考虑一下：

1234

• 首先我们有

  F（1）=1

• 然后

  F（2）=1+2

• 然后我们比较

  F（2）+4=1+2+4

  和

  F（1）+2*4=1+2*4

  ，因此

  F（3）=1+2*4=9

• 然后你有

  F（2）+4*3=1+2+4*3

  和

  F（3）+3=1+2*4+3

  ，所以它是

  F（4）=1+2+4*3=15

• 然后你有

  F（4）+4=1+2+4*3+4

  和

  F（3）+3*4=1+2*4+3*4

  ，所以它是

  F（5）=1+2*4+3*4=21

---

我正在发布此问题的完整java解决方案。为实现的逻辑添加了内联注释

public class MaxValueOfRagularExpression {

    public static void main(String[] args) {
        int size=6;
        int arr[] = new int[size];

        arr[0]=2;
        arr[1]=1;
        arr[2]=1;
        arr[3]=1;
        arr[4]=1;
        arr[5]=2;

        // array elements are as follows :
        // A0     A1    A2      A3    A4     A5
        // 2      1      1      1     1      2

        int sol[] = new int[size];
        sol[0]=arr[0];
        for(int i = 1;i<size;i++){
            // sol[i] would contain the optimized value so far calculated.
            for(int k = 0;k<i ;k++) {
                // for each k , find sum of all array elements  i.e. k+1<=j<=i
                // and then calculate max of (sol[k] + sum or sum[k] * k )
                int sum =0;
                for (int j = k+1; j <= i; j++) {
                    sum += arr[j];
                }
                sol[i] = Math.max(Math.max(sol[i],(sol[k] + sum)), sol[k]*sum);
            }
        }
        // after processing above block , the sol array will look like :
        //SOL[0]  SOL[2]   SOL[2]   SOL[3]   SOL[4]   SOL[5]
        // 2        3       4        6          9     18
        System.out.println(sol[size-1]);
    }
}

公共类MaxValueOfRagularExpression{
公共静态void main（字符串[]args）{
int size=6；
int arr[]=新的int[size]；
arr[0]=2；
arr[1]=1；
arr[2]=1；
arr[3]=1；
arr[4]=1；
arr[5]=2；
//数组元素如下所示：
//A0 A1 A2 A3 A4 A5
// 2      1      1      1     1      2
int sol[]=新的int[大小]；
sol[0]=arr[0]；
对于（int i=1；我想我们还需要初始化F（0）和F（1），然后使用以下递归。如果有更好的方法，请纠正我。@mribot i在前两个步骤中初始化F（1）和F（2）