solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
struct p {
int m;
int s;
} a[100001];
bool camp(p aa, p bb) { return aa.m < bb.m; }
int main() {
long long b[100001], max, result;
int n, d, i, l, r, mid;
scanf("%d%d", &n, &d);
for (i = 0; i < n; i++) {
scanf("%d%d", &a[i].m, &a[i].s);
}
sort(a, a + n, camp);
b[0] = 0;
for (i = 0; i < n; i++) b[i + 1] = a[i].s + b[i];
max = -1;
for (i = 0; i < n; i++) {
l = i;
r = n;
while (r - l > 1) {
mid = (l + r) / 2;
if (a[mid].m - a[i].m < d)
l = mid;
else
r = mid;
}
result = b[l + 1] - b[i];
if (result > max) max = result;
}
printf("%lld\n", max);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct myComp {
bool operator()(vector<int> const &a, vector<int> const &b) {
return a[2] > b[2];
}
};
void articualtion(vector<int> graph[], int v, int parent, vector<bool> &visited,
vector<int> &visit, vector<int> &low, vector<bool> &ap) {
static int time = 0;
visited[v] = 1;
low[v] = time++;
visit[v] = low[v];
if (parent == -1) {
int count = 0;
for (int i = 0; i < graph[v].size(); i++)
if (!visited[graph[v][i]]) {
articualtion(graph, graph[v][i], v, visited, visit, low, ap);
count++;
}
if (count > 1) ap[v] = 1;
return;
}
for (int i = 0; i < graph[v].size(); i++) {
if (graph[v][i] == parent)
continue;
else if (visited[graph[v][i]]) {
low[v] = min(low[v], low[graph[v][i]]);
continue;
}
articualtion(graph, graph[v][i], v, visited, visit, low, ap);
if (low[graph[v][i]] >= visit[v]) ap[v] = 1;
low[v] = min(low[v], low[graph[v][i]]);
}
return;
}
int main() {
int n, d;
cin >> n >> d;
pair<long long, long long> arr[n];
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
arr[i].first = a;
arr[i].second = b;
}
sort(arr, arr + n);
vector<long long> temp(n);
for (int i = 0; i < n; i++) temp[i] = arr[i].first;
long long pre[n + 1];
pre[0] = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + arr[i - 1].second;
long long ans = 0;
for (int i = 0; i < n; i++) {
int ind = lower_bound(temp.begin(), temp.end(), temp[i] + d) - temp.begin();
ind--;
ans = max(ans, pre[ind + 1] - pre[i]);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool sortcol(const vector<long long>& v1, const vector<long long>& v2) {
return v1[0] < v2[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
long long n, d;
cin >> n >> d;
vector<vector<long long> > a(n);
for (int i = 0; i < n; i++) {
long long c, b;
cin >> c >> b;
a[i].push_back(c);
a[i].push_back(b);
}
sort(a.begin(), a.end(), sortcol);
long long sum[n];
memset(sum, 0, sizeof(sum));
sum[0] = a[0][1];
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + a[i][1];
}
long long maxi = a[0][1];
long long j = 0;
for (int i = 0; i < n; i++) {
long long t = i;
while ((j < n) && ((a[j][0] - a[i][0]) < d)) {
t = j;
j++;
}
maxi = max(maxi, sum[t] - sum[i] + a[i][1]);
}
cout << maxi;
return 0;
}
| 8 | CPP |
from operator import itemgetter
import time
n, d = [int(x) for x in input("").split()]
friends = []
for i in range(n):
aux = [int(x) for x in input("").split()]
friends.append((aux[0], aux[1]))
friends = sorted(friends, key=itemgetter(0))
primero = 0
segundo = 1
def cumple(a, b):
return friends[b][0] - friends[a][0] < d
actual = friends[0][1]
maximo = friends[0][1]
while primero != len(friends) - 1:
if cumple(primero, segundo):
actual += friends[segundo][1]
segundo += 1
if maximo < actual:
maximo = actual
else:
while not cumple(primero, segundo) and primero != segundo:
actual -= friends[primero][1]
primero += 1
if primero == segundo:
segundo += 1
actual = friends[primero][1]
if maximo < actual:
maximo = actual
if segundo == len(friends):
segundo -= 1
if segundo == len(friends):
break
print(maximo) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool func(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int binsearch(vector<pair<int, int> > &mf, int i, int n, int d) {
int s = i, e = n - 1, m;
int find = mf[i].first + d;
while (s <= e) {
m = (s + e) / 2;
if (m > n - 1) m = n - 1;
if (mf[m].first >= find)
e = m - 1;
else if (m < n - 1 && mf[m + 1].first < find)
s = m + 1;
else
break;
}
return m;
}
int main() {
int n, d, i, j;
long long k, mx;
cin >> n >> d;
vector<pair<int, int> > mf(n, make_pair(0, 0));
for (i = 0; i < n; i++) cin >> mf[i].first >> mf[i].second;
sort(mf.begin(), mf.end(), func);
long long *csum = new long long[n];
csum[0] = mf[0].second;
for (i = 1; i < n; i++) csum[i] = mf[i].second + csum[i - 1];
j = binsearch(mf, 0, n, d);
mx = csum[j];
for (i = 1; i < n; i++) {
j = binsearch(mf, i, n, d);
k = csum[j] - csum[i - 1];
if (k > mx) mx = k;
}
cout << mx;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int n, d, R;
long long s[MAXN], ans;
pair<int, int> p[MAXN];
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + p[i].second;
for (int L = 1; L <= n; L++) {
R = max(L, R);
while (R + 1 <= n && p[R + 1].first - p[L].first < d) R++;
ans = max(ans, s[R] - s[L - 1]);
}
printf("%I64d\n", ans);
return 0;
}
| 8 | CPP |
[friendsSize, moneyDiff] = [int(x) for x in input().split()]
friends = []
for i in range(friendsSize):
friendMoney, currentPoints = map(int, input().split())
friends.append([friendMoney, currentPoints])
friends = sorted(friends)
currentPoints = 0
maxPoints = 0
j = 0
for i in range(friendsSize):
while j < friendsSize and abs(friends[i][0] - friends[j][0]) < moneyDiff:
currentPoints += friends[j][1]
j += 1
if currentPoints >= maxPoints:
maxPoints = currentPoints
currentPoints -= friends[i][1]
print(maxPoints) | 8 | PYTHON3 |
n,d = map(int,input().split())
vals = []
for i in range(n):
m,s=map(int, input().split())
vals.append((m,s))
vals.sort()
maxVal = vals[0][1]
position = 1
totals = vals[0][1]
for m,s in vals:
while position < len(vals) and vals[position][0]< m+d:
totals+=vals[position][1]
position+=1
if totals > maxVal:
maxVal=totals
totals-=s
print(maxVal)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.);
const int maxn = 100100;
pair<long long, long long> p[maxn];
int main() {
{
srand(time(0));
const string file = "";
if (!file.empty()) {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
}
long long n, d;
scanf("%I64d%I64d", &n, &d);
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &p[i].first, &p[i].second);
}
sort(&p[0], &p[n]);
long long ans = 0, mans = 0;
for (int i = 0, f = 0; i < n; i++) {
while (f < n && p[f].first - p[i].first < d) {
ans += p[f++].second;
}
mans = max(mans, ans);
ans -= p[i].second;
}
printf("%I64d", mans);
return (0);
}
| 8 | CPP |
n,d = map(int,input().split())
counter = 0
maximum = 0
total = 0
list = sorted([list(map(int,input().split())) for x in range(n)])
for i in range(n):
while counter < n and list[counter][0]-list[i][0] < d:
total += list[counter][1]
counter += 1
maximum = max(maximum,total)
total -= list[i][1]
print(maximum)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
double pi = acos(-1);
const long long MOD = 1000000007;
void OJ() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
}
int main() {
OJ();
clock_t clk = clock();
long long n, d, ans = 0;
cin >> n >> d;
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
if (m.count(a))
m[a] += b;
else
m[a] = b;
}
vector<long long> pre, temp;
for (auto i : m) {
if (pre.size() == 0)
pre.push_back(i.second);
else
pre.push_back(pre.back() + i.second);
temp.push_back(i.first);
}
n = temp.size();
for (long long i = 0; i < n; i++) {
long long lw =
lower_bound(temp.begin(), temp.end(), temp[i] + d) - temp.begin();
lw--;
long long val;
if (i) {
val = pre[lw] - pre[i - 1];
} else {
val = pre[lw];
}
ans = max(ans, val);
}
cout << ans;
clk = clock() - clk;
cerr << "Time Elapsed: " << fixed << setprecision(10)
<< ((long double)clk) / CLOCKS_PER_SEC << "\n";
}
| 8 | CPP |
n, d = map(int, input().split())
arr = []
for i in range(n):
temp = list(map(int, input().split()))
arr.append(temp)
arr = sorted(arr)
fri_factor = 0
mx_fri_factor = 0
money_min = arr[0][0]
l = 0
r = 0
while(l<=n-1):
while(l<=r and r <n):
if arr[r][0] - arr[l][0] < d:
fri_factor+= arr[r][1]
r+=1
else:
break
mx_fri_factor = max(mx_fri_factor, fri_factor)
fri_factor -= arr[l][1]
l+=1
print(mx_fri_factor) | 8 | PYTHON3 |
#include <bits/stdc++.h>
struct help {
long int money;
long int friends;
};
void fusion_sort(struct help *p, long int n);
void bablesort(struct help *p, long int n);
int main() {
long int n, m;
scanf("%ld %ld", &n, &m);
struct help *p = (struct help *)malloc(sizeof(struct help) * n);
for (int i = 0; i < n; i++) scanf("%ld %ld", &p[i].money, &p[i].friends);
if (n == 1) {
printf("%ld", p[0].friends);
return 0;
}
if (n > 1000)
fusion_sort(p, n);
else
bablesort(p, n);
unsigned long long max_friend = 0;
unsigned long long cur_sum = 0;
for (int b = 0, e = 0; e < n;)
if (p[e].money - p[b].money >= m) {
if (cur_sum > max_friend) {
max_friend = cur_sum;
}
cur_sum -= p[b].friends;
b++;
} else {
cur_sum += p[e].friends;
e++;
}
if (cur_sum > max_friend) max_friend = cur_sum;
printf("%lld", max_friend);
return 0;
}
void fusion_sort(struct help *p, long int n) {
if (n > 2) {
fusion_sort(p, n / 2);
fusion_sort((p + n / 2), n / 2 + n % 2);
}
struct help temp;
for (int i = 0, j = n / 2; i < j && j < n; i++)
if (p[i].money > p[j].money) {
temp.friends = p[j].friends;
temp.money = p[j].money;
for (int k = j; k > i; k--) {
p[k].friends = p[k - 1].friends;
p[k].money = p[k - 1].money;
}
p[i].friends = temp.friends;
p[i].money = temp.money;
j++;
}
}
void bablesort(struct help *p, long int n) {
long int fr;
long int mo;
while (n > 1) {
for (int i = 0; i < n - 1; i++)
if (p[i].money > p[i + 1].money) {
fr = p[i].friends;
mo = p[i].money;
p[i].friends = p[i + 1].friends;
p[i].money = p[i + 1].money;
p[i + 1].friends = fr;
p[i + 1].money = mo;
}
n--;
}
}
| 8 | CPP |
n, d = map(int, input().split())
li = sorted([list(map(int, input().split())) for i in range(n)])
temp = ans = li[0][1]
j = 0
for i in range(1, n):
while li[i][0] >= li[j][0] + d:
temp -= li[j][1]
j += 1
temp += li[i][1]
ans = max(temp, ans)
print(ans)
| 8 | PYTHON3 |
n , d = map(int,input().split())
l = []
for i in range(n):
x , y = map(int,input().split())
l.append([x , y])
l.sort()
i = 0
sm = 0
ans = 0
for j in range(n):
sm += l[j][1]
while(l[j][0] - l[i][0] >= d):
sm -= l[i][1]
i +=1
ans = max(ans , sm)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d, m, s;
vector<pair<long long, long long> > vp;
cin >> n >> d;
for (int i = 0; i < n; ++i) {
cin >> m >> s;
vp.push_back(make_pair(m, s));
}
sort(vp.begin(), vp.end());
long long maxx = 0.0;
long long res = 0.0;
for (int pt1 = 0, pt2 = 0; pt2 < n;) {
if (abs(vp[pt1].first - vp[pt2].first) < d) {
res += vp[pt2].second;
pt2++;
} else {
maxx = max(maxx, res);
res -= vp[pt1].second;
pt1++;
}
maxx = max(maxx, res);
}
cout << maxx;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, d;
pair<int, int> a[200005];
long long sum[200005];
int main() {
scanf("%d%d", &n, &d);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
}
sort(a, a + n);
long long cur = 0;
for (int i = 0; i < n; ++i) {
cur += a[i].second;
sum[i] = cur;
}
long long ans = 0;
int pos = 0;
for (int i = 0; i < n; ++i) {
while (pos < n && a[pos].first - a[i].first < d) pos++;
long long ret = sum[pos - 1];
if (i) ret -= sum[i - 1];
ans = max(ans, ret);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
std::cout.precision(15);
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> v;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
long long o = 0, ma = 0, l, r = 0;
for (l = 0; l < n; l++) {
while (r < n && abs(v[l].first - v[r].first) < m) {
o = o + v[r].second;
r++;
}
if (o >= ma) ma = o;
o = o - v[l].second;
}
cout << ma;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, d, now = 0, ans = 0;
pair<long long, long long> a[100005];
void solve() {
cin >> n >> d;
for (long long i = (0); i < (n); ++i) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
int right = n - 1;
for (int left = n - 1; left >= 0; left--) {
if (a[right].first - a[left].first < d) {
now += a[left].second;
} else {
ans = max(now, ans);
now += a[left].second;
while (a[right].first - a[left].first >= d && right > left) {
now -= a[right].second;
right--;
}
ans = max(now, ans);
}
}
ans = max(now, ans);
cout << ans;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
const double PI = acos(-1.0);
template <class T>
inline T _abs(T n) {
return ((n) < 0 ? -(n) : (n));
}
template <class T>
inline T _max(T a, T b) {
return (!((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _min(T a, T b) {
return (((a) < (b)) ? (a) : (b));
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
struct data {
int money, fact;
data() { ; }
data(int a, int b) {
money = a;
fact = b;
}
};
bool cmp(const data& a, const data& b) {
if (a.money < b.money)
return true;
else if (a.money == b.money)
return a.fact > b.fact;
return false;
}
int main() {
int n, d;
while (~scanf("%d%d", &n, &d)) {
vector<data> v;
data x;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x.money, &x.fact);
v.push_back(x);
}
sort(v.begin(), v.end(), cmp);
long long ans = 0, temp = 0;
int strt = 0;
for (int i = 0; i < n; i++) {
if (i) {
if (v[i].money - v[i - 1].money >= d) {
strt = i;
temp = v[i].fact;
} else if (v[i].money - v[strt].money >= d) {
while (strt < i && v[i].money - v[strt].money >= d) {
temp -= v[strt].fact;
strt++;
}
temp += v[i].fact;
} else
temp += v[i].fact;
} else
temp = v[i].fact;
ans = max(ans, temp);
}
printf("%lld\n", ans);
}
return 0;
}
| 8 | CPP |
n, d = map(int, input().split())
m_s = []
for _ in range(n):
m, s = map(int, input().split())
m_s.append((m, s))
m_s.sort()
s = 0
max_s = 0
i = 0
for j in range(n):
s += m_s[j][1]
while m_s[j][0] - m_s[i][0] >= d:
s -= m_s[i][1]
i += 1
max_s = max(max_s, s)
print(max_s) | 8 | PYTHON3 |
n, min_diff = [int(i) for i in input().split()]
pairs = []
for _ in range(n):
m, f = map(int, input().split())
pairs.append((m, f))
pairs.sort()
i = 0
j = 0
total = 0
ans = 0
while j < len(pairs):
total += pairs[j][1]
while pairs[j][0] - min_diff >= pairs[i][0] and i <= j:
total -= pairs[i][1]
i += 1
ans = max(ans, total)
j += 1
print(ans)
| 8 | PYTHON3 |
n, d = map(int, input().split())
friends = []
for i in range(n):
m, s = map(int, input().split())
friends.append([m, s])
max_f = 0
#print(d)
friends.sort(key = lambda x: x[0])
#print(friends)
i = 0
j = 0
f = 0
while i < n:
#print(friends[i][0])
while j < n:
diff = friends[j][0] - friends[i][0]
#print("diff", diff)
if diff < d:
f += friends[j][1]
if f > max_f:
max_f = f
#print("i, j, max_f", i, j, max_f)
j += 1
else:
break
f -= friends[i][1]
i += 1
print(max_f)
| 8 | PYTHON3 |
n,d=map(int,input().split(" "))
p=[]
for _ in range(n):
q=list(map(int,input().split(" ")))
p.append(q)
p=sorted(p, key =lambda k:(k[0]))
finalmax=curmax=p1=p2=0
while p2<n:
if p[p2][0]-p[p1][0]<d:
curmax+=p[p2][1]
p2+=1
finalmax=max(finalmax,curmax)
else:
curmax-=p[p1][1]
p1+=1
print(finalmax) | 8 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
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")
##########################################################
from collections import Counter
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
import heapq
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
# n = int(input())
# ls = list(map(int, input().split()))
# n, k = map(int, input().split())
# n =int(input())
# e=list(map(int, input().split()))
# n =int(input())
from collections import Counter
#for _ in range(int(input())):
n, d = map(int, input().split())
ans=0
ls=[]
for i in range(n):
m,f= map(int, input().split())
ls.append((m,f))
ls.sort()
ptr=0
s=0
for i in range(n):
s+=ls[i][1]
while ptr<n and (ls[i][0]-ls[ptr][0])>=d:
s -= ls[ptr][1]
ptr+=1
ans=max(ans,s)
print(ans)
| 8 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 11 12:58:17 2018
@author: Arsanuos
"""
def solve():
rd = lambda: list(map(int , input().split()))
n, d = rd()
arr = []
for i in range(n):
a, b = rd()
arr.append((a, b))
arr.sort()
prev = -1
val = -1
tmp = -1
for i, t in enumerate(arr):
a, b = t
if prev == -1:
val = b
prev = i
else:
if (a - arr[prev][0] < d):
#not poor
val += b
else:
tmp = max(val, tmp)
while a - arr[prev][0] >= d:
val -= arr[prev][1]
prev += 1
val += b
print(max(tmp, val))
solve() | 8 | PYTHON3 |
n,d=map(int,input().split())
a=[]
import sys
for i in range(n):
x=list(map(int,sys.stdin.readline().split()))
a.append(x)
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 |
n, d = [int(x) for x in input().split()]
dict = {}
for i in range (n):
m, s = [int(x) for x in input().split()]
if dict.get(m) == None:
dict[m] = s
else:
dict[m] += s
sortedKeys = sorted(dict.keys())
leng = len(sortedKeys)
s = 0
r = 0
while r < leng:
if sortedKeys[r] < sortedKeys[0] + d:
s += dict.get(sortedKeys[r])
r += 1
else:
break
maxValue = s
for i in range (1, leng):
l = i - 1
s -= dict.get(sortedKeys[l])
while r < leng and sortedKeys[i] + d > sortedKeys[r]:
s += dict.get(sortedKeys[r])
r += 1
maxValue = max(maxValue, s)
if r == leng:
break
print(maxValue) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int sum[100010];
int main() {
int n;
long long int d, a, b;
scanf("%d %lld", &n, &d);
vector<pair<long long int, long long int>> p;
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &a, &b);
p.push_back(make_pair(a, b));
}
sort(p.begin(), p.end());
int p1 = 0, p2 = 1;
long long int max = p[p1].second, sum = p[p1].second;
while (p1 < p2 && p2 < n) {
if (p[p2].first - p[p1].first < d) {
sum += p[p2].second;
p2++;
if (sum > max) {
max = sum;
}
} else {
sum = sum - p[p1].second;
p1++;
if (p1 == p2) {
sum = p[p1].second;
p2++;
}
if (sum > max) {
max = sum;
}
}
}
printf("%lld\n", max);
return 0;
}
| 8 | CPP |
import sys
input = sys.stdin.readline
prnt = sys.stdout.write
n, d = map(int,input().split())
ls = []
for i in range(n):
m,f = map(int,input().split())
ls.append([m,f])
ls.sort()
mx = ls[0][1]
res = ls[0][1]
j = 0
for i in range(1,n):
if ls[i][0]-ls[j][0]>=d:
res = max(mx,res)
while(ls[i][0]-ls[j][0]>=d):
j+=1
mx = 0
for x in range(j,i+1):
mx+=ls[x][1]
#print(mx)
else:
mx+=ls[i][1]
res = max(mx,res)
#prnt(str(ls)+"\n")
prnt(str(res))
| 8 | PYTHON3 |
num_friends, poor = [int(i) for i in input().split()]
party = []
for x in range(num_friends):
temp_array = [0, 0]
temp_array[0], temp_array[1] = [int(y) for y in input().split()]
party.append(temp_array)
#print(party[x])
party.sort()
answer = party[0][1] #default: bring the first person
if len(party) == 1:
print(answer)
exit()
y=0
temp_answer = 0
for x in range(0,len(party)):
while y < len(party):
if party[y][0] - party[x][0] < poor:
#print("party diff ", party[y][0] - party[x][0])
temp_answer += party[y][1]
#print("temp answer ", temp_answer)
else:
if temp_answer > answer:
answer = temp_answer
temp_answer -= party[x][1]
break
y += 1
if temp_answer > answer:
answer = temp_answer
# print(party[x])
print(answer)
"""
6
5 11
10 11 x
11 11 y
12 11
100 1
""" | 8 | PYTHON3 |
n,d=map(int,input().split())
arr=[]
xx=0
for i in range(n):
m,fr=map(int,input().split())
xx+=m
arr.append([m,fr,xx])
arr=sorted(arr)
cc=0
ans=0
r=0
for i in range(len(arr)):
while r<len(arr) and arr[r][0]-arr[i][0]<d:
cc+=arr[r][1]
r+=1
ans=max(ans,cc)
cc-=arr[i][1]
print(ans)
| 8 | PYTHON3 |
# Author - Soumya Saurav
import sys,io,os,time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect,math,heapq
alphabet = "abcdefghijklmnopqrstuvwxyz"
input = sys.stdin.readline
########################################
n , d = map(int , input().split())
arr = []
for i in range(n):
m , s = map(int , input().split())
arr.append([m,s])
ans = 0
arr.sort(key = lambda x : (x[0], -x[1]))
i = 0
j = 0
temp = 0
while j < n:
while j < n and abs(arr[j][0] - arr[i][0]) < d:
temp += arr[j][1]
j += 1
ans = max(ans , temp)
while i < n and j < n and abs(arr[j][0] - arr[i][0]) >= d:
temp -= arr[i][1]
i += 1
print(ans)
'''
# Wrap solution for more recursion depth
for dx,dy in [[1,0],[0,1],[-1,0],[0,-1]]:
#submit as python3
import collections,sys,threading
sys.setrecursionlimit(10**9)
threading.stack_size(10**8)
threading.Thread(target=solve).start()
'''
| 8 | PYTHON3 |
n,m=[int(i) for i in input().split(' ')]
cost=[]
f_factor=[]
for i in range(n):
s=input().split(' ')
cost.append(int(s[0]))
f_factor.append(int(s[1]))
sorted_map=sorted(zip(cost,f_factor))
cost=[x for x,y in sorted_map]
f_factor=[y for x,y in sorted_map]
# print(cost,f_factor)
maxans=0
cumSum=[f_factor[0]]
for i in range(1,n):
cumSum.append(cumSum[-1]+f_factor[i])
# print(cost,f_factor,cumSum)
for i in range(n):
low=i+1
high=n-1
findex=i
while low<=high:
mid=int((low+high)/2)
diff=cost[mid]-cost[i]
if diff>=m:
if cost[mid-1]-cost[i]<m:
findex=mid-1
break
else:
high=mid-1
else:
findex=mid
low=mid+1
temp=cumSum[findex]-cumSum[i]+f_factor[i]
if maxans<temp:
maxans=temp
print(maxans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, d;
long long int m, f;
long long int sum = 0;
long long int max = 0;
cin >> n >> d;
vector<long long int> arr(n);
map<long long int, long long int> mapp;
vector<long long int> fac;
for (int i = 0; i < n; ++i) {
cin >> m >> f;
arr[i] = m;
mapp[m] += f;
}
sort(arr.begin(), arr.end());
int i = 0;
arr.erase(unique(arr.begin(), arr.end()), arr.end());
for (auto it = mapp.begin(); it != mapp.end(); it++) {
sum += it->second;
fac.push_back(sum);
++i;
}
long long int sz = arr.size();
for (int i = 0; i < sz; ++i) {
long long int key = arr[i] + d - 1;
auto upper = upper_bound(arr.begin(), arr.end(), key);
long long int index = upper - arr.begin() - 1;
if (fac[index] - fac[i - 1] > max && i != 0)
max = fac[index] - fac[i - 1];
else if (i == 0 && fac[index] > max)
max = fac[index];
}
cout << max;
return 0;
}
| 8 | CPP |
import itertools
def read_data():
n, d = map(int, input().split())
MSs = []
for i in range(n):
m, s = map(int, input().split())
MSs.append((m, s))
return n, d, MSs
def solve(n, d, MSs):
if n == 1:
return MSs[0][1]
MSs.sort()
Ms = [m for m, s in MSs]
Ss = [s for m, s in MSs]
h = 0
cum = [0] + list(itertools.accumulate(Ss))
record = cum[1]
for t in range(1, n):
while Ms[t] - Ms[h] >= d:
h += 1
record = max(record, cum[t + 1] - cum[h])
return record
n, d, MSs = read_data()
print(solve(n, d, MSs)) | 8 | PYTHON3 |
n,d = map(int,input().split())
m = [0 for i in range(n)]
s = [0 for i in range(n)]
hash = [0 for i in range(n)]
mod = 10**10
for i in range(n):
m[i], s[i] = map(int,input().split())
hash[i] = m[i] * mod + s[i]
# print(m,s)
# print(hash)
hash = sorted(hash)
# print(hash)
def get_value(x):
return x%(mod)
def get_key(x):
return int(x/(mod))
i_max = n-1
i_min = n-1
S = 0
S_max = S
while((i_min>=0)&(i_max>=0)):
while ((get_key(hash[i_min]) > (get_key(hash[i_max]) - d)) & (i_min>=0)):
S += get_value(hash[i_min])
i_min -= 1
if (S > S_max):
S_max = S
S -= get_value(hash[i_max])
i_max -= 1
print(S_max) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y, ptr1, ptr2;
long long res = 0, t;
pair<int, int> p[100001];
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
p[i] = make_pair(x, y);
}
sort(p, p + n);
res = t = p[0].second;
ptr1 = 0;
for (ptr2 = 1; ptr2 < n;) {
if (p[ptr2].first - p[ptr1].first < m)
t += p[ptr2++].second;
else
while (p[ptr2].first - p[ptr1].first >= m) t -= p[ptr1].second, ptr1++;
res = max(res, t);
}
printf("%I64d\n", res);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int m, f;
} friends;
bool cmp(friends a, friends b) { return a.m < b.m; }
int main() {
int n, d;
while (scanf("%d%d", &n, &d) != EOF) {
friends a[n];
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].m, &a[i].f);
}
sort(a, a + n, cmp);
long long int max = a[0].f;
long long int ans = a[0].f;
int low_money = a[0].m;
int idx = 0;
for (int i = 1; i < n; i++) {
if (a[i].m - low_money < d) {
ans += a[i].f;
if (ans > max) max = ans;
} else {
ans += a[i].f;
for (int j = idx; j < i; j++) {
if (a[i].m - a[j].m < d) {
idx = j;
low_money = a[j].m;
break;
} else {
ans -= a[j].f;
idx++;
}
}
}
if (ans > max) max = ans;
}
printf("%I64d\n", max);
}
return 0;
}
| 8 | CPP |
import sys
from collections import Counter
from math import factorial
input = sys.stdin
output = sys.stdout
# input = open('input.txt')
def read_int():
return [int(x) for x in input.readline().rstrip().split()]
n, d = read_int()
friends = list()
for _ in range(n):
m, s = read_int()
friends.append((m, s))
friends.sort(key=lambda e: e[0])
answer, candidate = friends[0][1], friends[0][1]
l, r = -1, 0
while r + 1 < n:
if l >= 0:
candidate -= friends[l][1]
l += 1
while r + 1 < n and friends[l][0] + d > friends[r + 1][0]:
r += 1
candidate += friends[r][1]
answer = max(answer, candidate)
output.write('%d\n' % answer)
| 8 | PYTHON3 |
n, d = [int(i) for i in input().split(' ')]
friends = [[int(i) for i in input().split(' ')] for _ in range(n)]
friends.sort(key=lambda x: x[0])
first = 0
last = 0
max_friendship = 0
friendship = 0
while last < n:
while first <= last and friends[last][0] - friends[first][0] >= d:
friendship -= friends[first][1]
first += 1
friendship += friends[last][1]
max_friendship = max(max_friendship, friendship)
last += 1
print(max_friendship)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
array<long long, 2> a[n];
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
a[i] = {x, y};
}
sort(a, a + n);
long long arr[n][2];
arr[0][0] = a[0][0];
arr[0][1] = a[0][1];
for (int i = 1; i < n; i++) {
arr[i][0] = a[i][0];
arr[i][1] = a[i][1];
}
for (int i = 1; i < n; i++) {
arr[i][1] = arr[i][1] + arr[i - 1][1];
}
long long ans = 0;
int l = 0;
for (int i = 0; i < n; i++) {
if ((arr[i][0] - arr[l][0]) >= d) {
if (l == 0) {
ans = max(ans, arr[i - 1][1]);
} else {
ans = max(ans, arr[i - 1][1] - arr[l - 1][1]);
}
while ((arr[i][0] - arr[l][0]) >= d) {
l++;
}
ans = max(ans, arr[i][1] - arr[l - 1][1]);
}
}
if (l == 0) {
ans = max(ans, arr[n - 1][1]);
} else {
ans = max(ans, arr[n - 1][1] - arr[l - 1][1]);
}
cout << ans << endl;
}
| 8 | CPP |
n,d=map(int, input().split())
money=[]
factor=[]
for i in range(n):
m,s=map(int, input().split())
money.append(m)
factor.append(s)
factor=[x for _,x in sorted(zip(money,factor))]
money=sorted(money)
i=j=0
ans=0
c=0
while i<n and j<n:
if money[j]-money[i]<d:
c+=factor[j]
j+=1
else:
c-=factor[i]
i+=1
ans=max(c,ans)
print(ans) | 8 | PYTHON3 |
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def solve():
N, D = getInts()
#get all the monies in order
#find out which starting friend allows for the max friendship factor
friends = []
prefix_sums = []
curr_sum = 0
for n in range(N):
money, friendship = getInts()
friends.append((money,friendship))
friends.sort()
prefix_sums = []
for n in range(N):
curr_sum += friends[n][1]
prefix_sums.append(curr_sum)
last_friend = 0
best = 0
for first_friend in range(N):
min_money = friends[first_friend][0]
last_friend = max(last_friend,first_friend)
while last_friend < N-1 and friends[last_friend+1][0] < min_money+D:
last_friend += 1
if first_friend == 0:
curr_val = prefix_sums[last_friend]
else:
curr_val = prefix_sums[last_friend]-prefix_sums[first_friend-1]
best = max(best,curr_val)
if last_friend == N-1:
return best
ans = solve()
print(ans)
| 8 | PYTHON3 |
class MaximumFriendshipWithinMoneyRangeProblem:
def __init__(self):
self.numFriends, self.moneyRange, self.friends = self.getInput()
self.solution = self.computeMaximumFriendshipWithinMoneyRange()
def getInput(self):
numFriends, moneyDistance = map(int, input().split())
friends = [tuple(map(int, input().split())) for _ in range(numFriends)]
return numFriends, moneyDistance, friends
def computeMaximumFriendshipWithinMoneyRange(self):
self.friends.sort()
rangeFriendshipFactor = 0
maxFriendshipFactor = 0
poorestInMoneyRange = 0
for richestInMoneyRange in range(self.numFriends):
rangeFriendshipFactor += self.getFriendshipFactor(richestInMoneyRange)
while self.poorestFeelsPoor(poorestInMoneyRange, richestInMoneyRange):
rangeFriendshipFactor -= self.getFriendshipFactor(poorestInMoneyRange)
poorestInMoneyRange += 1
maxFriendshipFactor = max(rangeFriendshipFactor, maxFriendshipFactor)
return maxFriendshipFactor
def getFriendshipFactor(self, friend):
return self.friends[friend][1]
def poorestFeelsPoor(self, poorest, richest):
return self.getMoney(richest) - self.getMoney(poorest) >= self.moneyRange
def getMoney(self, friend):
return self.friends[friend][0]
def getSolution(self):
return self.solution
if __name__ == '__main__':
print(MaximumFriendshipWithinMoneyRangeProblem().getSolution())
| 8 | PYTHON3 |
n,d=map(int,input().split())
a=[]
for i in range(n):
a.append((list(map(int,input().split()))))
a.sort()
x=0
y=0
m=0
f=0
while y<n:
if a[y][0]-a[x][0]<d:
m+=a[y][1]
y+=1
f=max(m,f)
else:
m-=a[x][1]
x+=1
print(f) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, d;
cin >> n >> d;
long long temp1, temp2;
std::vector<pair<long long int, long long int> > v;
for (int i = 0; i < n; ++i) {
cin >> temp1 >> temp2;
v.push_back(make_pair(temp1, temp2));
}
sort(v.begin(), v.end());
long long current = v[0].second;
long long j = 1;
long long global_max = 0;
for (int i = 0; i < n; i++) {
while ((j < n) && abs(v[i].first - v[j].first) < d) {
current += v[j].second;
j++;
}
global_max = max(global_max, current);
current -= v[i].second;
}
cout << global_max;
}
| 8 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
(n, d) = (int(i) for i in input().split())
ms = {}
for i in range(n):
(m, s) = (int(i) for i in input().split())
if m in ms.keys():
ms[m] += s
else:
ms[m] = s
start = time.time()
l = sorted(ms.keys())
ans = 0
j = 0
while ((j < len(l)) and (l[j] - l[0] < d)):
ans += ms[l[j]]
j += 1
i = 0
now = ans
while j < len(l):
now = now - ms[l[i]]
i += 1
while ((j < len(l)) and (l[j] - l[i] < d)):
now += ms[l[j]]
j += 1
if now > ans:
ans = now
print(ans)
finish = time.time()
#print(finish - start)
| 8 | PYTHON3 |
import sys
from bisect import bisect_right
def main():
n, d = map(int, input().split())
friends = sorted(tuple(int(c) for c in line.split()) for line in sys.stdin)
money = [e[0] for e in friends]
friendship_sum = [0]
for _, e in friends:
friendship_sum.append(friendship_sum[-1] + e)
start = 0
_min, ans = friends[0]
for i in range(1, n):
cur = friends[i][0]
if cur - _min >= d:
start = bisect_right(money, cur - d)
_min = friends[start][0]
friendship = friendship_sum[i + 1] - friendship_sum[start]
ans = max(ans, friendship)
print(ans)
if __name__ == "__main__":
main()
| 8 | PYTHON3 |
from bisect import bisect
import sys
input = sys.stdin.buffer.readline
def prog():
n,d = map(int,input().split())
moneys = [list(map(int,input().split())) for i in range(n)]
moneys2 = []
moneys.sort()
max_friendship = 0
psum_friendship = [0]
for i in range(n):
psum_friendship.append(psum_friendship[-1] + moneys[i][1])
moneys2.append(moneys[i][0])
for i in range(n):
start = moneys2[i]
total_friendship = psum_friendship[bisect(moneys2, start + d-1)] - psum_friendship[i]
max_friendship = max(max_friendship, total_friendship)
print(max_friendship)
prog()
| 8 | PYTHON3 |
I = lambda :map(int, input().split())
n,d=I()
a=sorted([list(I()) for i in range(n)])
s=ans=a[0][1]
j=0
for i in range(1,n):
while(a[i][0]-a[j][0]>=d):
s-=a[j][1]
j+=1
s+=a[i][1]
ans=max(s,ans)
print(ans) | 8 | PYTHON3 |
def cmp(t):
return t[0]
n, d = (int(i) for i in input().split())
lista = []
for i in range(n):
a, b = (int(i) for i in input().split())
lista.append((a, b))
lista.sort(key=cmp)
#print(lista)
maxim = 0
# for i in range(len(lista)):
#
# crt = 0
#
# j = i
#
# while j < len(lista): ##
#
#
# if crt > maxim:
# maxim = crt
# i = j = 0
# crt = 0
# print(lista)
# for j in range(len(lista)):
#
# print('\npas nou\ni=', i,'j=', j, 'crt=', crt, sep=' ')
#
# if lista[j][0] - lista[i][0] > d:
# crt = 0
# print('i=', i, 'j=', j, 'crt=', crt, sep=' ')
#
# crt = crt + lista[j][1]
# print('i=', i,'j=', j, 'crt=', crt, sep=' ')
#
#
#
# while i < j and lista[j][0] - lista[i][0] > d:
# i += 1
# crt = crt - lista[i][1]
# print('i=', i,'j=', j, 'crt=', crt, sep=' ')
#
# if crt > maxim:
# maxim = crt
# print('maxim=', maxim, sep=' ')
#
# print(crt)
j = 0
crt = 0
for i in range(len(lista)):
#print(lista)
#print(crt)
while j < len(lista) and lista[j][0] - lista[i][0] < d:
crt = crt + lista[j][1]
j += 1
#print(crt)
if maxim < crt:
maxim = crt
crt = crt - lista[i][1]
#print(crt)
print(maxim)
| 8 | PYTHON3 |
n, d = map(int, input().split())
mat = []
for i in range(n):
m, s = map(int, input().split())
mat.append([m, s])
mat.sort(key=lambda x: x[0])
dp = [0] * ( n + 1)
for i in range(1, n + 1):
dp[i] = dp[i - 1] + mat[i - 1][1]
ans = mat[0][1]
i = 0
j = 0
while i < n and j < n:
if mat[j][0] - mat[i][0] < d:
ans = max(ans, dp[j + 1] - dp[i])
j += 1
else:
i += 1
print(ans) | 8 | PYTHON3 |
from sys import stdin
a=lambda:stdin.readline().split()
n,d=map(int,a())
di={-1:0}
for _ in range(n):
m,s=map(int,a())
if di.get(m)==None:di[m]=0
di[m]+=s
lst=[*di.keys()]
lst.sort()
for i,x in enumerate(lst[1:]):
di[x]+=di[lst[i]]
from bisect import bisect_left as bis
res=0
for i,x in enumerate(lst[1:]):
item=bis(lst,x+d)-1
res=max(res,di[lst[item]]-di[lst[i]])
print(res) | 8 | PYTHON3 |
n,d=map(int,input().split())
l=[]
for i in range(n):
x,y=map(int,input().split())
l.append([x,y])
l.sort()
ans=0
a=[]
i=0
j=0
while i<n:
if l[i][0]-l[j][0]>=d:
a.append(ans)
ans-=l[j][1]
j+=1
else:
ans+=l[i][1]
a.append(ans)
i+=1
print(max(a)) | 8 | PYTHON3 |
from sys import stdin, stdout
lines = stdin.readlines()
n, d = int(lines[0].split()[0]), int(lines[0].split()[1])
mat = [[int(x.split()[0]),int(x.split()[1])] for x in lines[1:]]
mat = sorted(mat)
mx = 0
temp_mx = 0
i = 0
for j in range(n):
temp_mx += mat[j][1]
if (mat[j][0] - mat[i][0])>=d:
while (mat[j][0] - mat[i][0]) >= d:
temp_mx -= mat[i][1]
i += 1
mx=max(temp_mx,mx)
print(mx)
| 8 | PYTHON3 |
r = lambda: map(int, input().split())
n, d = r()
a = sorted(tuple(r()) for i in range(n))
i = 0
Min = a[i][0]
Max = cur = 0
for m, s in a:
cur += s
if m - Min >= d:
while m - a[i][0] >= d:
cur -= a[i][1]
i += 1
Min = a[i][0]
Max = max(Max, cur)
print(Max)
| 8 | PYTHON3 |
def getIndex(a, k, start, end, val, i):
if start == end:
if val - a[start][0] < k:
return start
return i
mid = (start + end) // 2
if val - a[mid][0] < k:
return getIndex(a, k, start, mid, val, i)
return getIndex(a, k, mid + 1, end, val, i)
n, k = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
a.sort(key=lambda x: x[0])
pref = [0 for i in range(n)]
glob = a[0][1]
pref[0] = a[0][1]
for i in range(1, n):
pref[i] = pref[i - 1] + a[i][1]
# print(a)
for i in range(1, n):
temp = getIndex(a, k, 0, i - 1, a[i][0], i)
# print(temp)
glob = max(glob, pref[i] - (pref[temp - 1] if temp - 1 >= 0 else 0))
print(glob) | 8 | PYTHON3 |
n, diff = map(int, input().split())
a = sorted([tuple(map(int, input().split())) for _ in range(n)])
ret = 0
s = 0
left = 0
for right in range(n):
while a[right][0] - a[left][0] >= diff:
s -= a[left][1]
left += 1
s += a[right][1]
ret = max(s, ret)
print(ret) | 8 | PYTHON3 |
#include <bits/stdc++.h>
const int SIZE = 1e5 + 5;
using namespace std;
int n, d;
vector<pair<int, int> > arr;
int BS(int x) {
int res = -1;
int f = 0, e = n - 1;
while (f <= e) {
int m = (f + e) / 2;
if (arr[m].first > x)
e = m - 1, res = m;
else
f = m + 1, res = m + 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
cin >> n >> d;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
sort(arr.begin(), arr.end());
vector<long long> sum(n + 1);
sum[0] = 0;
for (int i = 0; i < n; i++) sum[i + 1] = sum[i] + arr[i].second;
long long res = 0;
for (int i = 0; i < n; i++) {
int idx = BS(arr[i].first + d - 1);
res = max(res, sum[idx] - sum[i]);
}
cout << res;
}
| 8 | CPP |
n,d = input().split()
n,d = int(n),int(d)
l = {}
for i in range(n):
m,s = input().split()
m,s = int(m),int(s)
if m not in l: l[m] = s
else: l[m] += s
a = sorted(l.keys())
e,f = 0,1
m = l[a[0]]; ma = l[a[0]]
while f < len(a):
m += l[a[f]]
while a[f] - a[e] >= d:
m-= l[a[e]]
e += 1
if m > ma: ma = m
f += 1
print(ma)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long m, s;
};
const int maxn = 100000 + 10;
node p[maxn];
long long sum[maxn];
int n;
long long d;
bool cmp(const node &a, const node &b) { return a.m < b.m; }
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) cin >> p[i].m >> p[i].s;
sort(p + 1, p + 1 + n, cmp);
p[n + 1].m = 1000000000 + 10;
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + p[i].s;
long long ans = -1;
for (int i = 1; i <= n; i++) {
int l = i + 1;
int r = n + 1;
int pos = i + 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (p[mid].m >= p[i].m + d) {
pos = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (sum[pos - 1] - sum[i - 1] > ans) ans = sum[pos - 1] - sum[i - 1];
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
def solve(n, d, f):
f.sort(key=lambda x: (x[0], -x[1]))
left = 0
right = 1
s = f[left][1]
c = s
while right < len(f):
m = f[right][0] - f[left][0]
if m < d:
c = c + f[right][1]
s = max(s, c)
right += 1
else:
c = c - f[left][1]
left += 1
return s
def main():
n,d = map(int,input().split())
f = []
for i in range(n):
f.append(list(map(int,input().split())))
print (solve(n, d, f))
if __name__ == '__main__':
main()
| 8 | PYTHON3 |
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
n, d = idata()
sp = []
for i in range(n):
sp += [idata()]
sp.sort()
l, r, maxx, ans = 0, 0, sp[0][1], sp[0][1]
while r != n - 1:
r += 1
maxx += sp[r][1]
while sp[r][0] - sp[l][0] >= d:
maxx -= sp[l][1]
l += 1
ans = max(ans, maxx)
print(ans)
| 8 | PYTHON3 |
from operator import itemgetter
n,d = map(int,input().split())
fnd = []
for i in range(n) :
fnd.append([0,0])
fnd[i] = list(map(int,input().split()))
fnd.sort(key=lambda x : x[0])
tmp = fnd[0][1]
mx = tmp
j=0
#print(fnd)
for i in range(n) :
if j==n-1 :
break
while fnd[j+1][0]-fnd[i][0] < d :
tmp += fnd[j+1][1]
j+=1
if j == n-1 :
break
#print(i,j,tmp)
if tmp>mx :
mx = tmp
tmp -= fnd[i][1]
print(mx)
| 8 | PYTHON3 |
#n = int(input())
n, m = map(int, input().split())
#s = input()
#c = list(map(int, input().split()))
a = [0] * n
for i in range(n):
a[i] = tuple(map(int, input().split()))
a.sort()
i = 0
j = 0
k = 0
s = 0
while j < n:
if a[j][0] - a[i][0] < m:
s += a[j][1]
j += 1
else:
k = max(k, s)
s -= a[i][1]
i += 1
k = max(k, s)
print(k) | 8 | PYTHON3 |
n , d = list(map(int,input().split()))
l = []
for i in range(n):
m , s = list(map(int,input().split()))
l.append([m , s])
l.sort()
i = 0
s = 0
m_x= 0
for k in range(n):
s += l[k][1]
while(l[k][0]-l[i][0] >= d):
s -= l[i][1]
i += 1
m_x = max(m_x , s)
print(m_x) | 8 | PYTHON3 |
from bisect import *
n, d = map(int, input().split())
lol = []
for _ in range(n):
m, s = map(int, input().split())
lol.append((m, s))
lol.sort()
pre = [0]
for c in lol:
pre.append(pre[-1] + c[1])
ans = 0
for i in range(n):
j = lol[i]
b2 = bisect_right(lol, (j[0] + d - 1, 10**100))
ans = max(ans, pre[b2]-pre[i])
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
long long int sum = v[0].second, sum1 = v[0].second;
bool b = false;
int start = 0;
for (int i = 1; i < n; i++) {
if (i == start) {
sum1 += v[i].second;
if (sum1 > sum) sum = sum1;
continue;
}
if (v[i].first - v[start].first < d)
sum1 += v[i].second;
else {
sum1 -= v[start].second;
i--;
start++;
}
if (sum1 > sum) sum = sum1;
}
cout << sum;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct node {
int mon, fac;
bool operator<(const node& t) const { return mon < t.mon; }
} st[maxn];
long long sum[maxn] = {0};
int main() {
int n, d;
cin >> n >> d;
for (int i = 1; i <= n; ++i) cin >> st[i].mon >> st[i].fac;
sort(st + 1, st + n + 1);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + st[i].fac;
int l = 1, r = 1;
long long ans = 0;
for (; l <= n; ++l) {
while (r <= n && st[r].mon - st[l].mon < d) r++;
ans = max(ans, sum[r - 1] - sum[l - 1]);
}
printf("%lld\n", ans);
return 0;
}
| 8 | CPP |
n, d = map(int, input().split())
a = []
for i in range(n):
x = list(map(int, input().split()))
a.append(x)
a.sort()
i = 0
j = 1
ans = a[0][1]
md = a[0][0] + d
ansq = ans
while j != n:
if a[j][0] < md:
ans += a[j][1]
ansq = max(ans, ansq)
j += 1
else:
ans -= a[i][1]
ansq = max(ans, ansq)
i += 1
md = a[i][0] + d
print(ansq)
| 8 | PYTHON3 |
n,d=map(int,input().split())
l=sorted([[*map(int,input().split())]for _ in' '*n])
j=a=A=0
for i in range(n):
a+=l[i][1]
while l[i][0]-l[j][0]>=d:
a-=l[j][1]
j+=1
A=max(A,a)
print(A) | 8 | PYTHON3 |
n,d = map(int, input().split())
m = [tuple(map(int, input().split())) for _ in range(n)]
m = sorted(m)
f = 0
fr = m[f][1]
poss = []
for i in range(1,n):
if m[i][0]-m[f][0] < d:
fr += m[i][1]
else:
poss.append(fr)
fr -= m[f][1]
f+=1
while f < i:
if m[i][0]-m[f][0] < d:
break
fr -= m[f][1]
f+=1
fr += m[i][1]
poss.append(fr)
print(max(poss)) | 8 | PYTHON3 |
import re
import sys
exit=sys.exit
from bisect import bisect_left as bsl,bisect_right as bsr
from collections import Counter,defaultdict as ddict,deque
from functools import lru_cache
cache=lru_cache(None)
from heapq import *
from itertools import *
from math import inf
from pprint import pprint as pp
enum=enumerate
ri=lambda:int(rln())
ris=lambda:list(map(int,rfs()))
rln=sys.stdin.readline
rl=lambda:rln().rstrip('\n')
rfs=lambda:rln().split()
mod=1000000007
d4=[(0,-1),(1,0),(0,1),(-1,0)]
d8=[(-1,-1),(0,-1),(1,-1),(-1,0),(1,0),(-1,1),(0,1),(1,1)]
########################################################################
n,d=ris()
a=[]
for _ in range(n):
a.append(ris())
a.sort()
ans=s=l=0
for r in range(n):
s+=a[r][1]
while d<=abs(a[l][0]-a[r][0]):
s-=a[l][1]
l+=1
ans=max(ans,s)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long calpowof2(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long ans = calpowof2(a, b / 2);
return (ans % mod * ans % mod) % mod;
}
long long ans = calpowof2(a, b - 1);
return (a % mod * ans % mod) % mod;
}
void solve() {
long long i, j, n, t, m, k, ct = 0, sum = 0, flag = 0;
cin >> n >> k;
vector<pair<long long, long long> > v1;
for (long long i = (0); i < (n); i++) {
cin >> j >> m;
v1.push_back({j, m});
}
sort(v1.begin(), v1.end());
long long start_ptr = 0;
sum = v1[0].second;
long long mx = INT_MIN;
mx = sum;
for (long long i = (1); i < (n); i++) {
if (v1[i].first - v1[start_ptr].first < k) {
sum += v1[i].second;
mx = max(sum, mx);
} else {
sum -= v1[start_ptr].second;
start_ptr++;
i--;
}
}
cout << mx;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
cerr << endl << clock() * 1000.0 / CLOCKS_PER_SEC << 'm' << 's';
return 0;
}
| 8 | CPP |
n, d = [int(i) for i in input().split()]
frendo = [[0, 0]]
for i in range(n):
xs = [int(x) for x in input().split()][:2]
frendo.append(xs)
def cmp(xs):
return xs[0]
frendo.sort(key=cmp)
j = 0
suma = rez = 0
diff = 0
for i in range(1, n + 1):
suma += frendo[i][1]
frendo[i][1] = suma
for i in range(n+1):
diff = frendo[i][0] - frendo[j][0]
if(diff<d):
rez = max(rez, frendo[i][1] - frendo[j][1])
else:
while(diff>=d):
j+=1
diff = frendo[i][0] - frendo[j][0]
j-=1
rez = max(rez, frendo[i][1] - frendo[j][1])
print(rez) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, a, b, cek, sum, ans;
vector<pair<long long, long long> > v;
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
long long id = 0;
for (int i = 0; i < n; i++) {
cek = v[i].first - v[id].first;
sum += v[i].second;
while (cek >= d) {
sum -= v[id].second;
id++;
cek = v[i].first - v[id].first;
}
ans = max(ans, sum);
}
cout << ans << "\n";
}
| 8 | CPP |
# !/usr/bin/env python3
# coding: UTF-8
# Modified: <08/Mar/2019 11:42:15 PM>
# ✪ H4WK3yE乡
# Mohd. Farhan Tahir
# Indian Institute Of Information Technology (IIIT),Gwalior
# ///==========Libraries, Constants and Functions=============///
import sys
inf = float("inf")
mod = 1000000007
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline()
# ///==========MAIN=============///
def main():
n, d = get_ints()
arr = [0]*n
for i in range(n):
arr[i] = get_array()
arr.sort()
ans = 0
j = 0
curr = 0
for i in range(n):
while j < n and arr[j][0] < arr[i][0]+d:
curr += arr[j][1]
j += 1
ans = max(ans, curr)
curr -= arr[i][1]
print(ans)
if __name__ == "__main__":
main()
| 8 | PYTHON3 |
def cmp(a):
return a[0]
n, d = [int(x) for x in input().split()]
arr = []
for i in range(n):
l = [int(x) for x in input().split()]
arr.append(l)
arr.sort(key=cmp)
i = 0
ans = arr[0][1]
now = arr[0][1]
for j in range(1, n):
if arr[j][0] - arr[i][0] < d:
now += arr[j][1]
else:
if now > ans:
ans = now
while arr[j][0] - arr[i][0] >= d:
now -= arr[i][1]
i += 1
now += arr[j][1]
if now > ans:
ans = now
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<pair<long long, long long> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
long long mx = 0;
long long cursum = 0;
int r = 0;
for (int i = 0; i < n; i++) {
while (r < n && v[r].first - v[i].first < d) {
cursum += v[r].second;
r++;
}
mx = max(mx, cursum);
cursum -= v[i].second;
}
cout << mx;
return 0;
}
| 8 | CPP |
p=lambda:map(int,input().split());a,b=p();f=[[*p()] for _ in " "*a];f=sorted(f);i,j,k,m=0,0,0,0
while(j<a):
if f[j][0]-f[i][0]<b:k+=f[j][1];m=max(m,k);j+=1
else:k-=f[i][1];i+=1
print(m) | 8 | PYTHON3 |
__author__ = 'User'
def p(x):
l = 0
r = n
while l + 1 < r:
m = (l + r) // 2
if arr[m][0] <= x:
l = m
else:
r = m
return l
def p2(x):
l = -1
r = n - 1
while l + 1 < r:
m = (l + r) // 2
if arr[m][0] < x:
l = m
else:
r = m
return r
n, d = map(int,input().split())
arr = [0] * n
summ = [0] * n
s = 0
for i in range(n):
arr[i] = tuple(map(int, input().split()))
arr.sort()
for i in range(n):
summ[i] = s + arr[i][1]
s += arr[i][1]
summ.append(0)
mx = 0
#print(arr)
c = 0
for i in arr:
r = p(i[0] + (d - 1))
l = p2(i[0])
#print(l, r)
s = summ[r] - summ[l - 1]
#print(s)
mx = max(mx, s)
print(mx)
#print(summ)
#print(p(70)) | 8 | PYTHON3 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,d = LI()
aa = sorted([LI() for _ in range(n)])
i = 0
j = 0
t = 0
r = 0
while j < n:
aj = aa[j]
t += aj[1]
j += 1
while aj[0] - aa[i][0] >= d:
t -= aa[i][1]
i += 1
if r < t:
r = t
return r
print(main())
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long n, d;
cin >> n >> d;
long long x[100000][2];
for (int i = 0; i < n; i++) {
cin >> x[i][0] >> x[i][1];
}
qsort(x, n, sizeof(*x), [](const void *arg1, const void *arg2) -> int {
int const *lhs = static_cast<int const *>(arg1);
int const *rhs = static_cast<int const *>(arg2);
return (lhs[0] < rhs[0])
? -1
: ((rhs[0] < lhs[0])
? 1
: (lhs[1] < rhs[1] ? -1 : ((rhs[1] < lhs[1] ? 1 : 0))));
});
int j = 1;
long long f = x[0][1], ans = 0;
for (int i = 0; i < n; i++) {
while (j < n && x[j][0] - x[i][0] < d) {
f += x[j][1];
j++;
}
if (ans < f) ans = f;
f -= x[i][1];
}
cout << ans;
return 0;
}
| 8 | CPP |
n,d=[int(i) for i in input().split()]
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
a.sort()
j=1
v=a[0][1]
maxx=[]
for i in range(n):
if j==n:
break
while abs(a[i][0]-a[j][0])<d:
v+=a[j][1]
j+=1
if j>n-1:
break
maxx.append(v)
v-=a[i][1]
maxx=maxx+[i[1] for i in a]
print(max(maxx))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> ar[100005];
long long int arr[100005];
long long int brr[100005];
long long int cm[100005];
int main() {
long long int i, n, t, a, b, pos, c, ans, k;
scanf("%lld%lld", &n, &t);
for (i = 0; i < n; i++) {
scanf("%lld%lld", &a, &b);
ar[i] = make_pair(a, b);
}
sort(ar, ar + n);
for (i = 0; i < n; i++) {
arr[i] = ar[i].first;
brr[i] = ar[i].second;
}
cm[0] = brr[0];
for (i = 1; i < n; i++) {
cm[i] = cm[i - 1] + brr[i];
}
arr[n] = -4;
c = 0;
ans = 0;
long long int ll;
for (i = 0; i < n; i++) {
ll = t + arr[i] - 1;
pos = upper_bound(arr, arr + n, ll) - arr;
pos = pos - 1;
k = i;
if (k == 0) {
c = cm[pos];
} else {
c = cm[pos] - cm[k - 1];
}
if (c > ans) {
ans = c;
}
}
printf("%lld", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t, i, sum = 0, l, r, m = 0;
cin >> n >> t;
pair<long long int, long long int> a[n];
l = 0;
r = 0;
for (i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
while (l < n) {
if (a[l].first - a[r].first < t) {
sum += a[l].second;
l++;
m = max(m, sum);
} else
sum -= a[r++].second;
}
cout << m << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, d;
long long ans;
pair<int, int> a[100001];
long long prefix[100001];
int main() {
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + a[i].second;
}
for (int i = 1; i <= n; i++) {
int mini = i, maxi = n, mid = (mini + maxi + 1) / 2;
while (mini != maxi) {
if (a[i].first + d > a[mid].first) {
mini = mid;
} else {
maxi = --mid;
}
mid = (mini + maxi + 1) / 2;
}
ans = max(ans, prefix[mid] - prefix[i - 1]);
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
n,d=map(int,input().split())
a=[]
for _ in range(n):
x,y=map(int,input().split())
a.append([x,y])
a.sort()
ans=a[0][1]
res=a[0][1]
p1=0
p2=0
while(p2<n-1):
if(a[p2+1][0]-a[p1][0]<d):
p2+=1
ans+=a[p2][1]
if(ans>res):
res=ans
else:
ans=ans-a[p1][1]
p1+=1
print(res) | 8 | PYTHON3 |
def sf(a):
return -a[0]
inp = input().split()
n = int(inp[0])
d = int(inp[1])
arr = []
for i in range(0, n):
dat = [int(x) for x in input().split()]
arr.append(dat)
arr.sort(key = sf)
l = r = 0
summ = arr[0][1]
ans = arr[0][1]
while(r < n - 1):
if(arr[l][0] - arr[r + 1][0] < d):
summ += arr[r + 1][1]
r += 1
else:
summ -= arr[l][1]
l += 1
ans = max(ans, summ)
print(ans)
| 8 | PYTHON3 |
n,d=map(int, input().split())
ms=[]
for o in range(n):
m,s = map(int, input().split())
ms.append((m,s))
ms.sort()
k=0
maximum=0
s=0
for i in range(n):
s += ms[i][1]
while ms[i][0] - ms[k][0] >= d:
s -= ms[k][1]
k += 1
maximum = max(maximum, s)
print(maximum)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, d;
vector<pair<int, int> > v;
int BS(int x) {
int l = x + 1, r = n - 1, mid, res = -1;
while (r >= l) {
mid = (l + r) / 2;
if (v[mid].first - v[x].first < d) {
res = mid;
l = mid + 1;
} else
r = mid - 1;
}
return res;
}
int main() {
scanf("%d%d", &n, &d);
v.resize(n);
vector<long long> sum;
sum.resize(n + 1);
sum[0] = 0;
for (int i = 0; i < n; i++) {
int m, f;
scanf("%d%d", &m, &f);
v[i] = make_pair(m, f);
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + v[i - 1].second;
long long mx = 0;
for (int i = 0; i < n; i++) {
long long res;
int x = BS(i);
if (x != -1)
res = sum[x + 1] - sum[i];
else
res = sum[i + 1] - sum[i];
mx = max(res, mx);
}
printf("%I64d\n", mx);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
pair<int, int> a[N];
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
long long L, R, maj, ans;
;
L = R = ans = maj = 0;
while (R < n) {
if (a[R].first - a[L].first < d) {
maj += a[R].second;
ans = max(maj, ans);
R++;
} else {
maj -= a[L].second;
L++;
ans = max(ans, maj);
}
}
cout << ans << endl;
}
| 8 | CPP |
n,d=map(int,input().split())
a=[]
for i in range(n):
a.append((list(map(int,input().split()))))
a.sort()
x=0
y=0
m=0
f=0
while y<n:
if abs(a[y][0]-a[x][0])<d:
m+=a[y][1]
y+=1
f=max(m,f)
else:
m-=a[x][1]
x+=1
print(f) | 8 | PYTHON3 |
#include <bits/stdc++.h>
typedef std::pair<int, int> PII;
int main() {
int n;
int d;
long long ans = 0;
long long sum = 0;
std::vector<PII> v;
std::cin >> n >> d;
v.resize(n);
for (int i = 0; i < n; ++i) std::cin >> v[i].first >> v[i].second;
std::sort(v.begin(), v.end());
int j = 0;
for (int i = 0; i < n; ++i) {
while (j < n && v[j].first - v[i].first < d) {
sum += v[j].second;
++j;
}
ans = std::max(ans, sum);
sum -= v[i].second;
}
std::cout << ans << std::endl;
return 0;
}
| 8 | CPP |
class Guest(object):
def __init__(self, money, friendship_factor):
self.money = money
self.friendship_factor = friendship_factor
def __repr__(self):
return "Guest"
def __str__(self):
return " ".join(["Guest:", str(self.money), str(self.friendship_factor)])
class Company(object):
def __init__(self, number_of_guests, poorness_threshold):
self.number_of_guests = number_of_guests
self.poorness_threshold = poorness_threshold
self.list_of_guests = list()
self.maximum_sum_of_friendship = 0
def add_guest(self, money, friendship_factor):
self.list_of_guests.append(Guest(money, friendship_factor))
def sort_guest_list(self):
self.list_of_guests.sort(key=lambda guest: guest.money)
def compute_maximal_friendship(self):
temporary_friendship = 0
trailing_guest_index = 0
for guest_index in range(self.number_of_guests):
temporary_friendship += self.list_of_guests[guest_index].friendship_factor
while self.list_of_guests[guest_index].money - self.list_of_guests[trailing_guest_index].money \
>= self.poorness_threshold:
temporary_friendship -= self.list_of_guests[trailing_guest_index].friendship_factor
trailing_guest_index += 1
if self.maximum_sum_of_friendship < temporary_friendship:
self.maximum_sum_of_friendship = temporary_friendship
# def compute_friendship_starting_from_specified_guest(self, guest_number):
# temporary_friendship = self.list_of_guests[guest_number].friendship_factor
# for index in range(guest_number + 1, len(self.list_of_guests)):
# if abs(self.list_of_guests[index].money -
# self.list_of_guests[guest_number].money) \
# >= self.poorness_threshold:
# break
# else:
# temporary_friendship += self.list_of_guests[index].friendship_factor
# if temporary_friendship > self.maximum_sum_of_friendship:
# self.maximum_sum_of_friendship = temporary_friendship
if __name__ == '__main__':
input_number_of_guests, input_poorness_threshold = map(int, input().split(" "))
company = Company(input_number_of_guests, input_poorness_threshold)
for counter in range(input_number_of_guests):
input_money, input_friendship_factor = map(int, input().split(" "))
company.add_guest(input_money, input_friendship_factor)
company.sort_guest_list()
company.compute_maximal_friendship()
# for counter in range(len(company.list_of_guests)):
# # if counter > 0:
# # if company.list_of_guests[counter-1].money == guest.money:
# # continue
# company.compute_friendship_starting_from_specified_guest(counter)
print(company.maximum_sum_of_friendship)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> arr[100500];
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
arr[i] = make_pair(x, y);
}
sort(arr, arr + n);
long long j = 0, i = 0;
long long ans = 0, maxi = 0;
for (int i = 0; i < n; i++) {
ans += arr[i].second;
while (arr[i].first - arr[j].first >= d) {
ans -= arr[j].second;
j++;
}
maxi = max(ans, maxi);
}
maxi = max(ans, maxi);
cout << maxi;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
pair<int, int> friendlist[100001];
scanf("%d%d", &n, &d);
for (int i = 0; i < n; i++)
scanf("%d%d", &((friendlist + i)->first), &((friendlist + i)->second));
sort(friendlist, friendlist + n);
int it_left = 0;
int it_right = 0;
long long maxfriendship = 0;
long long friendship = 0;
while (true) {
while (it_right < n &&
friendlist[it_right].first - friendlist[it_left].first < d) {
friendship += friendlist[it_right].second;
maxfriendship = max(maxfriendship, friendship);
it_right++;
}
if (it_right >= n) break;
while (friendlist[it_right].first - friendlist[it_left].first >= d) {
friendship -= friendlist[it_left].second;
it_left++;
}
}
cout << maxfriendship;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > fx;
int main() {
long long i, j, k, l, maxx = 0, n, b, sum = 0, d;
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> j >> k;
fx.push_back(pair<long long, long long>(j, k));
}
sort(fx.begin(), fx.end());
for (i = 0, j = 0; i < n; i++) {
while ((abs(fx[i].first - fx[j].first) < d) && (j < n)) {
sum += fx[j].second;
j++;
}
maxx = max(maxx, sum);
sum -= fx[i].second;
}
cout << maxx;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long int INF = 1e12;
const int N = 1e5 + 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, d;
cin >> n >> d;
pair<int, int> arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr, arr + n);
int i = 0, j = 0;
long long int ans = 0, sum = 0;
while (i < n) {
while (j < n && arr[j].first - arr[i].first < d) sum += arr[j].second, j++;
ans = max(ans, sum);
sum -= arr[i++].second;
}
cout << ans;
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.