使用nth_element找中位数，然后再循环一遍求合即可。

时间复杂度：O(n)
空间复杂度：O(1)

class Solution {
public:
  int minMoves2(vector<int>& nums) {
    const int n = nums.size();
    nth_element(begin(nums), begin(nums) + n / 2, end(nums));
    const int median = nums[n / 2];
    return accumulate(begin(nums), end(nums), 0, [median](int s, int x) {
      return s + abs(x - median);
    });
  }
};

A uni-value grid is a grid where all the elements of it are equal.

Return the minimum number of operations to make the grid uni-value. If it is not possible, return -1.

Example 1:

Input: grid = [[2,4],[6,8]], x = 2
Output: 4
Explanation: We can make every element equal to 4 by doing the following: 
- Add x to 2 once.
- Subtract x from 6 once.
- Subtract x from 8 twice.
A total of 4 operations were used.

Example 2:

Input: grid = [[1,5],[2,3]], x = 1
Output: 5
Explanation: We can make every element equal to 3.

Example 3:

Input: grid = [[1,2],[3,4]], x = 2
Output: -1
Explanation: It is impossible to make every element equal.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 105
• 1 <= m * n <= 105
• 1 <= x, grid[i][j] <= 104

Solution: Median

To achieve minimum operations, the uni-value must be the median of the array.

Time complexity: O(m*n)
Space complexity: O(m*n)

// Author; Huahua
class Solution {
public:
  int minOperations(vector<vector<int>>& grid, int x) {
    const int mn = grid.size() * grid[0].size();    
    vector<int> nums;
    nums.reserve(mn);
    for (const auto& row : grid)
      nums.insert(end(nums), begin(row), end(row));
    nth_element(begin(nums), begin(nums) + mn / 2, end(nums));
    const int median = nums[mn / 2];
    int ans = 0;
    for (int v : nums) {
      if (abs(v - median) % x) return -1;
      ans += abs(v - median) / x;
    }
    return ans;
  }
};

Return the minimum total distance between each house and its nearest mailbox.

The answer is guaranteed to fit in a 32-bit signed integer.

Example 1:

Input: houses = [1,4,8,10,20], k = 3
Output: 5
Explanation: Allocate mailboxes in position 3, 9 and 20.
Minimum total distance from each houses to nearest mailboxes is |3-1| + |4-3| + |9-8| + |10-9| + |20-20| = 5 

Example 2:

Input: houses = [2,3,5,12,18], k = 2
Output: 9
Explanation: Allocate mailboxes in position 3 and 14.
Minimum total distance from each houses to nearest mailboxes is |2-3| + |3-3| + |5-3| + |12-14| + |18-14| = 9.

Example 3:

Input: houses = [7,4,6,1], k = 1
Output: 8

Example 4:

Input: houses = [3,6,14,10], k = 4
Output: 0

Constraints:

• n == houses.length
• 1 <= n <= 100
• 1 <= houses[i] <= 10^4
• 1 <= k <= n
• Array houses contain unique integers.

Solution: DP

First, we need to sort the houses by their location.

This is a partitioning problem, e.g. optimal solution to partition first N houses into K groups. (allocating K mailboxes for the first N houses).

The key of this problem is to solve a base case, optimally allocating one mailbox for houses[i~j], The intuition is to put the mailbox in the middle location, this only works if there are only tow houses, or all the houses are evenly distributed. The correct location is the “median position” of a set of houses. For example, if the sorted locations are [1,2,3,100], the average will be 26 which costs 146 while the median is 2, and the cost becomes 100.

dp[i][k] := min cost to allocate k mailboxes houses[0~i].

base cases:

1. dp[i][1] = cost(0, i), min cost to allocate one mailbox.
2. dp[i][k] = 0 if k > i, more mailboxes than houses. // this is actually a pruning.

transition:

dp[i][k] = min(dp[p][k-1] + cost(p + 1, i)) 0 <= p < i,

