Java 最大子序列乘积特殊情况

我正在尝试编写一个最大子序列乘积程序，它基于最大子序列和程序的递归解（也就是说，它将遵循相同的格式）

到目前为止，它适用于所有情况，但结果应为“0”的情况除外，以表明序列中没有正的产物。对于我下面的五个序列，除了最后一个序列外，其他所有序列都有效：

sequence1 = new int[]{-2, 5, 4, 4};
sequence2 = new int[]{6, 5, 0, -3, -5, -3, 7};
sequence3 = new int[]{0, -1, 1, 5, 0, -3, -4};
sequence4 = new int[]{0, 3, 3};
sequence5 = new int[]{0, -3, 3};

这里是递归方法，其中a是序列，p1最初是[0]，p2是[last index]：

public static int msp3(int[] a, int p1, int p2) {

    if (p1 == p2) {
        if (a[p1] != 0) {
            maxprod = a[p1];
        } else {
            maxprod = 0;
        }

    } else {
        int m = (p1 + p2) / 2;

        int L = msp3(a, p1, m);
        int R = msp3(a, m + 1, p2);

        int prodlt = 1, prodrt = 1, PL = 0, PR = 0;

        int checkForSplit = 0;

        for (int i = m; i >= p1; i--) {

            if (a[i] != 0) {
                prodlt = prodlt * a[i];

                if (prodlt > PL) {
                    PL = prodlt;
                }
            } else {
                if (i == m) {
                    prodlt = 1;
                    checkForSplit = 1;
                }
            }
        }

        for (int i = m + 1; i <= p2; i++) {
            if (a[i] != 0) {
                prodrt = prodrt * a[i];

                if (prodrt > PR) {
                    PR = prodrt;
                }
            } else {
                if (i == m + 1) {
                    prodrt = 1;
                    checkForSplit = 1;
                }
            }
        }

        if (checkForSplit == 0) {
            maxprod = max3(L, R, PL * PR);
        } else {
            maxprod = max3(L, R, PL);
            maxprod = max(maxprod, PR);
        }

    }
    return maxprod;
}

publicstaticintmsp3（int[]a，intp1，intp2）{
如果（p1==p2）{
如果（a[p1]！=0）{
maxprod=a[p1]；
}否则{
maxprod=0；
}
}否则{
int m=（p1+p2）/2；
int L=msp3（a，p1，m）；
int R=msp3（a，m+1，p2）；
int prodlt=1，prodrt=1，PL=0，PR=0；
int checkForSplit=0；
对于（int i=m；i>=p1；i--）{
如果（a[i]！=0）{
prodlt=prodlt*a[i]；
if（prodlt>PL）{
PL=产品；
}
}否则{
如果（i==m）{
prodlt=1；
checkForSplit=1；
}
}
}
对于（int i=m+1；i PR）{
PR=prodrt；
}
}否则{
如果（i==m+1）{
prodrt=1；
checkForSplit=1；
}
}
}
如果（checkForSplit==0）{
maxprod=max3（L，R，PL*PR）；
}否则{
maxprod=max3（L，R，PL）；
maxprod=max（maxprod，PR）；
}
}
返回maxprod；
}

关于“checkForSplit”的一个注释，除非[i]==0，否则该值为0，并且我们正在检查当前子序列中最左边或最右边的索引，在这种情况下，它被设置为1。这会触发“max3”的不同计算，其中PL不乘以PR，逻辑是如果PL或PR中的任何一个为0，则两个中的另一个可能不为0，在这种情况下，它们不应相乘

正如我所说，这个算法适用于除第5个序列以外的所有序列

---

有什么想法吗？

空集的乘积是1，而不是0。因此，如果你真的在做类似的问题，那么乘积永远不会低于1

因此，您实际要解决的问题最好描述为“具有2个或更多成员的子序列的最大乘积”。要解决此问题，请尝试提出一个递归函数，该函数接受序列和范围，并返回4个数字：

最小元素

最大元素

两个或多个元素的最小乘积

两个或多个元素的最大乘积

2元素部分和3元素部分的情况需要编码为明显的特殊情况

对于递归步骤，最小和最大元素的逻辑是显而易见的。最小和最大乘积将是8个可能的乘积中的最小和最大乘积，其中一个是这4个数字中的一个，另一个是这4个数字中的一个