LintCode:区间求和

LintCode:区间求和

暴力求解，超时。。。

"""
Definition of Interval.
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""


class Solution: 
    """
    @param A, queries: Given an integer array and an Interval list
                       The ith query is [queries[i-1].start, queries[i-1].end]
    @return: The result list
    """
    def intervalSum(self, A, queries):
        # write your code here
        if not A:
            return []
        ans = []
        for interval in queries:
            ans.append(sum(A[interval.start:interval.end+1]))
        return ans

然后尝试线段树，内存超限。。。

"""
Definition of Interval.
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""


class Solution: 
    """
    @param A, queries: Given an integer array and an Interval list
                       The ith query is [queries[i-1].start, queries[i-1].end]
    @return: The result list
    """
    def intervalSum(self, A, queries):
        # write your code here
        if not A:
            return []
        n = len(A) - 1
        root = SegmentTreeNode(0, n, sum(A))
        self.build_segment_tree(root, A)
        ans = []
        for interval in queries:
            self.res = 0
            self.query(root, interval.start, interval.end)
            ans.append(self.res)
        return ans

    def build_segment_tree(self, root, A):
        if root.start == root.end:
            return

        left_start = root.start
        left_end = (root.start + root.end) / 2
        left_val = sum(A[left_start:left_end+1])

        right_start = (root.start + root.end) / 2 + 1
        right_end = root.end
        right_val = sum(A[right_start:right_end+1])

        root.left = SegmentTreeNode(left_start, left_end, left_val)
        root.right = SegmentTreeNode(right_start, right_end, right_val)

        self.build_segment_tree(root.left, A)
        self.build_segment_tree(root.right, A)

    def query(self, root, start, end):
        if start > root.end or end < root.start:
            return
        if start <= root.start and end >= root.end:
            self.res += root.max
            return
        self.query(root.left, start, end)
        self.query(root.right, start, end)

Java 终于AC，看来Java的数组相对Python来说确实省点空间。

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 */

 class SegmentTreeNode {
      public int start, end;
      long max;
      public SegmentTreeNode left, right;
      public SegmentTreeNode(int start, int end, long max) {
          this.start = start;
          this.end = end;
          this.max = max;
          this.left = this.right = null;
      }
  }

public class Solution {
    /**
     *@param A, queries: Given an integer array and an query list
     *@return: The result list
     */
     public Long res = (long) 0;
    public ArrayList<Long> intervalSum(int[] A, 
                                       ArrayList<Interval> queries) {
        // write your code here
        int n = A.length - 1;
        long val = sum(A, 0, n);
        SegmentTreeNode root = new SegmentTreeNode(0, n, val);
        buildSegmentTree(root, A);
        ArrayList<Long> resault = new ArrayList<Long> ();
        for(Interval interval : queries){
            res = (long) 0;
            myQuery(root, interval.start, interval.end);
            resault.add(res);
        }
        return resault;

    }
    private void buildSegmentTree(SegmentTreeNode root, int[] A){
        if(root.start == root.end){
            return;
        }
        int left_start = root.start;
        int left_end = (root.start + root.end) / 2;
        long left_val = sum(A, left_start, left_end);
        root.left = new SegmentTreeNode(left_start, left_end, left_val);

        int right_start = (root.start + root.end) / 2 + 1;
        int right_end = root.end;
        long right_val = sum(A, right_start, right_end);
        root.right = new SegmentTreeNode(right_start, right_end, right_val);

        buildSegmentTree(root.left, A);
        buildSegmentTree(root.right, A);
    }

    private long sum(int[] A, int start, int end){
        long ans = 0;
        for(int i=start; i<=end; i++){
            ans += A[i];
        }
        return ans;
    }
    private void myQuery(SegmentTreeNode root, int start, int end){
        if (start > root.end || end < root.start){
            return;
        } 
        if (start <= root.start && end >= root.end){
            res += root.max;
            return;
        }
        myQuery(root.left, start, end);
        myQuery(root.right, start, end);
    }
}