allocate k-1 mailboxes for houses[0~p], and allocate one for houses[p+1~i]

ans:

dp[n-1][k]

Time complexity: O(n^3)
Space complexity: O(n^2) -> O(n)

// Author: Huahua
class Solution {
public:
  int minDistance(vector<int>& houses, int k) {
    constexpr int kInf = 1e9;
    const int n = houses.size();
    sort(begin(houses), end(houses));
    vector<vector<int>> dp(n + 1, vector<int>(n + 1, kInf));
    vector<vector<int>> costs(n + 1, vector<int>(n + 1, kInf));
    // min cost to allocate one mailbox for houses[i~j].
    auto cost = [&](int i, int j) {
      int& ans = costs[i][j];
      if (ans != kInf) return ans;
      const int m = i + (j - i) / 2;
      int box = 0;
      if ((j - i + 1) & 1) // odd number of houses.
        box = houses[m];
      else // even number of houses.
        box = (houses[m] + houses[m + 1]) / 2;
      ans = 0;
      for (int h = i; h <= j; ++h)
        ans += abs(houses[h] - box);
      return ans;
    };
    // min cost to allocate k mailboxes for houses[0~i].
    function<int(int, int)> solve = [&](int i, int k) {
      if (k > i) return 0; // more mailboxs than houses.
      if (k == 1) return cost(0, i);
      int& ans = dp[i][k];
      if (ans != kInf) return ans;
      for (int p = 0; p < i; ++p)
        ans = min(ans, solve(p, k - 1) + cost(p + 1, i));
      return ans;
    };
    return solve(n - 1, k);
  }
};

O(1) time to compute cost. O(n) Time and space for pre-processing.

// Author: Huahua
vector<int> sums(n + 1);
for (int i = 1; i <= n; ++i)
  sums[i] = sums[i - 1] + houses[i - 1];
// min cost to allocate one mailbox for houses[i~j].
auto cost = [&](int i, int j) {      
  const int m1 = (i + j) / 2;
  const int m2 = (i + j + 1) / 2;
  const int center = (houses[m1] + houses[m2]) / 2;
  return (m1 - i + 1) * center - (sums[m1 + 1] - sums[i])
       + (sums[j + 1] - sums[m2]) - (j - m2 + 1) * center;
};

A value arr[i] is said to be stronger than a value arr[j] if |arr[i] - m| > |arr[j] - m| where m is the median of the array.
If |arr[i] - m| == |arr[j] - m|, then arr[i] is said to be stronger than arr[j] if arr[i] > arr[j].

Return a list of the strongest k values in the array. return the answer in any arbitrary order.

Median is the middle value in an ordered integer list. More formally, if the length of the list is n, the median is the element in position ((n - 1) / 2) in the sorted list (0-indexed).

• For arr = [6, -3, 7, 2, 11], n = 5 and the median is obtained by sorting the array arr = [-3, 2, 6, 7, 11] and the median is arr[m] where m = ((5 - 1) / 2) = 2. The median is 6.
• For arr = [-7, 22, 17, 3], n = 4 and the median is obtained by sorting the array arr = [-7, 3, 17, 22] and the median is arr[m] where m = ((4 - 1) / 2) = 1. The median is 3.

Example 1:

Input: arr = [1,2,3,4,5], k = 2
Output: [5,1]
Explanation: Median is 3, the elements of the array sorted by the strongest are [5,1,4,2,3]. The strongest 2 elements are [5, 1]. [1, 5] is also accepted answer.
Please note that although |5 - 3| == |1 - 3| but 5 is stronger than 1 because 5 > 1.

Example 2:

Input: arr = [1,1,3,5,5], k = 2
Output: [5,5]
Explanation: Median is 3, the elements of the array sorted by the strongest are [5,5,1,1,3]. The strongest 2 elements are [5, 5].

Example 3:

