zoukankan      html  css  js  c++  java
  • [饭后算法系列] 数组中"和非负"的最长子数组

    1. 问题

    给定一列数字数组 a[n], 求这个数组中最长的 "和>=0" 的子数组. (注: "子数组"表示下标必须是连续的. 另一个概念"子序列"则不必连续)

    举个例子:

    数组 a[n] = {1, 2, -4, 5, -6, 1}, 最长的和非负的子数组为 {1, 2, -4, 5}, 其他子数组要么和<0, 要么长度<4

    2. 暴力法

    我们先来看看暴力解法和时间复杂度

    1. 如果我求出所有的数组前缀和 即P(i) = a[1]到a[i]的和

    2. 然后对于数组的所有子数组 a[i..j], 它的和为 P(j) - P(i-1)

    第一步预处理的时间复杂度为O(n). 第二步是暴力法的主体, 穷举了所有O(n^2)个子数组, 每个子数组和的计算需要时间O(1). 因此整个算法的时间复杂度就是O(n^2)

    由此可见, 任何优化必须使得复杂度小于 O(n^2)

    3. 算法优化

    算法是一门基于观察的学科, 让我们先从例子入手, 观察一下优化的方法

    对于数组a[n], 用动态规划法从第一个数开始往后遍历

    1 2 -4 5 -6 1
    (1,1) (2,3) (3,-1) (4,4) (5,-2) (6,-1)
      (1,2) (2,-2) (3,3) (4,-3) (5,-2)
        (1,-4) (2,1) (3,-5) (4,-4)
          (1,5) (2,-1) (3, 0)
            (1,-6) (2,-5)
              (1, 1)

    1. 遍历到第一个数1时, 填写(1,1), 表示第一个数的和为1

    2. 遍历到第二个数2时, 填写(2,3), 表示前两个数的和为3; 填写(1,2), 表示前一个数(即2自己)的和为2

    以此类推, 填完所有6列, 可以看到第4列的(4,4)是和为4>=0, 且长度最长的结果

    这个做法仍然需要O(n^2), 有什么办法优化呢?

    3.1 计算简化

    这个表格的计算是可以简化的:

      1 2 -4 5 -6 1
      0          
        -1        
          -3      
            1    
              -4  
                2
    sum 1 3 -1 4 -2 -1

    这是什么意思呢?

    假设运算到第k列的时候, 所有以a[k]结尾的子数组和记为b[k] = [sum(1..k), sum(2..k), ..., sum(k..k)]

    我只要记录b[k]的变形c[k]即可, c[k] = [0, -sum(1..1), -sum(1..2), ..., -sum(1..k-1)], 要从c[k]转回b[k], 我只要简单的把c中的每个元素值加上sum(1..k)

    这样做的好处是: 我从c[k]前进到c[k+1]的时候, 只要简单地在最后加一个元素-sum(1..k), 而不需要修改前面的元素. 这使得前进一步的开销为O(1)

    转化后, 我要找b[k]中>=0的元素, 等同于找c[k]中>=-sum(1..k)的元素, 这个查找过程怎么简化呢?

    3.2 单调优化

    这个过程是可以发现单调性优化的. 为了方便, 我把表格转回最开始的样子:

    1 2 -4 5 -6 1
    (1,1) (2,3) (3,-1) (4,4) (5,-2) (6,-1)
      (1,2) (2,-2) (3,3) (4,-3) (5,-2)
        (1,-4) (2,1) (3,-5) (4,-4)
          (1,5) (2,-1) (3, 0)
            (1,-6) (2,-5)
              (1, 1)

    被飘灰的这些格子, 在同一列中, 都有长度以及总和都比它大的另一个格子. 这些飘灰的格子一定不在最终的结果中.

    比如第3列中, (2,-2)的上面有(3,-1). 也就是-4往前加2个数的和为-2, 往前加3个数的和为-1. 如果最终答案包含了-4往前的2个数, 那我一定能够换成-4往前3个数, 总和比原来大了1, 且长度也比原来长

    去掉飘灰的这些格子后, 我们发现, 每一列的第二个数(和)是单调递增的.

    因为我要找每列第二个数(和)>=0的格子, 由于有了单调性之后, 我就能用二分查找了, 查找的复杂度为O(lgn)

    3.3 总结

    综合3.1和3.2, 在这个动态规划过程中, 遍历的每一步, 时间复杂度=O(1)+O(lgn), 总共遍历n次, 因此总的时间复杂度为O(nlgn)

    关键字: 算法, 动态规划, 数组

  • 相关阅读:
    【Swift】图文混排,ios开发中在textfield或textView中插入图片
    ios开发-指纹识别
    ios开发-程序压后台后,悄悄的抓取数据~~
    setNeedDisplay和setNeedsLayout
    rangeOfString用法
    NSThread的使用
    UIActivityIndicatorView的详细使用
    iOS高斯模糊处理
    HIbernate学习笔记(一) 了解hibernate并搭建环境建立第一个hello world程序
    Hibernate4搭建Log4J日志管理(附Log4j.properties配置详解)
  • 原文地址:https://www.cnblogs.com/testview/p/3615493.html
Copyright © 2011-2022 走看看