Problem:
Score : 300 points

Problem Statement

We have a sequence of N integers A~=~A_0,~A_1,~...,~A_{N - 1}.

Let B be a sequence of K \times N integers obtained by concatenating K copies of A. For example, if A~=~1,~3,~2 and K~=~2, B~=~1,~3,~2,~1,~3,~2.

Find the inversion number of B, modulo 10^9 + 7.

Here the inversion number of B is defined as the number of ordered pairs of integers (i,~j)~(0 \leq i < j \leq K \times N - 1) such that B_i > B_j.

Constraints

All values in input are integers.

1 \leq N \leq 2000

1 \leq K \leq 10^9

1 \leq A_i \leq 2000

Input

Input is given from Standard Input in the following format:

N K
A_0 A_1 ... A_{N - 1}

Output

Print the inversion number of B, modulo 10^9 + 7.

Sample Input 1

2 2
2 1

Sample Output 1

3

In this case, B~=~2,~1,~2,~1. We have:

B_0 > B_1

B_0 > B_3

B_2 > B_3

Thus, the inversion number of B is 3.

Sample Input 2

3 5
1 1 1

Sample Output 2

0

A may contain multiple occurrences of the same number.

Sample Input 3

10 998244353
10 9 8 7 5 6 3 4 2 1

Sample Output 3

185297239

Be sure to print the output modulo 10^9 + 7.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>

using namespace std;

typedef long long ll;
// constexpr ll MOD = 998244353;
constexpr ll MOD = 1000000007;

// struct UnionFind {
//     vector<int> par;
    
//     UnionFind(int N): par(N) {
//         for (int i=0;i<N;i++) par[i] = i;
//     }

//     int root(int x) {
//         if (par[x] == x) return x;
//         else return par[x] = root(par[x]);
//     }

//     void unite(int x, int y) {
//         int rx = root(x);
//         int ry = root(y);
//         if (rx == ry) return;
//         par[rx] = ry;
//     }

//     bool same(int x, int y) {
//         int rx = root(x);
//         int ry = root(y);
//         return rx == ry;
//     }
// };

ll exp(ll b, ll e) {
    ll ans = 1LL;
    while (e) {
        if (e&1) ans = ans * b % MOD;
        e >>= 1;
        b = b*b % MOD;
    }
    return ans;
}

int main(void) {
    ll N, K;
    vector<ll> A(2010,0LL);
    cin >> N >> K;
    for (int i=0;i<N;i++) cin >> A[i];
    vector<ll> L(2010), R(2010);
    for (int i=0;i<N;i++) {
        L[i] = count_if(A.begin(), A.begin()+i, [&](ll x) { return x < A[i]; });
        R[i] = count_if(A.begin()+i+1, A.begin()+N, [&](ll x) { return x < A[i]; });
    }
    
    ll ans = 0;
    ll Ksum1 = K;
    Ksum1 = Ksum1 * (K+1) % MOD;
    Ksum1 = Ksum1 * exp(2LL,MOD-2) % MOD;
    ll Ksum2 = K;
    Ksum2 = Ksum2 * (K-1) % MOD;
    Ksum2 = Ksum2 * exp(2LL,MOD-2) % MOD;
    for (int i=0;i<N;i++) {
        ans = (ans + R[i] * Ksum1 % MOD) % MOD;
        ans = (ans + L[i] * Ksum2 % MOD) % MOD;
    }
#ifdef DEBUG
    cout << Ksum1 << endl;
    cout << Ksum2 << endl;
    for (int i=0;i<N;i++) cout << L[i] << " ";
    cout << endl;
    for (int i=0;i<N;i++) cout << R[i] << " ";
    cout << endl;
#endif
    cout << ans << endl;

    return 0;
}