You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].

Example:

Given nums = [5, 2, 6, 1]

To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1
 
 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.

Return the array [2, 1, 1, 0].

方法一：窮舉計數，時間複雜度O(n^2)，超時、無法通過。

public class Solution {
    public List<Integer> countSmaller(int[] nums) {
        int[] smaller = new int[nums.length];
        for(int i=0; i<nums.length-1; i++) {
            for(int j=i+1; j<nums.length; j++) {
                if (nums[i] > nums[j]) smaller[i] ++;
            }
        }
        List<Integer> results = new ArrayList<>(smaller.length);
        for(int i=0; i<smaller.length; i++) results.add(smaller[i]);
        return results;
    }
}
 

public class Solution {
    public List<Integer> countSmaller(int[] nums) {
        int[] smaller = new int[nums.length];
        for(int i=nums.length-2; i>=0; i--) {
            int left = i+1;
            int right = nums.length-1;
            while (left<=right) {
                int m = (left+right)/2;
                if (nums[i] > nums[m]) right = m - 1;
                else left = m + 1;
            }
            smaller[i] = nums.length - left;
            int temp = nums[i];
            for(int j=i; j<right; j++) nums[j] = nums[j+1];
            nums[right] = temp;
        }
        List<Integer> results = new ArrayList<>(nums.length);
        for(int i=0; i<smaller.length; i++) results.add(smaller[i]);
        return results;
    }
}
 

方法三：應用合併排序。如果我們對陣列進行排序，那麼對於某個特定的資料，其後面的逆序數等於在排序過程中需要移動到該數前面的個數。時間複雜度O(nlogn)。

我們定義陣列pos[i] = j，表示第排名i個數據的元素下標是j。

public class Solution {
    private void sort(int[] nums, int[] smaller, int[] pos, int from, int to) {
        if (from >= to) return;
        int m = (from + to) / 2;
        sort(nums, smaller, pos, from, m);
        sort(nums, smaller, pos, m+1, to);
        int[] merged = new int[to-from+1];
        int i=from, j=m+1, k=0, jump = 0;
        while (i<=m || j<=to) {
            if (i>m) {
                jump ++;
                merged[k++] = pos[j++];
            } else if (j>to) {
                smaller[pos[i]] += jump;
                merged[k++] = pos[i++];
            } else if (nums[pos[i]] <= nums[pos[j]]) {
                smaller[pos[i]] += jump;
                merged[k++] = pos[i++];
            } else {
                jump ++;
                merged[k++] = pos[j++];
            }
        }
        for(int p=0; p<merged.length; p++) pos[from+p] = merged[p];
    }
    public List<Integer> countSmaller(int[] nums) {
        int[] smaller = new int[nums.length];
        int[] pos =new int[nums.length];
        for(int i=0; i<pos.length; i++) pos[i] = i;
        sort(nums, smaller, pos, 0, nums.length-1);
        List<Integer> result = new ArrayList<>(nums.length);
        for(int i=0; i<nums.length; i++) result.add(smaller[i]);
        return result;
    }
}

另一種實現形式：

public class Solution {
    private void sort(int[] nums, int[] pos, int[] counts, int from, int to) {
        if (from+1>=to) return;
        int m=(from+to)/2;
        sort(nums, pos, counts, from, m);
        sort(nums, pos, counts, m, to);
        int[] merged = new int[to-from];
        int smaller = 0;
        for(int i=from, j=m, k=0; k<merged.length; k++) {
            if (i>=m) {
                merged[k] = pos[j++];
            } else if (j>=to) {
                counts[pos[i]] += smaller;
                merged[k] = pos[i++];
            } else if (nums[pos[i]] <= nums[pos[j]]) {
                counts[pos[i]] += smaller;
                merged[k] = pos[i++];
            } else {
                smaller ++;
                merged[k] = pos[j++];
            }
        }
        for(int i=0; i<merged.length; i++) pos[from+i] = merged[i];
    }
    public List<Integer> countSmaller(int[] nums) {
        int[] counts = new int[nums.length];
        int[] pos = new int[nums.length];
        for(int i=0; i<pos.length; i++) pos[i] = i;
        sort(nums, pos, counts, 0, nums.length);
        List<Integer> results = new ArrayList<>(nums.length);
        for(int count : counts) results.add(count);
        return results;
    }
}