Input: arr = [6,7,11,7,6,8], k = 5
Output: [11,8,6,6,7]
Explanation: Median is 7, the elements of the array sorted by the strongest are [11,8,6,6,7,7].
Any permutation of [11,8,6,6,7] is accepted.

Example 4:

Input: arr = [6,-3,7,2,11], k = 3
Output: [-3,11,2]

Example 5:

Input: arr = [-7,22,17,3], k = 2
Output: [22,17]

Constraints:

• 1 <= arr.length <= 10^5
• -10^5 <= arr[i] <= 10^5
• 1 <= k <= arr.length

Solution 1: quick selection + sort

Step 1: find the median element m
Step 2: Sort the array according to m
Step 3: output the first k elements of the sorted array.

Time complexity: O(nlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> getStrongest(vector<int>& arr, int k) {
    const int n = arr.size();
    const int i = (n - 1) / 2;
    // sort(begin(arr), end(arr));
    nth_element(begin(arr), begin(arr) + i, end(arr));
    const int m = arr[i];  
    sort(begin(arr), end(arr), [&](const int x, const int y) {      
      return abs(x - m) != abs(y - m) ? abs(x - m) > abs(y - m) : x > y;      
    });    
    return {begin(arr), begin(arr) + k};
  }
};

Return the minimum, maximum, mean, median, and mode of the sample respectively, as an array of floating point numbers.  The mode is guaranteed to be unique.

(Recall that the median of a sample is:

• The middle element, if the elements of the sample were sorted and the number of elements is odd;
• The average of the middle two elements, if the elements of the sample were sorted and the number of elements is even.)

Example 1:

