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)

// https://atcoder.jp/contests/abcXXX/tasks/abcXXX_x

#include <iostream>
#include <vector>

using namespace std;
using ll = long long;
using ull = unsigned long long;
using pll = pair<ll, ll>;

struct C1 {
    ll N_{};
    ll K_{};
    vector<ll> v_{};
    vector<ll> num_tenchi_{};
    vector<ll> num_larger_{};
    explicit C1(ll K, vector<ll> v) : N_(v.size()), K_(K), v_(move(v)){
        num_larger_.resize(N_, 0);
        num_tenchi_.resize(N_, 0);
        for(ll i=0; i < N_; ++i) {
            for(ll j=0; j < i; ++j) {
                if (v_[i] < v_[j]) {
                    num_tenchi_[i]++;
                }
            }
        }
        for(ll i=0; i < N_; ++i) {
            for(ll j=0; j < N_; ++j) {
                if (i != j && v_[i] < v_[j]) {
                    num_larger_[i]++;
                }
            }
        }
    }
    ll resolve() {
        const ll MOD = 1000000007;
        ll sum = 0;
        for (ll i = 0; i < N_; ++i) {
            sum += num_tenchi_[i] * K_ % MOD + num_larger_[i] * (K_ * (K_ -1) / 2 % MOD);
            sum = sum % MOD;
        }
        return sum;
    }
};

int main() {
    ll N, K;
    cin >>  N >> K;
    vector<ll> v{};
    for (int i=0; i < N; ++i) {
        ll x;
        cin >> x;
        v.emplace_back(x);
    }
    C1 c{K, move(v)};
    cout << c.resolve() << endl;
    return 0;
}