leetcode327 Count of Range Sum

问题描述：

给定一个整数数组nums，返回其所有落在[low, upper]范围内（包含边界）的区间和的数目。
区间和sums(i, j)的定义为所有下标为i到j之间（i ≤ j)的元素的和，包含边界。

思路：

归并排序

问题可描述为，对每个sums[i]，满足lower<=sums[i] - sums[j]<=upper的j的个数，并进行求和。

一个很巧妙的方法是，对sums进行排序得到ocums，然后求ocums[m] - ocums[n] = sums[i] - sums[j]落在上下界的个数，这里想强调的是ocums[m]，ocums[n]分别对应排序前的sums[i]，sums[j]。 这样做的好处是排序后求ocums区间内元素个数要方便很多，比如说对ocums[m]，只需找到刚好满足上界的ocums[y]，和刚好满足下界的ocums[x]，x-y即为个数（注意ocums是升序的，所以x一定大于y），找到上下界的方法如果不用循环线性查找（就是从小到大一个个试），就可以用算法复杂度更低的二分查找，这种思路用于归并排序。

归并排序的思路是，把区间划分为上下两个半空间ｘ和ｙ，然后对两个空间的数一个一个取ｘ［ｉ］和ｙ［ｊ］，比较这两个数，如果ｘ［ｉ］＜ｙ［ｊ］就让ｉ＋１，否则ｊ＋１，并把较小的数加入到新序列中，这样实现排序。当前排序的空间是从小到大的，也就是说需要先把区间划分到最小，然后慢慢合并。

用归并排序的思路求所有的区间和，就是先把区间ｓｕｍｓ划分到最小，然后求满足区间和上下界的个数，然后对区间进行排序，然后合并两个小区间，求满足区间和上下界的个数，然后对合并后区间进行排序，然后又合并排序后的两个区间。。。循环下去；从一棵树的角度来说，就是从根节点开始划分区间，从最底层的区间开始计算个数并排序，并向上排序，因此这是一个递归的过程，求个数的过程是在合并的过程中计算的。

# 归并排序
# 让人不解的两个点
# 1. 为什么最小只划分区间到两个数sums[i, i+1]，而不是一个数？
# 这是因为操作的对象是和，同时要遵循下半区间减上半区间
# 当只有两个数的时候，实质是看nums[i] = sums[i + 1] - sums[i]是否在上下界内
# 最小区间划分不会重叠，也就不会出现sums[i - 1, i]，那还有一个数nums[i - 1]呢
# 这个数会在相邻两个最小区间合并的过程中被考虑（想象一棵二分树）
# 2. 对sums进行排序后得到ocums，选择区间和ocums[i] - ocums[j]在上下界的，这个合理吗
# 问题也说了，区间和就等于sums[m] - sums[n]，本质上还是求源序列的区间和在[m, n]上是否满足上下界
# 这个方法真的很妙啊
# 最后要说这个的算法复杂度是N方的，真不知道怎么就通过了
class Solution(object):
    def countRangeSum(self, nums, lower, upper):
        """
        :type nums: List[int]
        :type lower: int
        :type upper: int
        :rtype: int
        """
        size = len(nums)
        sums = [0] * (size + 1)
        for x in range(1, size + 1):
            sums[x] += nums[x - 1] + sums[x - 1]
        INF = max(sums)

        def mergeSort(lo, hi):
            if lo == hi: return 0
            mi = int((lo + hi) / 2)
            cnt = mergeSort(lo, mi) + mergeSort(mi + 1, hi)
            x = y = lo
            for i in range(mi + 1, hi + 1):
                while x <= mi and sums[i] - sums[x] >= lower:
                    x += 1
                while y <= mi and sums[i] - sums[y] > upper:
                    y += 1
                cnt += x - y
            part = sums[lo : hi + 1]

            l, h = lo, mi + 1
            for i in range(lo, hi + 1):
                x = part[l - lo] if l <= mi else INF
                y = part[h - lo] if h <= hi else INF
                if x < y: l += 1
                else: h += 1
                sums[i] = min(x, y)
            return cnt

        return mergeSort(0, size)

