[leetcode]1109. 航班预订统计（击败100%用户算法-差分数组的详解）

执行用时2ms，击败100%用户

内存消耗52.1MB,击败91%用户

这也是我第一次用差分数组，之前从来没有碰到过，利用差分数组就是利用了差分数组在某一区间内同时加减情况，只会改变最左边和最右边+1的位置上的值。区间最左边同步加减，区间最右边同步加减其相反数。

例如有一原始数组为[2,5,4,7,10,1]

获得的差分数组为[2,3,-1,3,3,-9]

第一步：0-3区间的同步加6

则此时原始数组为[2+6,5+6,4+6,7+6,10,1]

获得的差分数组为[2+6,3,-1,3,3-6,-9]

第二步：2-4区间的同步加3

则此时原始数组为[2+6,5+6,4+6+3,7+6+3,10+3,1]

获得的差分数组为[2+6,3,-1+3,3,-3,-9-3]

可以看出其规律，差分数组对应d[i]=a[i]+a[i-1]

且如果在[m,n]区间同时相加x，那么在差分数组内只有最左边的边缘a改变同步加减，即d[m]=a[m]+x-a[m-1]=(a[m]-a[m-1])+x=d[m]+x

而最右边加了一个数，因为最右边加一的位置会产生变化，即d[n]=a[n]-(a[n-1]+x)=d[n]-x

因此在此题中，只需将其初始化为0的差分数组，然后对应相加减即可。

普通未优化的差分数组

class Solution {
    public int[] corpFlightBookings(int[][] bookings, int n) {
        int [] anser = new int[n];
        for (int i=0;i<bookings.length;i++){
            anser[bookings[i][0]-1] +=bookings[i][2];
            if (bookings[i][1]<=n-1){
                anser[bookings[i][1]] -= bookings[i][2];
            }
        }

//        for (int i=1;i<n;i++){
//            anser[i]=anser[i]+anser[i-1];
//        }
        for (int i =0;i<n;i++){
            if (i==0){
            }else {
                anser[i]=anser[i]+anser[i-1];
            }
        }
        return anser;
    }
}

此时在while循环中需要大量的判断，因此用空间换时间，新建差分数组是我们对留两个，一个留给0的位置，一个留给n+1的位置，这样边间的处理也都在while循环中，结束后再进行重新的赋值，此时时间复杂度最低！

class Solution {
    public int[] corpFlightBookings(int[][] bookings, int n) {
        int [] anser = new int[n+2];
        int [] anser2 = new int[n];
        for (int i=0;i<bookings.length;i++){
            anser[bookings[i][0]] +=bookings[i][2];
            anser[bookings[i][1]+1] -= bookings[i][2];
        }

        for (int i =0;i<n;i++){
            anser[i+1] = anser[i]+anser[i+1];
        }
        for (int i=1;i<=n;i++){
            anser2[i-1]=anser[i];
        }
        return anser2;
    }
}