1 //最笨的方法
  2 class Solution01 {
  3 public:
  4     int InversePairs(vector<int> data) {
  5         if (data.size() < 2)return 0;
  6         set<int>s;
  7         s.insert(data[0]);
  8         int res = 0;
  9         for (int i = 1; i < data.size(); ++i)
 10         {
 11             if (data[i] < *(s.begin()))
 12                 res += s.size();
 13             else if (data[i] > *(--s.end()))
 14                 res += 0;
 15             else
 16             {
 17                 int k = 0;
 18                 for (auto ptr = s.begin(); ptr != s.end(); ++ptr, ++k)
 19                 {
 20                     if (*ptr > data[i])
 21                     {
 22                         res += s.size() - k;
 23                         break;
 24                     }
 25                 }
 26             }
 27             s.insert(data[i]);
 28         }
 29         return res;
 30     }
 31 };
 32 
 33 //书本代码，有点乱
 34 class Solution02 {
 35 public:
 36     int InversePairs(vector<int> data) {
 37         if (data.size() < 2)return 0;
 38         vector<int>v;//用来复制的
 39         v = data;
 40         return InversePairsCore(data, v, 0, data.size() - 1);
 41     }
 42 
 43     int InversePairsCore(vector<int>&data, vector<int>&copy, int start, int end)
 44     {
 45         if (start == end)
 46         {
 47             copy[start] = data[start];
 48             return 0;
 49         }
 50 
 51         int length = (end - start) / 2;
 52 
 53         int left = InversePairsCore(copy, data, start, start + length) % 1000000007;
 54         int right = InversePairsCore(copy, data, start + length + 1, end) % 1000000007;
 55 
 56         // i初始化为前半段最后一个数字的下标
 57         int i = start + length;
 58         // j初始化为后半段最后一个数字的下标
 59         int j = end;
 60         int indexCopy = end;
 61         int count = 0;
 62         while (i >= start && j >= start + length + 1)
 63         {
 64             if (data[i] > data[j])
 65             {
 66                 copy[indexCopy--] = data[i--];
 67                 count += j - start - length;
 68                 if (count >= 1000000007)//数值过大求余
 69                 {
 70                     count %= 1000000007;
 71                 }
 72             }
 73             else
 74             {
 75                 copy[indexCopy--] = data[j--];
 76             }
 77         }
 78 
 79         for (; i >= start; --i)
 80             copy[indexCopy--] = data[i];
 81 
 82         for (; j >= start + length + 1; --j)
 83             copy[indexCopy--] = data[j];
 84 
 85         return (left + right + count) % 1000000007;
 86     }
 87 };
 88 
 89 
 90 //使用归并排序思想
 91 class Solution03 {
 92 private:
 93     int count = 0;
 94 public:
 95     int InversePairs(vector<int> data) {
 96         if (data.size() < 2)return 0;
 97         mergeSort(data, 0, data.size() - 1);
 98         return count;
 99     }
100     void mergeSort(vector<int>&data, int L, int R)
101     {
102         if (L < R)
103         {
104             int M = (L + R) / 2;
105             mergeSort(data, L, M);
106             mergeSort(data, M + 1, R);
107             merge(data, L, M, R);
108         }
109     }
110     void merge(vector<int>&data, int L, int M, int R)
111     {
112         vector<int>temp(R - L + 1);
113         int t = R - L;
114         int tL = M;
115         int tR = R;
116         while (tL >= L && tR >= M + 1)
117         {
118             if (data[tL] > data[tR])
119             {
120                 count += tR - M;
121                 temp[t--] = data[tL--];
122                 count %= 1000000007;
123             }
124             else
125                 temp[t--] = data[tR--];
126         }
127         while (tL >= L)
128             temp[t--] = data[tL--];
129         while (tR >= M + 1)
130             temp[t--] = data[tR--];
131         for (int i = 0; i <= R - L; ++i)
132             data[L + i] = temp[i];
133     }
134 };