nums = [-2, 5, 1, 3, 1, -4, 2]
lower = -2
upper = 2
X =Solution()
print(X.countRangeSum(nums, lower, upper))

树状数组

还可以对问题就行转换，即求满足sums[i] - upper<=sums[j]<=sums[i] - lower的j的个数，最朴素的方法就是对每一个sums[i]遍历所有的（ｊ，ｊ＜ｉ）

# leetcode 327：求所有区间和在[lower, upper]之间的个数
# 解法1 kk...复杂度为N方，超时了
class Solution(object):
    def countRangeSum(self, nums, lower, upper):
        """
        :type nums: List[int]
        :type lower: int
        :type upper: int
        :rtype: int
        """
        ans = 0
        sum = [0 for _ in nums]
        for i, num in enumerate(nums):
            if i == 0:
                sum[i] = num
            else:
                sum[i] = sum[i - 1] + num
            if sum[i] >= lower and sum[i] <= upper:
                ans += 1
            for j in range(i):
                if sum[j] >= (sum[i] - upper) and sum[j] <= (sum[i] - lower):
                    ans += 1
        return ans

nums = [-2, 5, 1, 3, 1, -4, 2]
lower = -2
upper = 2
X =Solution()
print(X.countRangeSum(nums, lower, upper))

但用更直白的描述就是，求位于(sums[i] - upper, sums[i] - lower)的sums[j]的个数，希望通过排序知道每个值取了多少次，都排在哪个位置，当然前提是每次排序都只有序列的前ｉ个数。也就是说，对sums[i]求个数的时候，只需把sums[i]的值插入到前面已经排好序的新序列中（这个可以用二分法做）。由于我们的目的是对个数求和，可以让序列的值为个数，然后序列的索引为sums[i]，这样，树状数组的结构就出来了。

# 基于上一思路，利用树状数组来降低复杂度
# 同样是为了求落在区间[sumi - upper, sumi - lower]的sumj的个数，
# 前一朴素法是对每个sumi，直接for j in range(0, i)，致使算法复杂度为O(N^2)
# 树状数组的思想是先对sums进行去重排序得到长为m的序列，然后构建一个与该序列等长的树状数组来记录每个值出现的次数
# 于是，要计算落在区间[sumi - upper, sumi - lower]的sumj的个数，只需对该数组求区间和
# 可行性的原因是，在for sumi in sums循环中，树状数组是随着sumi不断生成的，当前树状数组只记录了(x, x<=i)的sumx
# 对于每个sumi，算法复杂度为O(logN)，总的算法复杂度为O(NlogN)
import bisect
class Solution(object):
    def countRangeSum(self, nums, lower, upper):
        """
        :type nums: List[int]
        :type lower: int
        :type upper: int
        :rtype: int
        """
        ans = 0
        sums = [0 for _ in nums]
        for i, num in enumerate(nums):
            if i == 0:
                sums[i] = num
            else:
                sums[i] = sums[i - 1] + num
        oscums = sorted(set(sums))
        ft = FenwickTree(len(oscums))
        for sumi in sums:
            left = bisect.bisect_left(oscums, sumi - upper)
            right = bisect.bisect_right(oscums, sumi - lower)
            ans += ft.getSum(right) - ft.getSum(left) + (lower <= sumi <= upper)
            ft.add(bisect.bisect_right(  oscums, sumi), 1)
        return ans
class FenwickTree(object):
    def __init__(self, n):
        # n 为数组的长度
        self.n = n
        self.c = [0 for _ in range(n + 1)]
    def lowBit(self, x):
        return x & (x ^ (x - 1))
    def add(self, i, val):
        while i <= self.n:
            self.c[i] += val
            i += self.lowBit(i)
    def getSum(self, i):
        sum = 0
        while i > 0:
            sum += self.c[i]
            i -= self.lowBit(i)
        return sum

nums = [-2, 5, -1]
lower = -2
upper = 2
X =Solution()
print(X.countRangeSum(nums, lower, upper))

参考博文：

http://bookshadow.com/weblog/2016/01/11/leetcode-count-of-range-sum/