Problem p02804 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <cassert>
#include <functional>

typedef long long ll;
using namespace std;

#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;

template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << "{" << p.first << ", " << p.second << "}";
  return out;
}

template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
  out << '{';
  for (const T &item : v)
    out << item << ", ";
  out << "\b\b}";
  return out;
}
#endif

#define mod 1000000007              // 1e9+7(prime number)
#define INF 1000000000              // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 200010

vector<ll> factmemo, factmemoInv;
ll factmemoMod = -1;

ll factorial(int n, int M) {
  if (factmemoMod == M)
    return factmemo[n];
  if (n <= 1)
    return 1;

  ll res = 1;
  for (int i = 1; i <= n; i++)
    res = res * i % M;
  return res;
}

ll power(ll k, ll n, int M) {
  ll res = 1;
  while (n > 0) {
    if (n & 1)
      res = res * k % M;
    k = k * k % M;
    n /= 2;
  }
  return res;
}

void initFactorial(int n, int M) {
  factmemo.assign(n + 1, 0);
  factmemoInv.assign(n + 1, 0);
  factmemoMod = M;
  factmemo[0] = 1;
  for (int i = 1; i <= n; i++)
    factmemo[i] = factmemo[i - 1] * i % M;
  factmemoInv[n] = power(factmemo[n], M - 2, M);
  for (int i = n; i > 0; i--)
    factmemoInv[i - 1] = factmemoInv[i] * i % M;
}

// nCm nPm nHm (mod M)

/*Combination*/
ll C(int n, int m, int M) {
  if (n < m)
    return 0;
  if (m == 0 || n == m)
    return 1;

  if (factmemoMod == M)
    return factmemo[n] * factmemoInv[m] % M * factmemoInv[n - m] % M;

  ll numer = factorial(n, M);
  ll denom = factorial(m, M) * factorial(n - m, M) % M;

  denom = power((int)denom, M - 2, M);

  return numer * denom % M;
}

/*Permutation*/
ll P(int n, int m, int M) {
  if (n < m)
    return 0;
  if (m == 0)
    return 1;

  if (factmemoMod == M)
    return factmemo[n] * factmemoInv[n - m] % M;

  ll numer = factorial(n, M);
  ll denom = factorial(n - m, M);

  denom = power((int)denom, M - 2, M);

  return numer * denom % M;
}

/*Combination with Repetitions*/
ll H(int n, int m, int M) {
  if (n == 0 && m == 0)
    return 1;
  return C(n + m - 1, m, M);
}

int main() {
  int N, K;
  map<int, int> counter;

  scanf("%d%d", &N, &K);

  for (int i = 0; i < N; i++) {
    int A;
    scanf("%d", &A);
    counter[A]++;
  }

  ll ans = 0;
  int sum = 0;

  for (auto p : counter) {
    // max
    ll s = (mod + C(sum + p.second, K, mod) - C(sum, K, mod)) % mod;

    ans += s * p.first % mod;

    // max
    ll t = (mod + C(N - sum, K, mod) - C(N - sum - p.second, K, mod)) % mod;

    ans -= t * p.first % mod;

    debug(s);
    debug(t);

    sum += p.second;
  }

  cout << (ans % mod + mod) % mod << endl;

  return 0;
}


Fixed submission:
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <cassert>
#include <functional>

typedef long long ll;
using namespace std;

#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;

template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << "{" << p.first << ", " << p.second << "}";
  return out;
}

template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
  out << '{';
  for (const T &item : v)
    out << item << ", ";
  out << "\b\b}";
  return out;
}
#endif

#define mod 1000000007              // 1e9+7(prime number)
#define INF 1000000000              // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 200010

vector<ll> factmemo, factmemoInv;
ll factmemoMod = -1;

ll factorial(int n, int M) {
  if (factmemoMod == M)
    return factmemo[n];
  if (n <= 1)
    return 1;

  ll res = 1;
  for (int i = 1; i <= n; i++)
    res = res * i % M;
  return res;
}

ll power(ll k, ll n, int M) {
  ll res = 1;
  while (n > 0) {
    if (n & 1)
      res = res * k % M;
    k = k * k % M;
    n /= 2;
  }
  return res;
}

void initFactorial(int n, int M) {
  factmemo.assign(n + 1, 0);
  factmemoInv.assign(n + 1, 0);
  factmemoMod = M;
  factmemo[0] = 1;
  for (int i = 1; i <= n; i++)
    factmemo[i] = factmemo[i - 1] * i % M;
  factmemoInv[n] = power(factmemo[n], M - 2, M);
  for (int i = n; i > 0; i--)
    factmemoInv[i - 1] = factmemoInv[i] * i % M;
}

// nCm nPm nHm (mod M)

/*Combination*/
ll C(int n, int m, int M) {
  if (n < m)
    return 0;
  if (m == 0 || n == m)
    return 1;

  if (factmemoMod == M)
    return factmemo[n] * factmemoInv[m] % M * factmemoInv[n - m] % M;

  ll numer = factorial(n, M);
  ll denom = factorial(m, M) * factorial(n - m, M) % M;

  denom = power((int)denom, M - 2, M);

  return numer * denom % M;
}

/*Permutation*/
ll P(int n, int m, int M) {
  if (n < m)
    return 0;
  if (m == 0)
    return 1;

  if (factmemoMod == M)
    return factmemo[n] * factmemoInv[n - m] % M;

  ll numer = factorial(n, M);
  ll denom = factorial(n - m, M);

  denom = power((int)denom, M - 2, M);

  return numer * denom % M;
}

/*Combination with Repetitions*/
ll H(int n, int m, int M) {
  if (n == 0 && m == 0)
    return 1;
  return C(n + m - 1, m, M);
}

int main() {
  int N, K;
  map<int, int> counter;

  scanf("%d%d", &N, &K);

  initFactorial(N, mod);

  for (int i = 0; i < N; i++) {
    int A;
    scanf("%d", &A);
    counter[A]++;
  }

  ll ans = 0;
  int sum = 0;

  for (auto p : counter) {
    // max
    ll s = (mod + C(sum + p.second, K, mod) - C(sum, K, mod)) % mod;

    ans += s * p.first % mod;

    // max
    ll t = (mod + C(N - sum, K, mod) - C(N - sum - p.second, K, mod)) % mod;

    ans -= t * p.first % mod;

    debug(s);
    debug(t);

    sum += p.second;
  }

  cout << (ans % mod + mod) % mod << endl;

  return 0;
}