最大子列和问题

第一种三种循环遍历各种方式

int ans = 0;
    for(int i = n; i > 0; i++)// 长度
    {
        for(int j = 0; j + i< n; j++) //起点
        {
            int sum = 0;
            for(int z = j; z < j + i; z++) // 经历的每一个
            {
                sum += a[z];
            }
            ans = max(ans, sum);
        }
    }
    cout << ans;

第二种 用二重循环遍历

int ans = 0;
    for(int i = 0; i < 10; i++)// 起点
    {
        int sum = 0;
        for(int j = i; j < 10; j++) // 终点
        {
            sum += a[j];
            ans = max(ans, sum);
        }
    }
    cout << ans;

第二种方式其实是第一种方式的优化， 第一种方式是把每个循环的个体放在第三重循环再经历一边， 而第二种是在起点确定，终点增加时，前一个重点加上新的终点也就是  sum + a[j]

第三种 贪心

如果前面i-1个数 更新的连续的最大和是小于0 的 那么就舍弃 考虑新的子列

int sum = 0, ans = 0;
    for(int i = 0; i < 10; i++)
    {
        sum += a[i];
        ans = max(ans, sum);
        if(sum < 0)
        {
            sum = 0;
        }
    }
    cout << ans;

第四种 分治

int DivideAndConquer(int List[], int left, int right)
{
    int MaxLeftSum, MaxRightSum;
    int MaxLeftBorderSum, MaxRightBorderSum;
    int LeftBorderSum, RightBorderSum;
    int center, i;
    if (left == right)
    {
        return (List[Left] > 0) ? List[left] : 0;
    }
    center = (left + right)/2;
    MaxLeftSum = DivideAndConquer(List, left, center);
    MaxRightBorderSum = DivideAndConquer(List, center+1, right);
    MaxLeftBorderSum = LeftBorderSum = 0;
    for(int i = center; i >= left; i--)
    {
        LeftBorderSum += List[i];
        if(LeftBorderSum > MaxLeftBorderSum)
        {
            MaxLeftBorderSum = LeftBorderSum;
        }
    }
    RightBorderSum = RightBorderSum = 0;
    for(int i = center+1, i <= right; i++)
    {
        RightBorderSum += List[i];
        if(RightBorderSum > MaxRightBorderSum)
        {
            MaxLeftBorderSum = RightBorderSum;
        }
    }
    return MAX3(MaxLeftBorderSum, MaxRightBorderSum, MaxLeftSum, MaxRightSum);
}