方法四：使用BST進行統計。時間複雜度O(nlogn)。可以先對陣列排序，以便使BST均衡？

public class Solution {
    TreeNode root;
    private int smaller(TreeNode current, int val) {
        current.size ++;
         if (current.val < val) {
             if (current.right == null) current.right = new TreeNode(val);
             return current.size - 1 - current.right.size + smaller(current.right, val);
         } else if (current.val > val) {
             if (current.left == null) current.left = new TreeNode(val);
             return smaller(current.left, val);
         } else {
             return current.left == null? 0 : current.left.size;
         }
    }
    public List<Integer> countSmaller(int[] nums) {
        List<Integer> result = new ArrayList<>(nums.length);
        int[] smaller = new int[nums.length];
        if (nums == null || nums.length == 0) return result;
        root = new TreeNode(nums[nums.length-1]);
        for(int i=nums.length-1; i>=0; i--) {
            smaller[i] = smaller(root, nums[i]);
        }
        for(int i=0; i<smaller.length; i++) result.add(smaller[i]);
        return result;
    }
}
class TreeNode {
    int val;
    int size;
    TreeNode left, right;
    TreeNode(int val) {
        this.val = val;
    }
}

事實上，二叉搜尋樹可以用陣列實現：

public class Solution {
    private void update(int[] tree, int[] smaller, int value) {
        int i=0, j=tree.length-1;
        while (i<=j) {
            int m = (i+j)/2;
            if (value < tree[m]) {
                smaller[m] ++;
                j = m - 1;
            } else {
                i = m + 1;
            }
        }
    }
    private int smaller(int[] tree, int[] smaller, int value) {
        int sum = 0;
        int i=0, j=tree.length-1;
        while (i<=j) {
            int m = (i+j)/2;
            if (tree[m] <= value) {
                sum += smaller[m];
                i = m + 1;
            } else {
                j = m - 1;
            }
        }
        return sum;
    }
    public List<Integer> countSmaller(int[] nums) {
        int[] tree = Arrays.copyOf(nums, nums.length);
        Arrays.sort(tree);
        int[] smaller = new int[nums.length];
        int[] count = new int[nums.length];
        for(int i=nums.length-1; i>=0; i--) {
            count[i] = smaller(tree, smaller, nums[i]);
            update(tree, smaller, nums[i]);
        }
        List<Integer> results = new ArrayList<>(nums.length);
        for(int i=0; i<count.length; i++) results.add(count[i]);
        return results;
    }
}

甚至再進一步簡化：

public class Solution {
    private int smaller(int[] tree, int[] smaller, int value) {
        int sum = 0;
        int i=0, j=tree.length-1;
        while (i<=j) {
            int m = (i+j)/2;
            if (tree[m] <= value) {
                sum += smaller[m];
                i = m + 1;
            } else {
                smaller[m] ++;
                j = m - 1;
            }
        }
        return sum;
    }
    public List<Integer> countSmaller(int[] nums) {
        int[] tree = Arrays.copyOf(nums, nums.length);
        Arrays.sort(tree);
        int[] smaller = new int[nums.length];
        int[] count = new int[nums.length];
        for(int i=nums.length-1; i>=0; i--) {
            count[i] = smaller(tree, smaller, nums[i]);
        }
        List<Integer> results = new ArrayList<>(nums.length);
        for(int i=0; i<count.length; i++) results.add(count[i]);
        return results;
    }
}

上面判斷條件中，tree[m] <= value修改為tree[m] < value會更加make sense：

public class Solution {
    private int smaller(int[] tree, int[] count, int value) {
        int sum = 0;
        int i = 0, j = tree.length - 1;
        while (i <= j) {
            int m = (i + j) / 2;
            if (tree[m] < value) {
                sum += count[m];
                i = m + 1;
            } else {
                count[m]++;
                j = m - 1;
            }
        }
        return sum;
    }
    public List<Integer> countSmaller(int[] nums) {
        int[] tree = Arrays.copyOf(nums, nums.length);
        Arrays.sort(tree);
        int[] count = new int[nums.length];
        Integer[] result = new Integer[nums.length];
        for(int i = nums.length - 1; i >= 0; i--) {
            result[i] = smaller(tree, count, nums[i]);
        }
        return Arrays.asList(result);
    }
}

