text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
bool vis[maxn];
int main(int argc, const char* argv[]) {
int n, m, tmp1, tmp2, total = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> tmp1;
for (int j = 1; j <= tmp1; j++) {
cin >> tmp2;
if (vis[tmp2]) {
continue;
}
total++;
vis[tmp2] = 1;
}
}
if (total == m) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static struct IO {
char tmp[1 << 10];
char cur;
inline char nextChar() { return cur = getc(stdin); }
inline char peekChar() { return cur; }
inline operator bool() { return 0 != peekChar(); }
inline static bool isBlank(char c) { return (c < '-' && c); }
inline bool skipBlanks() {
while (isBlank(nextChar()))
;
return peekChar() != 0;
}
inline IO& operator>>(char& c) {
c = nextChar();
return *this;
}
inline IO& operator>>(char* buf) {
if (skipBlanks()) {
if (peekChar()) {
*(buf++) = peekChar();
while (!isBlank(nextChar())) *(buf++) = peekChar();
}
*(buf++) = 0;
}
return *this;
}
inline IO& operator>>(string& s) {
if (skipBlanks()) {
s.clear();
s += peekChar();
while (!isBlank(nextChar())) s += peekChar();
}
return *this;
}
inline IO& operator>>(double& d) {
if ((*this) >> tmp) sscanf(tmp, "%lf", &d);
return *this;
}
inline IO& operator>>(int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(unsigned int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(long long& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(unsigned long long& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline void putChar(char c) { putc(c, stdout); }
inline IO& operator<<(char c) {
putChar(c);
return *this;
}
inline IO& operator<<(const char* s) {
while (*s) putChar(*s++);
return *this;
}
inline IO& operator<<(const string& s) {
for (int i = 0; i < (int)s.size(); ++i) putChar(s[i]);
return *this;
}
char* toString(double d) {
sprintf(tmp, "%lf%c", d, '\0');
return tmp;
}
inline IO& operator<<(double d) { return (*this) << toString(d); }
inline char* toString(int n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(int n) { return (*this) << toString(n); }
inline char* toString(long long n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(long long n) { return (*this) << toString(n); }
inline char* toString(unsigned long long n) {
char* p = (tmp + 30);
if (n) {
while (n) *--p = (n % 10) + '0', n /= 10;
} else
*--p = '0';
return p;
}
inline IO& operator<<(unsigned long long n) { return (*this) << toString(n); }
} __io__;
class TimeTracker {
clock_t start, end;
public:
TimeTracker() { start = clock(); }
~TimeTracker() {
end = clock();
fprintf(stderr, "%.3lf s\n", (double)(end - start) / CLOCKS_PER_SEC);
}
};
int main() {
int button, bulb, i, j;
__io__ >> button >> bulb;
vector<int> v(bulb + 1, 0);
v[0] = 101;
for (i = 1; i <= button; i++)
for (__io__ >> j; j > 0; j--) {
int tmp;
__io__ >> tmp;
v[tmp] = 1;
}
if (*min_element(v.begin(), v.end()) < 1)
__io__ << "NO\n";
else
__io__ << "YES\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int buttons, bulbs, x, found = 0;
cin >> buttons >> bulbs;
int a[bulbs], z[bulbs];
bool f[1000] = {};
for (int i = 0; i < buttons; i++) {
cin >> a[0];
x = a[0];
for (int j = 0; j < a[0]; j++) {
cin >> z[j];
f[z[j]] = true;
}
}
for (int i = 1; i <= bulbs; i++) {
if (f[i] == true) {
found++;
}
}
if (found == bulbs)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M, N, mark[1000];
void openFile() { freopen("in.inp", "r", stdin); }
int main() {
ios::sync_with_stdio(false);
cin >> N >> M;
for (int i = 0, sz; i < N; ++i) {
cin >> sz;
for (int j = 0, x; j < sz; ++j) {
cin >> x;
mark[x] = 1;
}
}
int ans = 0;
for (int i = 1; i <= M; ++i) ans += mark[i];
if (ans == M)
printf("YES");
else
printf("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
bool arr[105]{false};
int numOfturnedOnBulb;
int numOfBulbs;
int numOfButtons;
int turnedOnBulbs;
bool allTurnedOn = true;
cin >> numOfButtons >> numOfBulbs;
for (int i = 0; i < numOfButtons; ++i) {
cin >> turnedOnBulbs;
for (int j = 0; j < turnedOnBulbs; ++j) {
cin >> numOfturnedOnBulb;
arr[numOfturnedOnBulb] = true;
}
}
for (int i = 1; i <= numOfBulbs; ++i) {
if (arr[i] == 0) allTurnedOn = false;
}
if (allTurnedOn)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
unordered_set<int> Set;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
int y;
cin >> y;
Set.insert(y);
}
}
if (Set.size() == m) {
cout << "YES";
} else {
cout << "NO";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool arr[100];
int n, m, k, k1;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> k;
for (int y = 1; y <= k; y++) {
cin >> k1;
arr[k1] = 1;
}
}
for (int i = 1; i <= m; i++) {
if (!arr[i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, x[102] = {};
bool ch = true;
cin >> n >> m;
for (i = 0; i < n; i++) {
int tmp;
cin >> tmp;
for (j = 0; j < tmp; j++) {
int tmp2;
cin >> tmp2;
x[tmp2] = 1;
}
}
for (i = 1; i <= m; i++)
if (x[i] == 0) ch = false;
if (ch == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int sta[300] = {0};
int main() {
int n, m;
scanf("%d %d", &n, &m);
while (n--) {
int x;
cin >> x;
while (x--) {
int y;
cin >> y;
sta[y] = 1;
}
}
int ans = 0;
for (int i = 0; i <= 100; ++i) ans += sta[i];
if (ans == m)
puts("YES");
else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e2 + 5;
int vis[MAX];
int n, m;
int x;
int bulbNo;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 0; j < x; j++) {
cin >> bulbNo;
vis[bulbNo] = 1;
}
}
bool flg = 1;
for (int i = 1; i <= m; i++) {
if (vis[i] == 0) {
flg = 0;
}
}
if (flg == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
bool is[110] = {false};
int main() {
scanf("%d%d", &n, &m);
while (n--) {
scanf("%d", &a);
while (a--) {
scanf("%d", &b);
is[b] = true;
}
}
bool flag = true;
for (int i = 1; i <= m; i++) {
if (!is[i]) {
flag = false;
break;
}
}
if (flag) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
vector<long long int> v1;
vector<long long int> v2;
const int inf = 100000005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int hs[105];
memset(hs, 0, sizeof(hs));
int n, m;
cin >> n >> m;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a;
for (int j = 0; j < a; j++) {
cin >> b;
hs[b] = 1;
}
}
for (int i = 1; i <= m; i++)
if (hs[i] == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, i;
cin >> n >> m;
unordered_set<int> set1;
for (i = 0; i < n; i++) {
int n1, x;
cin >> n1;
while (n1 > 0) {
n1--;
cin >> x;
set1.insert(x);
}
}
if (set1.size() == m)
cout << "YES";
else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, d, i, j, k, x;
cin >> n >> m;
vector<bool> a(m + 1, false);
for (i = 0; i < n; i++) {
cin >> d;
while (d--) {
cin >> x;
a[x] = true;
}
}
bool ans = true;
for (i = 1; i <= m; i++) {
if (!a[i]) ans = false;
}
if (ans)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[105], b[1000], c, f[105];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 1; j <= a[i]; j++) {
cin >> b[j];
f[b[j]]++;
}
}
for (int i = 1; i <= m; i++) {
if (f[i] > 0) {
c++;
}
}
if (c == m) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
bool bulbs[128] = {false};
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x;
for (int j = 0; j < x; ++j) {
cin >> y;
bulbs[y] = true;
}
}
printf("%s\n", all_of(bulbs + 1, bulbs + m + 1, [](bool a) { return a; })
? "YES"
: "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> st;
int n, m, a, b;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a;
for (int j = 1; j <= a; j++) {
cin >> b;
st.insert(b);
}
}
if (st.size() == m)
cout << "YES";
else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
bool flag[100];
int main() {
int n, m, x, fuck;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 0; j < x; j++) {
cin >> fuck;
flag[fuck - 1] = 1;
}
}
for (int i = 0; i < m; i++)
if (flag[i] == 0) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const double PI = 6.283185307179586476925286766559;
const int MAXN = 200011;
int n, m;
int mas[MAXN];
void solve() {
cin >> m >> n;
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
for (int j = 0; j < t; ++j) {
int k;
cin >> k;
mas[k] = 1;
}
}
for (int i = 1; i <= n; ++i) {
if (!mas[i]) {
cout << "NO";
return;
}
}
cout << "YES";
}
int main() {
srand(time(0));
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y;
int bin[123] = {0};
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
for (int j = 1; j <= x; j++) {
scanf("%d", &y);
bin[y] = 1;
}
}
bool OK = 1;
for (int i = 1; i <= m; i++)
if (bin[i] == 0) OK = 0;
if (OK)
printf("YES");
else
printf("NO");
}
|
#include <bits/stdc++.h>
int arr[101];
int main() {
int n, m, x, i, j, tmp;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &x);
for (j = 0; j < x; j++) {
scanf("%d", &tmp);
arr[tmp] = 1;
}
}
for (i = 1; i <= m; i++) {
if (!arr[i]) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int check(int a[], int m) {
for (int i = 1; i <= m; i++) {
if (a[i] != 0) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
int n, m, c, b;
cin >> n >> m;
int a[m + 1];
for (int i = 1; i <= m; i++) a[i] = i;
for (int i = 1; i <= n; i++) {
cin >> c;
for (int j = 1; j <= c; j++) {
cin >> b;
a[b] = 0;
}
}
if (check(a, m))
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[10000000], i, g, m, ans, k, x, y[1000000];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i];
for (g = 1; g <= a[i]; g++) {
cin >> x;
y[x]++;
}
}
for (i = 1; i <= m; i++) {
if (y[i] == 0) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, bulb, i, j, sum;
bool a[105] = {false};
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> sum;
while (sum--) {
cin >> bulb;
a[bulb] = true;
}
}
for (i = 1; i <= m; i++) {
if (a[i] == false) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solveQues() {
int n, m, a[1001], p;
cin >> n >> m;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
while (x--) cin >> p, a[p]++;
}
int c = 0;
for (int i = 1; i <= m; i++) {
if (a[i] != 0) c++;
}
if (c == m)
cout << "YES\n";
else
cout << "NO\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solveQues();
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
int ara[m + 1];
for (i = 1; i < m + 1; i++) {
ara[i] = 0;
}
for (i = 0; i < n; i++) {
int t;
scanf("%d", &t);
for (j = 0; j < t; j++) {
int l;
scanf("%d", &l);
ara[l] = 1;
}
}
int count = 0;
for (i = 1; i < m + 1; i++) {
if (ara[i] != 0) {
count++;
}
}
if (count == m)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("universal.in");
ofstream fout("");
int n, m;
set<int> on;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int aux;
cin >> aux;
for (int j = 1, bb; j <= aux; ++j) {
cin >> bb;
on.insert(bb);
}
if (on.size() == m) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
if (b == 0 || a == 1) {
if (mod == 1)
return 0;
else
return 1;
}
if (b % 2 == 0) {
long long k = powmod(a, b / 2, mod);
return (k * k) % mod;
} else {
long long k = powmod(a, b / 2, mod);
return ((k * k) % mod * a) % mod;
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(b % a, a);
}
long long prime(long long p) {
for (long long i = 2; i * i <= p; i++) {
if (p % i == 0 && i < p) return i;
}
return 1;
}
long long sqr(long long i) { return i * i; }
void solve(long long ppppppppp = 1) {
long long n, m;
cin >> n >> m;
bool used[m];
for (long long i = 0; i < m; i++) used[i] = false;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
long long m1[a];
map<long long, long long> mp;
for (long long j = 0; j < a; j++) {
cin >> m1[j];
mp[m1[j]]++;
}
for (long long j = 0; j < a; j++) {
if (mp[m1[j]] % 2 == 1) used[m1[j] - 1] = true;
}
}
for (long long i = 0; i < m; i++)
if (used[i] == false) {
cout << "NO";
return;
}
cout << "YES";
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tututu;
tututu = 1;
for (long long qwerty = 0; qwerty < tututu; qwerty++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n = 0, m = 0;
cin >> n >> m;
int baap[m + 1];
for (int i = 1; i < (m + 1); ++i) {
baap[i] = 0;
}
for (int i = 0; i < n; ++i) {
int k = 0;
cin >> k;
for (int i = 0; i < k; ++i) {
int temp = 0;
cin >> temp;
++baap[temp];
}
}
int counter = 0;
for (int i = 1; i < (m + 1); ++i) {
if (baap[i] == 0) {
cout << "NO";
break;
} else
++counter;
}
if (counter == m) {
cout << "YES";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
#pragma warning(default : 4996)
const long MAXN = 100002;
using namespace std;
long long n, i, j, k, m, ans = 0, x;
long long a[101];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> k;
for (j = 1; j <= k; j++) {
cin >> x;
if (a[x] == 0) {
ans++;
a[x] = 1;
}
if (ans == m) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
}
|
#include <bits/stdc++.h>
bool bulb[101];
int main() {
int m, n;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
for (int j = 0; j < x; ++j) {
int b;
scanf("%d", &b);
bulb[b] = true;
}
}
for (int i = 1; i <= m; ++i) {
if (!bulb[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
set<int> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
int v;
cin >> v;
a.insert(v);
}
}
if (a.size() == m) {
cout << "YES";
return 0;
}
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, s, nums[100] = {0}, k, i, a, j, flag = 0;
cin >> s >> b;
for (i = 0; i < s; i++) {
cin >> k;
for (j = 0; j < k; j++) {
cin >> a;
nums[a - 1] = 1;
}
}
for (i = 0; i < b; i++) {
if (nums[i] == 0) {
flag = 1;
break;
}
}
if (flag == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, x, y;
bool was[101];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 0; j < x; j++) {
cin >> y;
was[y] = true;
}
}
for (int i = 1; i <= m; i++) {
if (!was[i]) {
cout << "NO";
exit(0);
}
}
cout << "YES";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long int a[10000], s = 0, i, j, cont = 0;
while (n--) {
int x;
cin >> x;
j = s;
s += x;
for (i = j; i < s; i++) {
cin >> a[i];
}
}
sort(a, a + s);
for (i = 0; i < s; i++) {
if (a[i] == cont + 1) cont++;
}
if (cont == m)
cout << "YES";
else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
int i, k, j, x, n, m, a[1000];
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> x;
for (j = 0; j < x; j++) {
cin >> k;
a[k] = 1;
}
}
for (i = 1; i <= m; i++)
if (a[i] == 0) return cout << "NO", 0;
cout << "YES";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n], res[m], b[m];
int xx;
for (int i = 0; i < m; i++) {
res[i] = 0;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < a[i]; j++) {
cin >> xx;
res[--xx] = 1;
}
}
for (int i = 0; i < m; i++) {
if (res[i] == 0) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int tombol, lampu, lamp[105], pencet, index, tampung = 0;
scanf("%d %d", &tombol, &lampu);
for (int i = 1; i <= lampu; i++) {
lamp[i] = 0;
}
for (int i = 1; i <= tombol; i++) {
scanf("%d", &pencet);
for (int j = 1; j <= pencet; j++) {
scanf("%d", &index);
if (lamp[index] == 0) {
tampung++;
lamp[index] = 1;
}
}
}
if (tampung == lampu)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[120];
int main() {
int tmp, n, m;
int ans = 0;
scanf("%d%d", &n, &m);
memset(vis, 0, sizeof vis);
for (int i = 0; i < n; i++) {
int num;
scanf("%d", &num);
for (int j = 0; j < num; j++) {
scanf("%d", &tmp);
if (!vis[tmp]) {
vis[tmp] = 1;
ans++;
}
}
}
if (m - ans)
puts("NO");
else
puts("YES");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 100;
int main() {
long long int key, lmp;
cin >> key >> lmp;
bool a[lmp];
for (long long int i = 0; i < lmp; i++) a[i] = false;
for (long long int i = 0; i < key; i++) {
long long int d;
cin >> d;
for (long long int i = 0; i < d; i++) {
long long int f;
cin >> f;
a[f - 1] = true;
}
}
for (long long int i = 0; i < lmp; i++) {
if (a[i] == false) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int arrx[105];
int arr[105];
int temp1 = 0;
int temp2 = 1;
int counter1 = 0;
int x;
for (int j = 1; j <= b; j++) arr[j] = temp1;
for (int i = 0; i < a; i++) {
counter1 = 0;
cin >> x;
for (int k = 0; k < x; k++) {
cin >> arrx[k];
arr[arrx[k]] = temp2;
}
}
for (int k = 1; k <= b; k++) {
if (arr[k] == temp2) counter1++;
}
if (counter1 == b)
cout << "YES";
else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int flag = 0;
memset(a, 0, sizeof(a));
int x, y;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
for (int i = 1; i <= x; i++) {
scanf("%d", &y);
a[y]++;
}
}
for (int i = 1; i <= m; i++) {
if (a[i] == 0) flag = 1;
}
if (flag == 1)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
bool arr[m];
memset(arr, 0, sizeof(bool) * m);
int count = 0;
for (int i = 0; i < n; ++i) {
int no;
cin >> no;
for (int j = 0; j < no; ++j) {
int bulb;
cin >> bulb;
bulb--;
if (arr[bulb] == 0) {
arr[bulb] = 1;
count++;
}
}
}
if (count == m)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, arr[102] = {0};
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a;
for (int j = 0; j < a; j++) {
cin >> b;
arr[b]++;
}
}
for (int i = 1; i <= m; i++) {
if (arr[i] == 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
int min(int x, int y) { return x > y ? y : x; }
int max(int x, int y) { return x > y ? x : y; }
int abs(int x) { return x > 0 ? x : -x; }
int a[105];
int main() {
int n, m;
while (~scanf("%d %d", &n, &m)) {
memset(a, 0, sizeof(a));
for (int i = 1, x, q; i <= n; i++) {
scanf("%d", &x);
for (int i = 1; i <= x; i++) {
scanf("%d", &q);
a[q] = 1;
}
}
bool f = true;
for (int i = 1; i <= m; i++) {
if (a[i] == 0) f = false;
}
printf("%s\n", f ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t;
cin >> n >> m;
int visited[m + 1];
for (int i = 0; i <= m; i++) {
visited[i] = 0;
}
for (int i = 0; i < n; i++) {
int k;
cin >> t;
for (int j = 0; j < t; j++) {
cin >> k;
visited[k] = 1;
}
}
for (int i = 1; i <= m; i++) {
if (visited[i] == 0) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 101;
int cnt[M];
int main() {
int n, m, a;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
int temp;
for (int j = 0; j < a; ++j) {
scanf("%d", &temp);
cnt[temp]++;
}
}
for (int i = 1; i <= m; ++i) {
if (cnt[i] == 0) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
int arr[111];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
while (x--) {
cin >> y;
arr[y] = 1;
}
}
y = 0;
for (int i = 1; i <= m; i++) {
y += arr[i];
}
if (y == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
int a[1001];
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) {
int j;
scanf("%d", &j);
while (j--) {
int h;
scanf("%d", &h);
a[h] = 1;
}
}
int ans = 0;
for (int i = 1; i <= m; i++) {
if (a[i] == 1) ans++;
}
if (ans == m)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> ans(m + 1, false);
for (int l, i = 1; i <= n; i++) {
cin >> l;
for (int k, j = 1; j <= l; j++) {
cin >> k;
ans[k] = true;
}
}
for (int i = 1; i <= m; i++) {
if (ans[i] == false) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> bulbs;
int n, m;
cin >> n >> m;
int k, t;
for (int i = 0; i < (int)n; i++) {
cin >> k;
for (int j = 0; j < (int)k; j++) {
cin >> t;
bulbs.insert(t);
}
}
if (bulbs.size() == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, l, m, n, f;
map<int, int> mp;
cin >> m >> n;
f = 0;
for (i = 0; i < m; i++) {
cin >> k;
for (l = 0; l < k; l++) {
cin >> j;
mp[j]++;
}
}
for (i = 1; i <= n; i++) {
if (mp[i] == 0) f = 1;
}
if (f == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
int n, m;
int vis[110];
int temp;
int ans = 0;
int main(void) {
cin >> n >> m;
int num;
for (int i = 0; i < n; i++) {
cin >> num;
for (int j = 0; j < num; j++) {
scanf("%d", &temp);
if (!vis[temp]) {
ans++;
vis[temp]++;
}
}
}
if (ans == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592654;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
}
int main() {
fast();
int x, y;
cin >> x >> y;
set<int> st;
while (x--) {
int n;
cin >> n;
while (n--) {
int a;
cin >> a;
st.insert(a);
}
}
if (st.size() == y)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree[1000000][2];
long long ar[1000000];
int a, b;
long long query(int x, int l, int r, int s, int e, bool k) {
if (l > e || r < s || s > e) return 0;
if (l >= s && r <= e)
return tree[x][k];
else {
return query(x * 2, l, (l + r) / 2, s, e, k) +
query(x * 2 + 1, (l + r) / 2 + 1, r, s, e, k);
}
}
void upd(int x, int l, int r, int v) {
if (v > r || v < l) return;
if (l == r && v == l) {
tree[x][0] = min(ar[v], b + 0LL);
tree[x][1] = min(ar[v], a + 0LL);
} else {
upd(x * 2, l, (l + r) / 2, v);
upd(x * 2 + 1, (l + r) / 2 + 1, r, v);
tree[x][0] = tree[x * 2][0] + tree[x * 2 + 1][0];
tree[x][1] = tree[x * 2][1] + tree[x * 2 + 1][1];
}
}
int main() {
int n, k, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int d, x;
scanf("%d%d", &d, &x);
ar[d] += x;
upd(1, 1, n, d);
} else {
int p;
scanf("%d", &p);
printf("%I64d\n",
query(1, 1, n, 1, p - 1, 0) + query(1, 1, n, p + k, n, 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
struct node {
int smallerB;
int smallerA;
node() {
smallerA = 0;
smallerB = 0;
}
};
node tree[4 * MAXN];
int items[MAXN];
int a, b;
void Modify(int v, int tl, int tr, int where) {
if (tl == tr) {
tree[v].smallerA = min(a, items[where]);
tree[v].smallerB = min(b, items[where]);
} else {
int mid = (tl + tr) / 2;
if (where <= mid) {
Modify(2 * v, tl, mid, where);
} else {
Modify(2 * v + 1, mid + 1, tr, where);
}
tree[v].smallerA = tree[2 * v].smallerA + tree[2 * v + 1].smallerA;
tree[v].smallerB = tree[2 * v].smallerB + tree[2 * v + 1].smallerB;
}
}
int getSum(int v, int tl, int tr, int l, int r, int flag) {
if (tl > r || l > tr) return 0;
l = max(l, tl);
r = min(r, tr);
if (l == tl && r == tr) {
if (flag == 0)
return tree[v].smallerB;
else
return tree[v].smallerA;
} else {
int mid = (tl + tr) / 2;
return getSum(2 * v, tl, mid, l, r, flag) +
getSum(2 * v + 1, mid + 1, tr, l, r, flag);
}
}
int main() {
int N, K, Q;
cin >> N >> K >> a >> b >> Q;
for (int i = 1; i <= Q; i++) {
int typ;
cin >> typ;
if (typ == 1) {
int day, cnt;
cin >> day >> cnt;
items[day] += cnt;
Modify(1, 1, N, day);
} else {
int p;
cin >> p;
int SumL = (p != 1 ? getSum(1, 1, N, 1, p - 1, 0) : 0);
int SumR = (p != N - K + 1 ? getSum(1, 1, N, p + K, N, 1) : 0);
cout << SumL + SumR << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 201000;
int n, k, A, B, q;
int a[N], b[N];
int c[2][N];
void update(int wh, int i, int v) {
for (; i <= n; i += i & -i) c[wh][i] += v;
}
int query(int wh, int i) {
int res = 0;
for (; i; i -= i & -i) res += c[wh][i];
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &A, &B, &q);
while (q--) {
int op, i, d;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &i, &d);
if (a[i] + d < A)
update(0, i, d), a[i] += d;
else
update(0, i, A - a[i]), a[i] = A;
if (b[i] + d < B)
update(1, i, d), b[i] += d;
else
update(1, i, B - b[i]), b[i] = B;
} else {
scanf("%d", &i);
printf("%d\n", query(0, n) - query(0, i + k - 1) + query(1, i - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct FT {
long long t[(1 << 19)], S;
void clr(long long s) {
(memset(t, 0, sizeof(t)));
S = s;
}
void inc(long long i, long long d) {
for (; i < S; i |= i + 1) t[i] += d;
}
long long sum(long long i) {
long long s(0);
while (~i) s += t[i], i &= i + 1, --i;
return s;
}
long long gt(long long l, long long r) {
if (l > S) return 0;
if (l < 1) return 0;
r = min(r, S);
return sum(r) - sum(l - 1);
}
} U, V;
int N, K, a, b, Q, u, v, h, B, E;
int main(void) {
scanf("%d%d%d%d%d", &N, &K, &a, &b, &Q);
U.clr(N + 5), V.clr(N + 5);
for (int i(0); i < Q; i++) {
scanf("%d%d", &h, &B);
if (h == 1) {
scanf("%d", &E);
u = U.gt(B, B), v = V.gt(B, B);
if (u + E >= b)
U.inc(B, b - u);
else
U.inc(B, E);
if (v + E >= a)
V.inc(B, a - v);
else
V.inc(B, E);
} else
printf("%lld\n", U.gt(1, B - 1) + V.gt(B + K, N + 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int seg1[1000005];
long long int seg2[1000005];
long long int updt(int k, int l, int r, int q, long long int* seg,
long long int v, long long int lim) {
if (l == r) return (seg[k] = min(lim, seg[k] + v));
int m = (l + r) / 2;
if (q > m)
seg[k] = updt((k << 1) + 1, m + 1, r, q, seg, v, lim) + seg[(k << 1)];
else
seg[k] = updt((k << 1), l, m, q, seg, v, lim) + seg[(k << 1) + 1];
return seg[k];
}
long long int qry(int k, int l, int r, int qb, int qe, long long int* seg) {
if (qe < qb) return 0;
int m = (l + r) / 2;
if (qb > r || qe < l) return 0;
if (qb <= l && qe >= r)
return seg[k];
else
return (qry((2 * k), l, m, qb, qe, seg) +
qry((2 * k) + 1, m + 1, r, qb, qe, seg));
}
int main() {
long long int n, k, a, b, q;
scanf("%lld", &n);
scanf("%lld", &k);
scanf("%lld", &a);
scanf("%lld", &b);
scanf("%lld", &q);
long long int t, x, y;
while (q--) {
scanf("%lld", &t);
t--;
if (!t) {
scanf("%lld", &x);
scanf("%lld", &y);
updt(1, 1, n, x, seg1, y, b);
updt(1, 1, n, x, seg2, y, a);
} else {
scanf("%lld", &x);
long long int ans = 0;
ans += qry(1, 1, n, 1, x - 1, seg1);
ans += qry(1, 1, n, x + k, n, seg2);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> pref;
vector<int> suff;
void updatepref(int pos, int val) {
for (; pos < n; pos = (pos | (pos + 1))) {
pref[pos] += val;
}
}
int getpref(int pos) {
int ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ans += pref[pos];
}
return ans;
}
void updatesuff(int pos, int val) {
for (; pos < n; pos = (pos | (pos + 1))) {
suff[pos] += val;
}
}
int getsuff(int pos) {
int ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ans += suff[pos];
}
return ans;
}
int main() {
int k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
pref.resize(n);
suff.resize(n);
vector<int> ma(n), mb(n);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int day, cnt;
scanf("%d%d", &day, &cnt);
--day;
int delta = min(cnt + mb[day], b) - mb[day];
updatepref(day, delta);
mb[day] = min(cnt + mb[day], b);
delta = min(cnt + ma[day], a) - ma[day];
updatesuff(n - 1 - day, delta);
ma[day] = min(cnt + ma[day], a);
} else {
int day;
scanf("%d", &day);
--day;
int ans = getpref(day - 1) + getsuff(n - 1 - day - k);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int segA[4 * N];
int aaaa[N];
int segB[4 * N];
int n, k, a, b, q;
void update(int idx, int l, int r, int ql, int qr, int v) {
if (l > r or l > qr or r < ql) return;
if (l >= ql and r <= qr) {
segA[idx] = min(b, v);
segB[idx] = min(a, v);
return;
}
int mid = (l + r) / 2;
update(idx + idx, l, mid, ql, qr, v);
update(idx + idx + 1, mid + 1, r, ql, qr, v);
segA[idx] = segA[idx + idx] + segA[idx + idx + 1];
segB[idx] = segB[idx + idx] + segB[idx + idx + 1];
}
int queryA(int idx, int l, int r, int ql, int qr) {
if (l > r or l > qr or r < ql) return 0;
if (l >= ql and r <= qr) {
return segA[idx];
}
int mid = (l + r) / 2;
return queryA(idx + idx, l, mid, ql, qr) +
queryA(idx + idx + 1, mid + 1, r, ql, qr);
}
int queryB(int idx, int l, int r, int ql, int qr) {
if (l > r or l > qr or r < ql) return 0;
if (l >= ql and r <= qr) {
return segB[idx];
}
int mid = (l + r) / 2;
return queryB(idx + idx, l, mid, ql, qr) +
queryB(idx + idx + 1, mid + 1, r, ql, qr);
}
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int x;
scanf("%d", &x);
if (x == 1) {
int y, z;
scanf("%d%d", &y, &z);
aaaa[y] += z;
update(1, 1, n, y, y, aaaa[y]);
} else {
int z;
scanf("%d", &z);
int hi = z + k - 1;
if (hi > n) hi = n;
int fi = 0;
if (z > 1) {
fi = queryA(1, 1, n, 1, z - 1);
}
int si = 0;
if (hi < n) {
si = queryB(1, 1, n, hi + 1, n);
}
printf("%d", si + fi);
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
const char en = '\n';
using namespace std;
int size = 250000;
long long lastone(long long x) { return x & (x ^ (x - 1)); }
long long get(long long p, vector<long long> &F) {
long long res = 0;
for (long long i = p; i > 0; i -= lastone(i)) res += F[i];
return res;
}
long long se(long long p, long long h, vector<long long> &F) {
for (long long i = p; i < size; i += lastone(i)) F[i] += h;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
vector<long long> V(300000, 0), Fa = V, Fb = V;
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
long long dd, aa;
cin >> dd >> aa;
long long diff = min(a - V[dd], aa);
se(dd, diff, Fa);
long long diff1 = min(max(b - V[dd], 0LL), aa);
se(dd, diff1, Fb);
V[dd] += diff;
} else {
int p;
cin >> p;
cout << get(p - 1, Fb) + get(size - 47, Fa) - get(p + k - 1, Fa) << en;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000;
int len = 1;
int a, b;
vector<vector<int>> tree(maxn, vector<int>(2, 0));
void update(int ind, int i, int x) {
int curr = len + i;
int delta;
if (ind == 0) {
delta = min(a, tree[curr][0] + x);
} else {
delta = min(b, tree[curr][1] + x);
}
delta -= tree[curr][ind];
while (curr != 0) {
tree[curr][ind] += delta;
curr /= 2;
}
}
int get_sum(int ind, int l, int r) {
int currL = len + l;
int currR = len + r;
int ans = 0;
while (currL <= currR) {
if (currL % 2 == 1) {
ans += tree[currL][ind];
}
if (currR % 2 == 0) {
ans += tree[currR][ind];
}
currL = (currL + 1) / 2;
currR = (currR - 1) / 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, q;
cin >> n >> k >> a >> b >> q;
while (len < n) len *= 2;
int type, di, ai;
for (int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
cin >> di >> ai;
update(0, di - 1, ai);
update(1, di - 1, ai);
} else {
cin >> di;
cout << get_sum(1, 0, di - 2) + get_sum(0, di + k - 1, n - 1) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int SS = 4 * N;
long long n, q, k, a, b;
long long seg[SS][2];
void modif(int ind, int val, int s = 0, int e = n, int v = 1) {
if (ind < s || ind >= e) return;
if (e - s == 1) {
seg[v][0] += val, seg[v][0] = min(seg[v][0], a);
seg[v][1] += val, seg[v][1] = min(seg[v][1], b);
return;
}
int mid = (s + e) / 2;
modif(ind, val, s, mid, 2 * v);
modif(ind, val, mid, e, 2 * v + 1);
for (int i = 0; i < 2; i++) seg[v][i] = seg[2 * v][i] + seg[2 * v + 1][i];
}
long long get(int l, int r, int ind, int s = 0, int e = n, int v = 1) {
if (l >= e || r <= s) return 0;
if (l <= s && e <= r) return seg[v][ind];
int mid = (s + e) / 2;
long long res = 0;
res += get(l, r, ind, s, mid, 2 * v);
res += get(l, r, ind, mid, e, 2 * v + 1);
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int d, x;
cin >> d >> x;
d--;
modif(d, x);
} else {
int d;
cin >> d;
d--;
cout << get(0, d, 1) + get(d + k, n, 0) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
struct Fenwick {
long long arr[2][maxn];
inline long long lowbit(long long x) { return x & -x; }
void init() { memset(arr, 0, sizeof(arr)); }
void add(long long x, long long p, long long v) {
for (long long i = x; i < maxn; i += lowbit(i)) arr[p][i] += v;
}
long long qry(long long x, long long p) {
long long ret = 0;
for (long long i = x; i; i -= lowbit(i)) ret += arr[p][i];
return ret;
}
} bit;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
bit.init();
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long d, ai;
cin >> d >> ai;
long long qb = bit.qry(d, 0) - bit.qry(d - 1, 0),
qa = bit.qry(d, 1) - bit.qry(d - 1, 1);
bit.add(d, 0, min(b - qb, ai));
bit.add(d, 1, min(a - qa, ai));
} else {
long long p;
cin >> p;
cout << bit.qry(p - 1, 0) + bit.qry(n, 1) - bit.qry(p + k - 1, 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long rs = 1, cr = a;
while (b) {
if (b & 1) rs = (rs * cr) % 1000000007;
cr = (cr * cr) % 1000000007;
b >>= 1;
}
return rs;
}
long long a[212345], b[212345], cnt[212345];
void update(long long ar[], int idx, int vl) {
while (idx < 212345) {
ar[idx] += vl;
idx += (idx & -idx);
}
}
long long read(long long ar[], int idx) {
long long rs = 0;
while (idx) {
rs += ar[idx];
idx -= (idx & -idx);
}
return rs;
}
void solve() {
int n, k, q, d, ch;
long long o;
long long c1, c2;
scanf("%d", &n);
scanf("%d", &k);
scanf("%lld", &c1);
scanf("%lld", &c2);
scanf("%d", &q);
while (q--) {
scanf("%d", &ch);
if (ch == 1) {
scanf("%d", &d);
scanf("%lld", &o);
update(a, d, min(max(0ll, c1 - cnt[d]), o));
update(b, d, min(max(0ll, c2 - cnt[d]), o));
cnt[d] += o;
} else {
scanf("%d", &d);
long long rs = read(b, d - 1);
d += k - 1;
rs += read(a, 212345 - 1);
rs -= read(a, d);
printf("%lld\n", rs);
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = (int)1e6 + 7;
const int MAXN = (int)3e6 + 7;
int n, k, a, b, m;
int t[MAXN][2];
int arr[MAXN];
void upd(int pos, int val, int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
arr[pos] += val;
t[v][0] = min(a, arr[pos]);
t[v][1] = min(b, arr[pos]);
} else {
int mid = (tl + tr) / 2;
if (pos <= mid)
upd(pos, val, v + v, tl, mid);
else
upd(pos, val, v + v + 1, mid + 1, tr);
t[v][0] = t[v + v][0] + t[v + v + 1][0];
t[v][1] = t[v + v][1] + t[v + v + 1][1];
}
}
int get(int id, int l, int r, int v = 1, int tl = 1, int tr = n) {
if (tl > r || tr < l) return 0;
if (l <= tl && tr <= r) return t[v][id];
int mid = (tl + tr) / 2;
return get(id, l, r, v + v, tl, mid) + get(id, l, r, v + v + 1, mid + 1, tr);
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &b, &a, &m);
while (m--) {
int type;
scanf("%d", &type);
if (type == 1) {
int where, what;
scanf("%d%d", &where, &what);
upd(where, what);
} else {
int l, r;
scanf("%d", &l);
r = l + k - 1;
printf("%d\n", get(0, 1, l - 1) + get(1, r + 1, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 69, INF = 1e9 + 85, MOD = 1e9 + 7;
int n, k, a, b, q, arr[MAXN], seg[2][MAXN << 2];
void update(int indx, int val, int type, int l = 0, int r = n, int id = 1) {
if (indx < l or indx >= r) return;
if (r - l == 1) {
seg[type][id] = val;
return;
}
int mid = (l + r) >> 1;
update(indx, val, type, l, mid, id << 1 | 0);
update(indx, val, type, mid, r, id << 1 | 1);
seg[type][id] = seg[type][id << 1 | 0] + seg[type][id << 1 | 1];
}
int get(int st, int en, int type, int l = 0, int r = n, int id = 1) {
if (l >= en or r <= st) return 0;
if (l >= st and r <= en) return seg[type][id];
int mid = (l + r) >> 1;
return get(st, en, type, l, mid, id << 1 | 0) +
get(st, en, type, mid, r, id << 1 | 1);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> a >> b >> q;
while (q--) {
int type, day, order;
cin >> type;
if (type == 1) {
cin >> day >> order;
arr[day] += order;
update(day - 1, min(arr[day], a), 0);
update(day - 1, min(arr[day], b), 1);
} else {
cin >> day;
cout << get(0, day - 1, 1) + get(day + k - 1, n, 0) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class fenwick {
public:
vector<T> fenw;
int n;
fenwick(int _n) : n(_n) { fenw.resize(n); }
void modify(int x, T v) {
while (x < n) {
fenw[x] += v;
x |= (x + 1);
}
}
T get(int x) {
T v{};
while (x >= 0) {
v += fenw[x];
x = (x & (x + 1)) - 1;
}
return v;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
fenwick<int> f1(n + 1);
fenwick<int> f2(n + 1);
for (int i = 0; i < q; ++i) {
int type;
cin >> type;
if (type == 1) {
int day, cnt;
cin >> day >> cnt;
int new_x = f1.get(day) - f1.get(day - 1);
int new_y = f2.get(day) - f2.get(day - 1);
f1.modify(day, min(a - new_x, cnt));
f2.modify(day, min(b - new_y, cnt));
} else {
int from;
cin >> from;
int to = from + k - 1;
int ans = f2.get(from - 1);
ans += f1.get(n) - f1.get(to);
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 10;
int n, k, A, B, q;
long long arr[MN], fen[2][MN];
void add(int id, int p, long long val) {
for (p++; p < MN; p += p & -p) fen[id][p] += val;
}
long long get(int id, int p) {
long long ret = 0;
for (; p; p -= p & -p) ret += fen[id][p];
return ret;
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k >> A >> B >> q;
while (q--) {
int tp;
cin >> tp;
if (tp == 1) {
int d, x;
cin >> d >> x;
--d;
long long sv1 = min(1ll * B, arr[d]), sv2 = min(1ll * A, arr[d]);
arr[d] += x;
add(0, d, min((long long)B, arr[d]) - sv1),
add(1, d, min((long long)A, arr[d]) - sv2);
} else {
int p;
cin >> p;
--p;
cout << get(0, p) + get(1, n) - get(1, p + k) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)3e5 + 10;
const int mod = (int)1e9 + 7;
const int INF = (int)1e9 + 5;
const long long LLINF = (long long)1e18 + 5;
const double PI = acos(-1.0);
int k, n;
int b, a;
int q;
long long fwA[maxN];
long long fwB[maxN];
long long aC[maxN];
long long bC[maxN];
void update(long long fw[maxN], long long C[maxN], int r, long long x,
long long lim) {
x = min(lim - C[r], x);
C[r] += x;
for (; r < maxN; r |= r + 1) {
fw[r] += x;
}
}
long long sum(long long fw[maxN], int r) {
long long ret = 0LL;
for (; r >= 0; r = (r & (r + 1)) - 1) {
ret += fw[r];
}
return ret;
}
int main() {
n = nextInt<int>();
k = nextInt<int>();
a = nextInt<int>();
b = nextInt<int>();
q = nextInt<int>();
while (q--) {
int x, d;
int p;
int t;
t = nextInt<int>();
if (t == 1) {
d = nextInt<int>();
x = nextInt<int>();
update(fwA, aC, d, x, a);
update(fwB, bC, d, x, b);
} else {
long long ret = 0LL;
p = nextInt<int>();
ret += sum(fwB, p - 1);
ret += sum(fwA, maxN - 1) - sum(fwA, p + k - 1);
printf("%I64d\n", ret);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const int K = 500;
int n, a, b;
int sum[2][MAXN];
int sum_blocks[2][MAXN / K];
void add(int pos, int val) {
int a1 = min(b - sum[0][pos], val);
sum[0][pos] += a1;
sum_blocks[0][pos / K] += a1;
int a2 = min(a - sum[1][pos], val);
sum[1][pos] += a2;
sum_blocks[1][pos / K] += a2;
}
int get_sum(int left, int right, int type) {
int left_block = left / K, right_block = right / K, res = 0;
if (left_block == right_block) {
for (int i = left; i < right; ++i) res += sum[type][i];
} else {
for (int i = left_block + 1; i < right_block; ++i)
res += sum_blocks[type][i];
for (int i = left; i < (left_block + 1) * K; ++i) res += sum[type][i];
for (int i = right_block * K; i < right; ++i) res += sum[type][i];
}
return res;
}
int get_ans(int left_b, int right_b) {
return get_sum(0, left_b, 0) + get_sum(right_b, n, 1);
}
int main() {
int k, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
int val, day;
scanf("%d %d", &day, &val);
add(day - 1, val);
} else {
int day;
scanf("%d", &day);
int ans = get_ans(day - 1, day + k - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167177216")
using namespace std;
const int MAX = 2147483647;
const int MAXN = 201000;
const long long MOD = 1000000000 + 7;
long long FWB[MAXN], FWA[MAXN];
void update(long long *fw, int index, int count) {
for (int i = index; i < MAXN; i += (i + 1) & -(i + 1)) {
fw[i] += count;
}
}
long long get(long long *fw, int l, int r) {
long long result = 0;
for (int i = r; i >= 0; i -= (i + 1) & -(i + 1)) {
result += fw[i];
}
for (int i = l - 1; i >= 0; i -= (i + 1) & -(i + 1)) {
result -= fw[i];
}
return result;
}
long long get_pos(long long *fw, int pos) { return get(fw, pos, pos); }
int main() {
memset(FWB, 0, sizeof(FWB));
memset(FWA, 0, sizeof(FWA));
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int count, d;
scanf("%d%d", &d, &count);
d--;
long long val = get_pos(FWB, d);
long long newval = val;
newval += count;
newval = min(newval, (long long)b);
update(FWB, d, newval - val);
val = get_pos(FWA, d);
newval = val;
newval += count;
newval = min(newval, (long long)a);
update(FWA, d, newval - val);
} else {
int pos;
scanf("%d", &pos);
pos--;
long long leftsum = get(FWB, 0, pos - 1);
long long rightsum = get(FWA, pos + k, n - 1);
printf("%I64d\n", leftsum + rightsum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
int n, k, a, b, m;
struct seg_tr {
lli tr[200001];
int val[200001], b;
void upd(int cur, int v) {
v = min(v, b - val[cur]);
val[cur] += v;
while (cur <= n) tr[cur] += v, cur += cur & -cur;
}
lli sum(int cur) {
lli ret = 0;
while (cur) ret += tr[cur], cur -= cur & -cur;
return ret;
}
lli get(int l, int r) { return sum(r) - sum(l - 1); }
} sa, sb;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &m);
sa.b = a;
sb.b = b;
while (m--) {
int t, d, v;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &d, &v);
sa.upd(d, v);
sb.upd(d, v);
} else {
scanf("%d", &v);
printf("%lld\n", sb.get(1, v - 1) + sa.get(v + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree1[2LL * 200009], tree2[2LL * 200009];
int n, k, a, b, q;
int sum(int a, int b, int tree[]) {
a += n;
b += n;
int second = 0;
while (a <= b) {
if (a % 2 == 1) second += tree[a++];
if (b % 2 == 0) second += tree[b--];
a /= 2;
b /= 2;
}
return second;
}
void add(int k, int x, int tree[], int b) {
k += n;
tree[k] = min(b, tree[k] + x);
for (k /= 2; k >= 1; k /= 2) {
tree[k] = tree[2 * k] + tree[2 * k + 1];
}
}
void solve() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int t, d, o;
cin >> t;
if (t == 1) {
cin >> d >> o;
add(d - 1, o, tree1, b);
add(d - 1, o, tree2, a);
} else {
cin >> d;
long long int x = 0;
if (d - 2 >= 0) x = sum(0, max(d - 2, 0), tree1);
long long int y = sum(d - 2 + k + 1, n - 1, tree2);
cout << (x + y) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(5e5);
int ta[N], tb[N];
int n, k, a, b, q;
void upda(int v, int p) {
v += n - 1;
ta[v] = min(ta[v] + p, a);
while (v > 1) {
v /= 2;
ta[v] = ta[2 * v] + ta[2 * v + 1];
}
}
void updb(int v, int p) {
v += n - 1;
tb[v] = min(tb[v] + p, b);
while (v > 1) {
v /= 2;
tb[v] = tb[2 * v] + tb[2 * v + 1];
}
}
long long geta(int l, int r) {
l += n - 1;
r += n - 1;
long long res = 0;
while (l <= r) {
if (l & 1) res += ta[l];
if (!(r & 1)) res += ta[r];
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return res;
}
long long getb(int l, int r) {
l += n - 1;
r += n - 1;
long long res = 0;
while (l <= r) {
if (l & 1) res += tb[l];
if (!(r & 1)) res += tb[r];
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 1, t, d, p; i <= q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &d, &p);
upda(d, p);
updb(d, p);
} else {
scanf("%d", &p);
printf("%I64d\n", getb(1, p - 1) + geta(p + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b, q, i, j;
long long tp, l, r;
long long t1[888888], ta[888888], tb[888888];
void update(long long v, long long s, long long e, long long h, long long del) {
long long m = (s + e) / 2;
if (s == e) {
t1[v] += del;
if (t1[v] >= b) tb[v] = t1[v] - b;
if (t1[v] >= a) ta[v] = t1[v] - a;
return;
}
if (h <= m)
update(v * 2, s, m, h, del);
else
update(v * 2 + 1, m + 1, e, h, del);
t1[v] = t1[v * 2] + t1[v * 2 + 1];
ta[v] = ta[v * 2] + ta[v * 2 + 1];
tb[v] = tb[v * 2] + tb[v * 2 + 1];
}
long long qaqb(long long v, long long s, long long e, long long l,
long long r) {
long long m = (s + e) / 2;
if (l > r) return 0;
if (l == s && e == r) return t1[v] - tb[v];
return qaqb(v * 2, s, m, l, min(r, m)) +
qaqb(v * 2 + 1, m + 1, e, max(l, m + 1), r);
}
long long qaqa(long long v, long long s, long long e, long long l,
long long r) {
long long m = (s + e) / 2;
if (l > r) return 0;
if (l == s && e == r) return t1[v] - ta[v];
return qaqa(v * 2, s, m, l, min(r, m)) +
qaqa(v * 2 + 1, m + 1, e, max(l, m + 1), r);
}
int main() {
scanf("%lld%lld%lld%lld%lld", &n, &k, &a, &b, &q);
for (i = 1; i <= q; i++) {
scanf("%lld%lld", &tp, &l);
if (tp == 1) {
scanf("%lld", &r);
update(1, 1, n, l, r);
} else {
long long sum = qaqb(1, 1, n, 1, l - 1) + qaqa(1, 1, n, l + k, n);
printf("%lld\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200000 + 5;
int n;
class FTree {
protected:
int* t;
int sumR(int r) {
int res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
res += t[r];
}
return res;
}
public:
FTree() {
t = new int[maxN];
for (int i = 0; i < maxN; i++) {
t[i] = 0;
}
}
void update(int i, int delta) {
for (; i < n; i = i | (i + 1)) {
t[i] += delta;
}
}
int sum(int l, int r) { return sumR(r) - sumR(l - 1); }
};
int val[maxN] = {0};
int main() {
int k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
FTree f, s;
int type, x, y;
while (q--) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &x, &y);
f.update(x - 1, max(0, min(b, val[x - 1] + y) - val[x - 1]));
s.update(x - 1, max(0, min(a, val[x - 1] + y) - val[x - 1]));
val[x - 1] += y;
} else {
scanf("%d", &x);
printf("%d\n", f.sum(0, x - 2) + s.sum(x + k - 1, n - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 111;
int n, k, a[2], q;
int t[2][4 * MAXN];
long long query(int id, int v, int l, int r, int ql, int qr) {
if (l >= qr || ql >= r) return 0;
if (ql <= l && qr >= r) return t[id][v];
int mid = (l + r) / 2;
long long left = query(id, 2 * v + 1, l, mid, ql, qr);
long long right = query(id, 2 * v + 2, mid, r, ql, qr);
return left + right;
}
void update(int id, int v, int l, int r, int d, int val) {
if (d < l || d >= r) return;
if (l == r - 1) {
t[id][v] = min(a[id], t[id][v] + val);
return;
}
int mid = (l + r) / 2;
update(id, 2 * v + 1, l, mid, d, val);
update(id, 2 * v + 2, mid, r, d, val);
t[id][v] = t[id][2 * v + 1] + t[id][2 * v + 2];
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a[1], &a[0], &q);
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, a;
scanf("%d %d", &d, &a);
update(0, 0, 0, n, d - 1, a);
update(1, 0, 0, n, d - 1, a);
} else {
int d;
scanf("%d", &d);
printf("%d\n",
query(0, 0, 0, n, 0, d - 1) + query(1, 0, 0, n, d - 1 + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
inline bool Min(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool Max(T &a, T b) {
return a < b ? (a = b, true) : false;
}
inline int ni() {
int a;
scanf("%d", &a);
return a;
}
inline ll nl() {
ll a;
scanf("%lld", &a);
return a;
}
inline double nd() {
double a;
scanf("%lf", &a);
return a;
}
inline void pi(int a) { printf("%d ", a); }
inline void pl(ll a) { printf("%lld ", a); }
inline void pd(double a) { printf("%.12lf ", a); }
const int N = 2e5 + 100;
const int BL = 1000;
ll maxA[N / BL + 1];
ll maxB[N / BL + 1];
ll xs[N];
int n, k, a, b, q;
void add(int day, int amount) {
if (xs[day] + amount <= a)
maxA[day / BL] += amount;
else if (xs[day] <= a and xs[day] + amount > a)
maxA[day / BL] += a - xs[day];
if (xs[day] + amount <= b)
maxB[day / BL] += amount;
else if (xs[day] <= b and xs[day] + amount > b)
maxB[day / BL] += b - xs[day];
xs[day] += amount;
}
ll get(int p) {
int s = p - 1;
int e = p + k;
ll res = 0;
for (int i = 0; i <= s;) {
if (i % BL == 0 and i + BL - 1 <= s) {
res += maxB[i / BL];
i += BL;
} else {
res += min(xs[i], 1LL * b);
i++;
}
}
int ee = n - 1;
for (int i = e; i <= ee;) {
if (i % BL == 0 and i + BL - 1 <= ee) {
res += maxA[i / BL];
i += BL;
} else {
res += min(1LL * a, xs[i]);
i++;
}
}
return res;
}
void solve() {
n = ni();
k = ni();
a = ni();
b = ni();
q = ni();
for (int i = 0; i < (int)(q); ++i) {
int t = ni();
if (t == 1) {
int d = ni();
int m = ni();
add(d - 1, m);
} else {
int p = ni();
ll res = get(p - 1);
printf("%lld\n", res);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand((int)clock());
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int a, b, n, m, len;
long long cnt[N];
long long sum[N];
int lowbit(int x) { return x & (-x); }
void add(int x, int v) {
for (; x <= n; x += lowbit(x)) cnt[x] += v;
}
void add(int l, int r, int v) {
if (l > r) return;
add(l, v);
add(r + 1, -v);
}
long long query(int x) {
long long ret = 0;
for (; x; x -= lowbit(x)) ret += cnt[x];
return ret;
}
int main() {
scanf("%d%d%d%d%d", &n, &len, &a, &b, &m);
while (m--) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int d;
long long val;
scanf("%d%I64d", &d, &val);
int v1 = min(val, max(0ll, a - sum[d]));
add(1, d - len, v1);
int v2 = min(val, max(0ll, b - sum[d]));
add(d + 1, n, v2);
sum[d] += val;
} else {
int x;
scanf("%d", &x);
long long ans = query(x);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, k, a, b, q;
int cnt[MAXN];
int sum1[MAXN];
int sum2[MAXN];
void modify(int *sum, int p, int v) {
while (p <= n) {
sum[p] += v;
p += p & -p;
}
}
int query(int *sum, int p) {
int res = 0;
while (p >= 1) {
res += sum[p];
p -= p & -p;
}
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int tp, d, A, p, i = 1; i <= q; i++) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d", &d, &A);
modify(sum1, d, min(A, max(0, b - cnt[d])));
modify(sum2, d, min(A, max(0, a - cnt[d])));
cnt[d] += A;
} else {
scanf("%d", &p);
int ed = min(n, p + k - 1);
printf("%d\n", query(sum1, p - 1) + query(sum2, n) - query(sum2, ed));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int r[200100];
int l[200100];
int s[200100];
int n, k, a, b, q;
int getsum(int x, int c[]) {
int ret = 0;
while (x) {
ret += c[x];
x -= x & -x;
}
return ret;
}
void update(int x, int c[], int v) {
while (x <= n) {
c[x] += v;
x += x & -x;
}
}
void update(int x, int v) {
int os = s[x];
s[x] += v;
update(x, l, min(s[x], b) - min(os, b));
update(x, r, min(s[x], a) - min(os, a));
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 1; i <= q; ++i) {
int x, y, z;
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
update(y, z);
} else {
scanf("%d", &y);
printf("%d\n", getsum(y - 1, l) + getsum(n, r) - getsum(y + k - 1, r));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 200 * 1000 + 5;
const int maxM = 5000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int base = 701;
const int SQ = 500;
const int maxL = 20;
int seg[2][4 * maxN];
int lim[2];
void add(int f, int p, int val, int s, int e, int id) {
if (e - s == 1) {
seg[f][id] += val;
if (seg[f][id] > lim[f]) seg[f][id] = lim[f];
return;
}
int mid = (s + e) >> 1;
if (p < mid)
add(f, p, val, s, mid, 2 * id);
else
add(f, p, val, mid, e, 2 * id + 1);
seg[f][id] = seg[f][2 * id] + seg[f][2 * id + 1];
}
int get(int f, int l, int r, int s, int e, int id) {
if (l >= e || r <= s) return 0;
if (l <= s && e <= r) return seg[f][id];
int mid = (s + e) >> 1;
return get(f, l, r, s, mid, 2 * id) + get(f, l, r, mid, e, 2 * id + 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, q;
cin >> n >> k >> lim[1] >> lim[0] >> q;
for (int i = 0; i < q; i++) {
int t, d;
cin >> t >> d;
d--;
if (t == 1) {
int x;
cin >> x;
add(0, d, x, 0, n, 1);
add(1, d, x, 0, n, 1);
} else
cout << get(0, 0, d, 0, n, 1) + get(1, d + k, n, 0, n, 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct $ {
$() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
} $;
const int Maxn = 202005;
class BIT {
int *tree, sz;
public:
BIT() {
sz = 202005;
tree = new int[sz + 1];
}
BIT(int N) {
sz = N;
tree = new int[N + 1];
}
~BIT() { delete[] tree; }
void update(int idx, int Val) {
if (idx < 1 || idx > sz) return;
while (idx <= sz) {
tree[idx] += Val;
idx += idx & -idx;
}
}
int read(int idx) {
int Sum = 0;
while (idx > 0) {
Sum += tree[idx];
idx -= (idx & -idx);
}
return Sum;
}
int rangeSum(int l, int r) {
int Ret = read(r) - read(l - 1);
Ret = max(0, Ret);
return Ret;
}
int readSingle(int idx) {
int sum = tree[idx];
if (idx > 0) {
int z = idx - (idx & -idx);
idx--;
while (idx != z) {
sum -= tree[idx];
idx -= (idx & -idx);
}
}
return sum;
}
};
int T1[Maxn], T2[Maxn];
int main() {
int n, k, a, b, q, type, d, val;
cin >> n >> k >> a >> b >> q;
BIT B1, B2;
while (q--) {
cin >> type;
if (type == 1) {
cin >> d >> val;
if (T1[d] < a) {
int temp = min(val, a - T1[d]);
T1[d] += temp;
B1.update(d, temp);
}
if (T2[d] < b) {
int temp = min(val, b - T2[d]);
T2[d] += temp;
B2.update(d, temp);
}
} else {
cin >> d;
int Ans = 0;
Ans = B2.rangeSum(1, d - 1);
int z = B1.rangeSum(min(d + k, Maxn - 1), Maxn - 1);
Ans += z;
cout << Ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c1[200005], c2[200005];
int a[200005], n, k, A, B, q;
inline void upd(int *c, int i, int w) {
for (; i <= n; i += (i & -i)) c[i] += w;
}
inline int get(int *c, int i) {
int sum = 0;
for (; i; i -= (i & -i)) sum += c[i];
return sum;
}
int main() {
int i, p, d, w, op, q1, q2, ans;
cin >> n >> k >> A >> B >> q;
swap(A, B);
for (i = 1; i <= q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &d, &w);
if (a[d] < A)
q1 = min(a[d] + w, A) - a[d];
else
q1 = 0;
if (a[d] < B)
q2 = min(a[d] + w, B) - a[d];
else
q2 = 0;
a[d] += w;
upd(c1, d, q1);
upd(c2, d, q2);
} else {
scanf("%d", &p);
ans = (get(c1, p - 1) - get(c2, p + k - 1)) + get(c2, n);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
int n, k, a, b, q;
struct node {
long long val;
node *left = NULL;
node *right = NULL;
node(long long val) : val(val) {}
void split() {
left = new node(0LL);
right = new node(0LL);
}
};
struct segtree {
long long minwith;
node *root;
segtree(long long m) : minwith(m) { root = new node(0LL); }
void build(node *i, int l, int r) {
if (l == r) return;
i->split();
int m = (l + r) / 2;
build(i->left, l, m);
build(i->right, m + 1, r);
}
void upd(node *i, int l, int r, int k, long long x) {
if (l == r) {
i->val = min(minwith, i->val + x);
return;
}
int m = (l + r) / 2;
if (k <= m)
upd(i->left, l, m, k, x);
else
upd(i->right, m + 1, r, k, x);
i->val = i->left->val + i->right->val;
}
void upd(int k, long long x) { upd(root, 1, n, k, x); }
long long getsum(node *i, int l, int r, int L, int R) {
if (r < L || R < l) return 0LL;
if (L <= l && r <= R) return i->val;
int m = (l + r) / 2;
return getsum(i->left, l, m, L, R) + getsum(i->right, m + 1, r, L, R);
}
long long getsum(int L, int R) { return getsum(root, 1, n, L, R); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> a >> b >> q;
segtree sa(a), sb(b);
sa.build(sa.root, 1, n);
sb.build(sb.root, 1, n);
while (q--) {
int ty, d, p;
long long amt;
cin >> ty;
if (ty == 1) {
cin >> d >> amt;
sa.upd(d, amt);
sb.upd(d, amt);
} else {
cin >> p;
cout << sa.getsum(p + k, n) + sb.getsum(1, p - 1) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename G>
struct triple {
G first, second, T;
};
struct BIT {
vector<long long> items;
BIT(int sz = 0) { items = vector<long long>(sz + 5); }
void Update(int pos, long long value) {
for (int i = pos; i < items.size(); i += (i & -i)) items[i] += value;
}
long long Query(int pos) {
long long ans = 0;
for (int i = pos; i > 0; i -= (i & -i)) ans += items[i];
return ans;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
BIT abi1(n), abi2(n);
vector<int> v(n + 1);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int d, h;
cin >> d >> h;
if (v[d] < b) abi1.Update(d, min(h, b - v[d]));
if (v[d] < a) abi2.Update(n - d + 1, min(h, a - v[d]));
v[d] += h;
} else {
int d;
cin >> d;
cout << abi1.Query(d - 1) + abi2.Query(max(0, n - d - k + 1)) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b, q, u, v, w, ww, order[300000], orderr[300000], ans,
fenic[300000], fenicc[300000];
void insertt(long long v, long long w) {
long long vv = v;
while (vv <= n) {
fenic[vv] += w;
vv += vv & -vv;
}
}
void inserttt(long long v, long long w) {
long long vv = v;
while (vv <= n) {
fenicc[vv] += w;
vv += vv & -vv;
}
}
long long fenicsum(long long x) {
long long rlt = 0;
while (x > 0) {
rlt += fenic[x];
x -= x & -x;
}
return rlt;
}
long long feniccsum(long long x) {
long long rlt = 0;
while (x > 0) {
rlt += fenicc[x];
x -= x & -x;
}
return rlt;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &u);
if (u == 1) {
scanf("%d%d", &v, &ww);
long long wwww = min(order[v] + ww, a);
w = wwww - order[v];
order[v] = wwww;
insertt(v, w);
wwww = min(orderr[v] + ww, b);
w = wwww - orderr[v];
orderr[v] = wwww;
inserttt(v, w);
} else {
scanf("%d", &v);
ans = 0;
ans += feniccsum(v - 1);
ans += fenicsum(n) - fenicsum(v + k - 1);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long l, r, c;
};
struct node up[200000 * 4];
struct node down[200000 * 4];
long long chang[200000 + 1];
long long upp[200000 + 1];
long long downp[200000 + 1];
long long n, k, a, b, q;
int bj, di, ai;
long long Construct(long long l, long long r, long long k, node *arr) {
long long mid;
if (l == r) {
arr[k].l = arr[k].r = r;
return 0ll;
}
mid = (l + r) / 2;
arr[k].l = l;
arr[k].r = r;
return (arr[k].c = Construct(l, mid, 2 * k, arr) +
Construct(mid + 1, r, 2 * k + 1, arr));
}
void Deal(long long l, long long r, long long k, long long loc, long long num,
node *arr) {
long long mid;
if (arr[k].l == arr[k].r && arr[k].l == loc) {
arr[k].c = arr[k].c + num;
return;
}
mid = (l + r) / 2;
arr[k].c += num;
if (loc <= mid) {
Deal(l, mid, 2 * k, loc, num, arr);
} else {
Deal(mid + 1, r, 2 * k + 1, loc, num, arr);
}
}
long long Query(long long l, long long r, long long k, node *arr) {
long long mid;
if (arr[k].l == l && arr[k].r == r) {
return arr[k].c;
}
mid = (arr[k].l + arr[k].r) / 2;
if (r <= mid) {
return Query(l, r, 2 * k, arr);
} else if (l > mid) {
return Query(l, r, 2 * k + 1, arr);
} else {
return Query(l, mid, 2 * k, arr) + Query(mid + 1, r, 2 * k + 1, arr);
}
}
int main() {
cin >> n >> k >> a >> b >> q;
Construct(1, n, 1, up);
Construct(1, n, 1, down);
long long ans;
for (int i = 1; i <= q; i++) {
cin >> bj;
if (bj == 1) {
cin >> di >> ai;
chang[di] += ai;
long long p;
p = min(chang[di], a);
if (p > upp[di]) {
Deal(1, n, 1, di, p - upp[di], up);
upp[di] = p;
}
p = min(chang[di], b);
if (p > downp[di]) {
Deal(1, n, 1, di, p - downp[di], down);
downp[di] = p;
}
} else {
cin >> di;
ans = 0ll;
if (di > 1) {
ans += Query(1, di - 1, 1, down);
}
if (di + k <= n) {
ans += Query(di + k, n, 1, up);
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
const int maxn = 200003;
int arr[maxn];
int fa[maxn], fb[maxn];
void inc(int *f, int r, int val) {
for (; r < maxn; r = (r | (r + 1))) f[r] += val;
}
int sum(int *f, int r) {
int ans = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ans += f[r];
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int type;
cin >> type;
if (type == 1) {
int di, ai;
cin >> di >> ai;
inc(fa, di, min(ai, max(0, a - arr[di])));
inc(fb, di, min(ai, max(0, b - arr[di])));
arr[di] += ai;
} else {
int pi;
cin >> pi;
int ans = sum(fb, pi - 1) + sum(fa, n) - sum(fa, pi + k - 1);
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, q, ta, tb, tc;
long long x[19][100005 * 2], y[19][100005 * 2], oz, z[100005 * 2], ans, aa, bb;
long long f1(int a, int b, int c, int d) {
if (((1 << (c)) * (d)) == a && ((1 << (c)) * (d + 1)) == b) return x[c][d];
c--;
d = d * 2 + 1;
if (b <= ((1 << (c)) * (d))) return f1(a, b, c, d - 1);
if (a >= ((1 << (c)) * (d))) return f1(a, b, c, d);
return f1(a, ((1 << (c)) * (d)), c, d - 1) + f1(((1 << (c)) * (d)), b, c, d);
}
long long f2(int a, int b, int c, int d) {
if (((1 << (c)) * (d)) == a && ((1 << (c)) * (d + 1)) == b) return y[c][d];
c--;
d = d * 2 + 1;
if (b <= ((1 << (c)) * (d))) return f2(a, b, c, d - 1);
if (a >= ((1 << (c)) * (d))) return f2(a, b, c, d);
return f2(a, ((1 << (c)) * (d)), c, d - 1) + f2(((1 << (c)) * (d)), b, c, d);
}
int main() {
scanf("%d%d%I64d%I64d%d", &n, &k, &aa, &bb, &q);
while (q--) {
scanf("%d%d", &ta, &tb);
if (ta == 1) {
scanf("%d", &ta);
oz = z[--tb];
z[tb] += ta;
tc = tb;
for (int a = 0; a < 19; a++) {
x[a][tc] += min(bb, z[tb]) - min(bb, oz);
y[a][tc] += min(aa, z[tb]) - min(aa, oz);
tc >>= 1;
}
} else {
ans = 0;
tb--;
if (tb) ans += f1(0, tb, 18, 0);
if (tb + k < n) ans += f2(tb + k, n, 18, 0);
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
int val[200001];
long long ta[1 << 22];
long long tb[1 << 22];
int n;
long long a, b;
void update(int i, int l, int r, int x) {
if (l == r) {
ta[i] = std::min((long long)val[l], a);
tb[i] = std::min((long long)val[l], b);
} else {
int t = (l + r) >> 1;
if (x <= t)
update(2 * i, l, t, x);
else
update(2 * i + 1, t + 1, r, x);
ta[i] = ta[2 * i] + ta[2 * i + 1];
tb[i] = tb[2 * i] + tb[2 * i + 1];
}
}
long long sum(int i, int nl, int nr, int ql, int qr, bool f) {
if (qr < nl || ql > nr || ql > qr) return 0;
if (ql <= nl && qr >= nr) return f ? ta[i] : tb[i];
int t = (nl + nr) >> 1;
long long lv = sum(i * 2, nl, t, ql, qr, f);
long long rv = sum(i * 2 + 1, t + 1, nr, ql, qr, f);
return lv + rv;
}
int main() {
int k, q, x, y;
scanf("%d%d%I64d%I64d%d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &x);
if (x & 1) {
scanf("%d%d", &x, &y);
val[x] += y;
update(1, 1, n, x);
} else {
scanf("%d", &y);
long long ans = sum(1, 1, n, y + k, n, true);
ans += sum(1, 1, n, 1, y - 1, false);
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double eps = 1e-15;
double PI = 3.14159265359;
const int INF = 1e9;
const int N = 200005;
long long n, k, a, b, q;
long long x, y, z;
struct Node {
long long val;
long long suma, sumb;
Node() {}
Node(long long val) {
this->val = val;
suma = min(val, a);
sumb = min(val, b);
}
Node merge(Node n1) {
Node nn = Node();
nn.suma = this->suma + n1.suma;
nn.sumb = this->sumb + n1.sumb;
return nn;
}
};
Node tree[N * 4];
void build(int node, int l, int r) {
if (l == r) {
tree[node] = Node(0);
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
tree[node] = tree[node << 1].merge(tree[node << 1 | 1]);
}
void insert(int node, int l, int r, int idx, long long val) {
if (l == r) {
tree[node] = Node(val + tree[node].val);
return;
}
int mid = (l + r) >> 1;
if (idx <= mid)
insert(node << 1, l, mid, idx, val);
else
insert(node << 1 | 1, mid + 1, r, idx, val);
tree[node] = tree[node << 1].merge(tree[node << 1 | 1]);
}
long long query(int node, int l, int r, int ll, int rr, int type) {
if (l > rr || r < ll || ll > rr || l > r) return 0;
if (l >= ll && r <= rr) {
if (type)
return tree[node].suma;
else
return tree[node].sumb;
}
int mid = (l + r) >> 1;
long long q1 = query(node << 1, l, mid, ll, rr, type);
long long q2 = query(node << 1 | 1, mid + 1, r, ll, rr, type);
return q1 + q2;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> x >> y;
if (x & 1) {
cin >> z;
insert(1, 1, n, y, z);
} else {
long long res1 = query(1, 1, n, 1, y - 1, 0);
long long res2 = query(1, 1, n, y + k, n, 1);
cout << res1 + res2 << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[200000 + 5];
struct Fenwick_tree {
long long bit[200000 + 5];
void upd(int x, long long v) {
for (; x <= 200000; x += x & (-x)) bit[x] += v;
}
long long get(int x) {
long long ret = 0;
for (; x > 0; x -= x & (-x)) ret += bit[x];
return ret;
}
};
Fenwick_tree fwt0, fwt1;
int n, k, a, b, q;
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q > 0) {
int tt;
scanf("%d", &tt);
if (tt == 1) {
int d, x;
scanf("%d %d", &d, &x);
fwt0.upd(d, -min(1ll * b, t[d]));
fwt1.upd(d, -min(1ll * a, t[d]));
t[d] += x;
fwt0.upd(d, min(1ll * b, t[d]));
fwt1.upd(d, min(1ll * a, t[d]));
} else {
int p;
scanf("%d", &p);
cout << fwt0.get(p - 1) + fwt1.get(n) - fwt1.get(p + k - 1) << '\n';
}
q--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200500;
int t[3][3 * N];
int a[N];
int getsum(int id, int l, int r) {
int res = 0;
while (l <= r) {
if (l % 2 == 1) {
res += t[id][l];
}
if (r % 2 == 0) {
res += t[id][r];
}
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return res;
}
void upd(int id, int p) {
while (p) {
p /= 2;
t[id][p] = t[id][p * 2] + t[id][p * 2 + 1];
}
}
int main() {
srand(time(NULL));
int n, k, p1, p2, m;
cin >> n >> k >> p1 >> p2 >> m;
int sz = 1;
while (sz < n) {
sz *= 2;
}
for (int i = 1; i <= m; i++) {
int type;
cin >> type;
if (type == 1) {
int day, kol;
cin >> day >> kol;
a[day] += kol;
t[1][sz + day - 1] = min(a[day], p1);
t[2][sz + day - 1] = min(a[day], p2);
upd(1, sz + day - 1);
upd(2, sz + day - 1);
} else {
int pos;
cin >> pos;
cout << getsum(2, sz, sz + pos - 2) +
getsum(1, sz + pos + k - 1, sz + n - 1)
<< endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree1[200010], tree2[200010];
int n, k, a, b, q, fl, d, o, p, wa[200010], wb[200010];
vector<int> ddd;
int query1(int i) {
int k, ans = 0;
for (k = i; k > 0; k -= (k & -k)) ans += tree1[k];
return ans;
}
void update1(int i, int x) {
for (int k = i; k <= n; k += (k & -k)) tree1[k] += (x - wa[i]);
}
void build1() {
int i;
for (i = 2, tree1[1] = wa[1]; i <= n; i++) tree1[i] = tree1[i - 1] + wa[i];
for (i = n; i >= 1; i--) tree1[i] -= tree1[i - (i & -i)];
}
int query2(int i) {
int k, ans = 0;
for (k = i; k > 0; k -= (k & -k)) ans += tree2[k];
return ans;
}
void update2(int i, int x) {
for (int k = i; k <= n; k += (k & -k)) tree2[k] += (x - wb[i]);
}
void build2() {
int i;
for (i = 2, tree2[1] = wb[1]; i <= n; i++) tree2[i] = tree2[i - 1] + wb[i];
for (i = n; i >= 1; i--) tree2[i] -= tree2[i - (i & -i)];
}
void maxorder() {
int s = query1(n) - query1(p + k - 1) + query2(p - 1);
ddd.push_back(s);
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
build1(), build2();
while (q-- > 0) {
scanf("%d", &fl);
if (fl == 1) {
scanf("%d %d", &d, &o);
update1(d, min(a, wa[d] + o));
update2(d, min(b, wb[d] + o));
wa[d] = min(a, wa[d] + o);
wb[d] = min(b, wb[d] + o);
} else
scanf("%d", &p), maxorder();
}
for (int i = 0; i < ddd.size(); i++) printf("%d\n", ddd[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
long long a[N];
struct node {
int l, r;
long long sum;
} tree1[N * 4], tree2[N * 4];
long long aa, bb;
void pushup1(int cur) {
tree1[cur].sum = tree1[cur * 2].sum + tree1[cur * 2 + 1].sum;
}
void pushup2(int cur) {
tree2[cur].sum = tree2[cur * 2].sum + tree2[cur * 2 + 1].sum;
}
void build1(int cur, int l, int r) {
tree1[cur].l = l;
tree1[cur].r = r;
if (tree1[cur].l == tree1[cur].r) {
tree1[cur].sum = 0;
return;
}
int mid = (l + r) / 2;
build1(cur * 2, l, mid);
build1(cur * 2 + 1, mid + 1, r);
pushup1(cur);
}
void build2(int cur, int l, int r) {
tree2[cur].l = l;
tree2[cur].r = r;
if (tree2[cur].l == tree2[cur].r) {
tree2[cur].sum = 0;
return;
}
int mid = (l + r) / 2;
build2(cur * 2, l, mid);
build2(cur * 2 + 1, mid + 1, r);
pushup2(cur);
}
void updata1(int cur, int x, long long y) {
if (tree1[cur].l == tree1[cur].r) {
tree1[cur].sum = min(tree1[cur].sum + y, bb);
return;
}
if (x <= tree1[cur * 2].r)
updata1(cur * 2, x, y);
else
updata1(cur * 2 + 1, x, y);
pushup1(cur);
}
void updata2(int cur, int x, long long y) {
if (tree2[cur].l == tree2[cur].r) {
tree2[cur].sum = min(tree2[cur].sum + y, aa);
return;
}
if (x <= tree2[cur * 2].r)
updata2(cur * 2, x, y);
else
updata2(cur * 2 + 1, x, y);
pushup2(cur);
}
long long query1(int cur, int x, int y) {
if (x <= tree1[cur].l && tree1[cur].r <= y) return tree1[cur].sum;
long long res = 0;
if (x <= tree1[cur * 2].r) res += query1(cur * 2, x, y);
if (y >= tree1[cur * 2 + 1].l) res += query1(cur * 2 + 1, x, y);
return res;
}
long long query2(int cur, int x, int y) {
if (x <= tree2[cur].l && tree2[cur].r <= y) return tree2[cur].sum;
long long res = 0;
if (x <= tree2[cur * 2].r) res += query2(cur * 2, x, y);
if (y >= tree2[cur * 2 + 1].l) res += query2(cur * 2 + 1, x, y);
return res;
}
int main() {
int n, k;
int q;
int op;
int x;
long long z;
long long ans;
while (~scanf("%d%d%lld%lld%d", &n, &k, &aa, &bb, &q)) {
build1(1, 1, n);
build2(1, 1, n);
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%lld", &x, &z);
updata1(1, x, z);
updata2(1, x, z);
} else {
scanf("%d", &x);
ans = 0;
if (x - 1 >= 1) ans += query1(1, 1, x - 1);
if (x + k <= n) ans += query2(1, x + k, n);
printf("%lld\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, k, a, b, q;
long long sq[4 * maxn], sh[4 * maxn], s[4 * maxn];
int L[maxn], R[maxn];
int p, v, ql, qr;
void Push_up(int o) {
s[o] = s[o << 1] + s[o << 1 | 1];
sq[o] = sq[o << 1] + sq[o << 1 | 1];
sh[o] = sh[o << 1] + sh[o << 1 | 1];
}
void Update(int o, int l, int r) {
if (l == r) {
s[o] += 1LL * v;
sq[o] = s[o];
sh[o] = s[o];
if (sq[o] > b) sq[o] = b;
if (sh[o] > a) sh[o] = a;
return;
}
int mid = (l + r) / 2;
if (p <= mid)
Update(o << 1, l, mid);
else
Update(o << 1 | 1, mid + 1, r);
Push_up(o);
}
long long queryq(int o, int l, int r) {
if (ql <= l && r <= qr) {
return sq[o];
}
int mid = (l + r) / 2;
long long ans = 0LL;
if (ql <= mid) ans += queryq(o << 1, l, mid);
if (qr > mid) ans += queryq(o << 1 | 1, mid + 1, r);
return ans;
}
long long queryh(int o, int l, int r) {
if (ql <= l && r <= qr) {
return sh[o];
}
int mid = (l + r) / 2;
long long ans = 0LL;
if (ql <= mid) ans += queryh(o << 1, l, mid);
if (qr > mid) ans += queryh(o << 1 | 1, mid + 1, r);
return ans;
}
void solve() {
int cmd, dd, aa, pp;
memset(sq, 0, sizeof(sq));
memset(sh, 0, sizeof(sh));
memset(s, 0, sizeof(s));
for (int i = 1; i <= q; i++) {
scanf("%d", &cmd);
if (cmd == 1) {
scanf("%d %d", &p, &v);
Update(1, 1, n);
} else {
scanf("%d", &pp);
long long qian = 0LL, hou = 0LL, res = 0LL;
ql = 1;
qr = pp - 1;
if (qr >= ql) qian = queryq(1, 1, n);
ql = pp + k;
qr = n;
hou = queryh(1, 1, n);
res = qian + hou;
printf("%I64d\n", res);
}
}
}
int main() {
while (scanf("%d %d %d %d %d", &n, &k, &a, &b, &q) != EOF) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, N;
long long T1[4 * 200010], T2[4 * 200010];
void update(long long v, long long tl, long long tr, long long pos,
long long val) {
if (tl == tr) {
T1[v] = min(a, T1[v] + val);
T2[v] = min(b, T2[v] + val);
} else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, val);
else
update(v * 2 + 1, tm + 1, tr, pos, val);
T1[v] = T1[v * 2] + T1[v * 2 + 1];
T2[v] = T2[v * 2] + T2[v * 2 + 1];
}
}
long long query1(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (tl == l && tr == r)
return T1[v];
else {
long long tm = (tl + tr) / 2;
return query1(v * 2, tl, tm, l, min(r, tm)) +
query1(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r);
}
}
long long query2(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (tl == l && tr == r)
return T2[v];
else {
long long tm = (tl + tr) / 2;
return query2(v * 2, tl, tm, l, min(r, tm)) +
query2(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r);
}
}
int main() {
long long k, q;
cin >> N >> k >> a >> b >> q;
for (int i = 1; i <= q; i++) {
long long pi, t, di, ai;
cin >> t;
if (t == 1) {
cin >> di >> ai;
update(1, 1, N, di, ai);
} else {
cin >> pi;
cout << query2(1, 1, N, 1, pi - 1) + query1(1, 1, N, pi + k, N) << endl;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.