Input: count = [0,1,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
Output: [1.00000,3.00000,2.37500,2.50000,3.00000]

Example 2:

Input: count = [0,4,3,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
Output: [1.00000,4.00000,2.18182,2.00000,1.00000]

Constraints:

1. count.length == 256
2. 1 <= sum(count) <= 10^9
3. The mode of the sample that count represents is unique.
4. Answers within 10^-5 of the true value will be accepted as correct.

Solution: TreeMap

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<double> sampleStats(vector<int>& count) {
    int counts = 0;
    int minVal = 255;
    int maxVal = 0;
    int mode = -1;
    int modeCount = 0;
    long sum = 0;
    map<int, int> m;
    for (int i = 0; i <= 255; ++i) {      
      if (!count[i]) continue;
      sum += static_cast<long>(i) * count[i];
      minVal = min(minVal, i);
      maxVal = max(maxVal, i);
      if (count[i] > modeCount) {
        mode = i;
        modeCount = count[i];
      }
      m[counts += count[i]] = i;
    }
    auto it1 = m.lower_bound(counts / 2);
    double median = it1->second;    
    auto it2 = next(it1);
    if (counts % 2 == 0 && it2 != m.end() && it1->first == counts / 2) {  
      median = (median + it2->second) / 2;
    }
    return {minVal, maxVal, static_cast<double>(sum) / counts, median, mode};
  }
};

题目大意：让你求移动窗口的中位数。

Problem:

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples:

[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Your job is to output the median array for each window in the original array.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

Window position                Median
---------------               -----
[1  3  -1] -3  5  3  6  7       1
 1 [3  -1  -3] 5  3  6  7       -1
 1  3 [-1  -3  5] 3  6  7       -1
 1  3  -1 [-3  5  3] 6  7       3
 1  3  -1  -3 [5  3  6] 7       5
 1  3  -1  -3  5 [3  6  7]      6

Therefore, return the median sliding window as [1,-1,-1,3,5,6].

Note: 
You may assume k is always valid, ie: k is always smaller than input array’s size for non-empty array.

Solution 0: Brute Force

Time complexity: O(n*klogk) TLE 32/42 test cases passed

Solution 1: Insertion Sort

Time complexity: O(k*logk +  (n – k + 1)*k)

Space complexity: O(k)

C++ / vector

// Author: Huahua
// Running time: 99 ms
class Solution {
public:
  vector<double> medianSlidingWindow(vector<int>& nums, int k) {    
    vector<double> ans;
    if (k == 0) return ans;
    vector<int> window(nums.begin(), nums.begin() + k - 1);
    std::sort(window.begin(), window.end());
    for (int i = k - 1; i < nums.size(); ++i) {
      window.push_back(nums[i]);
      auto it = prev(window.end(), 1);
      auto const insertion_point = 
              std::upper_bound(window.begin(), it, *it);      
      std::rotate(insertion_point, it, it + 1);          
      ans.push_back((static_cast<double>(window[k / 2]) + window[(k - 1) / 2]) / 2);
      window.erase(std::find(window.begin(), window.end(), nums[i - k + 1]));      
    }
    return ans;
  }
};

C++ / vector + binary_search for deletion.

// Author: Huahua
// Running time: 84 ms
class Solution {
public:
  vector<double> medianSlidingWindow(vector<int>& nums, int k) {    
    vector<double> ans;
    if (k == 0) return ans;
    vector<int> window(nums.begin(), nums.begin() + k - 1);
    std::sort(window.begin(), window.end());
    for (int i = k - 1; i < nums.size(); ++i) {
      window.push_back(nums[i]);
      auto it = prev(window.end(), 1);
      auto const insertion_point = 
              std::upper_bound(window.begin(), it, *it);      
      std::rotate(insertion_point, it, it + 1);          
      ans.push_back((static_cast<double>(window[k / 2]) + window[(k - 1) / 2]) / 2);
      window.erase(std::lower_bound(window.begin(), window.end(), nums[i - k + 1]));      
    }
    return ans;
  }
};

Java

// Author: Huahua
// Running time: 60 ms
class Solution {
  public double[] medianSlidingWindow(int[] nums, int k) {
    if (k == 0) return new double[0];
    double[] ans = new double[nums.length - k + 1];
    int[] window = new int[k];
    for (int i = 0; i < k; ++i) 
      window[i] = nums[i];
    Arrays.sort(window);
    for (int i = k; i <= nums.length; ++i) {
      ans[i - k] = ((double)window[k / 2] + window[(k - 1)/2]) / 2;
      if (i == nums.length) break;
      remove(window, nums[i - k]);
      insert(window, nums[i]);
    }
    return ans;
  }
  
  // Insert val into window, window[k - 1] is empty before inseration
  private void insert(int[] window, int val) {
    int i = 0;
    while (i < window.length - 1 && val > window[i]) ++i;
    int j = window.length - 1;
    while (j > i) window[j] = window[--j];
    window[j] = val;
  }
  
  // Remove val from window and shrink it.
  private void remove(int[] window, int val) {
    int i = 0;
    while (i < window.length && val != window[i]) ++i;
    while (i < window.length - 1) window[i] = window[++i];
  }
}

Java / Binary Search

// Author: Huahua
// Running time: 47 ms (<98.96%)
class Solution {
  public double[] medianSlidingWindow(int[] nums, int k) {
    if (k == 0) return new double[0];
    double[] ans = new double[nums.length - k + 1];
    int[] window = new int[k];
    for (int i = 0; i < k; ++i) 
      window[i] = nums[i];
    Arrays.sort(window);
    for (int i = k; i <= nums.length; ++i) {
      ans[i - k] = ((double)window[k / 2] + window[(k - 1)/2]) / 2;
      if (i == nums.length) break;
      remove(window, nums[i - k]);
      insert(window, nums[i]);
    }
    return ans;
  }
  
  // Insert val into window, window[k - 1] is empty before inseration
  private void insert(int[] window, int val) {
    int i = Arrays.binarySearch(window, val);
    if (i < 0) i = - i - 1;    
    int j = window.length - 1;
    while (j > i) window[j] = window[--j];
    window[j] = val;
  }
  
  // Remove val from window and shrink it.
  private void remove(int[] window, int val) {
    int i = Arrays.binarySearch(window, val);
    while (i < window.length - 1) window[i] = window[++i];
  }
  
  
}

Python

"""
Author: Huahua
Running time: 161 ms (< 93.75%)
"""
class Solution:
  def medianSlidingWindow(self, nums, k):
    if k == 0: return []
    ans = []
    window = sorted(nums[0:k])
    for i in range(k, len(nums) + 1):
      ans.append((window[k // 2] + window[(k - 1) // 2]) / 2.0)
      if i == len(nums): break
      index = bisect.bisect_left(window, nums[i - k])
      window.pop(index)      
      bisect.insort_left(window, nums[i])
    return ans

Solution 2: BST

// Author: Huahua
// Running time: 68 ms
class Solution {
public:
  vector<double> medianSlidingWindow(vector<int>& nums, int k) {    
    vector<double> ans;
    if (k == 0) return ans;
    multiset<int> window(nums.begin(), nums.begin() + k);
    auto mid = next(window.begin(), (k - 1) / 2);    
    for (int i = k; i <= nums.size(); ++i) {
      ans.push_back((static_cast<double>(*mid) + 
                     *next(mid, (k + 1) % 2)) / 2.0);
      if (i == nums.size()) break;
      
      window.insert(nums[i]);
      if (nums[i] < *mid) --mid; 
      if (nums[i - k] <= *mid) ++mid;
      window.erase(window.lower_bound(nums[i - k])); 
    }
    return ans;
  }
};

Related Problems:

• [解题报告] LeetCode 295. Find Median from Data Stream O(logn) + O(1)
• 花花酱 LeetCode 239. Sliding Window Maximum

题目大意：求两个已经排序的数组的中位数（如果合并后）。

Problem:

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

Idea:

Binary Search

Time complexity: O(log(min(n1,n2)))

Space complexity: O(1)

Solution: Binary Search

// Author: Huahua
// Runtime: 52 ms
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        const int n1 = nums1.size();
        const int n2 = nums2.size();
        // Make sure n1 <= n2
        if (n1 > n2) return findMedianSortedArrays(nums2, nums1);
        
        const int k = (n1 + n2 + 1) / 2;

        int l = 0;
        int r = n1;
               
        while (l < r) {
            const int m1 = l + (r - l) / 2;
            const int m2 = k - m1;
            if (nums1[m1] < nums2[m2 - 1])
                l = m1 + 1;
            else
                r = m1;
        }
        
        const int m1 = l;
        const int m2 = k - l;
        
        const int c1 = max(m1 <= 0 ? INT_MIN : nums1[m1 - 1], 
                           m2 <= 0 ? INT_MIN : nums2[m2 - 1]);

        if ((n1 + n2) % 2 == 1)
            return c1;    
        
        const int c2 = min(m1 >= n1 ? INT_MAX : nums1[m1], 
                           m2 >= n2 ? INT_MAX : nums2[m2]);
                
        return (c1 + c2) * 0.5;
    }
};

// Author: Huahua
// Runtime: 66 ms
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        if (n1 > n2) 
            return findMedianSortedArrays(nums2, nums1);
        
        int k = (n1 + n2 + 1) / 2;
        int l = 0;
        int r = n1;
               
        while (l < r) {
            int m1 = l + (r - l) / 2;
            int m2 = k - m1;
            if (nums1[m1] < nums2[m2 - 1])
                l = m1 + 1;
            else
                r = m1;
        }
        
        int m1 = l;
        int m2 = k - l;
        
        int c1 = Math.max(m1 <= 0 ? Integer.MIN_VALUE : nums1[m1 - 1], 
                          m2 <= 0 ? Integer.MIN_VALUE : nums2[m2 - 1]);

        if ((n1 + n2) % 2 == 1)
            return c1;    
        
        int c2 = Math.min(m1 >= n1 ? Integer.MAX_VALUE : nums1[m1], 
                          m2 >= n2 ? Integer.MAX_VALUE : nums2[m2]);
                
        return (c1 + c2) * 0.5;
    }
}

Related Problem:

• [解题报告] LeetCode 295. Find Median from Data Stream O(logn) + O(1)

Problem:

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples:

[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Design a data structure that supports the following two operations:

• void addNum(int num) – Add a integer number from the data stream to the data structure.
• double findMedian() – Return the median of all elements so far.

For example:

addNum(1)
addNum(2)
findMedian() = 1.5
addNum(3) 
findMedian() = 2

Idea:

1. Min/Max heap
2. Balanced binary search tree

Time Complexity:

add(num): O(logn)

findMedian(): O(logn)

Solution1:

// Author: Huahua
// Running Time: 152 ms
class MedianFinder {
public:
    /** initialize your data structure here. */
    MedianFinder() {}
    
    // l_.size() >= r_.size()
    void addNum(int num) {
        if (l_.empty() || num <= l_.top()) {
            l_.push(num);
        } else {
            r_.push(num);
        }
        
        // Step 2: Balence left/right
        if (l_.size() < r_.size()) {
            l_.push(r_.top());
            r_.pop();
        } else if (l_.size() - r_.size() == 2) {
            r_.push(l_.top());
            l_.pop();
        }
    }
    
    double findMedian() {
        if (l_.size() > r_.size()) {
            return static_cast<double>(l_.top());
        } else {            
            return (static_cast<double>(l_.top()) + r_.top()) / 2;
        }
    }
private:
    priority_queue<int, vector<int>, less<int>> l_;    // max-heap
    priority_queue<int, vector<int>, greater<int>> r_; // min-heap
};

Solution 2:

// Author: Huahua
// Running time: 172 ms
class MedianFinder {
public:
    /** initialize your data structure here. */
    MedianFinder(): l_(m_.cend()), r_(m_.cend()) {}
    
    // O(logn)
    void addNum(int num) {
        if (m_.empty()) {
            l_ = r_ = m_.insert(num);
            return;
        }
        
        m_.insert(num);
        const size_t n = m_.size();    
        
        if (n & 1) {
            // odd number
            if (num >= *r_) {         
                l_ = r_;
            } else {
                // num < *r_, l_ could be invalidated
                l_ = --r_;
            }
        } else {
            if (num >= *r_)
                ++r_;
            else
                --l_;
        }
    }
    // O(1)
    double findMedian() {
        return (static_cast<double>(*l_) + *r_) / 2;
    }
private:
    multiset<int> m_;
    multiset<int>::const_iterator l_;  // current left median
    multiset<int>::const_iterator r_;  // current right median
};

Related Problems

• 花花酱 LeetCode 480. Sliding Window Median
• [解题报告] LeetCode 4. Median of Two Sorted Arrays
• [ZOJ] 3612: Median

// 3934633  2017-03-13 10:48:25 Accepted  3612  C++0x 900 540 xxfflower
#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <queue>
#include <set>
using namespace std;
typedef long long int64;

int main() {
  int t,n,x;
  char op[20];
  cin>>t;

  while(t--) {
    scanf("%d", &n);
    
    vector<int64> a;

    while(n--) {
      scanf("%s %d", op, &x);
      auto it = lower_bound(a.begin(), a.end(), x);

      if(op[0] == 'r') {
        if(it==a.end() || *it != x) {
          puts("Wrong!");
          continue;
        } else {
          a.erase(it);
          if(a.empty()) {
            puts("Empty!");
            continue;
          }
        }
      } else if(op[0] == 'a') {
        a.insert(it, x);
      }

      if(a.size()%2==1) {
        printf("%lld\n", a[a.size()/2]);
      } else {
        int64 ans = a[a.size()/2-1] + a[a.size()/2];
        if(ans%2==0) 
          printf("%lld\n", ans/2);
        else 
          printf("%.1lf\n", ans/2.0);
      }
    }
  }

  return 0;
}