public class Solution {
    private int smaller(int[] tree, int[] count, int value) {
        int sum = 0;
        int i = 0, j = tree.length - 1;
        while (i <= j) {
            int m = (i + j) / 2;
            if (tree[m] < value) {
                sum += count[m];
                i = m + 1;
            } else {
                count[m]++;
                j = m - 1;
            }
        }
        return sum;
    }
    public List<Integer> countSmaller(int[] nums) {
        Set<Integer> unique = new HashSet<>();
        for(int num : nums) unique.add(num);
        int[] tree = new int[unique.size()];
        int pos = 0;
        for(int num : unique) tree[pos++] = num;
        Arrays.sort(tree);
        int[] count = new int[nums.length];
        Integer[] result = new Integer[nums.length];
        for(int i = nums.length - 1; i >= 0; i--) {
            result[i] = smaller(tree, count, nums[i]);
        }
        return Arrays.asList(result);
    }
}

public class Solution {
    private int smaller(Node node, int val) {
        node.count ++;
        if (node.min == node.max) return 0;
        int m = (node.min + node.max) / 2;
        if (m < val) {
            if (node.right == null) node.right = new Node(m+1, node.max);
            return node.count - 1 - node.right.count + smaller(node.right, val);
        } else if (m > val) {
            if (node.min == m) return 0;
            if (node.left == null) node.left = new Node(node.min, m-1);
            return smaller(node.left, val);
        } else {
            if (node.left == null) return 0;
            return node.left.count;
        }
    }
    public List<Integer> countSmaller(int[] nums) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for(int num: nums) {
            min = Math.min(min, num);
            max = Math.max(max, num);
        }
        Node root = new Node(min, max);
        int[] smaller = new int[nums.length];
        for(int i=nums.length-1; i>=0; i--) {
            smaller[i] = smaller(root, nums[i]);
        }
        List<Integer> result = new ArrayList<>(nums.length);
        for(int i=0; i<smaller.length; i++) result.add(smaller[i]);
        return result;
    }
}
class Node {
    int min, max;
    int count;
    Node left, right;
    Node(int min, int max) {
        this.min = min;
        this.max = max;
    }
}

注意，關於分段樹此處可能有概念誤解，分段樹應該是按照名次進行分段，即等同於樹狀陣列，以後再具體檢查修正。

方法六：使用樹狀陣列，要點是按名次進行計數。時間複雜度O(nlogn)。

public class Solution {
    private void sort(int[] nums, int[] pos, int from, int to) {
        if (from>=to) return;
        int m = (from+to)/2;
        sort(nums, pos, from, m);
        sort(nums, pos, m+1, to);
        int[] merged = new int[to-from+1];
        int i=from, j=m+1, p=0;
        while (i<=m || j<=to) {
            if (i>m) {
                merged[p++] = pos[j++];
            } else if (j>to) {
                merged[p++] = pos[i++];
            } else if (nums[pos[i]] <= nums[pos[j]]) {
                merged[p++] = pos[i++];
            } else {
                merged[p++] = pos[j++];
            }
        }
        for(int k=0; k<merged.length; k++) pos[from+k] = merged[k];
    }
    private int count(int[] sum, int s) {
        int count = 0;
        while (s>0) {
            count += sum[s];
            s -= (s & -s);
        }
        return count;
    }
    private void update(int[] sum, int s) {
        while (s<sum.length) {
            sum[s] ++;
            s += (s & -s);
        }
    }
    public List<Integer> countSmaller(int[] nums) {
        int[] pos = new int[nums.length];
        for(int i=0; i<nums.length; i++) pos[i] = i;
        sort(nums, pos, 0, nums.length-1);
        int[] seq = new int[nums.length];
        for(int i=0, s=0; i<pos.length; i++) {
            if (i==0 || nums[pos[i]] != nums[pos[i-1]]) seq[pos[i]] = ++ s; else seq[pos[i]] = s;
        }
        int[] sum = new int[nums.length+1];
        int[] smaller = new int[nums.length];
        for(int i=nums.length-1; i>=0; i--) {
            smaller[i] = count(sum, seq[i]-1);
            update(sum, seq[i]);
        }
        List<Integer> result = new ArrayList<>(nums.length);
        for(int i=0; i<smaller.length; i++) result.add(smaller[i]);
        return result;
    }
}