leetcode【中等】1395、统计作战单位数

n 名士兵站成一排。每个士兵都有一个 独一无二 的评分 rating 。

每 3 个士兵可以组成一个作战单位，分组规则如下：

从队伍中选出下标分别为 i、j、k 的 3 名士兵，他们的评分分别为 rating[i]、rating[j]、rating[k]
作战单位需满足： rating[i] < rating[j] < rating[k] 或者 rating[i] > rating[j] > rating[k] ，其中 0 <= i < j < k < n
请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。

示例 1：

输入：rating = [2,5,3,4,1]
输出：3
解释：我们可以组建三个作战单位 (2,3,4)、(5,4,1)、(5,3,1) 。

示例 2：

输入：rating = [2,1,3]
输出：0
解释：根据题目条件，我们无法组建作战单位。

思路1、动态规划

对于rating中的任意一个数rating[i]，寻找rating[i]左侧比它小的数，和右侧比它大的数，两数相乘即为以rating[i]为中间数的升序个数
时间复杂度：O(N^2)

class Solution {
    public int numTeams(int[] rating) {
        if(rating.length<3) return 0;
        int res=0;
        //对于rating中的任意一个数rating[i]，
        //寻找rating[i]左侧比它小的数，和右侧比它大的数，
        //两数相乘即为以rating[i]为中间数的升序个数
        for(int i=0;i<rating.length;i++){
            int leftLess=0,leftMore=0,rightLess=0,rightMore=0;
            for(int j=i-1;j>=0;j--){
                if(rating[j]<rating[i]) leftLess++;
                else leftMore++;
            }
            for(int j=i+1;j<rating.length;j++){
                if(rating[j]>rating[i]) rightMore++;
                else rightLess++;
            }
            res+=leftLess*rightMore;
            res+=leftMore*rightLess;
        }
        return res;
    }
}

思路2、树状数组

• 枚举来求解这四个量leftLess=0,leftMore=0,rightLess=0,rightMore=0，单次枚举的时间代价是 O(N)
• 假设我们有一个桶数组，索引 i 的值为 1 就说明存在元素 i，为 0 就说明不存在元素 i。依次遍历，遍历过就标记1，算出之前遍历过的数中有几个比自己大的，也就是 1 的个数加起来。那么该桶数组的前缀和 preffixSum[i−1] 就表示，当前比 i 小的数的个数，我们只需要用树状数组动态维护这个前缀和，就可以把单次的时间代价从 O(N)优化到 O(logN)。
• 我们对 rating 数组做两次遍历，一次从前向后，一次从后向前。从前向后的时候，对于每一个 rating[i] （记为 x），求到上述桶数组下标 x - 1 的前缀和，即 leftLess；记 rating 数组中出现的最大值为 rmax，用 rmax 的前缀和减去 x 位置的前缀和，即可得到 leftMore。从后向前的那次遍历同理。

时间复杂度：O(NlogN)

3 <= n <= 100000

class Solution {
    public int numTeams(int[] rating) {
        int res = 0;
        int n = rating.length;
        int[] leftLess=new int[n],leftMore=new int[n],rightLess=new int[n],rightMore=new int[n];
        BIT bit=new BIT(100005);
        for(int i=0;i<n;i++){
            bit.update(rating[i]);
            leftLess[i]=bit.query(rating[i]-1);
            leftMore[i]=bit.query(100005)-bit.query(rating[i]);
        }
        BIT bit2=new BIT(100005);
        for(int i=n-1;i>=0;i--){
            bit2.update(rating[i]);
            rightLess[i]=bit2.query(rating[i]-1);
            rightMore[i]=bit2.query(100005)-bit2.query(rating[i]);
        }
        for(int i=0;i<n;i++){
            res+=leftLess[i]*rightMore[i]+leftMore[i]*rightLess[i];
        }
        return res;
    }
}

class BIT {
    private int[] tree;
    private int n;

    public BIT(int n) {
        this.n = n;
        this.tree = new int[n + 1];
    }

    public static int lowbit(int x) {
        return x & (-x);
    }

    public int query(int x) {//查找比x小的数的个数
        int ret = 0;
        while (x != 0) {
            ret += tree[x];
            x -= lowbit(x);
        }
        return ret;
    }

    public void update(int x) {
        while (x <= n) {
            ++tree[x];
            x += lowbit(x);
        }
    }
}