solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
long long int cache[1001][1001] = {
0,
};
long long int combi(int n1, int n2) {
if (cache[n1][n2]) return cache[n1][n2];
if (n1 == n2 || n2 == 0) return cache[n1][n2] = 1;
return cache[n1][n2] =
(combi(n1 - 1, n2 - 1) + combi(n1 - 1, n2)) % 1000000007;
}
int main() {
int n, sum = 0;
long long int temp = 1;
cache[1][1] = 1;
int cnt[1003];
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &cnt[i]);
for (int i = 1; i <= n; i++) {
sum += cnt[i];
temp = (combi(sum - 1, cnt[i] - 1) * temp) % 1000000007;
}
printf("%lld", temp);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, maax = 1010;
long long pos[maax][maax];
int main() {
int n;
cin >> n;
pos[0][0] = 1;
for (int i = 1; i < maax; i++) {
pos[i][0] = 1;
for (int j = 1; j <= i; j++)
pos[i][j] = (pos[i - 1][j] + pos[i - 1][j - 1]) % mod;
}
int col[maax];
for (int i = 0; i < n; i++) scanf("%d", &col[i]);
long long sol = 1;
int tot = 0;
for (int i = 0; i < n; i++) {
sol *= (pos[tot + col[i] - 1][col[i] - 1]);
sol %= mod;
tot += col[i];
}
cout << sol;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[1005];
const int MOD = 1e9 + 7;
long long fact[1000001];
long long MyPow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
long long C(int n, int m) {
if (m > n || m < 0) return 0;
long long a = fact[n], b = fact[n - m] * fact[m] % MOD;
return a * MyPow(b, MOD - 2) % MOD;
}
int main() {
fact[0] = 1;
for (int i = 1; i < 1000001; ++i) fact[i] = fact[i - 1] * i % MOD;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
int sum = arr[0];
long long ans = 1;
for (int i = 1; i < n; ++i) {
sum += arr[i];
ans = ans * C(sum - 1, arr[i] - 1) % MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long fact[1000001];
long long ifact[1000001];
long long pow(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long temp = pow(a, b / 2, mod);
temp *= temp;
temp %= mod;
if (b % 2) {
return (temp * a) % mod;
}
return temp;
}
void calfact(int n) {
fact[0] = 1;
int i;
for (i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
long long ilast = (i * fact[i - 1]) % mod;
ilast = pow(ilast, mod - 2, mod);
ifact[n] = (ilast * (n + 1)) % mod;
for (i = n - 1; i >= 0; i--) {
ifact[i] = ((i + 1) * ifact[i + 1]) % mod;
}
}
long long nCr(long long n, long long r) {
return (((fact[n] * ifact[r]) % mod) * ifact[n - r]) % mod;
}
int a[1004];
int main() {
ios_base::sync_with_stdio(false);
int i, j, k, m, x, t, y, n, flag;
cin >> k;
for (i = 0; i < k; i++) cin >> a[i];
calfact(1000000);
long long ans = 1;
long long sum = a[0];
for (i = 1; i < k; i++) {
ans *= nCr(a[i] - 1 + sum, sum);
ans %= mod;
sum += a[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
import math
MOD = 1000000007
MAXN = 1005
def fac(n, k):
res = 1
for i in range(n + 1 - k, n + 1):
res *= i
return res
k = int(input())
sum = 0
ans = 1
for i in range(0, k):
num = int(input())
sum += num
ans = ans * fac(sum - 1, num - 1) // fac(num - 1, num - 1)
print (ans % MOD) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long c[2000000] = {}, i, m = 1000000007, n, k, j, p[1001][1001] = {},
a[1001] = {};
int main() {
long long ans = 1, f[2000] = {}, h, y[1001] = {};
f[1] = 1;
for (i = 0; i < 1001; i++) {
p[i][0] = 1;
p[0][i] = 1;
}
for (i = 1; i < 1001; i++) {
for (j = 1; j < 1001; j++) {
p[i][j] = (p[i - 1][j] + p[i][j - 1]) % m;
}
}
cin >> k;
cin >> a[1];
y[1] = a[1];
for (i = 2; i <= k; i++) {
cin >> a[i];
y[i] = a[i] + y[i - 1];
}
for (i = 2; i <= k; i++) {
h = p[y[i] - a[i]][a[i] - 1];
ans *= h;
ans %= m;
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3010, mod = 1e9 + 7;
long long k, c[N], s[N], f[N][N], dp[N];
void init() {
for (long long i = 0; i <= N - 10; i++) f[i][i] = f[i][0] = 1;
for (long long i = 2; i <= N - 10; i++)
for (long long j = 1; j < i; j++)
f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % mod;
}
signed main() {
scanf("%lld", &k);
for (long long i = 1; i <= k; i++)
scanf("%lld", &c[i]), s[i] = s[i - 1] + c[i];
init();
dp[1] = 1;
for (long long i = 2; i <= k; i++)
dp[i] = (dp[i - 1] * f[s[i - 1] + c[i] - 1][c[i] - 1]) % mod;
printf("%lld", dp[k]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
int k, c[1000];
long long int perm[1001];
long long int ans;
long long int extgcd(long long int a, long long int b, long long int &x,
long long int &y) {
long long int g = a;
x = 1;
y = 0;
if (b != 0) g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
long long int mod_inverse(long long int a, long long int m = MOD) {
long long int x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
long long int nCr(int n, int r) {
return (((perm[n] * mod_inverse(perm[r])) % MOD) * mod_inverse(perm[n - r])) %
MOD;
}
int main(void) {
int i, j;
scanf("%d", &k);
for (i = 0; i < k; i++) {
scanf("%d", c + i);
}
perm[0] = 1;
for (i = 1; i < 1001; i++) {
perm[i] = (perm[i - 1] * i) % MOD;
}
ans = 1;
for (i = k - 1; i >= 1; i--) {
int sum = 0;
for (j = i - 1; j >= 0; j--) {
sum += c[j];
}
ans = (ans * nCr(sum + c[i] - 1, c[i] - 1)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
ll add_mod(ll a, ll b) { return (((a + b) % MOD) + MOD) % MOD; }
ll multiply_mod(ll a, ll b) { return (((a * b) % MOD) + MOD) % MOD; }
ll pow(ll x, ll n, int m) {
if (n == 0) return 1;
ll a = pow(x, n / 2, m);
a = a * a % m;
if (n % 2 == 1) a = a * x % m;
return a;
}
ll divide_mod(ll a, ll b) { return multiply_mod(a, pow(b, MOD - 2, MOD)); }
const int MAXN = 1010;
int c[MAXN];
ll factorial[MAXN];
void compute_factorial() {
factorial[0] = 1;
for (int i = 1; i < MAXN; i++) {
factorial[i] = multiply_mod(i, factorial[i - 1]);
}
}
int main() {
ll k;
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> c[i];
c[i]--;
}
ll res = 1;
int num_before = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j < c[i]; j++) {
res = multiply_mod(res, num_before + 1);
num_before++;
}
num_before++;
}
compute_factorial();
for (int i = 1; i <= k; i++) {
res = divide_mod(res, factorial[c[i]]);
}
cout << res << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[1003][1003];
long long arr[1003];
long long sum[1003];
long long cc(long long n, long long r) {
if (r == 0 || r == n) return 1;
if (dp[n][r] != -1) return dp[n][r] % 1000000007;
return dp[n][r] =
(cc(n - 1, r - 1) % 1000000007 + cc(n - 1, r) % 1000000007) %
1000000007;
}
long long solve(long long k) {
if (k == 1) return 1;
return (solve(k - 1) % 1000000007 * cc(sum[k] - 1, arr[k] - 1) % 1000000007) %
1000000007;
}
int main() {
for (int i = 0; i < 1003; i++) {
for (int j = 0; j < 1003; j++) {
arr[j] = 0;
sum[j] = 0;
dp[i][j] = -1;
}
}
long long k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> arr[i];
sum[1] = arr[1];
for (int i = 2; i <= k; i++) {
sum[i] = arr[i] + sum[i - 1];
}
cout << solve(k) % 1000000007;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline bool cheak(int x, int y, int xMax, int yMax) {
return x >= 0 && y >= 0 && xMax > x && yMax > y;
}
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[8] = {0, -1, 0, 1, -1, 1, -1, 1};
const int mod = 1000000007;
const int INF = 1e9;
const int M = 1001;
long long C[M][M];
int main() {
C[0][0] = C[1][1] = C[1][0] = 1;
for (int i = 2; i < M; i++) {
for (int j = 0; j <= i; ++j) {
long long l = j >= i ? 0 : C[i - 1][j];
long long r = j > 0 ? C[i - 1][j - 1] : 0;
C[i][j] = (l + r) % mod;
}
}
int k;
cin >> k;
int c[1001];
int sum = 0;
int ans = 1;
for (long long(i) = (0); i < (k); (i)++) {
cin >> c[i];
}
for (long long(i) = (0); i < (k); (i)++) sum += c[i];
for (int i = k - 1; i >= 1; i--) {
ans = (ans * C[sum - 1][c[i] - 1]) % mod;
sum -= c[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
int main() {
int64_t k;
int64_t n = 0;
std::cin >> k;
std::array<std::array<int64_t, 1001>, 1001> m;
for (int64_t j = 0; j < 1001; ++j) {
m[0][j] = 0;
}
m[0][0] = 1;
for (int64_t n = 1; n < 1001; ++n) {
for (int64_t k = 0; k < 1001; ++k) {
if (k == 0) {
m[n][k] = 1;
} else if (k == 1) {
m[n][k] = n;
} else if (k > n) {
m[n][k] = 0;
} else {
m[n][k] = (m[n - 1][k - 1] + m[n - 1][k]) % 1000000007;
}
}
}
std::array<int64_t, 1001> arr;
for (int64_t i = 0; i < k; ++i) {
int64_t k_i;
std::cin >> k_i;
arr[i] = k_i;
}
int64_t res = 1;
int64_t sum = 0;
for (int64_t i = 0; i < k; ++i) {
int64_t kl = arr[i];
auto ck = m[sum + kl - 1][kl - 1];
res = (ck * res) % 1000000007;
sum += kl;
}
std::cout << res << std::endl;
}
| 9 | CPP |
#!/usr/bin/env python3
"""
Codeforces Round #309 (Div. 2)
Problem 554 C. Kyoya and Colored Balls
@author yamaton
@date 2015-08-17
"""
import itertools as it
import functools
import operator
import collections
import math
import sys
LARGE_NUMBER = 1000000007
@functools.lru_cache(maxsize=None)
def binomial(n, k):
"""
>>> binomial(4, 0)
1
>>> binomial(4, 1)
4
>>> binomial(4, 2)
6
>>> binomial(4, 3)
4
>>> binomial(4, 4)
1
"""
if n < k:
return 0
elif n < 2 * k:
return binomial(n, n - k)
else:
numer = functools.reduce(operator.mul, range(n, n - k, -1), 1)
denom = functools.reduce(operator.mul, range(k, 0, -1), 1)
return numer // denom
def solve(xs):
n = len(xs)
for i in range(n):
if i == 0:
counts = 1
counts *= binomial(sum(xs[:i+1]) - 1, xs[i] - 1)
counts %= LARGE_NUMBER
return counts
@functools.lru_cache(maxsize=None)
def helper(xs, separators):
print_stderr(xs, separators)
if xs:
k = xs[-1]
ys = xs[:-1]
result = []
for i in range(k + 1):
coeff = binomial(i + (separators - 1), i)
out = coeff * helper(ys, separators + i - 1)
result.append(out)
return sum(result) % LARGE_NUMBER
else:
return 1
def print_stderr(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
def main():
n = int(input())
xs = [int(input()) for _ in range(n)]
result = solve(xs)
print(result)
if __name__ == '__main__':
main() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxk = 1000 + 5;
const long long mod = 1000000007;
long long fac[maxk];
int a[maxk];
void extgcd(long long a, long long& x, long long b, long long& y,
long long& d) {
if (!b) {
x = 1, y = 0;
d = a;
return;
}
extgcd(b, y, a % b, x, d);
y -= x * (a / b);
}
long long inv(long long val) {
long long a = val, x, b = mod, y, d;
extgcd(a, x, b, y, d);
return ((x % mod) + mod) % mod;
}
inline long long C(long long n, long long m) {
return (((fac[n] * inv(fac[n - m])) % mod) * inv(fac[m])) % mod;
}
inline long long H(long long n, long long m) { return C(n + m - 1, m); }
int main() {
fac[0] = 1;
for (long long i = 1; i < maxk; i++) fac[i] = (i * fac[i - 1]) % mod;
int k;
long long ans = 1, total = 0;
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", a + i);
for (int i = 0; i < k; total += a[i], i++)
(ans *= H(total + 1, a[i] - 1)) %= mod;
printf("%lld\n", ans);
}
| 9 | CPP |
nCr = [[0 for i in range(1001)] for j in range(1001)]
nCr[0][0] = 1
for i in range(1,1001):
nCr[i][0] = 1
for j in range(1,i+1):
nCr[i][j] = (nCr[i-1][j] + nCr[i-1][j-1]) % 1000000007
n = int(input())
data = []
for i in range(n):
data.append(int(input()))
ans = 1
total = 0
for i in range(n):
ans = ( ans * nCr[total + data[i] - 1][data[i] - 1] ) % 1000000007
total += data[i]
print(int(ans))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
const long long p = 1000000007;
struct gcdstruct {
long long y, x, d;
};
gcdstruct EXTENDED_EUCLID(long long a, long long b) {
gcdstruct aa, bb;
if (b == 0) {
aa.d = a;
aa.x = 1;
aa.y = 0;
return aa;
} else {
bb = EXTENDED_EUCLID(b, a % b);
aa.d = bb.d;
aa.x = bb.y;
aa.y = bb.x - bb.y * (a / b);
}
return aa;
}
long long inverse(long long a, long long m) {
long long x;
gcdstruct aa;
aa = EXTENDED_EUCLID(a, m);
return aa.x;
}
long long a[N], b[N];
int main() {
long long i, j, n, sum = 0, ans = 1;
cin >> n;
for (i = 1; i < N; i++) b[i] = (inverse(i, p) + p) % p;
for (i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (i = n; i; i--) {
sum--;
a[i]--;
for (j = 1; j <= a[i]; j++) {
ans = (ans * sum) % p;
ans = (ans * b[j]) % p;
sum--;
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long com[1010][1010];
int ball[1010];
void com_init() {
com[0][0] = 1;
for (int i = 1; i < 1010; i++) {
com[i][0] = 1;
for (int j = 1; j <= i; j++)
com[i][j] = (com[i - 1][j] + com[i - 1][j - 1]) % mod;
}
}
long long H(int n, int r) { return com[n + r - 1][n - 1]; }
int main() {
com_init();
int k;
while (cin >> k) {
for (int i = 1; i <= k; i++) cin >> ball[i];
long long ans = 1;
int cur = ball[1];
for (int i = 2; i <= k; i++) {
ans = ans * H(cur + 1, ball[i] - 1) % mod;
cur += ball[i];
}
cout << ans << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int aa[1003][1003];
long long int comb(int n, int m) {
int sum = 0;
if (n == 1)
return 1;
else if (m == 1 || m == n - 1)
return n;
else if (m == n || m == 0)
return 1;
else {
sum = sum + comb(n - 1, m) + comb(n - 1, m - 1);
if (sum >= 1000000007) sum = sum % 1000000007;
}
return sum;
}
int main() {
aa[0][0] = 1;
for (int i = 1; i < 1002; i++) {
aa[i][0] = 1;
for (int j = 1; j <= i; j++) {
aa[i][j] = (aa[i - 1][j] + aa[i - 1][j - 1]) % 1000000007;
}
}
int n, j;
scanf("%d", &n);
int a[n], sum = 0;
long long int man = 1, woman = 1;
for (int i = 0; i < n; i++) scanf("%d", &a[i]), sum = sum + a[i];
sum--;
for (int i = n - 1; i >= 0; i--) {
j = a[i] - 1;
man = (man * aa[sum][j]) % 1000000007;
sum = sum - a[i];
}
printf("%I64d", man);
return 0;
}
| 9 | CPP |
k=int(input())
l=[int(input()) for i in range(k)]
s=0
ans=[0]*k
ans[0]=1
MOD=10**9+7
fact=[0]*(10**6+5)
fact[0]=1
for i in range(1,10**6+5):
fact[i]=(fact[i-1]%MOD*i%MOD)%MOD
def MI(a,MOD):
return pow(a,MOD-2,MOD)
def c(n, k):
if n==k or k==0:
return 1
if n<k:
return 0
return (fact[n]*MI(fact[k],MOD)%MOD*MI(fact[n-k],MOD)%MOD)%MOD
ans=1
sm=l[0]
for i in range(1,k):
curr=l[i]
ans=ans*(c(sm+curr-1,curr-1))
ans%=MOD
sm+=l[i]
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long k, c[1002], a[1002][1002], sum = 0, f[1002];
int main() {
a[0][1] = 1;
a[1][1] = 1;
a[1][2] = 2;
for (long long i = 2; i < 1002; i++) {
a[0][i] = 1;
a[1][i] = i;
for (long long j = 1; j <= i; j++) {
a[j][i] = (a[j - 1][i - 1] + a[j][i - 1]) % 1000000007;
}
}
scanf("%I64d", &k);
for (long long i = 1; i <= k; i++) {
scanf("%I64d", &c[i]);
}
sum = c[1];
f[1] = 1;
for (long long i = 2; i <= k; i++) {
if (sum > 1)
f[i] = (f[i - 1] * a[sum][sum + c[i] - 1]) % 1000000007;
else if (sum == 1)
f[i] = (f[i - 1] * (c[i])) % 1000000007;
sum += c[i];
}
printf("%I64d\n", f[k]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int k, i, n, j;
long long int c[10005];
long long int finda(void) {
long long int a1 = 1;
for (i = 1; i <= n; i++) a1 = (a1 * i) % 1000000007;
for (i = 1; i <= k; i++) a1 = (a1 * c[k + 1 - i]) % 1000000007;
return a1;
}
long long int findb() {
long long int b1 = 1, n1 = n;
for (i = 1; i <= k; i++)
for (j = 1; j <= c[i]; j++) b1 = (b1 * j) % 1000000007;
for (i = 1; i <= k; i++) {
b1 = (b1 * n1) % 1000000007;
n1 -= c[k + 1 - i];
}
return b1;
}
unsigned long long invert_mod(unsigned long long a, unsigned long long p) {
unsigned long long ex = p - 2, result = 1;
while (ex > 0) {
if (ex % 2 == 1) {
result = (result * a) % p;
}
a = (a * a) % p;
ex /= 2;
}
return result;
}
int main() {
cin >> k;
for (i = 1; i <= k; i++) {
cin >> c[i];
n += c[i];
}
long long int a = finda();
long long int b = findb();
long long int inv = invert_mod(b, 1000000007);
cout << (a * inv) % 1000000007;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using std::endl;
using std::istream;
template <typename T>
T ioread(istream& in) {
T var;
in >> var;
return var;
}
class Calc {
public:
typedef int64_t type;
Calc(type divisor) : div_(divisor) {}
inline type multiply(type a, type b) const { return conv(a * b); }
inline type add(type a, type b) const { return conv(a + b); }
private:
inline type conv(type x) const { return (x % div_); }
const type div_;
};
static const int MAX_BALLS = 1000;
static const int MAX_N = 2 * MAX_BALLS;
static const int MAX_K = MAX_BALLS;
static Calc::type bc[MAX_N + 1][MAX_K + 1];
class WeakCompositions {
public:
WeakCompositions(const Calc& calculator) : calc_(calculator) {}
inline Calc::type ncompos(const int n, const int k) const;
private:
inline Calc::type combinations(const int n, const int k) const;
const Calc& calc_;
};
inline Calc::type WeakCompositions::ncompos(int n, int k) const {
--k;
n += k;
return combinations(n, k);
}
inline Calc::type WeakCompositions::combinations(int n, int k) const {
Calc::type& coeff = bc[n][k];
if (coeff) return coeff;
if (k == 0 || k == n) return (coeff = 1);
--n;
coeff = combinations(n, k);
--k;
coeff = calc_.add(coeff, combinations(n, k));
return coeff;
}
int main(void) {
using std::cin;
using std::cout;
std::ios_base::sync_with_stdio(false);
cin.tie(0);
const int K = ioread<int>(cin);
int nballs = 0;
Calc::type ncomb = 1;
Calc calc((Calc::type)1e9 + 7);
WeakCompositions wc(calc);
for (int color = 0; color < K; ++color) {
const int ci = ioread<int>(cin);
ncomb = calc.multiply(ncomb, wc.ncompos(ci - 1, nballs + 1));
nballs += ci;
}
cout << ncomb << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int C[1000 + 1][1000 + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
long long int i, j;
for (int i = 0; i <= 1000; i++) {
C[0][i] = 1;
C[i][0] = 1;
}
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= 1000; j++) {
C[i][j] = (C[i - 1][j] + C[i][j - 1]) % MOD;
}
}
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long int ans = 1;
long long int sum = 0;
for (i = 0; i < n; i++) {
ans = 1LL * ans * (C[sum][a[i] - 1]) % MOD;
sum += a[i];
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[2005][2005];
long long comb(long long n, long long k) {
if ((k == 0) || k == n) return 1;
if (dp[n][k] != 0) return dp[n][k];
long long x = comb(n - 1, k - 1) % 1000000007 + comb(n - 1, k) % 1000000007;
dp[n][k] = x % 1000000007;
x %= 1000000007;
return x;
}
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long ans = 1;
long long cnt = a[0];
for (long long i = 1; i < n; i++) {
ans *= comb(cnt + 1 + a[i] - 2, a[i] - 1);
cnt += a[i];
ans %= 1000000007;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
}
long long modPow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long x = a * a;
x %= 1000000007;
return modPow(x, b / 2);
}
return (a * modPow(a, b - 1)) % 1000000007;
}
| 9 | CPP |
k = int(input())
colors = []
for i in range(k) :
colors.append(int(input()))
ans = 1
accum = colors[0]
for i in range(1, k):
for j in range(1, colors[i]):
ans *= (accum + j)
for j in range(1, colors[i]):
ans //= j
accum += colors[i]
print(ans % 1000000007)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long fact[10001], invfact[10001], inv[10001];
const long long mod = 1000000007;
long long C(long long n, long long k) {
if (!(0 <= k && k <= n)) return 0;
return (((fact[n] * invfact[k]) % mod) * invfact[n - k]) % mod;
}
int main() {
fact[0] = invfact[0] = inv[1] = 1;
for (int i = 2; i < 10001; i++) {
inv[i] = mod - (mod / i) * inv[mod % i] % mod;
}
for (int i = 1; i < 10001; i++) {
fact[i] = (fact[i - 1] * i) % mod;
invfact[i] = (invfact[i - 1] * inv[i]) % mod;
}
int k;
cin >> k;
if (k == 1) {
cout << 1 << endl;
return 0;
}
int sum = 0;
vector<int> vc(k);
for (int i = 0; i < k; i++) {
cin >> vc[i];
sum += vc[i];
}
long long res = 1;
for (int i = 0; i < k; i++) {
sum--;
res = (res * C(sum, vc[k - 1 - i] - 1)) % mod;
sum -= vc[k - 1 - i] - 1;
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int INF = INT_MAX;
const int MAX_N = 1000 + 10;
const int MOD = 1000000007;
template <typename T>
inline T sqr(T a) {
return a * a;
};
int sum = 0, M, K, C[MAX_N];
long long fact[MAX_N];
long long mod_pow(long long x, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
int main(int argc, char const *argv[]) {
long long ans = 1;
fact[0] = 1;
for (int i = 1; i < MAX_N; ++i) fact[i] = fact[i - 1] * i % MOD;
cin >> K;
for (int i = 0; i < K; ++i) {
cin >> C[i];
sum += C[i];
}
for (int i = K - 1; i >= 0; --i) {
ans *= fact[sum - 1] *
mod_pow(fact[C[i] - 1] * fact[sum - C[i]] % MOD, MOD - 2, MOD) % MOD;
ans %= MOD;
sum -= C[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int MOD = 1e9 + 7;
long long fac[maxn + 10];
long long rfac[maxn + 10];
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = ((res * a) % MOD);
}
a = ((a * a) % MOD);
b >>= 1;
}
return res;
}
void init() {
fac[0] = fac[1] = 1;
for (int i = 2; i <= maxn; i++) {
fac[i] = ((fac[i - 1] * i) % MOD);
}
rfac[maxn] = qpow(fac[maxn], MOD - 2);
for (int i = maxn; i > 0; i--) {
rfac[i - 1] = ((rfac[i] * i) % MOD);
}
}
long long n, sum, res = 1;
long long a[maxn];
int main() {
ios_base::sync_with_stdio(0);
init();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = n - 1; i > 0; i--) {
res =
((res * ((((fac[sum - 1] * rfac[a[i] - 1]) % MOD) * rfac[sum - a[i]]) %
MOD)) %
MOD);
sum -= a[i];
}
printf("%I64d\n", res);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
inline long long int read() {
long long int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline char rch() {
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
return ch;
}
using namespace std;
const unsigned long long int MOD = 1000000007;
unsigned long long int C[1234][1234];
void nck(int n, int k) {
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
}
int main() {
nck(1222, 1222);
long long int k = read(), a[1111], total = 0;
unsigned long long int res = 1 % MOD;
for (long long int i = 0; i < k; i++) a[i] = read();
for (long long int i = 0; i < k; i++) {
res = (res * (C[total + a[i] - 1][a[i] - 1])) % MOD;
total += a[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c[1001];
unsigned long long comb[1010][1010];
void init() {
int i, j;
for (i = 0; i < 1010; i++) comb[i][0] = 1;
for (i = 1; i < 1010; i++) {
for (j = 1; j <= i; j++) {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
comb[i][j] %= 1000000007;
}
}
}
int main() {
memset(comb, 0, sizeof(comb));
init();
int n;
cin >> n;
unsigned long long dp[n + 1], s[n + 1];
memset(c, 0, sizeof(c));
s[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> c[i];
s[i] = s[i - 1] + c[i];
}
dp[1] = 1;
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] * comb[s[i] - 1][c[i] - 1];
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long use[1050][1050];
int main() {
memset(use, 0, sizeof(use));
use[0][0] = 1;
for (int i = 1; i <= 1005; i++)
for (int j = 1; j <= i; j++) {
use[i][0] = 1;
use[i][j] = (use[i - 1][j - 1] + use[i - 1][j]) % 1000000007;
}
int w;
cin >> w;
int num[1005];
for (int i = 1; i <= w; i++) cin >> num[i];
long long ans = 1;
int u = 0;
for (int i = 1; i <= w; i++) {
ans = (ans * use[u + num[i] - 1][num[i] - 1]) % 1000000007;
u += num[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAX = 1005;
long long C[MAX][MAX];
void initial() {
memset(C, 0, sizeof(C));
for (int i = 0; i < MAX; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j <= i / 2; j++)
C[i][j] = C[i][i - j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
}
int main() {
initial();
int k, c[MAX];
while (scanf("%d", &k) != EOF) {
int sum = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &c[i]);
sum += c[i];
}
long long ans = 1;
while (k--) {
ans = ans * (C[sum - 1][c[k] - 1]) % MOD;
sum -= c[k];
}
printf("%I64d\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long comb[1005][1005];
int main() {
comb[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
comb[i][j] = 1;
else {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
comb[i][j] %= 1000000007;
}
}
}
int n, s = 0;
long long ans = 1;
cin >> n;
int *a = new int[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
ans *= comb[s + a[i] - 1][a[i] - 1];
ans %= 1000000007;
s += a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[1005], inc[1005], a[1005], sum[1005];
const long long k = 1000000007;
long long c(int x, int y) {
long long res = 1;
for (int i = x; i > x - y; i--) {
res = (res * i) % k;
}
for (int i = y; i >= 1; i--) {
res = (res * inc[i]) % k;
}
return res;
}
int main() {
int n;
cin >> n;
inc[1] = 1;
for (int i = 2; i < 1002; i++) {
inc[i] = k - (((k / i) * inc[k % i]) % k);
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sum[0] = a[0];
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + a[i];
dp[0] = 1;
for (int i = 1; i < n; i++) {
dp[i] = c(sum[i] - 1, a[i] - 1) * dp[i - 1] % k;
}
cout << dp[n - 1];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long fact[2500], ifact[2500], arr[2500], su, way = 1;
long long pow_mod(long long A, long long B) {
long long res = 1;
while (B) {
if (B & 1) {
res = ((res * A) % 1000000007);
}
A = ((A * A) % 1000000007);
B >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j, N;
fact[0] = 1;
for (i = 1; i <= 2200; ++i) {
fact[i] = ((fact[i - 1] * i) % 1000000007);
}
ifact[2200] = pow_mod(fact[2200], 1000000007 - 2);
for (i = 2199; i >= 0; --i) {
ifact[i] = ((ifact[i + 1] * (i + 1)) % 1000000007);
}
cin >> N;
for (i = 0; i <= N - 1; ++i) {
cin >> arr[i];
}
su = arr[0];
for (i = 1; i <= N - 1; ++i) {
way = ((way * ((((fact[su + arr[i] - 1] * ifact[arr[i] - 1]) % 1000000007) *
ifact[su]) %
1000000007)) %
1000000007);
su += arr[i];
}
cout << way;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long a[1001], sum[1001], b[1001][1001];
signed main() {
long long k, ans = 1;
memset(b, 0, sizeof(b));
for (long long i = 1; i < 1001; i++) {
b[i][0] = b[i][i] = 1;
for (long long j = 1; j < i; j++) {
b[i][j] = (b[i - 1][j - 1] + b[i - 1][j]) % mod;
}
}
cin >> k;
memset(sum, 0, sizeof(sum));
for (long long i = 1; i <= k; i++) {
cin >> a[i];
sum[i] += sum[i - 1] + a[i];
}
for (long long i = k; i >= 1; i--) {
if (a[i] == 1) continue;
ans = (ans * b[sum[i] - 1][a[i] - 1]) % mod;
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c[1005][1005], a[1005];
int main() {
int k, total = 0;
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &a[i]), total += a[i];
c[0][0] = c[1][0] = c[1][1] = 1;
for (int i = 2; i <= total; i++) {
c[i][i] = 1;
for (int j = 0; j < i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
long long ans = 1;
for (int i = k - 1; i >= 0; i--) {
ans = (ans * c[total - 1][a[i] - 1]) % 1000000007;
total -= a[i];
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[1001][1001];
bool isPrime[1001];
vector<long long> Prime;
void pre1() {
long long i, j;
for (i = 2; i < 1001; i++) {
for (j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
isPrime[i] = false;
goto hell;
}
}
isPrime[i] = true;
Prime.push_back(i);
hell:;
}
}
long long fpow(long long base, long long power) {
long long res = 1;
while (power > 0) {
if (power % 2 == 1) {
res *= base;
res %= 1000000007;
}
base = (base * base) % 1000000007;
power /= 2;
if (base < 0) {
base += 1000000007;
}
}
return res;
}
long long calc(long long a, long long b) {
long long aa = 0, bb = b;
while (a / b) {
aa += a / b;
b *= bb;
}
return aa;
}
long long cc(long long a, long long b) { return fpow(a, b); }
void pre() {
memset(dp, 0, sizeof(dp));
memset(isPrime, false, sizeof(isPrime));
}
long long nCr(long long n, long long r) {
long long res = 1;
for (long long i = 0; i < Prime.size() && Prime[i] <= n; i++) {
long long tmp = Prime[i];
long long res1, res2;
res1 = calc(n, tmp) - calc(n - r, tmp) - calc(r, tmp);
res1 = cc(tmp, res1);
res1 %= 1000000007;
res *= res1;
res %= 1000000007;
if (res < 0) {
res += 1000000007;
}
}
return res;
}
int main() {
pre();
pre1();
long long k, i, j;
cin >> k;
long long ans = 1;
long long sum = 0;
for (i = 0; i < k; i++) {
long long c;
cin >> c;
sum += c;
ans *= nCr(sum - 1, c - 1);
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double EPS = 1e-6;
const int maxn = 500000 + 5;
const long long mod = 1e9 + 7;
const long long p = 1e9 + 7;
long long arr[1000 + 5];
long long quick_mod(long long a, long long b) {
long long ans = 1;
a %= p;
while (b) {
if (b & 1) {
ans = ans * a % p;
b--;
}
b >>= 1;
a = a * a % p;
}
return ans;
}
long long C(long long n, long long m) {
if (m > n) return 0;
long long ans = 1;
for (int i = 1; i <= m; i++) {
long long a = (n + i - m) % p;
long long b = i % p;
ans = ans * (a * quick_mod(b, p - 2) % p) % p;
}
return ans;
}
long long Lucas(long long n, long long m) {
if (m == 0) return 1;
return C(n % p, m % p) * Lucas(n / p, m / p) % p;
}
int main(void) {
long long N;
cin >> N;
long long kd = 0;
long long sum = 1;
for (int i = (1); i <= (N); i++) {
cin >> arr[i];
arr[i] -= 1;
kd += arr[i];
sum *= Lucas(kd, arr[i]);
sum %= p;
kd += 1;
}
cout << sum << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, m, a[1010], c[1010][1010], f[1010];
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
a[i] += a[i - 1];
}
c[1][0] = c[1][1] = 1;
for (i = 2; i <= 1000; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
f[1] = 1;
for (i = 2; i <= n; i++)
f[i] = (f[i - 1] * c[a[i] - 1][a[i] - a[i - 1] - 1]) % 1000000007;
printf("%I64d\n", f[n]);
}
| 9 | CPP |
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
mod=10**9+7
# sys.setrecursionlimit(10**6)
# mxm=sys.maxsize
# from functools import lru_cache
fact=[1]*(1002)
for i in range(2,1002):
fact[i]=(fact[i-1]*i)%mod
def ncr(n,r):
num=fact[n]
den=(fact[n-r]*fact[r])%mod
return (num*(pow(den,mod-2,mod)))%mod
def main():
k=int(input())
dp=[0]*(k+1)
dp[1]=1
dff=0
m=int(input())
total=m
for i in range(k-1):
m=int(input())
dff=m-1
total+=m
dp[i+2]=(dp[i+1]*ncr(total-1,dff))%mod
print(dp[k])
#----------------------------------------------------------------------------------------
def nouse0():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse1():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse2():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int base = 1e9 + 7;
const int maxn = 2005;
long long n, a[maxn], f[maxn], c[maxn][maxn], d[maxn][maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= 2000; ++i) d[0][i] = 1, c[0][i] = 1;
for (int i = 1; i <= 2000; ++i)
for (int j = 1; j <= 2000; ++j) {
if (j == 1)
c[i][j] = 1;
else
c[i][j] = d[i][j - 1];
d[i][j] = (d[i - 1][j] + c[i][j]) % base;
}
int num = a[1];
f[1] = 1;
for (int i = 2; i <= 2000; ++i) {
f[i] = (c[a[i] - 1][num + 1] * f[i - 1]) % base;
num += a[i];
}
cout << f[n];
fclose(stdin);
fclose(stdout);
}
| 9 | CPP |
n, d = map(int, input().split())
v = []
for i in range(0, n):
a, b = map(int, input().split())
v.append((a, b))
v = sorted(v)
lo = 0
totalFriendship = v[0][1]
bestFriendship = totalFriendship
for i in range(1, n):
while v[i][0] - v[lo][0] >= d:
totalFriendship -= v[lo][1]
lo += 1
totalFriendship += v[i][1]
bestFriendship = max(bestFriendship, totalFriendship)
print(bestFriendship)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 100000 + 1000;
struct node {
long long m, s;
bool operator<(const node& b) const { return m < b.m; }
} num[MAXN];
long long sum[MAXN];
long long M[MAXN];
int n, d;
int main() {
while (scanf("%d%d", &n, &d) != EOF) {
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &num[i].m, &num[i].s);
sort(num + 1, num + n + 1);
sum[0] = 0;
M[0] = 0;
for (int i = 1; i <= n; i++) M[i] = num[i].m;
M[n + 1] = INF;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + num[i].s;
sum[n + 1] = sum[n];
long long ans = 0;
for (int i = 1; i <= n + 1; i++) {
int s = i - 1;
int e = ((long long)upper_bound(M + 1, M + n + 2,
(long long)M[i] + (long long)d - 1) -
(long long)(M + 1)) /
sizeof(long long);
long long temp = sum[e] - sum[s];
ans = max(ans, temp);
}
printf("%I64d\n", ans);
}
}
| 8 | CPP |
z,zz=input,lambda:list(map(int,z().split()))
zzz=lambda:[int(i) for i in stdin.readline().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
n,m=zz()
lst=[]
for _ in range(n):
lst.append(zz())
lst=sorted(lst)
ans=0
l=0
s=0
for r in range(n):
while lst[r][0]-lst[l][0]>=m:
s-=lst[l][1]
l+=1
s+=lst[r][1]
ans=max(ans,s)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct man {
long long int m, s, I;
};
man a[131072];
bool cmp(man a, man b) {
if (a.m < b.m) return true;
if (a.m > b.m) return false;
if (a.I > b.I) return true;
if (a.I < b.I) return false;
}
int main() {
queue<man> x;
long long int n, d, i, tbr = 0, maxbr = 0;
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> a[i].m >> a[i].s;
a[i].I = i;
}
sort(a, a + n, cmp);
for (i = 0; i < n; i++) {
x.push(a[i]);
struct man m = x.front(), m2 = x.back();
while (m2.m - m.m >= d) {
tbr -= m.s;
x.pop();
m = x.front();
m2 = x.back();
}
tbr += m2.s;
if (tbr > maxbr) maxbr = tbr;
}
cout << maxbr << endl;
return 0;
}
| 8 | CPP |
friends = []
n, d = map(int, input().split())
for i in range(n):
friends.append(tuple(map(int, input().split())))
friends.sort()
sums = [friends[0][1]]
for i in range(1, n):
sums.append(sums[i - 1] + friends[i][1])
l = r = 0
answer = 0
while l <= n - 1 and r <= n - 1:
if friends[r][0] - friends[l][0] < d:
if sums[r] - sums[l] + friends[l][1] > answer:
answer = sums[r] - sums[l] + friends[l][1]
r += 1
elif l <= r - 1:
l += 1
else:
r += 1
print(answer)
| 8 | PYTHON3 |
import sys
n, d = map(int, sys.stdin.readline().split())
friends = []
for i in range(n):
m, s = map(int, sys.stdin.readline().split())
friends.append((m, s))
friends.sort(key = lambda x:x[0])
left = 0
right = 0
ans = 0
cur = 0
while left < n:
while right < n and friends[right][0] - friends[left][0] < d:
cur += friends[right][1]
right += 1
if cur > ans:
ans = cur
cur -= friends[left][1]
left += 1
print(ans)
| 8 | PYTHON3 |
n,d=map(int,input().split())
a=[]
for i in range(n):
a.append([])
for i in range(n):
a[i]=list(map(int,input().split()))
a[i].append(i)
a.sort()
i=0
mx=0
x=a[i][0]
s=a[i][1]
j=1
while j!=n:
if a[j][0]-x<d:
s+=a[j][1]
mx=max(s,mx)
j+=1
else:
mx=max(s,mx)
s-=a[i][1]
i+=1
x=a[i][0]
print(max(mx,s)) | 8 | PYTHON3 |
I = lambda :map(int, input().split())
n,d=I()
a=sorted([list(I()) for i in range(n)])
j = 0
ans = t= a[0][1]
for i in range (1,n):
while(a[i][0]-a[j][0]>=d) :
t-=a[j][1]
j+=1
t+=a[i][1]
ans = max(ans, t)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[100007];
long long p[100007];
int main() {
long long n, d, L, R, res, s;
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) p[i] = p[i - 1] + a[i].second;
R = 1;
res = a[1].second;
for (int L = 1; L <= n; L++) {
while (R <= n && a[R].first - a[L].first < d) {
if (p[R] - p[L - 1] > res) res = p[R] - p[L - 1];
R++;
}
}
cout << res << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > k;
int main() {
long long x, mii, sum = 0, sum2 = 0;
cin >> x >> mii;
for (long long i = 0; i < x; i++) {
long long n, m;
cin >> n >> m;
k.push_back(make_pair(n, m));
}
sort(k.begin(), k.end());
for (long long i = 0, t = 0; i < x && t < x && i <= t;) {
if (k[t].first - k[i].first < mii) {
sum = sum + k[t].second;
t++;
} else {
sum2 = max(sum2, sum);
sum -= k[i].second;
i++;
}
}
sum2 = max(sum2, sum);
cout << sum2;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long x, y, n, d, i, beg, p1 = 0;
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> x >> y;
v.push_back(make_pair(x, y));
}
sort(v.begin(), v.end());
long long minn = v[0].first, cur = v[0].second, ans = v[0].second;
for (i = 1; i < n; i++) {
if (v[i].first - minn >= d) {
cur += v[i].second;
while (p1 < i and v[i].first - v[p1].first >= d) {
cur -= v[p1].second;
p1++;
}
ans = max(ans, cur);
minn = v[p1].first;
} else {
cur += v[i].second;
ans = max(ans, cur);
}
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
"""
Author: Andrew Jakubowicz
Input:
<Num of Friends> <Amount of money to feel poor>
Loop over the friends.
"""
# Use this for very fast insertion
# bisect.insort_left(list, item[, lo[, hi]])
if __name__ == "__main__":
n, poorAmount = list(map(int, input().split(' ')))
everythingList = []
moneyList = []
friendshipFactorList = []
for _ in range(n):
money, friendshipFactor = list(map(int, input().split(' ')))
everythingList.append((money,friendshipFactor))
# insertionPoint = bisect.bisect_left(moneyList, money)
# moneyList.insert(insertionPoint, money)
# friendshipFactorList.insert(insertionPoint, friendshipFactor)
everythingList.sort(key=lambda x: x[0])
# Get the most friendships within the poorAmount.
i = 0 #Leading pointer
j = 0 # Trailing pointer
endingSequence = False
rollingFriendShip = everythingList[i][1]
maxFriendShip = rollingFriendShip
# There will always be at least 1
while not (j + 1 >= n):
# If the totalMoneyDif is less than poorAmount
# then extend the right pointer.
totalMoneyDif = abs(everythingList[j][0] - everythingList[i][0])
if totalMoneyDif < poorAmount and i+1 < n:
maxFriendShip = max(maxFriendShip, rollingFriendShip)
i += 1
rollingFriendShip += everythingList[i][1]
else:
# Re order so it doesn't trigger every time.
if abs(everythingList[j][0] - everythingList[i][0]) < poorAmount:
maxFriendShip = max(maxFriendShip, rollingFriendShip)
if i + 1 == n and rollingFriendShip < maxFriendShip:
break
rollingFriendShip -= everythingList[j][1]
j += 1
if abs(everythingList[j][0] - everythingList[i][0]) < poorAmount:
maxFriendShip = max(maxFriendShip, rollingFriendShip)
print(maxFriendShip)
| 8 | PYTHON3 |
n,d = input().strip().split()
n = int(n)
d = int(d)
a = [[] for i in range(n)]
for i in range(n):
t1,t2 = input().strip().split()
a[i].append(int(t1))
a[i].append(int(t2))
a.sort()
i = 0
j = 0
s = 0
ans = 0
while i < n:
if a[j][0]-a[i][0] < d:
if j < n-1:
s += a[j][1]
j += 1
ans = max(ans,s)
#print("i:",i,"j:",j,"s:",s,"ans:",ans)
else:
s += a[j][1]
ans = max(ans,s)
break
else:
s -= a[i][1]
i += 1
#print("i:",i,"j:",j,"s:",s)
print(ans) | 8 | PYTHON3 |
from collections import namedtuple
# The first line of the input contains two space-separated integers,
# n and d (1 ≤ n ≤ 105, )
# — the number of Kefa's friends
# and the minimum difference between the amount of money in order to feel poor
N, D = map(int, input().split())
# Next n lines contain the descriptions of Kefa's friends,
# the (i + 1)-th line contains the description of the i-th friend
# of type mi, si (0 ≤ mi, si ≤ 109)
# — the amount of money and the friendship factor, respectively.
Friend = namedtuple('Friend', ['money', 'factor'])
friends = list()
for n in range(N):
mi, si = map(int, input().split())
pair = Friend(mi, si)
friends.append(pair)
friends.sort()
# print(f'friends:{friends}')
tail = 0
diff = 0
maxfactor = friends[0].factor
currfactor= friends[0].factor
for head in range(1, len(friends)):
currfactor += friends[head].factor
diff = friends[head].money - friends[tail].money
while diff >= D:
currfactor -= friends[tail].factor
tail += 1
diff = friends[head].money - friends[tail].money
maxfactor = max(maxfactor, currfactor)
# print(f'currfactor:{currfactor} maxfactor:{maxfactor}')
# print(f'diff:{diff}')
print(maxfactor)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Friend {
int m, s;
};
Friend f[100005];
bool operator<(const Friend &a, const Friend &b) { return a.m < b.m; }
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; ++i) cin >> f[i].m >> f[i].s;
sort(f, f + n);
long long Max = 0;
long long sum = 0;
int qian = 0;
for (int i = 0; i < n; ++i) {
if (f[i].m - f[qian].m >= d) {
--i;
sum -= f[qian].s;
++qian;
} else {
sum += f[i].s;
if (sum > Max) Max = sum;
}
}
cout << Max;
return 0;
}
| 8 | CPP |
from operator import itemgetter
n, d = map(int, input().split())
fir = 0
sec = 0
ar = [list(map(int, input().split())) for i in range(n)]
ar.sort(key = itemgetter(0))
ans = ar[0][1]
ar2 = [0] * (n+1)
for i in range(n):
ar2[i+1] = ar2[i] + ar[i][1]
while sec < n:
if ar[sec][0] - ar[fir][0] >= d:
fir += 1
else:
ans = max(ans, ar2[sec+1] - ar2[fir])
sec += 1
print(ans)
| 8 | PYTHON3 |
n, d = input().split()
L = []
for i in range(int(n)+1):
if i == 0:
L.append([0 ,0])
else:
m, f = input().split()
L.append([int(m), int(f)])
L.sort(key = lambda X: X[0])
Sum = 0
for i in range(1, int(n)+1):
Sum += L[i][1]
L[i][1] = Sum
j = dif = 0
answer = 0
for i in range(1, int(n)+1):
if L[i][0] - L[j][0] < int(d):
dif = L[i][0] - L[j][0]
else:
dif = L[i][0] - L[j][0]
while dif >= int(d):
j += 1
dif = L[i][0] - L[j][0]
if j == 0:
answer = max(answer, L[i][1] - L[j][1])
else:
answer = max(answer, L[i][1] - L[j-1][1])
print(answer) | 8 | PYTHON3 |
n, d = map(int, input().split())
values = []
for i in range(n):
m, f = input().split()
values.append((int(m), int(f)))
values.sort()
l,r=0,1
ans,curr=values[0][1],values[0][1]
while r<n:
curr+=values[r][1]
while l<r and values[r][0]-values[l][0]>=d:
curr-=values[l][1]
l+=1
ans=max(ans,curr)
# print(l,r)
r+=1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
vector<pair<long long, long long>> v;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
long long prevf = v[0].second;
long long prevm = v[0].first;
long long mx = v[0].second;
long long i = 1;
long long j = 0;
while (i < v.size()) {
if (v[i].first - prevm >= d) {
prevf = prevf + v[i].second;
while (v[i].first - v[j].first >= d) {
prevf = prevf - v[j].second;
j++;
}
prevm = v[j].first;
mx = max(mx, prevf);
} else {
prevf = prevf + v[i].second;
mx = max(mx, prevf);
}
i++;
}
mx = max(mx, prevf);
cout << mx << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool sortbylogic(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
bool sortbylogic1(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first < b.first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, d;
cin >> n >> d;
vector<pair<long long, long long> > vect(n);
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
vect[i].first = a;
vect[i].second = b;
}
sort(vect.begin(), vect.end(), sortbylogic);
long long k = vect[0].second;
sort(vect.begin(), vect.end(), sortbylogic1);
long long ans = INT_MIN;
long long p = 0;
long long sum = 0;
long long j = 0;
long long res = 0;
if (n == 1)
cout << max(k, vect[0].second) << endl;
else {
for (long long i = 0; i < n; i++) {
long long diff = vect[i].first - vect[j].first;
while (diff >= d) {
sum -= vect[j].second;
diff = vect[i].first - vect[j + 1].first;
j++;
}
sum += vect[i].second;
res = max(res, sum);
}
cout << res << endl;
}
}
| 8 | CPP |
def main():
n, d = map(int, input().split())
ms = []
for i in range(n):
ms.append(list(map(int, input().split())))
ms.sort()
hr = 0
hl = 0
mini = ms[0][0]
sumi = 0
s = 0
while hr < n:
mini = ms[hr][0]
while hl < n and (ms[hl][0] - mini) < d:
s += ms[hl][1]
hl += 1
if s > sumi:
sumi = s
s -= ms[hr][1]
hr += 1
print(sumi)
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long value;
long long factor;
};
bool compare(struct node a, struct node b) { return a.value < b.value; }
int main() {
ios::sync_with_stdio(false);
long long n, d, i, j;
cin >> n >> d;
struct node a[n];
for (i = 0; i < n; i++) cin >> a[i].value >> a[i].factor;
sort(a, a + n, compare);
long long max_factor = a[0].factor, factor = a[0].factor;
j = 1;
i = 0;
while (j < n) {
if (a[j].value - a[i].value < d) {
factor += a[j].factor;
j++;
} else {
max_factor = max(max_factor, factor);
while (a[j].value - a[i].value >= d) {
factor -= a[i].factor;
i++;
}
}
}
max_factor = max(max_factor, factor);
cout << max_factor << endl;
return 0;
}
| 8 | CPP |
n, d = map(int, input().split())
a = [tuple(map(int, input().split())) for i in range(n) ]
a.sort(reverse = True)
sums = [0] * n
sums[0] = a[0][1]
for i in range(1,n):
sums[i] = sums[i-1] + a[i][1]
maxsum = 0
r = 0
for l in range(n):
if r < l:
r = l
while r < n and(- a[r][0] + a[l][0] < d):
r += 1
r -= 1
if l > 0:
summ = sums[r] - sums[l-1]
else:
summ = sums[r]
maxsum = max(maxsum, summ)
print(maxsum) | 8 | PYTHON3 |
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,d=I()
l=[]
for x in range(n):
l.append(I())
l.sort()
an=max(i[1] for i in l)
i=0
m=l[0][0];c=0
st=0
while i<n:
if l[i][0]-m<d:
c+=l[i][1]
else:
an=max(an,c)
while l[i][0]-l[st][0]>=d:
c-=l[st][1];st+=1
m=l[st][0]
c+=l[i][1]
i+=1
an=max(an,c)
print(an)
| 8 | PYTHON3 |
from bisect import *
n,d = map(int,input().split())
tp = list()
for i in range(n):
m,s = map(int,input().split())
tp.append((m,s))
tp.sort(key = lambda x : x[0])
m = list()
s = list()
for i in range(n):
m.append(tp[i][0])
s.append(tp[i][1])
ps = list()
sn = 0
for i in range(n):
sn += s[i]
ps.append(sn)
mx = -1000
for i in range(n):
ind = bisect_left(m,m[i]+d)
if(i!=0):
mx = max(mx,ps[ind-1]-ps[i-1])
else:
mx = max(mx,ps[ind-1])
print(mx) | 8 | PYTHON3 |
def find_company(friends, d):
def mergesort_tuples(tuples, index):
def merge(A, B):
i, j = 0, 0
result = []
while i < len(A) and j < len(B):
if A[i][index] < B[j][index]:
result.append(A[i])
i += 1
else:
result.append(B[j])
j += 1
result += A[i:]
result += B[j:]
return result
def divide(tuples):
if len(tuples) > 1:
middle = len(tuples) // 2
return merge(divide(tuples[:middle]), divide(tuples[middle:]))
return tuples
return divide(tuples)
def solve(friends, d):
friends = mergesort_tuples(friends, 0)
left_ptr = 0
right_ptr = 0
current_friendship = 0
max_friendship = 0
while right_ptr < len(friends):
if friends[right_ptr][0] - friends[left_ptr][0] < d:
current_friendship += friends[right_ptr][1]
right_ptr += 1
else:
max_friendship = max(current_friendship, max_friendship)
current_friendship -= friends[left_ptr][1]
left_ptr += 1
max_friendship = max(current_friendship, max_friendship)
return max_friendship
return solve(friends, d)
if __name__ == "__main__":
n, d = [int(x) for x in input().split()]
friends = []
for _ in range(n):
friends.append(tuple([int(x) for x in input().split()]))
print(find_company(friends, d)) | 8 | PYTHON3 |
from collections import deque as dq
a,b = map(int,input().split())
v =[]
for i in range(a):
l = list(map(int,input().split()))
v.append(l)
v.sort(key = lambda i:(i[0],i[1]),reverse =True)
t =p=dq([])
ans =out=0
for i in v:
if t==[]:
t.append(i[0])
p.append(i[1])
ans+=i[1]
else:
while t and t[0]-i[0]>=b:
k = t.popleft()
ans-=p.popleft()
t.append(i[0])
p.append(i[1])
ans+=i[1]
out = max(ans ,out)
print(out) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, j = 0;
cin >> n >> k;
pair<long long int, long long int> arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr, arr + n);
long long int sum = 0, ans = 0;
for (long long int i = 0; i < n; i++) {
while (j < n && arr[j].first < arr[i].first + k) {
sum = sum + arr[j].second;
j++;
}
if (ans < sum) ans = sum;
sum -= arr[i].second;
}
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, d, x, y;
vector<pair<long long, long long> > vec2;
int main() {
scanf("%lld%lld", &n, &d);
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &x, &y);
vec2.push_back(make_pair(x, y));
}
sort(vec2.begin(), vec2.end());
long long ans2 = 0;
int st = 0;
long long sum = 0;
for (int i = 0; i < vec2.size(); sum -= vec2[i].second, i++) {
while (st < vec2.size() && abs(vec2[i].first - vec2[st].first) < d)
sum += vec2[st].second, st++;
ans2 = max(ans2, sum);
}
printf("%lld\n", ans2);
return 0;
}
| 8 | CPP |
n,d=map(int,input().split())
sc=[]
for i in range(n):
a,b=map(int,input().split())
sc.append([a,b])
sc.sort()
i=0
j=1
s=sc[0][1]
ma=sc[0][1]
while j<n:
if sc[j][0]-sc[i][0]<d:
s=s+sc[j][1]
if s>ma:
ma=s
j=j+1
else:
s=s-sc[i][1]
i=i+1
print(ma)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
vector<long long> v;
long long n, d;
long long sum = 0;
long long A[N];
long long f[N];
vector<pair<long long, long long>> vv;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
cin >> d;
long long i;
for (i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
vv.push_back({a, b});
}
sort(vv.begin(), vv.end());
for (i = 0; i < n; i++) {
sum += vv[i].second;
A[i] = sum;
f[i] = vv[i].second;
v.push_back(vv[i].first);
}
long long best = INT_MIN;
for (i = 0; i < n; i++) {
long long xx = (v[i] - d);
long long yy = (v[i] + d);
auto p = upper_bound(v.begin(), v.end(), xx);
long long xxx = p - v.begin();
long long cur1 = A[i] - A[xxx] + f[xxx];
auto q = lower_bound(v.begin(), v.end(), yy);
long long yyy = q - v.begin();
yyy--;
long long cur2 = A[yyy] - A[i] + f[i];
long long cur = max(cur1, cur2);
if (cur > best) {
best = cur;
}
}
cout << best << "\n";
}
| 8 | CPP |
#!/usr/bin/env python
# 580B_company.py - Codeforces.com/problemset/problem/580/B by Sergey 2015
import unittest
import sys
###############################################################################
# Company Class (Main Program)
###############################################################################
class Company:
""" Company representation """
def __init__(self, test_inputs=None):
""" Default constructor """
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
return next(it) if it else sys.stdin.readline().rstrip()
# Reading single elements
[self.n, self.d] = map(int, uinput().split())
# Reading multiple lines of pairs
pairs = (" ".join(uinput() for i in range(self.n))).split()
self.numa = [int(pairs[i]) for i in range(0, 2*self.n, 2)]
self.numb = [int(pairs[i]) for i in range(1, 2*self.n, 2)]
self.money = [(self.numa[i], self.numb[i]) for i in range(self.n)]
self.money = sorted(self.money)
self.partsum = [0]
sum = 0
for i in range(self.n):
sum += self.money[i][1]
self.partsum.append(sum)
def calculate(self):
""" Main calcualtion function of the class """
result = 0
for i in range(self.n):
mlb = self.money[i][0]
mrb = mlb + self.d
ilb = i
irb = lbound(self.money, mrb)
sumf = self.partsum[irb] - self.partsum[ilb]
result = max(result, sumf)
return str(result)
def lbound(v, n):
b = 0
e = len(v)
while b != e:
mid = (b + e) // 2
if v[mid][0] < n:
b = mid + 1
else:
e = mid
return b
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_single_test(self):
""" Company class testing """
# Constructor test
test = "4 5\n75 5\n0 100\n150 20\n75 1"
d = Company(test)
self.assertEqual(d.n, 4)
self.assertEqual(d.d, 5)
self.assertEqual(d.numa, [75, 0, 150, 75])
self.assertEqual(d.numb, [5, 100, 20, 1])
# Sample test
self.assertEqual(Company(test).calculate(), "100")
# Sample test
test = "5 100\n0 7\n11 32\n99 10\n46 8\n87 54"
self.assertEqual(Company(test).calculate(), "111")
# Sample test
test = ""
# self.assertEqual(Company(test).calculate(), "0")
# My tests
test = ""
# self.assertEqual(Company(test).calculate(), "0")
# Time limit test
# self.time_limit_test(5000)
def time_limit_test(self, nmax):
""" Timelimit testing """
import random
import timeit
# Random inputs
test = str(nmax) + " " + str(nmax) + "\n"
numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
test += "\n".join(numnums) + "\n"
nums = [random.randint(1, 10000) for i in range(nmax)]
test += " ".join(map(str, nums)) + "\n"
# Run the test
start = timeit.default_timer()
d = Company(test)
calc = timeit.default_timer()
d.calculate()
stop = timeit.default_timer()
print("\nTimelimit Test: " +
"{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
format(stop-start, calc-start, stop-calc))
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(Company().calculate())
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll inf = 1;
const ll mod = 1E9;
int main() {
ios::sync_with_stdio(false);
int n;
ll d;
cin >> n >> d;
vector<pll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
ll sum = 0, ans = 0;
for (int i = 0, j = 0; i < n; i++) {
if (i) sum -= a[i - 1].second;
while (j < n && a[j].first - a[i].first < d) {
sum += a[j].second;
j++;
}
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, d, i, j, mx, lst, f;
pair<long long, long long> v[100005];
int main() {
scanf("%I64d%I64d", &n, &d);
for (i = 1; i <= n; i++) scanf("%I64d%I64d", &v[i].first, &v[i].second);
sort(v + 1, v + n + 1);
for (i = 1; i <= n; i++) {
if (j < i) {
f += v[i].second;
j = i + 1;
}
while (j <= n && v[j].first - v[i].first < d) {
f += v[j].second;
j++;
}
if (f > mx) mx = f;
f -= v[i].second;
}
printf("%I64d", mx);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
vector<pair<int, long long>> fr(n + 1);
for (int i = 1; i <= n; i++) cin >> fr[i].first >> fr[i].second;
sort(fr.begin(), fr.end());
int j = 1;
long long answ = -1;
for (int i = 1; i <= n; i++) {
fr[i].second += fr[i - 1].second;
while (fr[i].first - fr[j].first >= d) j++;
answ = max(answ, fr[i].second - fr[j - 1].second);
}
cout << answ;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void file() {}
int tc;
const int N = 1e5 + 5, M = 2e6 + 5, MOD = 998244353, OO = 1e9 + 7;
const long long INF = 1e18;
void solve(int tc) {
int n, d;
scanf("%d %d", &n, &d);
std::vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
}
sort((a).begin(), (a).end());
std::vector<long long> dp(n);
dp[0] = a[0].second;
long long ans = 0;
for (int i = 1; i < n; i++) dp[i] = dp[i - 1] + a[i].second;
for (int i = 0; i < n; i++) {
auto j = upper_bound((a).begin(), (a).end(),
make_pair(a[i].first + d - 1, 1000000000)) -
a.begin();
ans = max(ans, i ? dp[j - 1] - dp[i - 1] : dp[j - 1]);
}
printf("%lld\n", ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
file();
int tc = 1;
for (int i = 1; i <= tc; i++) solve(i);
}
| 8 | CPP |
def answer(n,d,A):
A.sort(key=lambda x:x[0])
pre=[0]*(n+1)
for i in range(1,n+1):
pre[i]=pre[i-1]+A[i-1][1]
l=0
r=0
maxi=0
while r>=l and r<n:
if A[r][0]-A[l][0]<d:
r+=1
else:
maxi=max(maxi,pre[r]-pre[l])
l+=1
maxi=max(maxi,pre[r]-pre[l])
return maxi
n,d=map(int,input().split())
arr=[]
for i in range(n):
v,f=map(int,input().split())
arr.append([v,f])
print(answer(n,d,arr)) | 8 | PYTHON3 |
n, d = [int(i) for i in input().split()]
friends = []
for i in range(n):
lista = []
m, s = [int(i) for i in input().split()]
lista = [m, s]
friends.append(lista)
friends_ordenados = sorted(friends)
soma_factors = []
inicio, fim, soma = 0, 0, 0,
while fim < n:
if friends_ordenados[fim][0] - friends_ordenados[inicio][0] < d:
soma += friends_ordenados[fim][1]
fim += 1
else:
soma_factors.append(soma)
soma -= friends_ordenados[inicio][1]
inicio += 1
soma_factors.append(soma)
print(max(soma_factors))
| 8 | PYTHON3 |
def sol(a,n,d):
i,j,ans,tmpans = 0,0,0,0
while j < n:
if a[j][0] - a[i][0] < d:
tmpans+=a[j][1]
j+=1
else:
ans = max(ans,tmpans)
while a[j][0] - a[i][0] >= d:
tmpans-= a[i][1]
i+=1
ans = max(ans,tmpans)
return ans
n,d = map(int,input().split())
a = [None]*n
for i in range(n):
a[i] = tuple(map(int,input().split()))
a.sort()
print(sol(a,n,d)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, d;
cin >> n >> d;
vector<pair<int, int> > friends(n);
vector<int> first(n);
for (int fl = 0; fl < n; fl++) {
cin >> friends[fl].first;
cin >> friends[fl].second;
first[fl] = friends[fl].first;
}
sort(friends.begin(), friends.end());
for (int fl = 0; fl < n; fl++) {
first[fl] = friends[fl].first;
}
vector<long long int> cum_friend_factor(n, 0);
for (int fl = 0; fl < n; fl++) {
if (fl == 0) {
cum_friend_factor[0] = friends[0].second;
continue;
}
cum_friend_factor[fl] =
cum_friend_factor[fl - 1] + (long long int)friends[fl].second;
}
long long int ret = 0;
for (int fl = 0; fl < n; fl++) {
int i = lower_bound(first.begin(), first.end(), friends[fl].first + d) -
first.begin();
if (i < n)
ret = max(ret, cum_friend_factor[i] - (long long int)friends[i].second -
cum_friend_factor[fl] +
(long long int)friends[fl].second);
else {
ret = max(ret, cum_friend_factor[n - 1] +
(long long int)friends[fl].second -
(long long int)cum_friend_factor[fl]);
}
}
cout << ret << endl;
return 0;
}
| 8 | CPP |
def kac(l,d):
l.sort(reverse=True)
ma=l[0][1]
v=l[0][1]
i=j=0
for i in range(1,len(l)):
v=v+l[i][1]
while abs(l[i][0]-l[j][0])>=d:
v-=l[j][1]
j+=1
if(v>ma):
ma=v
print(ma)
return
n,d=map(int,input().split())
l1=[]
for i in range(n):
m=list(map(int,input().split()))
l1.append(m)
kac(l1,d)
| 8 | PYTHON3 |
n,d=map(int,input().split())
l=[]
for i in range(n):
a,b=map(int,input().split())
l.append([a,b])
l.sort()
i=0
j=0
ans=0
maxx=0
#print(l)
while(j<n):
if l[j][0]<l[i][0]+d:
maxx+=l[j][1]
j+=1
elif l[j][0]<l[i+1][0]+d:
maxx-=l[i][1]
maxx+=l[j][1]
j+=1
i+=1
else:
maxx-=l[i][1]
i+=1
ans=max(ans,maxx)
print(ans)
| 8 | PYTHON3 |
import operator
n,d = list(map(int,input().split()))
l = []
for i in range(n):
l.append(list(map(int,input().split())))
l = sorted(l,key=lambda x:x[0])
b = len(l)
friendship = 0
a = 0
index,place = 0,0
while index < b:
while place < b and abs(l[index][0] - l[place][0]) < d:
a += l[place][1]
place += 1
friendship = max(a,friendship)
a -= l[index][1]
index += 1
print (friendship) | 8 | PYTHON3 |
n,d = map(int,input().split())
#n = 3
a = []
for i in range (n):
l = input().split()
a.append(int(l[0])*(10**9+1) + int(l[1]))
#print(a)
a.sort()
b=[]
c=[]
x = a[0]%(10**9+1)
y = a[0]//(10**9+1)
b.append([y,x])
##c.append(x)
for i in range (1,n):
x = a[i]%(10**9+1)
y = a[i]//(10**9+1)
b.append([y,x])
## c.append(c[i-1]+x)
##print(b)
##print(len(b), len(c))
##print()
##print()
suma = 0
p1 = 0
p2 = 0
sol = 0
##print (c)
for p1 in range (n):
## print(p1,p2)
while (p2 < n and b[p2][0] - b[p1][0] < d):
## print('while',p1,p2)
## print(b[p2][0] - b[p1][0])
suma += b[p2][1]
p2 += 1
## print('while',p1,p2)
## print (b[p2])
## print ('suma',suma)
## if p1 == p2:
## delta = c[p1]
## else:
## delta = c[p2] - c[p1]
## sol = max(sol, delta)
sol = max(sol, suma)
suma -= b[p1][1]
## print(c[p2] - c[p1])
## print(delta)
## print(sol)
## print()
print (sol)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Frend {
unsigned long long m, f;
};
bool comparator(const Frend& a, const Frend& b) {
bool c1 = (a.m < b.m);
bool c2 = (a.m == b.m && a.f < b.f);
return (c1 || c2);
}
int main() {
int n, d;
unsigned long long ans = 0;
cin >> n >> d;
int a[n];
Frend frends[n];
unsigned long long f[n];
unsigned long long prefix_f[n];
for (int i = 0; i < n; ++i) {
cin >> frends[i].m >> frends[i].f;
f[i] = frends[i].m;
}
sort(f + 0, f + n);
sort(frends + 0, frends + n, &comparator);
for (int i = 0; i < n; i++) {
prefix_f[i] = frends[i].f;
if (i > 0) prefix_f[i] += prefix_f[i - 1];
}
for (int i = 0; i < n; i++) {
int x = f[i] + d - 1;
int q = (upper_bound(f + i, f + n, x) - f) - 1;
unsigned long long ctn;
if (i == 0) {
ctn = prefix_f[q];
} else {
ctn = prefix_f[q] - prefix_f[i - 1];
}
if (ctn > ans) {
ans = ctn;
}
if (q == n - 1) {
break;
}
}
cout << ans;
return 0;
}
| 8 | CPP |
def binarySearch(aList, target, low, high):
while low <= high:
mid = (low+high)//2
if aList[mid][0] > target:
high = mid - 1
else:
low = mid + 1
return low - 1
nd = input().split()
nd = [int(i) for i in nd]
data = []
for i in range(nd[0]):
line = input().split()
line = [int(j) for j in line]
data.append(line)
data.sort()
ff_list = []
for i in range(nd[0]):
if i == 0:
ff_list.append(data[0][1])
else:
ff_list.append(ff_list[i-1] + data[i][1])
maxff = 0
for i in range(nd[0]):
last = binarySearch(data, data[i][0] + nd[1] -1, i, nd[0] - 1)
if i != 0:
if ff_list[last] - ff_list[i - 1] > maxff:
maxff = ff_list[last] - ff_list[i - 1]
else:
if ff_list[last] > maxff:
maxff = ff_list[last]
print(maxff)
| 8 | PYTHON3 |
[n ,d] = [ int(x) for x in input().split()]
a = [[ int(x) for x in input().split()] for i in range(n)]
a.sort(key=lambda a:a[0] )
maxo = 0
i = 0
j = 0
k = 0
while j < n -1 :
while ( j <= n -1) and (a[i][0] + d > a[j][0]) :
k += a[j][1]
j += 1
maxo = max(maxo,k)
k -= a[i][1]
i = i + 1
maxo = max(maxo ,a[n-1][1])
print(maxo)
| 8 | PYTHON3 |
n, d = map(int, input().split())
friends = [(0, 0)]
for i in range(n):
money, cute = map(int, input().split())
friends.append((money, cute))
friends.sort()
sumcute = [0 for i in range(n + 1)]
for i in range(1, n + 1):
sumcute[i] = sumcute[i - 1] + friends[i][1]
l = 1
r = 1
ans = 0
while r != len(sumcute):
while r != len(sumcute) - 1 and friends[r + 1][0] - friends[l][0] < d:
r += 1
ans = max(sumcute[r] - sumcute[l - 1], ans)
if r == len(sumcute) - 1: r += 1
l += 1
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
int32_t main() {
unsigned long long n = 0;
unsigned long long d = 0;
cin >> n >> d;
vector<pair<unsigned long long, unsigned long long>> a(n);
for (unsigned long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
unsigned long long ans = 0;
unsigned long long max = 0;
for (long long l = 0, r = 0; l < n && r < n; max -= a[l].second, l++) {
while (r < n && a[r].first - a[l].first < d) {
max += a[r].second;
r++;
}
if (max > ans) ans = max;
}
cout << ans;
}
| 8 | CPP |
n, d = map(int, input().split())
ms = []
for i in range(n):
ms.append(list(map(int, input().split())))
ms.sort()
hr = 0
hl = 0
mini = ms[0][0]
sumi = 0
s = 0
while hr < n:
mini = ms[hr][0]
while hl < n and (ms[hl][0] - mini) < d:
s += ms[hl][1]
hl += 1
if s > sumi:
sumi = s
s -= ms[hr][1]
hr += 1
print(sumi)
| 8 | PYTHON3 |
n, m = map(int, input().split())
amig = []
for i in range(n):
d, a = map(int, input().split())
amig.append((d, a))
amig.sort()
ip = 0
maxi = 0
atual = 0
for i in range(0, n):
if(amig[i][0] - amig[ip][0] < m):
atual += amig[i][1]
else:
if(atual > maxi):
maxi = atual
while(amig[i][0] - amig[ip][0] >= m):
atual -= amig[ip][1]
ip += 1
atual += amig[i][1]
print(max(maxi, atual))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, d;
cin >> n >> d;
vector<pair<long long int, long long int> > arr(n);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr.begin(), arr.end(), comp);
long long int ma = 0;
vector<long long int> cum(n);
cum[0] = arr[0].second;
for (__typeof(n) i = (1) - ((1) > (n)); i != (n) - ((1) > (n));
i += 1 - 2 * ((1) > (n)))
cum[i] = cum[i - 1] + arr[i].second;
vector<long long int> temp(n);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
temp[i] = arr[i].first;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
auto it = upper_bound(temp.begin(), temp.end(), temp[i] + d - 1);
long long int index = it - temp.begin();
if (index < n && (temp[index] >= d + temp[i])) index--;
if (index == n) index--;
long long int temp_ans;
if (i == 0)
temp_ans = cum[index];
else
temp_ans = cum[index] - cum[i - 1];
ma = max(ma, temp_ans);
}
cout << ma;
return 0;
}
| 8 | CPP |
n,d=map(int,input().split())
l=[]
for i in range(n):
x,y=map(int,input().split())
l.append((x,y))
l.sort()
v=[]
f=[]
for i,j in l:
v.append(i)
f.append(j)
count=f[0]
max_count=f[0]
i=0
j=1
while j<n:
max_count=max(count,max_count)
#print(count)
if v[j]-v[i]<d:
count+=f[j]
j+=1
else:
count-=f[i]
i+=1
max_count=max(count,max_count)
print(max_count)
#4 5
#75 5
#0 100
#150 20
#75 1
#5 100
#0 7
#11 32
#99 10
#46 8
#87 54
#4 2
#10909234 9
#10909236 8
#10909237 10
#10909235 98
#5 6
#5 11
#10 11
#11 11
#12 11
#100 1
#1 1000000000
#15 12 | 8 | PYTHON3 |
line = input().split()
n = int(line[0])
d = int(line[1])
friends = []
for i in range(n):
line = input().split()
friends.append([int(line[0]), int(line[1])])
friends = sorted(friends, key=lambda x: x[0], reverse=True)
i = 0
frCoef = 0
max = 0
for j in range (len(friends)):
frCoef += friends[j][1]
while (abs(friends[i][0] - friends[j][0]) >= d):
frCoef -= friends[i][1]
i += 1
if (frCoef > max):
max = frCoef
print(max)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
int main() {
int n, m;
long long s, d, res, sum;
cin >> n >> d;
for (int i = 0; i < n; ++i) {
cin >> m >> s;
v.push_back(pair<long long, long long>(m, s));
}
sort(v.begin(), v.end());
sum = res = v[0].second;
int beg = 0;
for (int i = 1; i < n; ++i) {
while ((v[i].first - v[beg].first) >= d) {
sum -= v[beg].second;
++beg;
}
sum += v[i].second;
res = max(res, sum);
}
cout << res;
}
| 8 | CPP |
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(" ".join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
def cmp(a, b):
if a[0] < b[0]:
return -1
if a[0] > b[0]:
return 1
if a[1] > b[1]:
return -1
return 1
n, d = sp()
mat = []
for i in range(n):
mat.append(l())
mat = sorted(mat, key=cmp_to_key(cmp))
money, factor = [i[0] for i in mat], [i[1] for i in mat]
pref = dd(int)
pref[0] = factor[0]
for i in range(1, n):
pref[i] = pref[i-1] + factor[i]
answer = 0
# print(pref)
for i in range(n):
res = factor[i]
temp = bl(money, money[i] + d)
if temp == n:
temp -= 1
while money[temp] >= money[i]+d:
temp -= 1
# print(i, temp, money, factor)
res += pref[temp] - pref[i]
# print(i, res)
answer = max(answer, res)
out(answer)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long, long long> > v;
int n, i, j, k;
long long d, m, s, a, b;
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
long long maxx = 0, maxm = v[0].second;
j = 1;
for (i = 0; i < n; i++) {
while (j < n && (v[j].first - v[i].first) < d) {
maxm += v[j].second;
j++;
}
maxx = max(maxm, maxx);
maxm -= v[i].second;
}
cout << maxx << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, d;
cin >> n >> d;
std::vector<pair<long long, long long>> a(n);
long long ans = 0;
std::vector<long long> p(n, 0);
for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
p[0] = a[0].second;
for (long long i = 1; i < n; i++) p[i] += a[i].second + p[i - 1];
for (long long i = 0; i < n; i++) {
long long l = i, r = n, f = 0;
while (r - l) {
if (r - l <= 1) f = 1;
long long m = ((unsigned long long)r + (unsigned long long)l) >> 1;
if (a[m].first - a[i].first < d)
l = m;
else
r = m;
if (f) break;
}
ans = max(ans, p[l] - p[i] + a[i].second);
}
std::cout << ans << std::endl;
return 0;
}
| 8 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.