List 返回最大子列表的和

我必须编写一个函数，它接受整数列表并返回列表的最大和子列表。例如：

l = [4,-2,-8,5,-2,7,7,2,-6,5]

返回

19

到目前为止，我的代码是：

count = 0
for i in range(0,len(l)-1):
    for j in range(i,len(l)-1):
        if l[i] >= l[j]:

            count += l[i:j]

return count

我有点困惑，有人能帮我吗？

---

谢谢大家!

我假设这是一个家庭作业，所以我不会尝试在这里搜索算法和/或发布太多代码

一些想法（只是出于我的想法，因为我喜欢这类任务：-）

正如用户lc已经指出的那样，简单且详尽的方法是测试每个子列表。我相信你的（user2101463）代码就是朝这个方向发展的。只需使用

sum（）

建立总和，并与已知最佳值进行比较。要用一个合理的起始值对最著名的和进行素数，只需使用列表的第一个值

the_list = [4,-2,-8,5,-2,7,7,2,-6,5]

best_value = the_list[0]
best_idx = (0,0)
for start_element in range(0, len(the_list)+1):
    for stop_element in range(start_element+1, len(the_list)+1):
        sum_sublist = sum(the_list[start_element:stop_element])
        if sum_sublist > best_value:
            best_value = sum_sublist
            best_idx = (start_element, stop_element)

print("sum(list([{}:{}])) yields the biggest sum of {}".format(best_idx[0], best_idx[1], best_value))

这当然有二次运行时O（N^2）。这意味着：如果问题大小（由输入列表的元素数量定义）随N增长，则运行时随N*N增长，并带有一些任意系数

改进的一些启发式方法：

• 显然，负数是不好的，因为它们减少了可实现的和
• 如果遇到一系列负数，如果到目前为止最佳列表加上负数之和小于0，请在该序列之后重新启动最佳子列表。在您的示例列表中，前三个数字不能是最佳列表的一部分，因为

  4

  的积极作用总是被

  -2，-8

  抵消
• 这甚至可能导致一个

  O（N）

  实现，它只是从开始到结束进行迭代，在存储最著名的开始索引的同时，计算该开始索引的完整总数的运行和，以及分别计算最后一个连续的正数和负数序列的正数和负数小计
• 一旦找到这样一个最佳列表，可能需要进行最终清理，以删除尾部的负子列表，例如示例末尾的

  -6,5

---

希望这是正确的方向。

这被称为“最大子阵列问题”，可以在线性时间内完成。这个问题有你的答案。

最理想的解决方案是采用线性运行时，即O（n）。但是这个问题有“n*lgn”运行时解决方案（基于分治算法）和“n^2”运行时解决方案。如果您对这些算法感兴趣，这里是极力推荐的链接，我在java中编写了一个具有线性运行时的代码

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int []A=new int[n];
    int highestsum=Integer.MIN_VALUE;
    int sumvariable=0;
    int x=0;
    for(int i=0;i<n;i++)
    {
        A[i]=sc.nextInt();
    }
    for(int i=0;i<n;i++)
    {
        sumvariable+=A[i];
        if(sumvariable<0)
        {
            if(sumvariable>=highestsum)
            {
                highestsum=A[i];
                sumvariable=A[i];
            }
            else
            {
                sumvariable=0;
            }
        }
        else
        {
            if(sumvariable>highestsum)
            {
                highestsum=sumvariable;
            }

        }
    }
    System.out.println(highestsum);
}

publicstaticvoidmain（字符串[]args）{
//TODO自动生成的方法存根
扫描仪sc=新的扫描仪（System.in）；
int n=sc.nextInt（）；
int[]A=新的int[n]；
int highestsum=Integer.MIN_值；
int变量=0；
int x=0；
对于（int i=0；i）而言，最简单的方法是检查所有长度为1的每个可能的子列表。
len（l）
。也就是说，您将检查每个子列表长度1，然后检查每个子列表长度2，然后检查每个子列表长度3，并输出找到的最大可能的副本