Javascript 求最大和的递增子序列

我试图找到数组的子数组（也称为子序列）。到目前为止，我找到了正确的最大和，但不知道如何找到元素本身。 例如：

输入=[10,70,20,30,50,11,30] 输出=[110，[10,20,30,50]]

我的代码找到110，但我很难找到元素。 我的代码：

const maxsubsequence=（arr）=>{
让我，j；
设msis=arr.slice（）；//复制输入数组
//结果变量
设resultSeq=[]；
设maxSum=0；
让结果=[]；
/*以自下而上的方式计算最大和值*/
对于（i=1；iarr[j]&msis[i]=0；i--）{
if（msis[i])

考虑将索引

i

标记为书签，其中上一个最大递增和序列结束，索引

j

中的当前数字扩展。如果当前数字没有扩展任何先前的序列，则将其设置为-1。现在，在找到最大和的索引后，可以使用书签返回，直到索引变为-1。反向数组将是您期望的最大递增和序列

const maxsubsequence=（arr）=>{
让我，j；
设msis=arr.slice（）；//复制输入数组
//结果变量
设resultSeq=[]；
设maxSum=0；
让结果=[]；
var bookmark=新数组（arr.length）；
书签[0]=-1；
/*以自下而上的方式计算最大和值*/
对于（i=1；iarr[j]&msis[i]=0；i=bookmark[i]）{
结果q.unshift（arr[i]）
}
结果=[maxSum，resultSeq]；
返回结果；
}
console.log(
最大亚层序（[30,20,10,50]）
)

const findSum=arr=>{
var总和=0；
arr.forEach（元素=>{
总和=总和+元素
});
回报金额；
}
常量MaxSubquencesum=arr=>{
//L[i]-最大和增加
//以arr[i]结尾的子序列
var L=[]；
对于（变量i=0；iarr[j]）&&（sumLi${arr[j]}&${sumLi}<${sumLj}`）；
L[j].forEach（k=>{
如果（！L[i].包括（k））{
L[i].推力（k）；
控制台日志（L）；
}     
});
}
}
//L[i]以arr[i]结尾
L[i].push（arr[i]）；
//L[i]现在存储最大和
//以arr[i]结尾的arr[0..i]的子序列
}
//res=L[0]；
var res=[L[0]]；
//找到max
L.forEach（x=>{
如果（findSum（x）>findSum（res））
res=x；
});
//结果变量
var max=0；
var子序列=[]；
var结果；
//对res元素求和=最大和
//每个res元素=子序列
res.forEach（i=>{
max=max+i；
子序列推送（i）；
});
结果=[最大值，子序列]；
//时间复杂度：O（n^2））
返回结果；
}

您愿意分享一些输入和输出示例吗？arrayTwo=[30,20,10,50]；输出：[60，[10,50]]您通常需要维护

maxSumStartIndex

和

maxSumEndIndex

（或

MaxSumarLength

）。maxSumStartIndex和maxSumEndIndex（或MaxSumarLength）-已经尝试了一些类似的方法，但不起作用。答案应该是[80，[30,50]？您的解决方案是O（n^3）由于您的

findsum

功能而导致的时间。在我的答案中，产生递增和序列的解决方案更好，因为它是O（n^2）时间。此外，它只需要O（n）个额外空间，而您的解决方案需要O（n^2）个额外空间。

        const findSum = arr =>{ 
            var sum = 0;
            arr.forEach(element=>{
                sum = sum + element
            });
            return sum;
        }



        const maxSubequenceSum = arr =>{

        // L[i] - The Maximum Sum Increasing
        // Subsequence that ends with arr[i]
        var L = [];

        for (var i = 0; i < arr.length; i++)
                L[i] = [];

        // L[0] is equal to arr[0]
        L[0].push(arr[0]);

        // Start from index 1
        for (var i = 1; i < arr.length; i++) {

            // For each j less than i
            for (var j = 0; j < i; j++) {

            /*
            * L[i] = {MaxSum(L[j])} + arr[i]
            where j < i and arr[j] < arr[i]
            */
                var sumLi = findSum(L[i]);
                var sumLj = findSum(L[j]);

                if ( (arr[i] > arr[j]) && (sumLi < sumLj) ) {
                    console.log(`${arr[i]} > ${arr[j]} && ${sumLi} < ${sumLj}`);
                    L[j].forEach( k=>{
                        if (!L[i].includes(k)){
                            L[i].push(k);
                            console.log(L);
                            
                        }     
                    });
                
                }
            }

            // L[i] ends with arr[i]

            L[i].push(arr[i]);

            // L[i] now stores Maximum Sum Increasing
            // Subsequence of arr[0..i] that ends with arr[i]

        }

        // res = L[0];
        var res = [L[0]];
        
        // Find max
        L.forEach( x =>{
            if (findSum(x) > findSum(res))
                res = x;

        });

        // Results variables
        var max = 0;
        var subSequence=[];
        var result;

        //Summing res elements = Max sum
        //Each res element = subsequence 
        res.forEach(i=>{
            max = max + i;
            subSequence.push(i);
        });


        result = [max,subSequence];
        //Time complexity: O(n^2))
        return result;
}