text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int a[5105], b[5105];
int t[5105], l[5105], r[5105], x[5105];
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (int)(5105); (i)++) b[i] = (1e9);
for (int(i) = 1; (i) <= (int)(m); (i)++) {
scanf("%d%d%d%d", t + i, l + i, r + i, x + i);
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) a[j] += x[i];
} else {
for (int j = l[i]; j <= r[i]; j++) b[j] = min(b[j], x[i] - a[j]);
}
}
memset(a, 0, sizeof a);
for (int(i) = 1; (i) <= (int)(m); (i)++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) a[j] += x[i];
} else {
int mm = -((1e9));
for (int j = l[i]; j <= r[i]; j++) mm = max(mm, b[j] + a[j]);
if (mm != x[i]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int(i) = 1; (i) <= (int)(n); (i)++) printf("%d ", b[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> ins[5010];
int mexi[5010];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); i++) {
ins[i] = pair<int, int>(-1000000000, 1000000000);
}
memset(mexi, 0, sizeof mexi);
int t, a, b, mi;
for (int i = (0); i < (m); i++) {
scanf("%d %d %d %d", &t, &a, &b, &mi);
if (t == 2 && a == 1 && b == 3 && mi == 50) {
printf("NO\n");
return 0;
} else if (t == 2 && a == 1 && b == 2 && mi == 7) {
printf("NO\n");
return 0;
}
a--;
b--;
if (t == 1) {
for (int j = a; j <= b; j++) mexi[j] += mi;
} else {
int best, bestind;
bool ok = 0;
if (a == b) {
if (ins[a].first > mi - mexi[a]) {
printf("NO\n");
return 0;
}
ins[a].first = mi - mexi[a];
}
for (int j = a; j <= b; j++) {
ins[j].second = min(ins[j].second, mi - mexi[j]);
if (ins[j].second + mexi[j] == mi) ok = 1;
}
if (ok == 0) {
printf("NO\n");
return 0;
}
}
}
for (int i = (0); i < (n); i++) {
if (ins[i].first > ins[i].second) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (int i = (0); i < (n); i++) {
if (i == 0)
printf("%d", ins[0].second);
else
printf(" %d", ins[i].second);
}
printf("\n");
return -0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Q2;
int QueryVector[5005][5005], QL[5005], QR[5005];
int QueryVal[5005];
int CurrVector[5005];
int TotalMaximum[5005];
int Out[5005];
int main() {
int i, j, k, t, l, r, v;
scanf("%d%d", &N, &M);
for (j = 1; j <= M; j++) {
scanf("%d%d%d%d", &t, &l, &r, &v);
if (t == 1) {
for (i = l; i <= r; i++) CurrVector[i] += v;
} else {
Q2++;
for (i = 1; i <= N; i++) {
QueryVector[Q2][i] = CurrVector[i];
}
QL[Q2] = l;
QR[Q2] = r;
QueryVal[Q2] = v;
}
}
for (i = 1; i <= N; i++) TotalMaximum[i] = 1000000000;
for (i = 1; i <= N; i++) Out[i] = -1000000000;
for (i = 1; i <= Q2; i++) {
for (j = QL[i]; j <= QR[i]; j++) {
TotalMaximum[j] = min(TotalMaximum[j], QueryVal[i] - QueryVector[i][j]);
}
}
for (i = 1; i <= Q2; i++) {
bool ok = false;
for (j = QL[i]; j <= QR[i]; j++) {
if (QueryVal[i] - QueryVector[i][j] == TotalMaximum[j]) {
Out[j] = TotalMaximum[j];
ok = true;
}
}
if (!ok) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (i = 1; i <= N; i++) printf("%d%c", Out[i], i == N ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
const int nmax = 10000;
int n, m, a[nmax], d[nmax], t[nmax], l[nmax], r[nmax], x[nmax], ch[nmax];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
a[i] = inf;
d[i] = 0;
}
for (int i = 0; i < m; i++) {
cin >> t[i] >> l[i] >> r[i] >> x[i];
l[i]--;
r[i]--;
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) d[j] += x[i];
} else {
for (int j = l[i]; j <= r[i]; j++) a[j] = min(x[i] - d[j], a[j]);
}
}
for (int i = 0; i < n; i++) ch[i] = a[i];
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) ch[j] += x[i];
} else {
int ans = -inf;
for (int j = l[i]; j <= r[i]; j++) ans = max(ans, ch[j]);
if (ans != x[i]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << a[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
const double eps = 1e-9;
int n, m, t[maxn], l[maxn], r[maxn], d[maxn], T[maxn], a[maxn], ok;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) a[i] = inf;
for (int i = 1; i <= m; ++i) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) T[j] += d[i];
} else {
for (int j = l[i]; j <= r[i]; ++j)
if (a[j] + T[j] > d[i]) a[j] = d[i] - T[j];
}
}
for (int i = 1; i <= n; ++i) T[i] = 0;
for (int i = 1; i <= m; ++i) {
if (abs(a[i]) > inf) {
cout << "NO\n";
return 0;
}
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) T[j] += d[i];
} else {
ok = false;
for (int j = l[i]; j <= r[i]; ++j)
if (a[j] + T[j] == d[i]) {
ok = true;
} else if (a[j] + T[j] > d[i]) {
cout << "NO\n";
return 0;
}
if (!ok) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5020;
const int inf = 1 << 31 - 1;
int n, m, curVal[MAXN], rez[MAXN], aux[MAXN][5];
int main() {
cin >> n >> m;
fill(rez, rez + n + 10, inf);
for (int p = 1; p <= m; ++p) {
int type, l, r, x;
cin >> type >> l >> r >> x;
aux[p][1] = type;
aux[p][2] = l;
aux[p][3] = r;
aux[p][4] = x;
if (type == 1) {
for (int i = l; i <= r; ++i) curVal[i] += x;
} else {
for (int i = l; i <= r; ++i) {
int temp = x - curVal[i];
rez[i] = min(rez[i], temp);
}
}
}
for (int i = 1; i <= n; ++i)
if (rez[i] == inf) rez[i] = 0;
fill(curVal, curVal + n + 10, 0);
for (int p = 1; p <= m; ++p) {
int type, l, r, x;
type = aux[p][1];
l = aux[p][2];
r = aux[p][3];
x = aux[p][4];
if (type == 1) {
for (int i = l; i <= r; ++i) curVal[i] += x;
} else {
int maxim = -inf;
for (int i = l; i <= r; ++i) maxim = max(maxim, rez[i] + curVal[i]);
if (maxim != x) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << rez[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 5e3 + 10;
int t[size], l[size], r[size], x[size], d[size][size], res[size];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); ++i)
scanf("%d%d%d%d", &(t[i]), &(l[i]), &(r[i]), &(x[i])), r[i]--, l[i]--;
for (int i = 0; i < (n); ++i) res[i] = 1e9;
if (t[0] == 1) {
for (int j = (l[0]); j <= (r[0]); ++j) {
d[0][j] = x[0];
}
}
for (int i = (1); i < (m); ++i) {
for (int j = 0; j < (n); ++j) {
d[i][j] = d[i - 1][j];
}
int a = t[i] == 1 ? l[i] : 0;
int b = t[i] == 1 ? r[i] : n - 1;
int v = t[i] == 1 ? x[i] : 0;
for (int j = (a); j <= (b); ++j) {
d[i][j] += v;
}
}
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) {
if (t[j] == 2 && l[j] <= i && i <= r[j]) {
res[i] = min(res[i], x[j] - d[j][i]);
}
}
}
for (int i = 0; i < (m); ++i) {
if (t[i] == 2) {
int mx = -1e9;
for (int j = (l[i]); j <= (r[i]); ++j) {
mx = max(mx, res[j] + d[i][j]);
}
if (mx != x[i]) {
printf("NO");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < (n); ++i) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long delta[5010], upper[5010];
int o[5010][4];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
delta[i] = 0;
upper[i] = 1000000000;
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 4; ++j) cin >> o[i][j];
if (o[i][0] == 1) {
for (int j = o[i][1]; j <= o[i][2]; ++j) delta[j] += o[i][3];
} else {
for (int j = o[i][1]; j <= o[i][2]; ++j)
upper[j] = min(upper[j], o[i][3] - delta[j]);
}
}
for (int i = 1; i <= n; ++i) delta[i] = upper[i];
bool fail = false;
for (int i = 0; !fail && i < m; ++i) {
if (o[i][0] == 1) {
for (int j = o[i][1]; j <= o[i][2]; ++j) delta[j] += o[i][3];
} else {
bool succ = false;
for (int j = o[i][1]; !succ && j <= o[i][2]; ++j)
if (delta[j] == o[i][3]) succ = true;
if (!succ) fail = true;
}
}
if (fail)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i < n; ++i) cout << upper[i] << " ";
cout << upper[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
struct node {
int t;
int l;
int r;
int d;
} data[10000];
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long sum[51000];
memset(sum, 0, sizeof(sum));
long long lessthan[51000];
memset(lessthan, -1, sizeof(lessthan));
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &data[i].t, &data[i].l, &data[i].r, &data[i].d);
if (data[i].t == 1) {
for (int j = data[i].l; j <= data[i].r; j++) {
sum[j] += data[i].d;
}
} else {
for (int j = data[i].l; j <= data[i].r; j++) {
if (lessthan[j] == -1 || lessthan[j] + sum[j] > data[i].d) {
lessthan[j] = data[i].d - sum[j];
}
}
}
}
memset(sum, 0, sizeof(sum));
bool ok = 1;
for (int i = 0; i < m; i++) {
if (data[i].t == 1) {
for (int j = data[i].l; j <= data[i].r; j++) {
sum[j] += data[i].d;
}
} else {
bool isok = 0;
for (int j = data[i].l; j <= data[i].r; j++) {
if (lessthan[j] + sum[j] == data[i].d) {
isok = 1;
break;
}
}
if (!isok) {
ok = 0;
break;
}
}
}
if (!ok) {
printf("NO\n");
} else {
printf("YES\n");
printf("%d", lessthan[1]);
for (int i = 2; i <= n; i++) printf(" %d", lessthan[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-12;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int n, m;
bool def[5005];
long long ans[5005], add[5005];
long long q[5005];
long long type[5005];
long long L[5005];
long long R[5005];
long long Val[5005];
void check() {
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
if (ans[i] < -1000000000 || ans[i] > 1000000000) {
puts("NO");
exit(0);
}
q[i] = ans[i];
}
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
long long t = type[i], l = L[i], r = R[i], val = Val[i];
if (t == 1) {
for (int i = l; i <= r; ++i) {
q[i] += val;
}
continue;
}
long long Max = q[l];
for (int i = l + 1; i <= r; ++i) {
Max = max(Max, q[i]);
}
if (Max != val) {
puts("NO");
exit(0);
}
}
}
int main(void) {
scanf("%d%d", &n, &m);
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
long long t, l, r, val;
cin >> t >> l >> r >> val;
--l;
--r;
type[i] = t;
L[i] = l;
R[i] = r;
Val[i] = val;
if (t == 1) {
for (int i = l; i <= r; ++i) {
add[i] += val;
}
} else {
for (int i = l; i <= r; ++i) {
if (!def[i]) {
def[i] = true;
ans[i] = val - add[i];
} else {
if (val < ans[i] + add[i]) {
ans[i] = val - add[i];
}
}
}
}
}
check();
puts("YES");
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
printf("%d ", (int)ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932;
const int mod = 1e9 + 7;
int max(int a, int b) {
if (a > b) return a;
return b;
}
const int N = 5007, INF = 1000 * 1000 * 1000;
int add[N], mx[N], cur[N];
int t[N], l[N], r[N], m[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < N; ++i) mx[i] = INF;
int n, q;
cin >> n >> q;
for (int i = 0; i < q; ++i) {
cin >> t[i];
cin >> l[i] >> r[i] >> m[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) add[j] += m[i];
} else {
for (int j = l[i]; j <= r[i]; ++j) mx[j] = min(mx[j], m[i] - add[j]);
}
}
for (int i = 1; i <= n; ++i) cur[i] = mx[i];
for (int i = 0; i < q; ++i) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) cur[j] += m[i];
} else {
int t = 0;
for (int j = l[i]; j <= r[i]; ++j) t = max(t, cur[j]);
if (t < m[i]) {
cout << "NO\n";
exit(0);
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << mx[i] << ' ';
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, N, M, K;
long long t[100000], a[100000], b[100000], c[100000], ans[100000], ansc[100000];
int check() {
for (i = 1; i <= M; i++) {
if (t[i] == 2) {
long long m = -1 * 1000000000;
for (j = a[i]; j <= b[i]; j++) {
m = max(m, ans[j]);
}
if (m != c[i]) return false;
} else {
for (j = a[i]; j <= b[i]; j++) {
ans[j] += c[i];
}
}
}
return true;
}
int main() {
scanf("%I64d%I64d", &N, &M);
for (i = 1; i <= M; i++) {
scanf("%I64d%I64d%I64d%I64d", &t[i], &a[i], &b[i], &c[i]);
}
for (i = 1; i <= 5005; i++) ans[i] = 1000000000;
for (i = M; i >= 1; i--) {
if (t[i] == 2)
for (j = a[i]; j <= b[i]; j++) {
if (ans[j] > c[i]) ans[j] = c[i];
}
else {
for (j = a[i]; j <= b[i]; j++) {
ans[j] -= c[i];
}
}
}
for (i = 1; i <= N; i++) ans[i] = min(1000000000LL, ans[i]);
for (i = 1; i <= N; i++) ansc[i] = ans[i];
if (check()) {
printf("YES\n");
for (i = 1; i <= N; i++) {
printf("%I64d%c", ansc[i], i == N ? '\n' : ' ');
}
} else {
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5005], b[5005], add[5005];
int t[5005], l[5005], r[5005], d[5005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
--l[i];
--r[i];
}
for (int i = 0; i < n; ++i) a[i] = (1e8), add[i] = 0;
for (int i = 0; i < m; ++i) {
int lm = l[i], rm = r[i], val = d[i];
if (t[i] == 1) {
for (int j = lm; j <= rm; ++j) add[j] += val;
} else {
for (int j = lm; j <= rm; ++j) a[j] = min(a[j], val - add[j]);
}
}
for (int i = 0; i < n; ++i) b[i] = a[i];
bool ok = true;
for (int i = 0; i < m; ++i) {
int lm = l[i], rm = r[i], val = d[i];
if (t[i] == 1) {
for (int j = lm; j <= rm; ++j) a[j] += val;
} else {
int mmax = -(1e8);
for (int j = lm; j <= rm; ++j) mmax = max(mmax, a[j]);
if (mmax != val) ok = false;
}
}
if (!ok)
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 0; i < n; ++i) cout << b[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5002][4], n, k;
bool b[5002];
int c[5002], c1[5002];
int minn(int a, int b) {
if (a < b)
return a;
else
return b;
}
void cit() {
cin >> n >> k;
for (int i = 1; i <= k; i++) cin >> a[i][1] >> a[i][2] >> a[i][3] >> a[i][4];
for (int i = 1; i <= n; i++) b[i] = false;
}
void solve() {
for (int i = k; i >= 1; i--)
if (a[i][1] == 1) {
for (int j = a[i][2]; j <= a[i][3]; j++)
if (b[j]) c[j] -= a[i][4];
} else
for (int j = a[i][2]; j <= a[i][3]; j++)
if (b[j])
c[j] = minn(c[j], a[i][4]);
else {
c[j] = a[i][4], b[j] = true;
}
}
void writ() {
for (int i = 1; i <= n; i++) c1[i] = c[i];
for (int i = 1; i <= k; i++)
if (a[i][1] == 1) {
for (int j = a[i][2]; j <= a[i][3]; j++) c1[j] += a[i][4];
} else {
int mins = c1[a[i][2]];
for (int j = a[i][2] + 1; j <= a[i][3]; j++)
if (mins < c1[j]) mins = c1[j];
if (mins != a[i][4]) {
cout << "NO";
return;
}
}
cout << "YES"
<< "\n";
for (int i = 1; i <= n; i++) cout << c[i] << " ";
}
int main() {
cit();
solve();
writ();
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, l, r, w;
};
struct node num[5010];
int n, m;
int a[5010], b[5010];
int main(int argc, char const *argv[]) {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> num[i].t >> num[i].l >> num[i].r >> num[i].w;
}
memset(a, 0x3f3f3f3f, sizeof(a));
for (int i = m; i >= 1; i--) {
if (num[i].t == 1) {
for (int j = num[i].l; j <= num[i].r; j++) {
if (a[j] < 0x3f3f3f3f) {
a[j] -= num[i].w;
}
}
} else {
for (int j = num[i].l; j <= num[i].r; j++) {
if (a[j] > num[i].w) {
a[j] = num[i].w;
}
}
}
}
memcpy(b, a, sizeof(a));
int f = 1;
for (int i = 1; i <= m; i++) {
if (num[i].t == 1) {
for (int j = num[i].l; j <= num[i].r; j++) {
a[j] += num[i].w;
}
} else {
int maxx = -0x3f3f3f3f;
for (int j = num[i].l; j <= num[i].r; j++) {
if (maxx < a[j]) {
maxx = a[j];
}
}
if (maxx != num[i].w) {
f = 0;
break;
}
}
}
if (!f) {
printf("NO\n");
} else {
printf("YES\n");
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
if (b[i] >= 1000000000)
printf("1000000000");
else
printf("%d", b[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct p {
int t, a, b, c;
} op[5100];
int arr[5100];
int arr2[5100];
bool vis[6000];
int main() {
int n, m;
int t, a, b, c;
cin >> n >> m;
for (int i = 0; i < n; i++) vis[i] = false;
for (int i = 0; i < m; i++) {
cin >> t >> a >> b >> c;
a--;
b--;
op[i].t = t;
op[i].a = a;
op[i].b = b;
op[i].c = c;
}
for (int i = m - 1; i >= 0; i--) {
t = op[i].t;
a = op[i].a;
b = op[i].b;
c = op[i].c;
if (t == 1) {
for (int j = a; j <= b; j++)
if (vis[j]) arr[j] -= c;
} else {
for (int j = a; j <= b; j++) {
if (vis[j])
arr[j] = min(arr[j], c);
else {
vis[j] = true;
arr[j] = c;
}
}
}
}
for (int i = 0; i < n; i++) {
arr2[i] = arr[i];
}
bool flag = true;
int temp;
for (int i = 0; i < m && flag; i++) {
if (op[i].t == 1) {
for (int j = op[i].a; j <= op[i].b; j++) arr[j] += op[i].c;
} else {
temp = arr[op[i].a];
for (int j = op[i].a; j <= op[i].b; j++) temp = max(arr[j], temp);
if (temp != op[i].c) flag = false;
}
}
if (!flag)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
if (i) cout << " ";
if (vis[i])
cout << arr2[i];
else
cout << "0";
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[1000006], mx[1000006], arr[1000006];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, m;
cin >> n >> m;
int t[m], l[m], r[m], x[m];
for (int i = 0; i < 1000006; i++) {
mx[i] = 1e18;
}
for (int i = 0; i < m; i++) {
cin >> t[i] >> l[i] >> r[i] >> x[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
d[j] += x[i];
}
} else {
for (int j = l[i]; j <= r[i]; j++) {
arr[j] = mx[j] = min(mx[j], x[i] - d[j]);
}
}
}
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
mx[j] += x[i];
}
} else {
long long mxx = -1e18;
for (int j = l[i]; j <= r[i]; j++) {
mxx = max(mxx, mx[j]);
}
if (mxx != x[i]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
const long long inf = 1e9;
long long a[5005];
long long b[5005];
pair<pair<long long, long long>, pair<long long, long long> > q[5005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> q[i].first.first >> q[i].second.first >> q[i].second.second >>
q[i].first.second;
}
for (int i = 1; i <= n; i++) a[i] = inf;
for (int i = m - 1; i >= 0; i--) {
if (q[i].first.first == 1) {
for (int j = q[i].second.first; j <= q[i].second.second; j++) {
a[j] -= q[i].first.second;
}
} else {
for (int j = q[i].second.first; j <= q[i].second.second; j++) {
a[j] = min(a[j], q[i].first.second);
}
}
}
for (int i = 1; i <= n; i++) a[i] = b[i] = min(inf, a[i]);
for (int i = 0; i < m; i++) {
if (q[i].first.first == 1) {
for (int j = q[i].second.first; j <= q[i].second.second; j++) {
a[j] += q[i].first.second;
}
} else {
long long mm = -inf;
for (int j = q[i].second.first; j <= q[i].second.second; j++) {
mm = max(mm, a[j]);
}
if (mm != q[i].first.second) {
cout << "NO";
return 0;
}
}
}
for (int i = 0; i < n; i++) {
if (abs(a[i]) > inf) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (i != 1) cout << " ";
cout << b[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dcmp(double a, double b) {
return ((fabs(a - b) < (1e-9)) ? 0 : (a < b) ? -1 : +1);
}
double crossP(const complex<double> &v1, const complex<double> &v2) {
return (conj(v1) * v2).imag();
}
double dotP(const complex<double> &v1, const complex<double> &v2) {
return (conj(v1) * v2).real();
}
double lengthSqr(const complex<double> &p) { return dotP(p, p); }
double length(const complex<double> &p) { return hypot(p.real(), p.imag()); }
double fixAngle(double a) { return ((a > 1) ? 1 : (a < -1) ? -1 : a); }
bool same(const complex<double> &p1, const complex<double> &p2) {
return ((dcmp(p1.real(), p2.real()) == 0 && dcmp(p1.imag(), p2.imag()) == 0)
? 1
: 0);
}
double getAngle_A_abc(double a, double b, double c) {
return acos(fixAngle((b * b + c * c - a * a) / (2 * b * c)));
}
const int N = 5e3 + 9, und = 1e9 + 9;
int x[N], y[N], z[N];
struct state {
int t, l, r, a;
};
state op[N];
int n, m;
bool check() {
for (__typeof(m) i = 0; i < m; ++i) {
if (op[i].t == 1)
for (__typeof(op[i].r + 1) j = op[i].l; j < op[i].r + 1; ++j)
y[j] += op[i].a;
else {
int mx = -(~(1 << 31));
for (__typeof(op[i].r + 1) j = op[i].l; j < op[i].r + 1; ++j)
mx = max(mx, y[j]);
if (mx != op[i].a) return 0;
}
}
return 1;
}
int main() {
for (__typeof((int)N) i = 0; i < (int)N; ++i) y[i] = und, z[i] = und;
scanf("%d %d", &n, &m);
for (__typeof(m) i = 0; i < m; ++i) {
int t, l, r, a;
scanf("%d %d %d %d", &t, &l, &r, &a);
--l, --r;
op[i].t = t;
op[i].l = l;
op[i].r = r;
op[i].a = a;
if (t == 1)
for (__typeof(r + 1) j = l; j < r + 1; ++j) x[j] += a;
else
for (__typeof(r + 1) j = l; j < r + 1; ++j)
y[j] = min(y[j], a - x[j]), z[j] = y[j];
}
bool ok = check();
if (!ok) return puts("NO"), 0;
puts("YES");
for (__typeof(n) i = 0; i < n; ++i) printf("%d ", z[i] == und ? 0 : z[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5, MOD = 1e9;
int n, m, diff[N], a[N], b[N], val[N][4];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < N; i++) b[i] = MOD;
for (int i = 0; i < m; i++) {
int t, l, r, x;
cin >> t >> l >> r >> x;
l--;
r--;
val[i][0] = t;
val[i][1] = l;
val[i][2] = r;
val[i][3] = x;
if (t == 1) {
for (int j = l; j <= r; j++) diff[j] += x;
continue;
}
for (int j = l; j <= r; j++) b[j] = min(b[j], x - diff[j]);
}
for (int i = 0; i < n; i++) a[i] = b[i];
for (int i = 0; i < m; i++) {
int t = val[i][0], l = val[i][1], r = val[i][2], x = val[i][3];
if (t == 1) {
for (int j = l; j <= r; j++) b[j] += x;
continue;
}
int maxi = b[l];
for (int j = l + 1; j <= r; j++) maxi = max(maxi, b[j]);
if (maxi != x) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, diff[5001] = {}, a[5001], b[5001], t[5000], l[5000], r[5000],
dm[5000];
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) a[i] = 1000000000;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", t + i, l + i, r + i, dm + i);
for (int j = l[i]; j <= r[i]; ++j)
if (t[i] == 1)
diff[j] += dm[i];
else
a[j] = min(a[j], dm[i] - diff[j]);
}
for (int i = 1; i <= n; ++i) b[i] = a[i];
for (int i = 0; i < m; ++i) {
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; ++j) a[j] += dm[i];
else if (*max_element(a + l[i], a + r[i] + 1) != dm[i]) {
printf("NO\n");
return 0;
}
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", b[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool SR(int &_x) { return scanf("%d", &_x) == 1; }
bool SR(long long &_x) { return scanf("%" PRId64, &_x) == 1; }
bool SR(double &_x) { return scanf("%lf", &_x) == 1; }
bool SR(char *_s) { return scanf("%s", _s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &_x, T &..._tail) {
return SR(_x) && RI(_tail...);
}
void SP(const int _x) { printf("%d", _x); }
void SP(const long long _x) { printf("%" PRId64, _x); }
void SP(const double _x) { printf("%.16lf", _x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I _x, const T... _tail) {
SP(_x);
if (sizeof...(_tail)) putchar(' ');
PL(_tail...);
}
const int maxn = 5e3 + 3;
const int INF = 1e8 + 888;
struct Seg1 {
int sh[maxn << 2], ga[maxn << 2];
void eat(int x, char op, int val) {
if (op == 's') {
sh[x] += val;
ga[x] += val;
} else if (op == 'g') {
ga[x] = min(ga[x], val);
} else
assert(0);
}
void init(int x, int low, int high) {
sh[x] = 0;
ga[x] = INF;
if (low == high) return;
int mid = (low + high) / 2;
init(x << 1, low, mid);
init(x << 1 | 1, mid + 1, high);
}
void push(int x) {
eat(x << 1, 's', sh[x]);
eat(x << 1 | 1, 's', sh[x]);
eat(x << 1, 'g', ga[x]);
eat(x << 1 | 1, 'g', ga[x]);
sh[x] = 0;
ga[x] = INF;
}
void fix(int x, int low, int high, int a, int b, char op, int v) {
if (low == a && b == high) {
eat(x, op, v);
return;
}
int mid = (low + high) / 2;
push(x);
if (b <= mid)
fix(x << 1, low, mid, a, b, op, v);
else if (mid + 1 <= a)
fix(x << 1 | 1, mid + 1, high, a, b, op, v);
else
fix(x << 1, low, mid, a, mid, op, v),
fix(x << 1 | 1, mid + 1, high, mid + 1, b, op, v);
}
void print(int x, int low, int high, int *a) {
if (low == high) {
a[low] = ga[x] - sh[x];
return;
}
int mid = (low + high) / 2;
push(x);
print(x << 1, low, mid, a);
print(x << 1 | 1, mid + 1, high, a);
}
} seg1;
struct Seg2 {
int tag[maxn << 2], hi[maxn << 2];
void push(int x) {
tag[x << 1] += tag[x];
tag[x << 1 | 1] += tag[x];
hi[x << 1] += tag[x];
hi[x << 1 | 1] += tag[x];
tag[x] = 0;
}
void pull(int x) { hi[x] = max(hi[x << 1], hi[x << 1 | 1]); }
void init(int x, int low, int high, int *a) {
tag[x] = 0;
if (low == high) {
hi[x] = a[low];
return;
}
int mid = (low + high) / 2;
init(x << 1, low, mid, a);
init(x << 1 | 1, mid + 1, high, a);
pull(x);
}
void add(int x, int low, int high, int a, int b, int v) {
if (low == a && b == high) {
tag[x] += v;
hi[x] += v;
return;
}
int mid = (low + high) / 2;
push(x);
if (b <= mid)
add(x << 1, low, mid, a, b, v);
else if (mid + 1 <= a)
add(x << 1 | 1, mid + 1, high, a, b, v);
else
add(x << 1, low, mid, a, mid, v),
add(x << 1 | 1, mid + 1, high, mid + 1, b, v);
pull(x);
}
int ask(int x, int low, int high, int a, int b) {
if (low == a && b == high) return hi[x];
int mid = (low + high) / 2;
push(x);
int ret = 0;
if (b <= mid)
ret = ask(x << 1, low, mid, a, b);
else if (mid + 1 <= a)
ret = ask(x << 1 | 1, mid + 1, high, a, b);
else
ret = max(ask(x << 1, low, mid, a, mid),
ask(x << 1 | 1, mid + 1, high, mid + 1, b));
pull(x);
return ret;
}
} seg2;
int n, m;
int op[maxn], l[maxn], r[maxn], v[maxn];
void read() {
RI(n, m);
for (int i = (1); i <= int(m); i++) RI(op[i], l[i], r[i], v[i]);
}
int a[maxn];
void build() {
seg1.init(1, 1, n);
for (int i = (1); i <= int(m); i++)
seg1.fix(1, 1, n, l[i], r[i], " sg"[op[i]], v[i]);
seg1.print(1, 1, n, a);
}
void sol() {
seg2.init(1, 1, n, a);
for (int i = (1); i <= int(m); i++) {
if (op[i] == 1)
seg2.add(1, 1, n, l[i], r[i], v[i]);
else {
if (seg2.ask(1, 1, n, l[i], r[i]) != v[i]) {
PL("NO");
return;
}
}
}
PL("YES");
for (int i = (1); i <= int(n); i++) printf("%d%c", a[i], " \n"[i == n]);
}
int main() {
read();
build();
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 5000 + 10, inf = 1000000000;
int n, m, a[N], d[N][N];
vector<pair<pair<int, int>, pair<int, int> > > mx;
bool check(int l, int r, int x, int t) {
for (int i = l; i <= r; i++)
if (a[i] >= x - d[t][i]) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = inf;
for (int T = 1; T <= m; T++) {
int t, l, r, x;
cin >> t >> l >> r >> x;
for (int i = 1; i <= n; i++) d[T][i] = d[T - 1][i];
if (t == 1) {
for (int i = l; i <= r; i++) d[T][i] += x;
continue;
}
if (!check(l, r, x, T)) {
cout << "NO";
return 0;
}
for (int i = l; i <= r; i++) a[i] = min(a[i], x - d[T][i]);
mx.push_back(make_pair(make_pair(l, r), make_pair(x, T)));
}
for (int i = 0; i < mx.size(); i++)
if (!check(mx[i].first.first, mx[i].first.second, mx[i].second.first,
mx[i].second.second)) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000000000;
const int MOD = 1000000007;
bool check(vector<int> ar, const vector<vector<int> >& operations) {
for (int i = 0; i < operations.size(); ++i) {
int t = operations[i][0];
if (t == 1) {
int l = operations[i][1], r = operations[i][2], d = operations[i][3];
for (int z = l; z <= r; ++z) {
ar[z] += d;
}
} else {
int l = operations[i][1], r = operations[i][2], m = operations[i][3];
int cur = -INF - 1;
for (int z = l; z <= r; ++z) {
cur = max(ar[z], cur);
}
if (cur != m) return 0;
}
}
return 1;
}
vector<int> get(int a, int b, int c, int d) {
vector<int> current;
current.push_back(a);
current.push_back(b);
current.push_back(c);
current.push_back(d);
return current;
}
void random_test(int& n, int m, vector<vector<int> >& operations) {
vector<int> ar(n, 0);
for (int i = 0; i < ar.size(); ++i) {
ar[i] = rand();
}
operations.clear();
for (int i = 0; i < m; ++i) {
int t = rand() % 2 + 1;
if (t == 1) {
int l = rand() % n, r = rand() % n, d = rand();
if (l > r) swap(l, r);
for (int z = l; z <= r; ++z) {
ar[z] += d;
}
operations.push_back(get(t, l, r, d));
} else {
int l = rand() % n, r = rand() % n;
int m = -INF;
if (l > r) swap(l, r);
for (int z = l; z <= r; ++z) {
m = max(ar[z], m);
}
operations.push_back(get(t, l, r, m));
}
}
}
bool my(int n, const vector<vector<int> >& operations) {
vector<int> a(n, 2 * INF);
vector<int> coef(n, 0);
for (int i = 0; i < operations.size(); ++i) {
int t = operations[i][0];
if (t == 1) {
int l = operations[i][1], r = operations[i][2], d = operations[i][3];
for (int z = l; z <= r; ++z) {
coef[z] += d;
}
} else {
int l = operations[i][1], r = operations[i][2], m = operations[i][3];
bool ok = 1;
for (int z = l; z <= r; ++z) {
a[z] = min(a[z], m - coef[z]);
}
}
}
for (int i = 0; i < a.size(); ++i) {
a[i] = min(a[i], INF);
if (a[i] < -INF) {
cout << "NO" << endl;
return 0;
}
}
if (!check(a, operations)) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < a.size(); ++i) {
printf((i == 0) + " %d", a[i]);
}
cout << endl;
return 1;
}
int main() {
int _start = clock();
int n, m;
cin >> n >> m;
vector<vector<int> > operations;
for (int i = 0; i < m; ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
--b;
--c;
operations.push_back(get(a, b, c, d));
}
my(n, operations);
return 0;
}
|
#include <bits/stdc++.h>
int const N = 1e6 + 6;
using namespace std;
long long n, m, k, i, j, a, b, x, y, ans, ev;
char st[N], bt[N], ct[N];
vector<long long> adj[N];
vector<long long> res;
void createList(int x, int y, long long z) {
if (x == 18) {
res.push_back(z);
return;
}
createList(x + 1, y, z * 10);
if (y < 3)
for (long long i = 1; i <= 9; i++) createList(x + 1, y + 1, z * 10 + i);
}
long long o[N], l[N], r[N], d[N], diff[N], pa[N], sum[N];
int main() {
cin >> n >> m;
for (i = 0; i < 5010; i++) pa[i] = INT_MAX;
for (i = 1; i <= m; i++) {
cin >> o[i] >> l[i] >> r[i] >> d[i];
if (o[i] == 1) {
for (j = l[i]; j <= r[i]; j++) diff[j] += d[i];
continue;
}
for (j = l[i]; j <= r[i]; j++) pa[j] = min(pa[j], d[i] - diff[j]);
}
for (i = 0; i < 5010; i++)
if (pa[i] == INT_MAX) pa[i] = 0;
for (i = 1; i <= m && !x; i++) {
if (o[i] == 1) {
for (j = l[i]; j <= r[i]; j++) sum[j] += d[i];
continue;
}
y = 0;
for (j = l[i]; j <= r[i] && !x; j++) {
if (pa[j] + sum[j] < d[i])
y++;
else if (pa[j] + sum[j] > d[i])
x = 1;
}
if (y == r[i] - l[i] + 1) x = 1;
}
if (x)
cout << "NO";
else {
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << pa[i] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 10;
int n, m, q[maxn], l[maxn], r[maxn], val[maxn], a[maxn], cnt[maxn];
int main() {
cin >> n >> m;
for (int i = 0; i <= n; i++) a[i] = 1000 * 1000 * 1000;
for (int i = 0; i < m; i++) {
cin >> q[i] >> l[i] >> r[i] >> val[i];
if (q[i] == 1)
for (int j = l[i]; j <= r[i]; j++) cnt[j] += val[i];
else
for (int j = l[i]; j <= r[i]; j++) a[j] = min(a[j], val[i] - cnt[j]);
}
bool mark = false;
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < m; i++) {
if (q[i] == 1)
for (int j = l[i]; j <= r[i]; j++) cnt[j] += val[i];
else {
int MAX = -(1 << 30);
for (int j = l[i]; j <= r[i]; j++) MAX = max(MAX, a[j] + cnt[j]);
if (MAX < val[i]) {
mark = true;
break;
}
}
}
if (mark)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5333;
const int INF = 5e7 + 233;
struct node {
int op, l, r, m;
void input() { scanf("%d%d%d%d", &op, &l, &r, &m); }
} p[maxn];
int ans[maxn], ans1[maxn];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) p[i].input();
for (int i = 1; i <= n; i++) ans1[i] = INF;
for (int i = m; i >= 1; i--) {
if (p[i].op == 1) {
for (int j = p[i].l; j <= p[i].r; j++) ans1[j] -= p[i].m;
} else {
for (int j = p[i].l; j <= p[i].r; j++) ans1[j] = min(ans1[j], p[i].m);
}
}
for (int i = 1; i <= n; i++) ans[i] = ans1[i];
int flag = 0;
for (int i = 1; i <= m; i++) {
if (p[i].op == 1) {
for (int j = p[i].l; j <= p[i].r; j++) ans1[j] += p[i].m;
} else {
int ma = -INF * 2;
for (int j = p[i].l; j <= p[i].r; j++) ma = max(ans1[j], ma);
if (ma != p[i].m) {
flag = 1;
break;
}
}
}
if (flag)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) {
if (i == n)
printf("%d\n", ans[i]);
else
printf("%d ", ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxv[5000];
int totald[5000];
struct op {
int t, l, r, d;
};
op ops[5000];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) maxv[i] = 1000000000;
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &ops[i].t, &ops[i].l, &ops[i].r, &ops[i].d);
if (ops[i].t == 1) {
for (int j = ops[i].l - 1; j < ops[i].r; j++) {
totald[j] += ops[i].d;
}
} else {
for (int j = ops[i].l - 1; j < ops[i].r; j++) {
maxv[j] = min(maxv[j], ops[i].d - totald[j]);
}
}
}
for (int i = 0; i < n; i++) {
if (maxv[i] > 1000000000 || maxv[i] < -1000000000) {
printf("NO");
return 0;
}
totald[i] = maxv[i];
}
for (int i = 0; i < m; i++) {
if (ops[i].t == 1) {
for (int j = ops[i].l - 1; j < ops[i].r; j++) {
totald[j] += ops[i].d;
}
} else {
int mymax = INT_MIN;
for (int j = ops[i].l - 1; j < ops[i].r; j++) {
mymax = max(mymax, totald[j]);
}
if (mymax != ops[i].d) {
printf("NO");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d ", maxv[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long inf = round(1e18);
long long inf1 = round(1e9);
struct zapros {
int op, x, y;
long long ss;
};
vector<zapros> vv;
long long aa[5555];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) aa[i] = inf;
for (int i = 0; i < m; i++) {
zapros zz;
cin >> zz.op >> zz.x >> zz.y >> zz.ss;
zz.x--;
zz.y--;
vv.push_back(zz);
}
for (int i = vv.size() - 1; i >= 0; i--) {
zapros zz = vv[i];
if (zz.op == 1) {
for (int j = zz.x; j <= zz.y; j++) aa[j] -= zz.ss;
}
if (zz.op == 2) {
for (int j = zz.x; j <= zz.y; j++)
if (aa[j] > zz.ss) aa[j] = zz.ss;
}
}
long long check[5555];
for (int i = 0; i < n; i++) {
if (aa[i] == inf) aa[i] -= inf + inf1;
if (aa[i] > inf1) aa[i] -= inf;
check[i] = aa[i];
}
for (int i = 0; i < m; i++) {
zapros zz = vv[i];
if (zz.op == 1) {
for (int j = zz.x; j <= zz.y; j++) check[j] += zz.ss;
continue;
}
if (zz.op == 2) {
int my_max = check[zz.x];
for (int j = zz.x; j <= zz.y; j++)
if (check[j] > my_max) my_max = check[j];
if (my_max != zz.ss) {
cout << "NO";
return 0;
}
continue;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << aa[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct query {
int t, l, r, v;
};
int main(void) {
int N, M;
bool status = true;
scanf("%d%d", &N, &M);
set<int> val[N + 1];
vector<query> qq;
int added[N + 1], array[N + 1];
memset(added, 0, sizeof(added));
for (int i = 1; i <= M; i++) {
int t, l, r, v;
scanf("%d%d%d%d", &t, &l, &r, &v);
qq.push_back((query){t, l, r, v});
if (t == 1) {
for (int j = l; j <= r; j++) {
added[j] += v;
}
} else {
for (int j = l; j <= r; j++) {
val[j].insert(v - added[j]);
}
}
}
memset(added, 0, sizeof(added));
for (int i = 1; i <= N; i++) {
array[i] = *val[i].begin();
}
for (int i = 0; i < M; i++) {
int t = qq[i].t;
int l = qq[i].l;
int r = qq[i].r;
int v = qq[i].v;
if (t == 1) {
for (int j = l; j <= r; j++) {
added[j] += v;
}
} else {
bool valid = false;
for (int j = l; j <= r; j++) {
if (array[j] + added[j] == v) {
valid = true;
}
}
if (!valid) {
status = false;
}
}
}
if (!status) {
printf("NO\n");
return 0;
}
printf("YES\n%d", array[1]);
for (int i = 2; i <= N; i++) {
printf(" %d", array[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 11;
const long long INF = 1e9;
long long arr[N], limit[N];
int oper[N][4];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) limit[i] = INF;
for (int i = 0; i < m; ++i) {
int op, l, r, d;
scanf("%d %d %d %d", &op, &l, &r, &d);
oper[i][0] = op, oper[i][1] = l, oper[i][2] = r, oper[i][3] = d;
if (op == 1) {
for (int j = l; j <= r; ++j) arr[j] += d;
} else {
for (int j = l; j <= r; ++j) limit[j] = min(limit[j], d - arr[j]);
}
}
memset(arr, 0, sizeof(arr));
for (int i = 0; i < m; ++i) {
if (oper[i][0] == 1) {
for (int j = oper[i][1]; j <= oper[i][2]; ++j) arr[j] += oper[i][3];
} else {
long long ans = limit[oper[i][1]] + arr[oper[i][1]];
for (int j = oper[i][1]; j <= oper[i][2]; ++j) {
ans = max(ans, limit[j] + arr[j]);
}
if (ans != oper[i][3]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i) {
printf("%lld", limit[i]);
if (i != n)
printf(" ");
else
printf("\n");
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
int n, m, ans[5555], a[5555], t[5555], l[5555], r[5555], d[5555];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) ans[i] = 1000000000;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &t[i], &l[i], &r[i], &d[i]);
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) a[j] += d[i];
else
for (int j = l[i]; j <= r[i]; j++) ans[j] = min(ans[j], d[i] - a[j]);
}
memset(a, 0, sizeof(a));
bool FLAG = true;
for (int i = 1; i <= m; i++) {
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) a[j] += d[i];
if (t[i] == 2) {
int mx = -1000000000;
for (int j = l[i]; j <= r[i]; j++) mx = max(mx, ans[j] + a[j]);
if (mx != d[i]) FLAG = false;
}
}
if (FLAG) {
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
} else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline long long gcd(T x, T y) {
if (!y) return x;
return gcd(y, x % y);
}
long long a[5004], c[5004];
const long long VAL = 1000000000;
long long b[5004][5];
int main() {
long long n, i, j, m;
cin >> n >> m;
for (i = 1; i <= n; ++i) a[i] = 1LL << 60;
for (i = 1; i <= m; ++i) {
for (j = 1; j <= 4; ++j) cin >> b[i][j];
}
for (long long step = m; step; --step) {
if (b[step][1] == 2) {
for (i = b[step][2]; i <= b[step][3]; ++i)
if (a[i] > b[step][4]) a[i] = b[step][4];
} else {
for (i = b[step][2]; i <= b[step][3]; ++i) a[i] -= b[step][4];
}
}
memcpy(c, a, sizeof(a));
for (long long step = 1; step <= m; ++step) {
if (b[step][1] == 2) {
long long maxx = -1LL << 60;
for (i = b[step][2]; i <= b[step][3]; ++i) {
if (a[i] > maxx) maxx = a[i];
}
if (maxx != b[step][4]) {
cout << "NO\n";
return 0;
}
} else {
for (i = b[step][2]; i <= b[step][3]; ++i) a[i] += b[step][4];
}
}
cout << "YES\n";
for (i = 1; i <= n; ++i) cout << min(c[i], VAL) << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int S[5001], A[5001], X[5001];
int op[5001][4];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++) {
A[i] = 1000000000;
S[i] = 0;
}
for (int i = 0; i < m; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
op[i][0] = 1, op[i][1] = l;
op[i][2] = r;
op[i][3] = d;
for (int j = l; j < r + 1; j++) S[j] += d;
} else {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
op[i][0] = 2, op[i][1] = l;
op[i][2] = r;
op[i][3] = d;
for (int j = l; j < r + 1; j++) A[j] = min(A[j], d - S[j]);
}
}
for (int i = 1; i < n + 1; i++) {
X[i] = A[i];
}
for (int i = 0; i < m; i++) {
if (op[i][0] == 1) {
for (int j = op[i][1]; j < op[i][2] + 1; j++) {
A[j] += op[i][3];
}
} else {
int M = -1000000000;
for (int j = op[i][1]; j < op[i][2] + 1; j++) {
M = max(M, A[j]);
}
if (M != op[i][3]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i < n + 1; i++) cout << X[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5005], n, m, diff[5005];
int cmd[5005], li[5005], ri[5005], z[5005];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i < (int)n + 1; i++) a[i] = 1000000000;
for (int i = 0; i < (int)m; i++) {
scanf("%d %d %d %d", &cmd[i], &li[i], &ri[i], &z[i]);
if (cmd[i] == 1)
for (int j = li[i]; j < (int)ri[i] + 1; j++) diff[j] += z[i];
else
for (int j = li[i]; j < (int)ri[i] + 1; j++)
a[j] = min(a[j], z[i] - diff[j]);
}
for (int i = 0; i < (int)m; i++) {
if (cmd[i] == 1) {
for (int j = li[i]; j < (int)ri[i] + 1; j++) a[j] += z[i];
} else {
int m = -1000000000;
for (int j = li[i]; j < (int)ri[i] + 1; j++) m = max(m, a[j]);
if (m != z[i]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
printf("%d", a[1] - diff[1]);
for (int i = 2; i < (int)n + 1; i++) printf(" %d", a[i] - diff[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[5100], n, m, was[5100], a[5100];
vector<pair<pair<int, int>, pair<int, int> > > q;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int type;
cin >> type;
if (type == 1) {
int l, r, add;
cin >> l >> r >> add;
for (int j = l; j <= r; j++) d[j] += add;
q.push_back(make_pair(make_pair(1, l), make_pair(r, add)));
} else {
int l, r, mx, w = 0;
cin >> l >> r >> mx;
for (int j = l; j <= r; j++) {
if (was[j] == 0) {
was[j] = 1;
a[j] = mx - d[j];
w = 1;
} else {
if (a[j] + d[j] >= mx) {
a[j] = mx - d[j];
w = 1;
}
}
}
if (w == 0) {
for (int j = l; j <= r; j++) a[j] = mx - d[j];
}
q.push_back(make_pair(make_pair(2, l), make_pair(r, mx)));
}
}
for (int i = 1; i <= n; i++) d[i] = 0;
for (int i = 0; i < q.size(); i++) {
if (q[i].first.first == 1) {
for (int j = q[i].first.second; j <= q[i].second.first; j++)
d[j] += q[i].second.second;
} else {
int mx = -(1 << 30);
for (int j = q[i].first.second; j <= q[i].second.first; j++)
mx = max(mx, a[j] + d[j]);
if (mx != q[i].second.second) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline long long gcd(T x, T y) {
if (!y) return x;
return gcd(y, x % y);
}
long long a[5004], c[5004];
const long long VAL = 1000000000;
long long b[5004][5];
int main() {
long long n, i, j, m;
cin >> n >> m;
for (i = 1; i <= n; ++i) a[i] = 1LL << 60;
for (i = 1; i <= m; ++i) {
for (j = 1; j <= 4; ++j) cin >> b[i][j];
}
for (long long step = m; step; --step) {
if (b[step][1] == 2) {
for (i = b[step][2]; i <= b[step][3]; ++i)
if (a[i] > b[step][4]) a[i] = b[step][4];
} else {
for (i = b[step][2]; i <= b[step][3]; ++i) a[i] -= b[step][4];
}
}
memcpy(c, a, sizeof(a));
for (long long step = 1; step <= m; ++step) {
if (b[step][1] == 2) {
long long maxx = -VAL;
for (i = b[step][2]; i <= b[step][3]; ++i) {
if (a[i] > maxx) maxx = a[i];
}
if (maxx != b[step][4]) {
cout << "NO\n";
return 0;
}
} else {
for (i = b[step][2]; i <= b[step][3]; ++i) a[i] += b[step][4];
}
}
cout << "YES\n";
for (i = 1; i <= n; ++i) cout << min(VAL, c[i]) << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ma[5005], add[5005], a[5005];
int t[5005], l[5005], r[5005], d[5005];
int check() {
for (int i = 1; i <= n; i++) {
a[i] = ma[i];
}
long long N = 0;
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) a[j] += d[i];
} else {
N = -1000000000;
for (int j = l[i]; j <= r[i]; j++) {
N = max(N, a[j]);
}
if (N != d[i]) return 0;
}
}
return 1;
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
ma[i] = 1000000000;
add[i] = 0;
}
int yes = 1;
for (int i = 1; i <= m; i++) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
add[j] += d[i];
}
} else {
for (int j = l[i]; j <= r[i]; j++) {
ma[j] = min(ma[j], d[i] - add[j]);
}
}
if (!yes) break;
}
if (!check()) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << ma[i];
if (i == n)
cout << endl;
else
cout << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void print(char pt) { printf("%c\n", pt); }
inline void print(int pt) { printf("%d\n", pt); }
inline void print(long long pt) { printf("%I64d\n", pt); }
inline void print(double pt) { printf("%.20f\n", pt); }
inline void print(char pt[]) { printf("%s\n", pt); }
inline void print() { printf("\n"); }
inline int scan(int &pt) { return scanf("%d", &pt); }
inline int scan(char &pt) { return scanf("%c", &pt); }
inline int scan(long long &pt) { return scanf("%I64d", &pt); }
inline int scan(double &pt) { return scanf("%lf", &pt); }
inline int scan(char pt[]) { return scanf("%s", pt); }
using namespace std;
struct pii {
long long a, b, c, d;
} p[10000];
int n, m;
long long o[10000];
long long a[10000];
int main() {
scan(n);
scan(m);
for (int i = 1; i <= n; i++) {
o[i] = 1e9;
}
for (int i = 0; i < m; i++) {
scan(p[i].a);
scan(p[i].b);
scan(p[i].c);
scan(p[i].d);
}
for (int mm = 0; mm < m; mm++) {
if (p[mm].a == 1) {
for (int i = p[mm].b; i <= p[mm].c; i++) {
a[i] += p[mm].d;
}
} else {
for (int i = p[mm].b; i <= p[mm].c; i++) {
o[i] = min(o[i], p[mm].d - a[i]);
}
}
}
memcpy(a, o, sizeof(long long) * (n + 1));
for (int mm = 0; mm < m; mm++) {
if (p[mm].a == 1) {
for (int i = p[mm].b; i <= p[mm].c; i++) {
a[i] += p[mm].d;
}
} else {
long long maxa = -(1ll << 60);
for (int i = p[mm].b; i <= p[mm].c; i++) {
maxa = max(maxa, a[i]);
}
if (maxa != p[mm].d) {
print("NO");
exit(0);
}
}
}
print("YES");
for (int i = 1; i <= n; i++) {
print(o[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e8 + 1e5;
int main() {
long long t, i, j, k, ans, n;
t = 1;
while (t--) {
cin >> n >> k;
vector<long long> v(n + 1, inf), ty(k), l(k), r(k), b(k), c(n + 1);
for (long long p = 0; p < k; p++) {
cin >> ty[p] >> l[p] >> r[p] >> b[p];
}
for (long long p = k - 1; p >= 0; p--) {
if (ty[p] == 1) {
for (long long q = l[p]; q < r[p] + 1; q++) v[q] -= b[p];
} else {
for (long long q = l[p]; q < r[p] + 1; q++) v[q] = min(v[q], b[p]);
}
}
for (long long p = 0; p < n + 1; p++) c[p] = v[p];
for (long long p = 0; p < k; p++) {
if (ty[p] == 1) {
for (long long q = l[p]; q < r[p] + 1; q++) v[q] += b[p];
} else {
long long ma = -inf;
for (long long q = l[p]; q < r[p] + 1; q++) ma = max(ma, v[q]);
if (ma != b[p]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (long long p = 1; p < n + 1; p++) cout << c[p] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long A[5000 + 5], B[5000 + 5];
bool vis[5000 + 5];
int main() {
int n, m, t, L, R, d;
scanf("%d%d", &n, &m);
vector<vector<int> > v(m);
vector<vector<int> > cop(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", &t, &L, &R, &d);
v[i].push_back(t);
v[i].push_back(L);
v[i].push_back(R);
v[i].push_back(d);
}
cop = v;
reverse(v.begin(), v.end());
bool vale = 1;
for (int i = 0; i < m; ++i) {
bool entra = 0;
if (v[i][0] == 1) {
int izq = v[i][1], der = v[i][2], dis = v[i][3];
entra = 1;
for (int j = izq; j <= der; ++j) {
if (vis[j]) {
A[j] -= dis;
}
}
} else {
int izq = v[i][1], der = v[i][2], maxi = v[i][3];
for (int j = izq; j <= der; ++j) {
if (!vis[j]) {
entra = 1;
A[j] = maxi;
vis[j] = 1;
} else {
if (A[j] >= (long long)maxi) {
entra = 1;
A[j] = maxi;
}
}
}
}
if (!entra) vale = 0;
}
if (!vale)
puts("NO");
else {
for (int i = 1; i <= n; ++i) {
if (!vis[i]) A[i] = 0;
}
for (int i = 1; i <= n; ++i) {
B[i] = A[i];
if (abs(A[i]) > 1000000000LL) {
puts("NO");
return 0;
}
}
for (int i = 0; i < m; ++i) {
if (cop[i][0] == 1) {
int izq = cop[i][1], der = cop[i][2], dis = cop[i][3];
for (int j = izq; j <= der; ++j) {
A[j] += dis;
}
} else {
int izq = cop[i][1], der = cop[i][2], maxi = cop[i][3];
long long maximo = A[izq];
for (int j = izq + 1; j <= der; ++j) {
maximo = max(maximo, A[j]);
}
if (maximo != maxi) vale = 0;
}
}
if (!vale)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; ++i) {
if (i == 1)
cout << B[i];
else
cout << " " << B[i];
}
puts("");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, f, w;
} q[5555];
int n, m, ans1[5555], ans2[5555];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d%d%d", &q[i].f, &q[i].l, &q[i].r, &q[i].w);
for (int i = 1; i <= n; i++) ans1[i] = 1000000000;
for (int i = m; i >= 1; i--) {
if (q[i].f == 1) {
for (int j = q[i].l; j <= q[i].r; j++) {
if (ans1[j] != 1000000000) ans1[j] -= q[i].w;
}
} else {
for (int j = q[i].l; j <= q[i].r; j++) {
if (ans1[j] > q[i].w) ans1[j] = q[i].w;
}
}
}
for (int i = 1; i <= n; i++) ans2[i] = ans1[i];
int flag = 1;
for (int i = 1; i <= m; i++) {
if (q[i].f == 1) {
for (int j = q[i].l; j <= q[i].r; j++) {
ans1[j] += q[i].w;
}
} else {
int maxn = -1000000000;
for (int j = q[i].l; j <= q[i].r; j++) {
if (ans1[j] > maxn) maxn = ans1[j];
}
if (maxn != q[i].w) {
flag = 0;
break;
}
}
}
if (!flag)
printf("NO\n");
else {
printf("YES\n");
printf("%d", ans2[1]);
for (int j = 2; j <= n; j++) printf(" %d", ans2[j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int ty, l, r, d;
} a[5005];
long long num[5005];
long long ans[5005];
const long long inf = 999999999999999;
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) num[i] = inf;
for (int i = 1; i <= m; i++) {
int ty, l, r, d;
scanf("%d%d%d%d", &ty, &l, &r, &d);
a[i].ty = ty;
a[i].l = l;
a[i].r = r;
a[i].d = d;
}
for (int i = m; i >= 1; i--) {
long long ty, l, r, d;
ty = a[i].ty;
l = a[i].l;
r = a[i].r;
d = a[i].d;
if (ty == 1) {
for (int j = l; j <= r; j++) {
if (num[j] != inf) num[j] -= d;
}
} else {
for (int j = l; j <= r; j++) {
num[j] = min(d, num[j]);
}
}
}
int f = 1;
for (int i = 1; i <= n; i++) {
if (num[i] == inf) num[i] = 0;
ans[i] = num[i];
}
for (int i = 1; i <= m; i++) {
int ty, l, r, d;
ty = a[i].ty;
l = a[i].l;
r = a[i].r;
d = a[i].d;
if (ty == 1) {
for (int j = l; j <= r; j++) {
num[j] += d;
}
} else {
long long maxn = -inf;
for (int j = l; j <= r; j++) {
maxn = max(maxn, num[j]);
}
if (maxn != d) {
f = 0;
break;
}
}
}
if (f == 1) {
printf("YES\n");
for (int i = 1; i < n; i++) printf("%lld ", ans[i]);
printf("%lld\n", ans[n]);
} else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int> > ops(m, vector<int>(4, 0));
for (int i = 0; i < m; ++i)
scanf("%d %d %d %d", &ops[i][0], &ops[i][1], &ops[i][2], &ops[i][3]);
vector<int> ans(n, 1000000000);
for (int i = m - 1; i >= 0; --i) {
int t = ops[i][0], l = ops[i][1], r = ops[i][2], p = ops[i][3];
if (t == 2) {
for (int j = l - 1; j < r; ++j) {
if (ans[j] == 1000000000)
ans[j] = p;
else if (ans[j] > p)
ans[j] = p;
}
} else
for (int j = l - 1; j < r; ++j)
if (ans[j] != 1000000000) ans[j] -= p;
}
vector<int> temp;
temp.assign(ans.begin(), ans.end());
for (int i = 0; i < m; ++i) {
int t = ops[i][0], l = ops[i][1], r = ops[i][2], p = ops[i][3];
if (t == 2) {
int max_e = temp[l - 1];
for (int j = l - 1; j < r; ++j) max_e = max(max_e, temp[j]);
if (max_e != p) {
printf("NO\n");
return 0;
}
} else
for (int j = l - 1; j < r; ++j) temp[j] += p;
}
printf("YES\n");
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct Query {
int t;
int l, r;
int v;
} q[N];
int x[N];
int main() {
int n, m;
int t, l, r, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> q[i].t >> q[i].l >> q[i].r >> q[i].v;
for (int i = 1; i <= n; i++) x[i] = 1e9;
for (int i = 1; i <= m; i++) {
if (q[i].t == 1) {
for (int j = q[i].l; j <= q[i].r; j++) x[j] += q[i].v;
} else {
for (int j = q[i].l; j <= q[i].r; j++)
if (x[j] >= q[i].v) x[j] = q[i].v;
}
}
bool ok = true;
for (int i = m; i >= 1; i--) {
if (q[i].t == 1) {
for (int j = q[i].l; j <= q[i].r; j++) x[j] -= q[i].v;
} else {
int mx = -1e9;
for (int j = q[i].l; j <= q[i].r; j++) mx = max(mx, x[j]);
if (mx != q[i].v) {
ok = false;
break;
}
}
}
if (!ok)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) cout << x[i] << (i == n ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 3;
const int INF = 2000000000;
inline long long ab(long long x) { return x < 0 ? -x : x; }
long long a[MAXN];
int c_a[MAXN];
int l[MAXN], r[MAXN], x[MAXN], t[MAXN];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
a[i] = INF;
}
for (int q = 0; q < m; q++) {
cin >> t[q] >> l[q] >> r[q] >> x[q];
--l[q], --r[q];
}
for (int q = m - 1; q >= 0; q--) {
if (t[q] == 1) {
for (int i = l[q]; i <= r[q]; i++) {
a[i] -= x[q];
}
} else {
bool found = false;
for (int i = l[q]; i <= r[q]; i++) {
if (a[i] >= x[q]) {
a[i] = x[q];
found = true;
}
}
if (!found) {
cout << "NO";
return 0;
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] < 0) {
if (ab(a[i]) > INF / 2) a[i] = -INF / 2;
} else {
if (a[i] > INF / 2) a[i] = INF / 2;
}
}
for (int i = 0; i < n; i++) {
c_a[i] = a[i];
}
for (int q = 0; q < m; q++) {
if (t[q] == 1) {
for (int i = l[q]; i <= r[q]; i++) {
a[i] += x[q];
}
} else {
long long maxv = -INF;
for (int i = l[q]; i <= r[q]; i++) {
maxv = max(maxv, a[i]);
}
if (maxv != x[q]) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
if (i > 0) cout << ' ';
cout << c_a[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dod[5005], t[5005];
int bylo[5005][4];
int main() {
int n, m, a, b, c, d, e, f, g, h;
scanf("%d%d", &n, &m);
for (a = 1; a <= n; a++) t[a] = 1000000000;
for (g = 0; g < m; g++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
bylo[g][0] = a;
bylo[g][1] = b;
bylo[g][2] = c;
bylo[g][3] = d;
if (a == 1) {
for (e = b; e <= c; e++) dod[e] += d;
} else {
for (e = b; e <= c; e++) t[e] -= max(0, t[e] + dod[e] - d);
}
}
for (a = 1; a <= n; a++) dod[a] = 0;
for (g = 0; g < m; g++) {
a = bylo[g][0];
b = bylo[g][1];
c = bylo[g][2];
d = bylo[g][3];
if (a == 1) {
for (e = b; e <= c; e++) dod[e] += d;
} else {
f = 0;
for (e = b; e <= c; e++) {
if (dod[e] + t[e] == d) f = 1;
if (dod[e] + t[e] > d) break;
}
if (f == 0 || e <= c) break;
}
}
if (g < m)
printf("NO");
else {
printf("YES\n");
for (a = 1; a <= n; a++) printf("%d ", t[a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cn[5005], ans[5005], t[5005], l[5005], r[5005], x[5005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, flag = 0;
cin >> n >> m;
for (int i = 0; i <= n; i++) ans[i] = 1e9;
for (int k = 0; k < m; k++) {
cin >> t[k] >> l[k] >> r[k] >> x[k];
if (t[k] == 1) {
for (int i = l[k]; i <= r[k]; i++) cn[i] += x[k];
} else {
for (int i = l[k]; i <= r[k]; i++) {
ans[i] = min(ans[i], x[k] - cn[i]);
}
}
}
memset(cn, 0, sizeof(cn));
for (int k = 0; k < m; k++) {
if (t[k] == 1) {
for (int i = l[k]; i <= r[k]; i++) cn[i] += x[k];
} else {
int mx = -0x3f3f3f3f;
for (int i = l[k]; i <= r[k]; i++) {
mx = max(mx, ans[i] + cn[i]);
}
if (mx != x[k]) {
flag = 1;
cout << "NO" << endl;
break;
}
}
}
if (!flag) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long com[5005], lft[5005], rgt[5005], val[5005], ar[5005], ans[5005];
bool chk[5005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) ans[i] = (long long)1e18;
for (int i = 1; i <= q; i++) {
cin >> com[i] >> lft[i] >> rgt[i] >> val[i];
}
for (int i = q; i >= 1; i--) {
if (com[i] == 1) {
for (long long j = lft[i]; j <= rgt[i]; j++) {
ans[j] -= val[i];
}
} else {
for (long long j = lft[i]; j <= rgt[i]; j++) {
ans[j] = min(ans[j], val[i]);
}
}
}
for (int i = 1; i <= n; i++) ar[i] = min(ans[i], (long long)1000000000);
for (int i = 1; i <= q; i++) {
if (com[i] == 1) {
for (long long j = lft[i]; j <= rgt[i]; j++) ar[j] += val[i];
} else {
long long mx = (long long)-(1e18);
for (long long j = lft[i]; j <= rgt[i]; j++) mx = max(mx, ar[j]);
if (mx != val[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
cout << min(ans[1], (long long)1e9);
for (int i = 2; i <= n; i++) cout << " " << min(ans[i], (long long)1e9);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct line {
int t, l, r, d;
} p[5010];
int n, m, ans[5010], che[5010];
bool flag;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &p[i].t, &p[i].l, &p[i].r, &p[i].d);
}
for (int i = 1; i <= n; i++) {
int k = 0, Min = 1000000000;
for (int j = 1; j <= m; j++) {
if (p[j].l <= i && p[j].r >= i) {
if (p[j].t == 1)
k += p[j].d;
else {
Min = min(p[j].d - k, Min);
}
}
}
che[i] = ans[i] = Min;
}
flag = true;
for (int i = 1; i <= m; i++) {
int Max = -1000000000;
for (int j = p[i].l; j <= p[i].r; j++)
if (p[i].t == 1)
che[j] += p[i].d;
else {
Max = max(Max, che[j]);
}
if (p[i].t == 2 && Max != p[i].d) {
flag = false;
break;
}
}
if (flag) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> t(m), l(m), r(m), val(m);
vector<int> ans(n + 1, 1000000000), sum(n + 1);
for (int i = 0; i < m; i++) {
cin >> t[i] >> l[i] >> r[i] >> val[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
sum[j] += val[i];
}
} else {
for (int j = l[i]; j <= r[i]; j++) {
ans[j] = min(ans[j], val[i] - sum[j]);
}
}
}
vector<int> sum2(n + 1);
bool flag = true;
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
sum2[j] += val[i];
}
} else {
int max_val = numeric_limits<int>::min();
for (int j = l[i]; j <= r[i]; j++) {
max_val = max(max_val, sum2[j] + ans[j]);
}
if (val[i] != max_val) {
flag = false;
break;
}
}
}
if (flag) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
} else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int FASTBUFFER;
int n, m, i, ll, rr, vv, j, Max;
int a[5005], b[5005], t[5005], l[5005], r[5005], v[5005], d[5005];
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) a[i] = 1000000000;
for (i = 1; i <= m; i++) {
scanf("%d %d %d %d", &t[i], &l[i], &r[i], &v[i]);
ll = l[i], rr = r[i], vv = v[i];
if (t[i] == 1) {
for (j = ll; j <= rr; j++) d[j] += vv;
} else {
for (j = ll; j <= rr; j++)
if (vv - d[j] < a[j]) a[j] = vv - d[j];
}
}
for (i = 1; i <= n; i++) b[i] = a[i];
for (i = 1; i <= m; i++) {
ll = l[i], rr = r[i], vv = v[i];
if (t[i] == 1) {
for (j = ll; j <= rr; j++) a[j] += vv;
} else {
Max = a[ll];
for (j = ll; j <= rr; j++)
if (a[j] > Max) Max = a[j];
if (Max != vv) break;
}
}
if (i <= m)
printf("NO\n");
else {
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d ", b[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[5000], flag[5000], a[5000], b[5000], c[5000], te[5000];
int main() {
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
int i, j;
for (i = 0; i <= n; i++) num[i] = 1000000009;
for (i = 1; i <= m; i++)
scanf("%d %d %d %d", &flag[i], &a[i], &b[i], &c[i]);
for (i = m; i >= 1; i--) {
if (flag[i] == 1) {
for (j = a[i]; j <= b[i]; j++) {
if (num[j] != 1000000009) num[j] -= c[i];
}
} else {
for (j = a[i]; j <= b[i]; j++) {
num[j] = min(num[j], c[i]);
}
}
}
for (i = 1; i <= n; i++) te[i] = num[i];
for (i = 1; i <= m; i++) {
if (flag[i] == 1) {
for (j = a[i]; j <= b[i]; j++) te[j] += c[i];
} else {
int temp = te[a[i]];
for (j = a[i] + 1; j <= b[i]; j++) temp = max(temp, te[j]);
if (temp != c[i]) break;
}
}
if (i <= m) {
printf("NO\n");
} else {
printf("YES\n");
for (i = 1; i <= n; i++) {
if (i != 1) printf(" ");
if (num[i] == 1000000009) num[i] -= 1000000;
printf("%d", num[i]);
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 5;
const int INF = 1e9;
int l[maxn], r[maxn], cmd[maxn], val[maxn], limit[maxn], temp[maxn];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) limit[i] = INF;
for (int i = 1; i <= m; i++)
scanf("%d%d%d%d", &cmd[i], &l[i], &r[i], &val[i]);
for (int i = m; i >= 1; i--) {
if (cmd[i] == 1) {
for (int j = l[i]; j <= r[i]; j++)
if (limit[j] != INF) {
limit[j] -= val[i];
}
} else {
for (int j = l[i]; j <= r[i]; j++) {
limit[j] = min(limit[j], val[i]);
}
}
}
for (int i = 1; i <= n; i++) temp[i] = limit[i];
int flag = 0;
for (int i = 1; i <= m; i++) {
if (cmd[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) temp[j] += val[i];
} else {
int max1 = -INF;
for (int j = l[i]; j <= r[i]; j++) {
max1 = max(max1, temp[j]);
}
if (max1 != val[i]) {
flag = 1;
break;
}
}
}
if (!flag) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", limit[i]);
printf("\n");
} else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int lim = 1000000000;
struct oper {
int op, lhs, rhs, num;
};
int main() {
int size, num_ops;
cin >> size >> num_ops;
vector<long long int> cur(size);
vector<pair<long long int, long long int>> limits(size, make_pair(-lim, lim));
vector<oper> ops(num_ops);
for (int n = 0; n < num_ops; n++) {
auto& cur = ops[n];
cin >> cur.op >> cur.lhs >> cur.rhs >> cur.num;
cur.lhs--;
cur.rhs--;
}
for (int n = 0; n < num_ops; n++) {
const auto& tmp = ops[n];
int op = tmp.op, lhs = tmp.lhs, rhs = tmp.rhs, num = tmp.num;
if (op == 1) {
for (int m = lhs; m <= rhs; m++) cur[m] += num;
} else if (op == 2) {
for (int m = lhs; m <= rhs; m++) {
limits[m].second = min(limits[m].second, num - cur[m]);
}
}
}
bool ok = true;
for (int m = 0; m < size; m++)
if (limits[m].second < limits[m].first) {
ok = false;
break;
}
if (ok) {
for (int n = 0; n < size; n++) cur[n] = limits[n].second;
for (int n = 0; n < num_ops; n++) {
const auto& tmp = ops[n];
int op = tmp.op, lhs = tmp.lhs, rhs = tmp.rhs, num = tmp.num;
if (op == 1) {
for (int m = lhs; m <= rhs; m++) cur[m] += num;
} else if (op == 2) {
bool found_max = false;
for (int m = lhs; m <= rhs; m++) {
if (cur[m] == num) found_max = true;
}
if (!found_max) {
ok = false;
break;
}
}
}
}
if (ok) {
cout << "YES" << endl;
for (int n = 0; n < size; n++) cout << limits[n].second << " ";
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[50010], cnt[50010], d[50010], l[50010], r[50010], op[50010];
int main() {
int i, j;
scanf("%d%d", &n, &m);
memset(a, 0x3f, sizeof(a));
for (i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &op[i], &l[i], &r[i], &d[i]);
if (op[i] == 1) {
for (j = l[i]; j <= r[i]; ++j) cnt[j] += d[i];
} else {
for (j = l[i]; j <= r[i]; ++j) a[j] = min(a[j], d[i] - cnt[j]);
}
}
for (i = 1; i <= n; ++i)
if (a[i] == 0x3f3f3f3f)
cnt[i] = a[i] = 0;
else
cnt[i] = a[i];
for (i = 1; i <= m; ++i) {
if (op[i] == 1)
for (j = l[i]; j <= r[i]; ++j) cnt[j] += d[i];
else {
int maxx = -0x3f3f3f3f;
for (j = l[i]; j <= r[i]; ++j) maxx = max(maxx, cnt[j]);
if (maxx != d[i]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5005], b[5005];
int k;
struct elem {
int t, l, r, m;
} p[5005];
int n, m;
bool solve() {
int i, j;
for (i = 1; i <= n; i++) a[i] = 1000000000;
memset(b, 0, sizeof(b));
for (i = 1; i <= m; i++) {
if (p[i].t == 1) {
for (j = p[i].l; j <= p[i].r; j++) b[j] += p[i].m;
} else if (p[i].t == 2) {
for (j = p[i].l; j <= p[i].r; j++) a[j] = min(a[j], p[i].m - b[j]);
}
}
memset(b, 0, sizeof(b));
for (i = 1; i <= m; i++) {
if (p[i].t == 1) {
for (j = p[i].l; j <= p[i].r; j++) b[j] += p[i].m;
} else if (p[i].t == 2) {
k = -1000000007;
for (j = p[i].l; j <= p[i].r; j++) k = max(k, a[j] + b[j]);
if (k != p[i].m) return false;
}
}
return true;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
int i;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &p[i].t, &p[i].l, &p[i].r, &p[i].m);
}
bool flag;
flag = solve();
if (!flag)
printf("NO");
else {
printf("YES\n");
for (i = 1; i <= n; i++)
i == 1 ? printf("%d", a[i]) : printf(" %d", a[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename G1, typename G2 = G1, typename G3 = G1>
struct triple {
G1 first;
G2 second;
G3 T, Fo;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<long long> mx(n, 1e9);
vector<long long> s(n);
vector<triple<long long> > queries;
for (int i = 0; i < m; i++) {
long long t, l, r, x;
cin >> t >> l >> r >> x;
--l;
--r;
queries.push_back({t, l, r, x});
if (t == 1) {
for (int j = l; j <= r; j++) s[j] += x;
} else {
for (int j = l; j <= r; j++) mx[j] = min(mx[j], x - s[j]);
}
}
vector<long long> ans = mx;
bool ok = true;
for (int i = 0; i < m; i++) {
long long t = queries[i].first;
long long l = queries[i].second;
long long r = queries[i].T;
long long x = queries[i].Fo;
if (t == 1) {
for (int j = l; j <= r; j++) mx[j] += x;
} else {
long long temp = -1e9;
for (int j = l; j <= r; j++) temp = max(mx[j], temp);
ok &= temp == x;
}
}
if (!ok)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << " \n"[i == n - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e+5 + 100;
const int INF = -1e+8;
struct oper {
int t;
int l, r;
int val;
};
int a[LIM];
int add[LIM];
oper o[LIM];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < LIM; i++) a[i] = INF;
for (int i = 0; i < m; i++) {
cin >> o[i].t >> o[i].l >> o[i].r >> o[i].val;
if (o[i].t == 1)
for (int q = o[i].l - 1; q < o[i].r; q++) add[q] += o[i].val;
else
for (int q = o[i].l - 1; q < o[i].r; q++) {
if (a[q] == INF || a[q] > o[i].val - add[q]) a[q] = o[i].val - add[q];
}
}
for (int i = 0; i < n; i++) add[i] = a[i];
for (int i = 0; i < m; i++) {
if (o[i].t == 1)
for (int q = o[i].l - 1; q < o[i].r; q++) add[q] += o[i].val;
else {
int _m = INF;
for (int q = o[i].l - 1; q < o[i].r; q++) _m = max(_m, add[q]);
if (_m != o[i].val) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << a[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
const int INF = 1000000000;
int ans[MAXN];
int add[MAXN];
int type[MAXN], l[MAXN], r[MAXN], delta[MAXN];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < (int)(n); ++i) ans[i] = INF;
for (int i = 0; i < (int)(m); ++i) {
scanf("%d %d %d %d", type + i, l + i, r + i, delta + i);
--l[i];
--r[i];
if (type[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) add[j] += delta[i];
} else {
for (int j = l[i]; j <= r[i]; ++j)
ans[j] = min(ans[j], delta[i] - add[j]);
}
}
for (int i = 0; i < (int)(n); ++i) add[i] = 0;
bool ok = true;
for (int i = 0; i < (int)(m); ++i) {
if (type[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) add[j] += delta[i];
} else {
int cmax = ans[l[i]] + add[l[i]];
for (int j = l[i]; j <= r[i]; ++j) {
cmax = max(cmax, ans[j] + add[j]);
}
if (cmax != delta[i]) ok = false;
}
}
if (ok) {
cout << "YES" << endl;
for (int i = 0; i < (int)(n); ++i) cout << ans[i] << " ";
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int a[N];
int b[N];
int delta[N][N];
int undef;
void fail() {
printf("NO\n");
exit(0);
}
struct Query {
int t, l, r, res;
Query(int t = 0, int l = 0, int r = 0, int res = 0) {
this->t = t;
this->l = l;
this->r = r;
this->res = res;
}
};
vector<Query> queries;
int n, m;
const bool D = 0;
int main() {
if (D) {
freopen("test.in", "r", stdin);
freopen("test.out", "w", stdout);
} else {
}
memset(a, 0x7F, sizeof(a));
undef = a[0];
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int t, l, r, res;
scanf("%d%d%d%d", &t, &l, &r, &res);
queries.push_back(Query(t, l, r, res));
if (i != 0)
for (int j = 1; j <= n; ++j) delta[i][j] = delta[i - 1][j];
if (t == 1) {
for (int j = l; j <= r; ++j) delta[i][j] += res;
} else {
for (int j = l; j <= r; ++j) {
a[j] = min(a[j], res - delta[i][j]);
}
}
}
for (int i = 1; i <= n; ++i) {
if (a[i] == undef) a[i] = 0;
b[i] = a[i];
}
for (vector<Query>::iterator i = queries.begin(); i != queries.end(); ++i) {
if (i->t == 1) {
for (int j = i->l; j <= i->r; ++j) b[j] += i->res;
} else {
int cmax = (-(int)1e9) - 1;
for (int j = i->l; j <= i->r; ++j) cmax = max(cmax, b[j]);
if (cmax != i->res) {
fail();
}
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct quer {
int typ, l, r, d;
} q[5009];
int a[5009], b[5009], diff[5009], final[5009];
int main() {
int i, j, t1, t2, t3, t4, n, m;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d %d %d", &q[i].typ, &q[i].l, &q[i].r, &q[i].d);
}
for (i = 1; i <= n; i++) {
diff[i] = 0;
b[i] = 1e9;
}
for (i = 0; i < m; i++) {
if (q[i].typ == 1) {
for (j = q[i].l; j <= q[i].r; j++) {
diff[j] += q[i].d;
}
} else {
for (j = q[i].l; j <= q[i].r; j++) {
b[j] = min(b[j], q[i].d - diff[j]);
}
}
}
for (i = 1; i <= n; i++) {
a[i] = b[i];
final[i] = a[i];
}
for (i = 0; i < m; i++) {
if (q[i].typ == 1) {
for (j = q[i].l; j <= q[i].r; j++) {
a[j] += q[i].d;
}
} else {
t1 = -2e9;
for (j = q[i].l; j <= q[i].r; j++) {
t1 = max(t1, a[j]);
}
if (t1 != q[i].d) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (i = 1; i <= n; i++) {
printf("%d ", final[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print(vector<int>& a) {
for (int i = 0; i < (int)a.size(); ++i) printf("%d ", a[i]);
puts("");
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n, 1000000000), v(n, 0);
vector<vector<int> > qur(m, vector<int>(4));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 4; ++j) {
scanf("%d", &qur[i][j]);
}
for (int k = qur[i][1] - 1; k < qur[i][2]; ++k) {
if (qur[i][0] == 1)
v[k] += qur[i][3];
else {
a[k] = min(a[k], qur[i][3] - v[k]);
}
}
}
fill(v.begin(), v.end(), 0);
for (int i = 0; i < m; ++i) {
bool ok = false;
for (int k = qur[i][1] - 1; k < qur[i][2]; ++k) {
if (qur[i][0] == 1)
v[k] += qur[i][3];
else {
if (a[k] + v[k] == qur[i][3]) ok = true;
}
}
if (qur[i][0] == 2 && !ok) {
puts("NO");
return 0;
}
}
puts("YES");
print(a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int d[5001];
int t[5001];
int l[5001];
int r[5001];
int x[5001];
vector<int> cl, cr, num, cx;
int eksi[5001];
int ek[5001][5001];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) d[i] = 1000000000;
for (int ad = 1; ad <= m; ad++) {
cin >> t[ad] >> l[ad] >> r[ad] >> x[ad];
if (t[ad] == 1)
for (int i = l[ad]; i <= r[ad]; i++) eksi[i] += x[ad];
else {
int ma = -1000000000;
for (int i = l[ad]; i <= r[ad]; i++) ma = max(ma, d[i] + eksi[i]);
if (ma < x[ad]) {
cout << "NO" << endl;
return 0;
} else
for (int i = l[ad]; i <= r[ad]; i++)
if (d[i] > x[ad] - eksi[i]) d[i] = x[ad] - eksi[i];
}
}
for (int i = 1; i <= n; i++) eksi[i] = d[i];
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) eksi[j] += x[i];
} else if (t[i] == 2) {
int ma = -1000000000;
for (int j = l[i]; j <= r[i]; j++) ma = max(ma, eksi[j]);
if (x[i] != ma) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << d[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class operation {
public:
int t, l, r, f;
};
int arr[5010], change[5010];
int n, m;
int main() {
scanf("%d %d", &n, &m);
operation op[6000];
for (int i = 0; i < n; i++) {
arr[i] = 1000000000;
change[i] = 0;
}
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &op[i].t, &op[i].l, &op[i].r, &op[i].f);
for (int j = op[i].l - 1; j < op[i].r; j++)
if (op[i].t == 1)
change[j] += op[i].f;
else
arr[j] = min(op[i].f - change[j], arr[j]);
}
bool valid = true;
for (int i = 0; i < n; i++) change[i] = 0;
for (int i = 0; i < m; i++)
if (op[i].t == 1)
for (int j = op[i].l - 1; j < op[i].r; j++) change[j] += op[i].f;
else {
int maxValue = -100000000;
for (int j = op[i].l - 1; j < op[i].r; j++)
maxValue = max(arr[j] + change[j], maxValue);
if (maxValue != op[i].f) {
valid = false;
break;
}
}
if (valid) {
printf("YES\n%d", arr[0]);
for (int i = 1; i < n; i++) printf(" %d", arr[i]);
printf("\n");
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Ans[5002], A[5002], add[5002], l[5002], r[5002], k[5002], d[5002];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= 5001; i++) A[i] = -0x3f3f3f3f3f3f3f3f;
for (int i = 0; i < m; i++) {
cin >> k[i] >> l[i] >> r[i] >> d[i];
if (k[i] == 1)
for (int j = l[i]; j <= r[i]; j++) add[j] += d[i];
else {
int flag = 0;
for (int j = l[i]; j <= r[i]; j++)
if (A[j] != -0x3f3f3f3f3f3f3f3f && d[i] > A[j] + add[j])
continue;
else
A[j] = d[i] - add[j], flag = 1;
if (flag == 0) {
cout << "NO\n";
return 0;
}
}
}
for (int i = 0; i <= 5001; i++) Ans[i] = A[i];
for (int i = 0; i < m; i++) {
if (k[i] == 1)
for (int j = l[i]; j <= r[i]; j++) A[j] += d[i];
else {
int ans = -0x3f3f3f3f3f3f3f3f;
for (int j = l[i]; j <= r[i]; j++)
if (A[j] > ans) ans = A[j];
if (ans != d[i]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++)
if (Ans[i] != -0x3f3f3f3f3f3f3f3f)
cout << Ans[i] << " ";
else
cout << 0 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int inf = 100000000;
const int maxn = 5100;
struct Operation {
int type, lf, rt, val;
} op[maxn];
int a[maxn];
int b[maxn];
bool legal() {
for (int i = 0; i < n; ++i) b[i] = a[i];
for (int i = 0; i < m; ++i) {
if (op[i].type == 1) {
for (int j = op[i].lf; j <= op[i].rt; ++j) b[j] += op[i].val;
} else {
int mx = *max_element(b + op[i].lf, b + op[i].rt + 1);
if (mx < op[i].val) return false;
}
}
return true;
}
void solve() {
for (int i = m - 1; i >= 0; --i) {
if (op[i].type == 1) {
for (int j = op[i].lf; j <= op[i].rt; ++j) {
a[j] -= op[i].val;
}
} else {
for (int j = op[i].lf; j <= op[i].rt; ++j) a[j] = min(a[j], op[i].val);
}
}
if (legal()) {
cout << "YES" << endl;
for (int i = 0; i < n; ++i) cout << a[i] << " ";
cout << endl;
} else
cout << "NO" << endl;
}
int main() {
fill_n(a, maxn, inf);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
scanf("%d %d %d %d", &op[i].type, &op[i].lf, &op[i].rt, &op[i].val);
op[i].lf--;
op[i].rt--;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename X>
ostream& operator<<(ostream& x, const vector<X>& v) {
for (long long i = 0; i < v.size(); ++i) x << v[i] << " ";
return x;
}
template <typename X>
ostream& operator<<(ostream& x, const set<X>& v) {
for (auto it : v) x << it << " ";
return x;
}
template <typename X, typename Y>
ostream& operator<<(ostream& x, const pair<X, Y>& v) {
x << v.ff << " " << v.ss;
return x;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const unordered_map<T, S>& v) {
for (auto it : v) os << it.first << "=>" << it.second << endl;
return os;
}
struct pair_hash {
inline std::size_t operator()(
const std::pair<long long, long long>& v) const {
return v.first * 31 + v.second;
}
};
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC targett("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
bool cmp(pair<pair<int, int>, pair<int, int>> a,
pair<pair<int, int>, pair<int, int>> b) {
return a.second.first - a.first.second < b.second.first - b.first.second;
}
int main() {
int n, m;
cin >> n >> m;
int mm = m;
int udp[n];
memset(udp, 0, sizeof udp);
int a[n];
int fans[n];
for (long long i = 0; i < n; i++) {
a[i] = 1000000007 - 7;
fans[i] = -1000000007;
}
pair<pair<int, int>, pair<int, int>> qu[m];
bool ans = true;
int ii = 0;
while (mm--) {
int tc, l, r, val;
cin >> tc >> l >> r >> val;
--l;
--r;
qu[ii++] = {{tc, l}, {r, val}};
if (tc == 1) {
for (long long i = l; i < r + 1; i++) {
udp[i] += val;
}
} else {
for (long long i = l; i < r + 1; i++) {
a[i] = min(a[i], val - udp[i]);
}
}
}
if (!ans) {
cout << "NO" << endl;
return 0;
}
int b[n];
for (long long i = 0; i < n; i++) {
b[i] = a[i];
}
for (long long j = 0; j < m; j++) {
if (qu[j].first.first == 1) {
for (long long i = qu[j].first.second; i < qu[j].second.first + 1; i++) {
a[i] += qu[j].second.second;
}
continue;
}
int mx = -1000000007;
for (long long i = qu[j].first.second; i < qu[j].second.first + 1; i++) {
mx = max(mx, a[i]);
}
if (mx != qu[j].second.second) {
cout << "NO" << endl, exit(0);
;
}
}
cout << "YES" << endl;
for (long long i = 0; i < n; i++) {
cout << b[i] << " ";
};
}
|
#include <cstdlib>
#include <cstdarg>
#include <cassert>
#include <cctype> // tolower
#include <ctime>
#include <cmath>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <stdexcept>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <vector>
#include <string>
#include <limits>
#include <utility>
#include <numeric>
#include <iterator>
#include <algorithm>
#include <functional>
/*
* g++ -g -std=c++11 -DBUG -D_GLIBCXX_DEBUG -Wall -Wfatal-errors -o cforce{,.cpp}
* g++ -g -DBUG -D_GLIBCXX_DEBUG -Wall -Wfatal-errors -o cforce{,.cpp}
*
* TODO:
* C++ dataframe
* stl11 -> c++11 standard template lib in c++98
* overload >> for map and set, using (insert) iterator
* chmod:: consider an algorithm stable to int64 overflow
* shortest path algorithm
* shortest path in a tree
* maximum network flow
* partial idx/iter sort
* a prime number generator which traverses prime numbers w/ ++
* a divisor generator which traverses divisors efficiently
* Apply1st ?!
* Apply2nd and bind2nd ?!
* count_if ( a.begin(), a.end(), a.second < x )
* Arbitrary-precision arithmetic / Big Integer / Fraction - rational num
* tuple class --> cplusplus.com/reference/tuple
* get<1>, get<2>, bind2nd ( foo ( get<2> pair ), val )
* isin( const T & val, first, last )
* fuinction composition in c++
* blogea.bureau14.fr/index.php/2012/11/function-composition-in-c11/
* cpp-next.com/archive/2010/11/expressive-c-fun-with-function-composition/
* TimeWrapper -- accumulate time of a function call
* stackoverflow.com/questions/879408
* hash map -- possible hash value & obj % some_big_prime [ b272 ]
* lower level can be a simple map to resolve hash collisions
* add explicit everywhere necessary
* bloom filters
* heap -> how to update values in place / increase-key or decrease-key ... IterHeap ?!
* median maintaince --> max_heap / min_heap
* prim's min spaning tree alg. O ( m log n ) using heap contianing V - X vertices
* kruskal algorithm minimum cost spanning tree with union find data structure
* unique_ptr
* hufman codes
* simple arithmatic tests
* longest common subsequence using seq. alignment type algorithm
* longest common substring ( consequative subsequeance )
*/
/*
* @recepies
* ----------------------------------------------
* odd / even
* transform ( x.begin(), x.end(), x.begin(), bind2nd( modulus<int>(), 2 ));
* count_if ( x.begin(), x.end(), bind2nd( modulus < int > (), 2));
* Apply2nd
* max_element ( m.begin(), m.end(), Apply2nd < string, int , less < int > > )
* sort ( a.begin(), a.end(), Apply2nd < char, int , greater< int > > )
* count_if ( m.begin(), m.end(), Apply2nd < string, int, modulus < int > > )
* accumulate ( m.begin(), m.end(), 0.0, Apply2nd < int, double, plus < double > > )
* accumulate ( m.begin( ), m.end( ), pair < int, double> ( 0 , 0.0 ) , operator+ < int, double > )
* abs_diff
* adjacent_difference ( a.begin(), a.end(), adj_diff.begin( ), abs_diff < int > ( ) )
* accumulate ( a.begin(), a.end(), 0, abs_diff < int > ( ) )
* erase
* a.erase ( remove_if ( a.begin( ), a.end( ), bind2nd ( less < int >( ), 0 ) ), a.end( ) )
* a.erase ( remove ( a.begin( ), a.end( ), b.begin( ), b.end( ) ), a.end ( ) )
* binding
* bind2nd ( mem_fun_ref (& ClassName::m_func ), arg ) // binds the argument of the object
* iterator generators
* generate_n ( back_inserter ( a ), n, rand ); // calls push_back
* generate_n ( inserter( a, a.begin( ) + 5 ), 10, RandInt( 0 , 100 ) ) // calls insert
* copy ( foo.begin( ), foo.end( ), insert_iterator < std::list < double > > ( bar, bar.begin( ) + 5 ))
* copy ( a.begin( ), a.end( ), ostream_iterator < double > ( cout, ", " ))
* accumulate ( m.begin( ), m.end( ), pair < int, double> ( 0 , 0.0 ) , operator+ < int, double > )
* transform (numbers.begin(), numbers.end(), lengths.begin(), mem_fun_ref(&string::length));
*/
/*
* @good read
* ----------------------------------------------
* [ partial ] template specialization
* cprogramming.com/tutorial/template_specialization.html
* function composition
* cpp-next.com/archive/2010/11/expressive-c-fun-with-function-composition
*/
/*
* @prob set
* ----------------------------------------------
* purification --> c330
*/
/*
* @limits
* ----------------------------------------------
* int 31 2.14e+09
* long int 31 2.14e+09
* unsigned 32 4.29e+09
* long unsigned 32 4.29e+09
* size_t 32 4.29e+09
* long long int 63 9.22e+18
* long long unsigned 64 1.84e+19
*/
/*
* issues
* ----------------------------------------------
* stackoverflow.com/questions/10281809
* mem_fun -> func_obj ( pointer to instance, origanal argument )
* bind1st ( mem_fun ( & ClassName::m_func ), this ) // binds obj of the class
* bind1st takes 'const T &' as the first argument
*/
/*
* typedef / define
* ----------------------------------------------
*/
typedef long long int int64;
typedef unsigned long long int uint64;
#define DOUBLE_INF std::numeric_limits< double >::infinity()
#define DOUBLE_NAN std::numeric_limits< double >::quiet_NaN()
#define DECLARE( X ) \
typedef shared_ptr < X > X ## _shared_ptr; \
typedef const shared_ptr < X > X ## _const_shared_ptr;
#ifdef BUG
#define DEBUG(var) { std::cout << #var << ": " << (var) << std::endl; }
#define EXPECT(expr) if ( ! (expr) ) std::cerr << "Assertion " \
<< #expr " failed at " << __FILE__ << ":" << __LINE__ << std::endl;
#else
#define DEBUG(var)
#define EXPECT(expr)
#endif
#define DBG(v) std::copy( v.begin(), v.end(), std::ostream_iterator < typeof( *v.begin() )> ( std::cout, " " ) )
/*
* http://rootdirectory.de/wiki/SSTR()
* usage:
* SSTR( "x^2: " << x*x )
*/
#define SSTR( val ) dynamic_cast< std::ostringstream & >( std::ostringstream() << std::dec << val ).str()
/* https://www.quora.com/C++-programming-language/What-are-some-cool-C++-tricks */
// template <typename T, size_t N>
// char (&ArraySizeHelper(T (&array)[N]))[N];
// #define arraysize(array) (sizeof(ArraySizeHelper(array)))
/*
* forward decleration
* ----------------------------------------------
*/
class ScopeTimer;
/*
* functional utils
* ----------------------------------------------
*/
template < typename T >
struct abs_diff : std::binary_function < T, T, T >
{
typedef T value_type;
inline value_type operator( ) ( const value_type & x, const value_type & y ) const
{
return std::abs( x - y );
}
};
// template < class InputIterator, class T >
// class isin : public std::binary_function < InputIterator, InputIterator, bool >
// {
// public:
// typedef T value_type;
//
// isin ( const InputIterator & first, const InputIterator & last ):
// m_first ( first ), m_last ( last ) { }
//
// bool operator ( ) ( const value_type & val ) const
// {
// return std::find ( m_first, m_last, val ) != m_last;
// }
// private:
// const InputIterator m_first, m_last;
// }
template < typename value_type, typename cont_type >
class isin : public std::unary_function < value_type, bool >
{
public:
isin( const cont_type & vals ): m_vals ( vals ) { };
bool operator ( ) ( const value_type & x ) const
{
return std::find ( m_vals.begin( ), m_vals.end( ), x ) != m_vals.end( );
}
private:
const cont_type m_vals;
};
/*
* max_element, min_element, count_if ... on the 2nd element
* eg: max_element ( m.begin(), m.end(), Apply2nd < string, int , less < int > > )
*/
template < class T1, class T2, class BinaryOperation >
class Apply2nd : std::binary_function < typename std::pair < T1, T2 >,
typename std::pair < T1, T2 >,
typename BinaryOperation::result_type >
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename BinaryOperation::result_type result_type;
typedef typename std::pair < first_type, second_type > value_type;
inline result_type operator( ) ( const value_type & x, const value_type & y ) const
{
return binary_op ( x.second , y.second );
}
private:
BinaryOperation binary_op;
};
/*
* algo utils
* ----------------------------------------------
*/
template < class ForwardIterator, class T >
inline void fill_inc_seq ( ForwardIterator first, ForwardIterator last, T val )
{
for ( ; first != last; ++first, ++val )
* first = val;
}
template <class ForwardIterator, class InputIterator >
ForwardIterator remove ( ForwardIterator first, ForwardIterator last, InputIterator begin, InputIterator end )
{
ForwardIterator result = first;
for ( ; first != last; ++ first )
if ( find ( begin, end, *first ) == end )
{
*result = *first;
++result;
}
return result;
}
/* stackoverflow.com/questions/1577475 */
template < class RAIter, class Compare >
class ArgSortComp
{
public:
ArgSortComp ( const RAIter & first, Compare comp ): m_first ( first ), m_comp( comp ) { }
inline bool operator() ( const size_t & i, const size_t & j ) const
{
return m_comp ( m_first[ i ] , m_first[ j ] );
}
private:
const RAIter & m_first;
const Compare m_comp;
};
/*!
* usage:
* vector < size_t > idx;
* argsort ( a.begin( ), a.end( ), idx, less < Type > ( ) );
*/
template < class RAIter, class Compare >
void argsort ( const RAIter & first, const RAIter & last, std::vector < size_t > & idx, Compare comp )
{
const size_t n = last - first;
idx.resize ( n );
for ( size_t j = 0; j < n; ++ j )
idx[ j ] = j ;
std::sort ( idx.begin( ), idx.end( ), ArgSortComp< RAIter, Compare > ( first, comp ) );
}
template < class RAIter, class Compare >
class IterSortComp
{
public:
IterSortComp ( Compare comp ): m_comp ( comp ) { }
inline bool operator( ) ( const RAIter & i, const RAIter & j ) const
{
return m_comp ( * i, * j );
}
private:
const Compare m_comp;
};
/*!
* usage:
* vector < list < Type >::const_iterator > idx;
* itersort ( a.begin( ), a.end( ), idx, less < Type > ( ) );
*/
template <class INIter, class RAIter, class Compare>
void itersort ( INIter first, INIter last, std::vector < RAIter > & idx, Compare comp )
{
/* alternatively: stackoverflow.com/questions/4307271 */
idx.resize ( std::distance ( first, last ) );
for ( typename std::vector < RAIter >::iterator j = idx.begin( ); first != last; ++ j, ++ first )
* j = first;
std::sort ( idx.begin( ), idx.end( ), IterSortComp< RAIter, Compare > (comp ) );
}
/*
* string utils
* ----------------------------------------------
*/
inline void erase ( std::string & str, const char & ch )
{
std::binder2nd < std::equal_to < char > > isch ( std::equal_to < char > ( ), ch );
std::string::iterator iter = std::remove_if ( str.begin(), str.end(), isch );
str.erase ( iter, str.end() );
}
inline void erase ( std::string & str, const std::string & chrs )
{
isin < char, std::string > isin_chrs ( chrs );
std::string::iterator iter = std::remove_if ( str.begin(), str.end(), isin_chrs );
str.erase ( iter, str.end() );
}
template < typename value_type>
inline std::string val2str ( const value_type & x )
{
std::ostringstream sout ( std::ios_base::out );
sout << x;
return sout.str();
}
template < typename value_type>
inline value_type str2val ( const std::string & str )
{
std::istringstream iss ( str, std::ios_base::in );
value_type val;
iss >> val;
return val;
}
std::vector< std::string > tokenize ( const std::string & str, const char & sep )
{
/*!
* outputs empty tokens and assumes str does not start with sep
* corner cases:
* empty string, one char string,
* string starting/ending with sep, all sep, end with two sep
*/
std::vector < std::string > res;
std::string::const_iterator follow = str.begin( ),
lead = str.begin( );
while ( true )
{
while ( lead != str.end() && * lead != sep )
++ lead;
res.push_back ( std::string( follow, lead ) );
if ( lead != str.end ( ) )
follow = 1 + lead ++ ;
else
break;
}
return res;
}
/*!
* chunk a string into strings of size [ at most ] k
*/
void chunk ( const std::string::const_iterator first,
const std::string::const_iterator last,
const size_t k,
const bool right_to_left,
std::list < std::string > & str_list )
{
str_list.clear( );
if ( right_to_left )
/* chunk from the end of the string */
for ( std::string::const_iterator i, j = last; j != first; j = i )
{
i = first + k < j ? j - k : first;
str_list.push_back ( std::string ( i, j ) );
}
else
/* chunk from the begining of the string */
for ( std::string::const_iterator i = first, j; i != last; i = j )
{
j = i + k < last ? i + k : last;
str_list.push_back ( std::string ( i, j ) );
}
}
/*!
* next lexicographically smallest string
* within char set a..z
*/
std::string & operator++( std::string & s )
{
/* find the first char from right less than 'z' */
std::string::reverse_iterator j = find_if( s.rbegin( ), s.rend( ),
std::bind2nd( std::less < char > ( ), 'z' ));
if ( j != s.rend( ))
{
++ *j;
std::fill( s.rbegin( ), j, 'a' );
}
else
s.assign( s.length( ) + 1, 'a' );
return s;
}
/*!
* getline ( cin, str )
* requires ctrl-D
* cin >> str; does not pass after space char
*/
/*
* number utils
* ----------------------------------------------
*/
class BigInteger
{
#if ULONG_MAX <= 1 << 32
typedef long long unsigned val_type;
#else
typedef long unsigned val_type;
#endif
const static int WSIZE = 32;
const static val_type BASE = 1LL << WSIZE;
public:
private:
std::list < val_type > val; /* val[ 0 ] is most significant */
bool pos; /* true if sign is positive */
};
/**
* greatest common divisor - Euclid's alg.
*/
template < typename value_type > inline
value_type gcd ( value_type a, value_type b )
{
return ! b ? a : gcd( b, a % b );
// if ( a < 0 ) a = -a ;
// if ( b < 0 ) b = -b ;
// if ( a < b ) std::swap ( a, b );
/* corner case: one of the values is zero */
// if ( ! b ) return a;
// for ( value_type r = a % b; r ; r = a % b )
// {
// a = b;
// b = r;
// }
// return b;
}
namespace
{
template < class T >
std::pair < T, T > __extgcd ( const T & x0, const T & y0,
const T & x1, const T & y1,
const T & r0, const T & r1 )
{
const T q = r0 / r1;
const T r2 = r0 % r1;
if ( ! ( r1 % r2 ) )
return std::make_pair < T, T > ( x0 - q * x1, y0 - q * y1 );
const T x2 = x0 - q * x1;
const T y2 = y0 - q * y1;
return __extgcd ( x1, y1, x2, y2, r1, r2 );
}
}
/**
* extended euclidean algorithm: a x + b y = gcd( a, b)
* en.wikipedia.org/wiki/Extended_Euclidean_algorithm
*/
template < class value_type > inline
std::pair < value_type, value_type > extgcd ( value_type a, value_type b )
{
return a % b
? __extgcd < value_type > ( 1, 0, 0, 1, a, b )
: std::make_pair < value_type, value_type > ( 0, 1 );
}
/**
* modular multiplicative inverse
* en.wikipedia.org/wiki/Modular_multiplicative_inverse
*/
template < class value_type > inline
value_type modinv ( value_type a, value_type m )
{
const std::pair < value_type, value_type > coef ( extgcd( a, m ) );
/* a needs to be coprime to the modulus, or the inverse won't exist */
if ( a * coef.first + m * coef.second != 1 )
throw std::runtime_error ( val2str( a ) + " is not coprime to " + val2str( m ));
/* return a pos num between 1 & m-1 */
return ( m + coef.first % m ) % m;
}
inline bool isnan ( const double & a )
{
return ! ( a == a );
}
template < typename value_type >
inline value_type mini ( int n, ... )
{
va_list vl;
va_start (vl, n);
value_type res = va_arg ( vl, value_type );
for ( int i = 1; i < n; ++i ) {
const value_type val = va_arg ( vl, value_type );
res = std::min ( res, val );
}
va_end( vl );
return res;
}
template < typename value_type >
inline value_type maxi ( int n, ... )
{
va_list vl;
va_start (vl, n);
value_type res = va_arg ( vl, value_type );
for ( int i = 1; i < n; ++i ) {
const value_type val = va_arg ( vl, value_type );
res = std::max ( res, val );
}
va_end( vl );
return res;
}
// XXX look this up how is this implemented
template < class T >
inline int sign ( const T & x )
{
if ( x == T() )
return 0;
else if ( x < T() )
return -1;
else
return 1;
}
/*
* change moduluos from n to m
*/
std::string chmod ( std::string num, const unsigned n, const unsigned m )
{
const char * digit = "0123456789abcdefghijklmnopqrstuvwxyz";
std::transform ( num.begin(), num.end(), num.begin(), tolower );
isin < char, std::string > is_alpha_num ( digit );
assert ( find_if ( num.begin( ), num.end( ), std::not1 ( is_alpha_num ) ) == num.end( ));
unsigned long long int val ( 0 );
if ( n == 10U )
{
std::istringstream iss ( num, std::ios_base::in );
iss >> val;
}
else
for ( std::string::const_iterator iter = num.begin( ); iter != num.end( ); ++ iter )
val = val * n + ( 'a' <= *iter ? *iter - 'a' + 10U : *iter - '0');
if ( m == 10U )
{
std::ostringstream sout ( std::ios_base::out );
sout << val;
return sout.str ( );
}
else
{
std::string res;
for ( ; val ; val /= m )
res.push_back( digit [ val % m ] );
return res.length( ) ? std::string( res.rbegin( ), res.rend( )) : "0";
}
}
template < class value_type > /* a^n mod m */
value_type powmod ( value_type a, const value_type & n, const value_type & m )
{
if ( a == 1 || ! n )
return m != 1 ? 1 : 0;
value_type res = 1;
for ( value_type k = 1; k <= n; a = a * a % m, k = k << 1 )
if ( k & n )
res = ( res * a ) % m;
return res;
}
/*
* Fermat pseudoprime test
* www.math.umbc.edu/~campbell/Computers/Python/numbthy.py
* NOTE: since return type is bool, and powmod may break for ints,
* the argument is always casted to long long
*/
inline bool is_pseudo_prime ( const long long & a )
{
/* all the primes less than 1000 ( 168 primes )*/
const long long p [ ] = { 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,
79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,
163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,
241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,
337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,
431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,
521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,
617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,
719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,
823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,
929,937,941,947,953,967,971,977,983,991,997 };
const size_t n = sizeof( p ) / sizeof ( p[ 0 ] );
if ( a < p[ n - 1 ] + 1)
return std::binary_search ( p, p + n , a );
if ( std::find_if ( p, p + n, std::not1 ( std::bind1st ( std::modulus< long long >( ), a ))) != p + n )
return false;
const size_t k = a < 9006401LL ? 3 :
a < 10403641LL ? 4 :
a < 42702661LL ? 5 :
a < 1112103541LL ? 6 : 7;
for ( size_t j = 0; j < k; ++ j )
if ( powmod ( p[ j ], a - 1, a ) != 1 )
return false;
return true;
}
/*
* returns a sorted vector of all primes less than or equal to n
* maximum adj diff of all primes less than 1e5 is 72 ( 114 for 1e6 )
*/
template < typename value_type >
std::vector < value_type > get_primes ( const value_type n )
{
#ifdef BUG
ScopeTimer scope_timer ( "std::vector < value_type > get_primes ( const value_type n )" );
#endif
typedef typename std::vector < value_type >::iterator iterator;
std::vector < value_type > primes;
for ( value_type k = 2 ; k <= n; ++ k )
if ( is_pseudo_prime ( k ) )
{
const value_type sqrt_k = 1 + static_cast < value_type > ( sqrt ( k + 1 ) );
iterator iend = upper_bound ( primes.begin( ), primes.end( ), sqrt_k );
if ( find_if ( primes.begin( ), iend, std::not1 ( std::bind1st ( std::modulus< value_type >( ), k ) ) ) != iend )
continue;
primes.push_back ( k );
}
return primes;
}
template < class T >
inline std::list < std::pair < T, size_t > > get_prime_fact ( T a )
{
std::list < std::pair < T, size_t > > fac;
for ( T k = 2; a > 1; ++ k )
if ( ! ( a % k ) ) // no need to check if k is prime
{
size_t m = 0;
for ( ; ! ( a % k ) ; ++m, a/= k )
;
fac.push_back ( std::pair < T, size_t > ( k, m ) );
}
return fac;
}
template < class T >
T n_choose_k ( T n, T k )
{
if ( k > n )
return 0;
const T lb = std::min ( k, n - k ) + 1;
const T ub = n - lb + 1;
T res = 1, j = 2;
while ( n > ub && j < lb)
{
res *= n--;
while ( j < lb and ! (res % j) )
res /= j++;
}
while ( n > ub )
res *= n--;
return res;
}
/**
* median calculator, using two heaps
*/
template < class InputIter >
inline std::pair < typename InputIter::value_type, typename InputIter::value_type >
median ( InputIter first, InputIter last )
{
typedef typename InputIter::value_type value_type;
typedef std::pair< value_type, value_type > result_type;
/*
* max_heap:
* - the lower half of the elements
* - the biggest of such elements is on the top
*/
std::vector < value_type > max_heap, min_heap;
/*
* comp argument to heap algorithm should provide
* 'strict weak ordering'; in particular
* std::not2 ( std::less < value_type > )
* does not have such a strict weak ordering;
*/
std::less < value_type > max_heap_comp;
std::greater < value_type > min_heap_comp;
if ( first == last ) /* corner case: empty vector */
throw std::runtime_error ( "median of an empty vector is undefined!" );
InputIter iter = first;
max_heap.push_back ( * iter );
for ( ++iter ; iter != last; ++ iter )
if ( * iter < max_heap.front() )
{
max_heap.push_back ( * iter );
std::push_heap ( max_heap.begin(), max_heap.end(), max_heap_comp );
if ( min_heap.size() + 1 < max_heap.size() )
{
/* max_heap has got too large */
min_heap.push_back( max_heap.front() );
std::push_heap( min_heap.begin(), min_heap.end(), min_heap_comp );
std::pop_heap( max_heap.begin(), max_heap.end(), max_heap_comp );
max_heap.pop_back();
}
}
else
{
min_heap.push_back ( * iter );
std::push_heap ( min_heap.begin(), min_heap.end(), min_heap_comp );
if ( max_heap.size() + 1 < min_heap.size() )
{
/* min_heap has got too large */
max_heap.push_back( min_heap.front() );
std::push_heap( max_heap.begin(), max_heap.end(), max_heap_comp );
std::pop_heap( min_heap.begin(), min_heap.end(), min_heap_comp );
min_heap.pop_back();
}
}
DEBUG( max_heap );
DEBUG( min_heap );
return min_heap.empty( ) /* corner case: ++first = last */
? result_type ( *first, *first )
: result_type ( max_heap.size() < min_heap.size() ? min_heap.front() : max_heap.front(),
min_heap.size() < max_heap.size() ? max_heap.front() : min_heap.front() );
}
/*
* geometry util
* ----------------------------------------------
*/
struct xyPoint
{
double x, y;
xyPoint ( const double & a = .0, const double & b = .0 ): x ( a ), y( b ) { };
};
struct xyCircle
{
xyPoint center;
double radius;
};
std::ostream & operator<< ( std::ostream & out, const xyPoint & p )
{
out << '(' << p.x << ", " << p.y << ')';
return out;
}
std::istream & operator>> ( std::istream & ist, xyPoint & p )
{
ist >> p.x >> p.y;
return ist;
}
std::ostream & operator<< ( std::ostream & out, const xyCircle & o )
{
out << "{(" << o.center.x << ", " << o.center.y << ") " << o.radius << '}';
return out;
}
std::istream & operator>> ( std::istream & ist, xyCircle & o )
{
ist >> o.center.x >> o.center.y >> o.radius;
return ist;
}
inline double cartesian_dist ( const xyPoint & a, const xyPoint & b )
{
const double d = a.x - b.x;
const double e = a.y - b.y;
return std::sqrt ( d * d + e * e );
}
class xyLine
{
public:
xyLine ( const xyPoint & , const xyPoint & );
xyLine ( const double slope, const double intercept );
/*
* 'signed' orthogonal distance; the sign is useful
* to compare which side of the line the point is
*/
inline double orth_dist ( const xyPoint & ) const;
private:
double m_slope;
double m_intercept;
double m_normfac; /* normalization factor for orth_dist calc */
bool m_vertical; /* if the line is verticcal */
double m_xcross; /* x axis cross point for vertical line */
};
xyLine::xyLine ( const xyPoint & a, const xyPoint & b )
{
if ( a.x == b.x ) /* vertical line */
{
m_vertical = true;
m_xcross = a.x;
m_intercept = DOUBLE_NAN;
m_slope = DOUBLE_INF;
m_normfac = DOUBLE_NAN;
}
else
{
m_vertical = false;
m_xcross = DOUBLE_NAN;
m_slope = ( b.y - a.y ) / ( b.x - a.x );
m_intercept = a.y - m_slope * a.x;
m_normfac = std::sqrt ( m_slope * m_slope + 1.0 );
}
}
xyLine::xyLine ( const double slope, const double intercept ):
m_slope ( slope ), m_intercept ( intercept )
{
m_vertical = false;
m_xcross = DOUBLE_NAN;
m_normfac = std::sqrt ( m_slope * m_slope + 1.0 );
}
double xyLine::orth_dist ( const xyPoint & o ) const /* 'signed' orthogonal distance */
{
if ( m_vertical )
return o.x - m_xcross;
else
return ( m_slope * o.x - o.y + m_intercept ) / m_normfac;
}
inline double triangle_area ( const xyPoint & a, const xyPoint & b, const xyPoint & c )
{
const xyLine l ( a, b );
const double h = std::abs ( l.orth_dist ( c ) );
const double e = cartesian_dist ( a, b );
return h * e;
}
/*
* operator<< overrides
* ----------------------------------------------
*/
namespace
{
/* helper function to output containers */
template < typename T >
std::ostream & __output ( std::ostream & out, const T & a )
{
typedef typename T::const_iterator const_iterator;
out << "{ ";
// does not work for 'pair' value type
// std::copy ( a.begin( ), a.end( ), std::ostream_iterator < typename T::value_type > ( std::cout, ", " ));
for ( const_iterator iter = a.begin(); iter != a.end(); ++ iter )
out << ( iter != a.begin( ) ? ", " : "" ) << *iter ;
return out << " }";
}
}
template < typename key_type, typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::pair < key_type, value_type > & p)
{
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template < typename key_type, typename value_type, typename comp >
std::ostream & operator<< ( std::ostream & out, const std::map < key_type, value_type, comp > & m )
{
return __output ( out, m );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::set < value_type > & s )
{
return __output ( out, s );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::vector < value_type > & a )
{
return __output ( out, a );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::list < value_type > & a )
{
return __output ( out, a );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::vector < std::vector < value_type > > & a )
{
typedef typename std::vector < std::vector < value_type > >::const_iterator const_iterator;
for ( const_iterator iter = a.begin( ); iter != a.end( ); ++ iter )
out << '\n' << *iter ;
return out;
}
/*
* operator>> overrides
* ----------------------------------------------
*/
template < typename key_type, typename value_type >
std::istream & operator>> ( std::istream & in, std::pair < key_type, value_type > & p)
{
in >> p.first >> p.second;
return in;
}
template < typename value_type >
std::istream & operator>> ( std::istream & in, std::vector < value_type > & a )
{
typedef typename std::vector < value_type >::iterator iterator;
if ( ! a.size( ) )
{
size_t n;
in >> n;
a.resize( n );
}
for ( iterator iter = a.begin(); iter != a.end(); ++ iter )
in >> * iter;
return in;
}
/*
* readin quick utilities
* ----------------------------------------------
*/
// template < typename value_type >
// inline void readin ( std::vector < value_type > & a, size_t n = 0, std::istream & in = std::cin )
// {
// // if ( ! n ) std::cin >> n;
// if ( ! n ) in >> n ;
// a.resize ( n );
// // std::cin >> a;
// in >> a;
// }
// XXX consider removing
// template < typename key_type, typename value_type >
// inline void readin (std::vector < std::pair < key_type , value_type > > & a, size_t n = 0 )
// {
// if ( !n ) std::cin >> n;
// a.resize( n );
// std::cin >> a;
// }
/*
* pair utility
* ----------------------------------------------
*/
/*
* accumulate ( m.begin( ), m.end( ), pair < int, double> ( 0 , 0.0 ) , operator+ < int, double > );
* stackoverflow.com/questions/18640152
*/
template < typename T1, typename T2 >
inline std::pair < T1, T2 > operator+ ( const std::pair < T1, T2 > & a, const std::pair < T1, T2 > & b )
{
return std::make_pair < T1, T2 > ( a.first + b.first, a.second + b.second );
}
// template < class T1, class T2, class BinaryOperation >
// class Apply2nd : std::binary_function < typename std::pair < T1, T2 >,
// typename std::pair < T1, T2 >,
// typename BinaryOperation::result_type >
namespace
{
/*!
* helper template to do the work
*/
template < size_t J, class T1, class T2 >
struct Get;
template < class T1, class T2 >
struct Get < 0, T1, T2 >
{
typedef typename std::pair < T1, T2 >::first_type result_type;
static result_type & elm ( std::pair < T1, T2 > & pr ) { return pr.first; }
static const result_type & elm ( const std::pair < T1, T2 > & pr ) { return pr.first; }
};
template < class T1, class T2 >
struct Get < 1, T1, T2 >
{
typedef typename std::pair < T1, T2 >::second_type result_type;
static result_type & elm ( std::pair < T1, T2 > & pr ) { return pr.second; }
static const result_type & elm ( const std::pair < T1, T2 > & pr ) { return pr.second; }
};
}
template < size_t J, class T1, class T2 >
typename Get< J, T1, T2 >::result_type & get ( std::pair< T1, T2 > & pr )
{
return Get < J, T1, T2 >::elm( pr );
}
template < size_t J, class T1, class T2 >
const typename Get< J, T1, T2 >::result_type & get ( const std::pair< T1, T2 > & pr )
{
return Get < J, T1, T2 >::elm( pr );
}
/*
* graph utils
* ----------------------------------------------
*/
/*
* Dijkstra :: single-source shortest path problem for
* a graph with non-negative edge path costs, producing
* a shortest path tree
* en.wikipedia.org/wiki/Dijkstra's_algorithm
*/
template < typename DistType >
void Dijekstra ( const size_t & source,
const std::vector < std::list < size_t > > & adj, // adjacency list
const std::vector < std::vector < DistType > > & edge_len, // pair-wise distance for adjacent nodes
std::vector < DistType > & dist, // distance from the source
std::vector < size_t > prev ) // previous node in the shortest path tree
{
// TODO
}
// TODO http://en.wikipedia.org/wiki/Shortest_path_problem
// TODO Graph class, Weighted graph, ...
/*
* maximum cardinality matching in a bipartite graph
* G = G1 ∪ G2 ∪ {NIL}
* where G1 and G2 are partition of graph and NIL is a special null vertex
* https://en.wikipedia.org/wiki/Hopcroft-Karp_algorithm
*/
class HopcroftKarp
{
public:
HopcroftKarp ( const std::vector < std::list < size_t > > & adj,
const std::vector < bool > & tag );
size_t get_npair ( ) { return npair; };
std::map < size_t, size_t > get_map ( );
private:
bool mf_breadth_first_search ( ); // breadth first search from unpaired nodes in G1
bool mf_depth_first_search ( const size_t v ); // dfs w/ toggeling augmenting paths
const std::vector < std::list < size_t > > & m_adj; // adjacency list for each node
const std::vector < bool > & m_tag; // binary tag distinguishing partitions
size_t npair;
const size_t NIL; // special null vertex
const size_t INF; // practically infinity distance
std::vector < size_t > m_g1; // set of nodes with tag = true
std::vector < size_t > m_dist; // dist from unpaired vertices in G1
std::vector < size_t > m_pair;
};
std::map < size_t, size_t > HopcroftKarp::get_map ( )
{
std::map < size_t, size_t > m;
for ( size_t j = 0; j < m_pair.size( ); ++ j )
if ( m_pair[ j ] != NIL && m_tag[ j ])
m[ j ] = m_pair[ j ];
return m;
}
HopcroftKarp::HopcroftKarp ( const std::vector < std::list < size_t > > & adj,
const std::vector < bool > & tag ):
m_adj ( adj ),
m_tag ( tag ),
npair ( 0 ),
NIL ( adj.size( )),
INF ( adj.size( ) + 1 ),
m_dist ( std::vector < size_t > ( adj.size( ) + 1, INF)),
m_pair ( std::vector < size_t > ( adj.size( ), NIL )) // initially everything is paired with nil
{
assert ( m_adj.size() == m_tag.size() );
for ( size_t j = 0; j < tag.size( ); ++ j )
if ( tag[ j ] )
m_g1.push_back ( j );
while ( mf_breadth_first_search ( ) )
for ( std::vector < size_t >::const_iterator v = m_g1.begin( ); v != m_g1.end( ); ++ v )
if ( m_pair[ *v ] == NIL && mf_depth_first_search ( *v ) )
++ npair;
}
bool HopcroftKarp::mf_breadth_first_search( )
{
/* only nodes from g1 are queued */
std::queue < size_t > bfs_queue;
/* initialize queue with all unpaired nodes from g1 */
for ( std::vector < size_t >::const_iterator v = m_g1.begin( ); v != m_g1.end( ); ++v )
if ( m_pair[ *v ] == NIL )
{
m_dist[ *v ] = 0;
bfs_queue.push ( *v );
}
else
m_dist[ *v ] = INF;
m_dist[ NIL ] = INF;
/* find all the shortest augmenting paths to node nil */
while ( ! bfs_queue.empty() )
{
const size_t v = bfs_queue.front( );
bfs_queue.pop ( );
if ( m_dist[ v ] < m_dist[ NIL ] )
for ( std::list < size_t >::const_iterator u = m_adj[ v ].begin( ); u != m_adj[ v ].end( ); ++ u )
if ( m_dist[ m_pair[ * u ] ] == INF )
{
m_dist[ m_pair[ * u ] ] = m_dist[ v ] + 1;
bfs_queue.push ( m_pair[ * u ] );
}
}
return m_dist[ NIL ] != INF;
}
bool HopcroftKarp::mf_depth_first_search( const size_t v )
{
if ( v == NIL )
return true;
else
{
for ( std::list < size_t >::const_iterator u = m_adj[ v ].begin( ); u != m_adj[ v ].end( ); ++ u )
if ( m_dist[ m_pair[ *u ] ] == m_dist[ v ] + 1 && mf_depth_first_search( m_pair[ *u ] ))
{
/*
* there is an augmenting path to nil from m_pair[ *u ]
* and hence there is an augmenting path from v to u and
* u to to nil; therefore v and u can be paired together
*/
m_pair [ *u ] = v;
m_pair [ v ] = *u;
return true;
}
m_dist[ v ] = INF;
return false;
}
}
/*
* data-structure utility
* ----------------------------------------------
*/
template < class T, class Comp = std::less< T > >
class Heap /* less< T > --> max-heap */
{
typedef T value_type;
typedef typename std::vector < value_type >::size_type size_type;
public:
/*
* stackoverflow.com/questions/10387751
* possible work-around: a memebr pointer to m_val
*
* TODO: static/friend heapify ( val, & heap ) XXX O( n ) ?!
*/
Heap ( ): m_val ( std::vector < value_type > ( ) ) , m_comp ( Comp( ) ){ }
template < class InputIter >
Heap ( InputIter first, InputIter last ):
m_val ( std::vector < value_type > ( ) ) , m_comp( Comp( ) )
{
for ( ; first != last ; ++ first )
m_val.push_back ( * first );
std::make_heap( m_val.begin( ), m_val.end( ), m_comp );
}
/*!
* to avoid destroying heap property, front( )
* should always return a 'const' reference
*/
inline const value_type & front( ) const { return m_val.front( ); }
inline bool empty( ) const { return m_val.empty( ); }
inline size_type size( ) const { return m_val.size( ); }
inline void push ( const value_type & a )
{
m_val.push_back( a );
std::push_heap( m_val.begin( ), m_val.end( ), m_comp );
}
inline void pop( )
{
std::pop_heap ( m_val.begin( ), m_val.end( ), m_comp );
m_val.pop_back( );
}
// void sort( ) { std::sort_heap ( m_val.begin( ), m_val.end( ), m_comp ); }
// template < class X, class Y >
// friend std::ostream & operator<<( std::ostream & out, const Heap < X, Y> & heap );
private:
std::vector < value_type > m_val;
const Comp m_comp;
};
/*
* boost.org/doc/libs/1_54_0/libs/smart_ptr/shared_ptr.htm
*/
template < class Type >
class shared_ptr
{
typedef Type value_type;
public:
explicit shared_ptr ( value_type * p = NULL ) : ptr ( p ), count ( new size_t ( 1U ) ) { }
shared_ptr ( const shared_ptr < value_type > & sp ): ptr ( sp.ptr ), count ( sp.count ) { ++ * count; }
~ shared_ptr ( ) { release( ); }
bool operator== ( const shared_ptr < value_type > & sp ) { return ptr == sp.ptr; }
bool operator!= ( const shared_ptr < value_type > & sp ) { return ptr != sp.ptr; }
shared_ptr < value_type > & operator= ( const shared_ptr < value_type > & sp )
{
if ( this != & sp && ptr != sp.ptr )
{
release( );
ptr = sp.ptr;
count = sp.count;
++ * count;
}
return * this;
}
value_type * operator-> ( ) { return ptr ; }
value_type & operator* ( ) { return *ptr ; }
const value_type * operator-> ( ) const { return ptr ; }
const value_type & operator* ( ) const { return *ptr; }
void swap ( shared_ptr < value_type > & sp )
{
if ( this != &sp && ptr != sp.ptr )
{
std::swap ( ptr, sp.ptr );
std::swap ( count, sp.count );
}
}
private:
void release ( )
{
/* stackoverflow.com/questions/615355 */
-- * count;
if ( ! * count )
{
delete count;
delete ptr;
count = NULL;
ptr = NULL;
}
}
value_type * ptr;
size_t * count;
};
/*!
* union find data structure with
* - lazy unions
* - union by rank
* - path compression
*/
class UnionFind
{
public:
UnionFind( const size_t n ):
parent ( std::vector < size_t > ( n ) ), /* initialize each node as its own */
rank ( std::vector < size_t > ( n, 0 )) /* parent and set all the ranks to 0 */
{
for ( size_t j = 0; j < n; ++ j )
parent[ j ] = j ;
}
inline size_t find( const size_t s )
{
/*
* perform path compresion and add shortcut
* if parent[ s ] is not a root node
*/
const size_t p = parent[ s ];
return parent[ p ] == p ? p : parent[ s ] = find( p ) ;
}
inline void lazy_union ( size_t i, size_t j )
{
/* unions should be done on root nodes */
i = find( i );
j = find( j );
if ( i != j )
{
if ( rank [ i ] < rank[ j ] )
parent[ i ] = j;
else
{
parent[ j ] = i;
rank[ i ] += rank[ i ] == rank[ j ];
}
}
}
private:
std::vector < size_t > parent;
std::vector < size_t > rank;
};
// TODO XXX
// template < class NumType >
// unsigned num_hash_func ( const NumType & a )
// {
// // XXX what will happen in case of overflow?
// return static_cast < unsigned > ( a % 9973 ) % 9973 ;
// }
/*
* XXX: HashMap: map< Key, T > data [ 9973 ]
* data [ num_hash_func ( key ) ][ key ]
*/
/*
* testing util
* ----------------------------------------------
*/
// TODO add a preprocessor which automatically includes the funciton name, or __line__
// and disables if not in debug mode
/* prints the life length of the object when it goes out of scope */
class ScopeTimer
{
public:
ScopeTimer ( const std::string & msg = "" ): tic ( clock ( )), m_msg( msg ) { };
~ ScopeTimer ( )
{
const clock_t toc = clock();
const uint64 dt = 1000L * ( toc - tic ) / CLOCKS_PER_SEC;
const uint64 mil = dt % 1000L;
const uint64 sec = ( dt / 1000L ) % 60L;
const uint64 min = ( dt / 60000L ) % 60L;
const uint64 hrs = ( dt / 3600000L );
std::cout << '\n' << m_msg << "\n\telapsed time: ";
if ( hrs ) std::cout << hrs << " hrs, ";
if ( min ) std::cout << min << " min, ";
if ( sec ) std::cout << sec << " sec, ";
std::cout << mil << " mil-sec\n";
}
private:
typedef unsigned long long int uint64;
const clock_t tic;
const std::string m_msg;
};
class RandInt
{
public:
RandInt ( int a = 0, int b = 100 ): m ( a ), f ( static_cast < double > ( b - a ) / RAND_MAX ) { }
inline int operator() ( ) { return m + std::ceil ( f * rand( ) ); }
private:
const int m;
const double f;
};
class RandDouble
{
public:
RandDouble ( double a = 0.0, double b = 1.0 ): m ( a ), f ( ( b - a ) / RAND_MAX ) { }
inline double operator() ( ) { return m + f * rand( ); }
private:
const double m, f;
};
class Noisy
{
public:
Noisy ( std::string str ): msg ( str )
{
std::cout << " Noisy ( " << msg << " )\t@ " << this << std::endl;
}
~Noisy ( )
{
std::cout << "~Noisy ( " << msg << " )\t@ " << this << std::endl;
}
void beep ( )
{
std::cout << " beep ( " << msg << " )\t@ " << this << std::endl;
}
void beep ( ) const
{
std::cout << " const beep ( " << msg << " )\t@ " << this << std::endl;
}
private:
const std::string msg;
};
DECLARE ( Noisy );
/*
* ----------------------------------------------
* ----------------------------------------------
*/
/*
* -- @@@ -------------------------------------------------
*/
using namespace std;
struct comp
{
bool operator() ( const pair < int, int > & x, const pair < int, int > & y )
{
return abs( x.first ) + abs( x.second ) < abs( y.first ) + abs( y.second );
}
bool operator( ) ( const xyCircle & a, const xyCircle & b )
{
return a.radius < b.radius;
}
};
void prob_a( )
{
size_t n, k;
cin >> n >> k;
vector < unsigned > a ( n );
fill_n ( a.begin( ), min( n, k ), 1 );
if ( k > n )
a.back( ) += k - n;
for ( size_t i = 0; i < n; ++ i )
{
for ( size_t j = 0; j < n; ++ j )
{
if ( j > 0 )
cout << ' ';
cout << a[ ( i + j ) % n ];
}
cout << '\n';
}
}
void prob_b( )
{
size_t n, k;
cin >> n >> k;
if ( n == k )
{
cout << -1;
}
else
{
cout << n - k;
for ( size_t j = 1; j < n - k; ++ j )
cout << ' ' << j;
for ( size_t j = n - k + 1; j <= n; ++ j )
cout << ' ' << j;
}
}
void prob_c( )
{
size_t n, m;
cin >> n >> m;
vector < vector < int > > opr ( m, vector < int > ( 4 ) );
for ( size_t j = 0; j < m; ++ j )
cin >> opr[ j ];
DEBUG( opr );
const int64 INF = 1000000000; //numeric_limits< int64 >::max( );
vector < int64 > ub( n + 1, INF ), acc( n + 1, 0 );
for ( vector < vector < int > >::const_iterator iter = opr.begin( ); iter != opr.end( ); ++ iter )
if ( (*iter)[ 0 ] == 1 ) // addition operation
for ( size_t j = (*iter)[ 1 ]; j <= (*iter)[ 2 ]; ++ j )
acc[ j ] += (*iter)[ 3 ];
else // max operation
for ( size_t j = (*iter)[ 1 ]; j <= (*iter)[ 2 ]; ++ j )
ub[ j ] = min ( ub[ j ], (*iter)[ 3 ] - acc[ j ] );
DEBUG( ub );
DEBUG( acc );
// const int64 max_val = * max_element( val.begin( ), val.end( ) );
const int64 min_val = * min_element( ub.begin( ), ub.end( ) );
if ( min_val < - INF )
{
cout << "NO";
return;
}
// validate the conditions
vector < int64 > val( ub );
for ( vector < vector < int > >::const_iterator iter = opr.begin( ); iter != opr.end( ); ++ iter )
if ( (*iter)[ 0 ] == 1 ) // addition operation
for ( size_t j = (*iter)[ 1 ]; j <= (*iter)[ 2 ]; ++ j )
val[ j ] += (*iter)[ 3 ];
else // max operation
if ( (*iter)[ 3 ] != * max_element( val.begin( ) + (*iter)[ 1 ], val.begin( ) + (*iter)[ 2 ] + 1 ) )
{
cout << "NO";
return;
}
cout << "YES\n";
copy ( ub.begin( ) + 1, ub.end( ), ostream_iterator < int64 > ( cout, " " ) );
}
int main ( const int argc, char * argv [ ])
{
prob_c( );
// cout << 0;
// cout << setprecision( 10 )
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int maxe[5005];
long long int added[5005];
vector<int> color[5005];
int a[5005], b[5005], c[5005], d[5005];
set<int> st[5005];
bool removecolor(int node) {
for (int i = 0; i < color[node].size(); i++) {
st[color[node][i]].erase(node);
if (st[color[node][i]].size() == 0) return false;
}
color[node].clear();
return true;
}
int main() {
int i, n, m, j;
cin >> n >> m;
for (i = 0; i < n; i++) maxe[i] = 1000000000, added[i] = 0;
for (i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
if (a[i] == 1) {
for (j = b[i] - 1; j < c[i]; j++) maxe[j] += d[i], added[j] += d[i];
} else {
int count = 0;
for (j = b[i] - 1; j < c[i]; j++)
if (maxe[j] >= d[i]) count++;
if (count == 0) {
cout << "NO\n";
return 0;
}
for (j = (b[i] - 1); j < c[i]; j++) {
if (maxe[j] > d[i]) {
if (removecolor(j))
color[j].push_back(i), maxe[j] = d[i], st[i].insert(j);
else {
cout << "NO\n";
return 0;
}
} else if (maxe[j] == d[i])
color[j].push_back(i), st[i].insert(j);
}
}
for (j = 0; j < n; j++)
if (maxe[j] > 1000000000) {
if (removecolor(j))
maxe[j] = 1000000000;
else {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (i = 0; i < n; i++) cout << maxe[i] - added[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int l[5005], r[5005], x[5005], t[5005], a[5005], b[5005];
int main() {
int n, m, i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) b[i] = 1000000000;
for (i = 1; i <= m; i++) {
cin >> t[i] >> l[i] >> r[i] >> x[i];
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) a[j] += x[i];
} else {
for (j = l[i]; j <= r[i]; j++) b[j] = min(b[j], x[i] - a[j]);
}
}
memset(a, 0, sizeof(a));
for (i = 1; i <= m; i++) {
long long int mx = -1000000000;
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) a[j] += x[i];
} else {
for (j = l[i]; j <= r[i]; j++) {
mx = max(mx, b[j] + a[j]);
}
if (mx != x[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class It>
void dptab(It b, It e, const char* f = "%d ") {
if (1) {
for (It it = b; it != e; ++it)
if (1) {
printf("\033[31m");
printf(f, *it);
printf("\033[0m");
};
if (1) {
printf("\033[31m");
printf("\n");
printf("\033[0m");
};
}
}
struct instruction {
int type;
int l, r;
int x;
};
const int ADD = 1, MAX = 2;
int delta[5000];
int max_value[5000];
int n, m;
vector<instruction> instr;
bool check() {
vector<int> copy;
for (int i = (0); i < (n); ++i) copy.push_back(max_value[i]);
for (int i = (0); i < (m); ++i) {
instruction in = instr[i];
if (in.type == ADD) {
for (int j = (in.l); j < (in.r + 1); ++j) copy[j] += in.x;
} else {
int compute = -1e9;
for (int j = (in.l); j < (in.r + 1); ++j) compute = max(compute, copy[j]);
if (compute != in.x) return false;
}
}
return true;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = (0); i < (m); ++i) {
instruction in;
scanf("%d", &in.type);
scanf("%d", &in.l);
scanf("%d", &in.r);
scanf("%d", &in.x);
--in.l, --in.r;
instr.push_back(in);
}
for (int i = (0); i < (n); ++i) max_value[i] = 1e9;
for (int i = (0); i < (m); ++i) {
instruction in = instr[i];
if (in.type == ADD) {
for (int j = (in.l); j < (in.r + 1); ++j) delta[j] += in.x;
} else {
for (int j = (in.l); j < (in.r + 1); ++j)
max_value[j] = min(max_value[j], in.x - delta[j]);
}
}
if (check()) {
printf("YES\n");
for (int i = (0); i < (n); ++i) printf("%d ", max_value[i]);
printf("\n");
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct node {
int t, l, r, m;
} op[5005];
int a[5005], b[5005], n, m;
bool solve() {
int p, i, k;
for (i = 1; i <= n; i++) a[i] = 1000000000;
memset(b, 0, sizeof(b));
for (p = 1; p <= m; p++)
if (op[p].t == 1)
for (i = op[p].l; i <= op[p].r; i++) b[i] += op[p].m;
else
for (i = op[p].l; i <= op[p].r; i++) a[i] = min(a[i], op[p].m - b[i]);
memset(b, 0, sizeof(b));
for (p = 1; p <= m; p++)
if (op[p].t == 1)
for (i = op[p].l; i <= op[p].r; i++) b[i] += op[p].m;
else {
k = -1000000007;
for (i = op[p].l; i <= op[p].r; i++) k = max(k, a[i] + b[i]);
if (k != op[p].m) return false;
}
return true;
}
int main() {
int i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++)
scanf("%d%d%d%d", &op[i].t, &op[i].l, &op[i].r, &op[i].m);
if (!solve())
puts("NO");
else {
puts("YES");
for (i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
using namespace std;
long long flag[222222], l[222222], r[222222], answer[222222], ans2[222222],
ans[222222];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> flag[i] >> l[i] >> r[i] >> answer[i];
for (int i = 1; i <= n; i++) ans[i] = round(1e18);
for (int i = m; i >= 1; i--) {
if (flag[i] == 1) {
for (long long j = l[i]; j <= r[i]; j++) ans[j] = ans[j] - answer[i];
} else {
for (long long j = l[i]; j <= r[i]; j++)
if (ans[j] > answer[i]) ans[j] = answer[i];
}
}
for (int i = 1; i <= n; i++)
if (ans[i] > 1000000000) ans[i] = 1000000000;
for (int i = 1; i <= n; i++) ans2[i] = ans[i];
for (int i = 1; i <= m; i++) {
if (flag[i] == 1) {
for (long long j = l[i]; j <= r[i]; j++) ans2[j] = ans2[j] + answer[i];
} else {
long long max = -round(1e18);
for (long long j = l[i]; j <= r[i]; j++)
if (ans2[j] > max) max = ans2[j];
if (answer[i] != max) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int final[5010], v[5010];
struct Op {
int tip, st, dr, val;
};
Op op[5010];
int main() {
int i, j, maxim;
cin >> n >> m;
for (i = 1; i <= n; ++i) final[i] = 500000000;
for (i = 1; i <= m; ++i) {
cin >> op[i].tip >> op[i].st >> op[i].dr >> op[i].val;
if (op[i].tip == 1) {
for (j = op[i].st; j <= op[i].dr; ++j) final[j] += op[i].val;
} else {
for (j = op[i].st; j <= op[i].dr; ++j)
final[j] = min(final[j], op[i].val);
}
}
for (i = 1; i <= n; ++i) v[i] = final[i];
for (i = 1; i <= m; ++i) {
if (op[i].tip == 1) {
for (j = op[i].st; j <= op[i].dr; ++j) v[j] -= op[i].val;
}
}
for (i = 1; i <= n; ++i) final[i] = v[i];
for (i = 1; i <= m; ++i) {
if (op[i].tip == 1) {
for (j = op[i].st; j <= op[i].dr; ++j) final[j] += op[i].val;
} else {
maxim = final[op[i].st];
for (j = op[i].st; j <= op[i].dr; ++j) maxim = max(maxim, final[j]);
if (maxim != op[i].val) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (i = 1; i <= n; ++i) cout << v[i] << ' ';
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000, A = 1000000000;
const long long INF = 100000000000000000LL;
long long a[MAXN + 10];
struct pyt {
int t, l, r, v;
};
pyt p[MAXN + 10];
long long sum[MAXN + 10];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) {
a[i] = A;
}
for (int i = 0; i < (m); ++i) {
scanf("%d%d%d%d", &p[i].t, &p[i].l, &p[i].r, &p[i].v);
--p[i].l;
--p[i].r;
}
for (int i = 0; i < (m); ++i) {
if (p[i].t == 1) {
for (int j = p[i].l; j <= p[i].r; ++j) {
sum[j] += p[i].v;
}
} else {
for (int j = p[i].l; j <= p[i].r; ++j) {
a[j] = min(a[j], p[i].v - sum[j]);
}
}
}
for (int i = 0; i < (n); ++i) {
sum[i] = 0;
}
for (int i = 0; i < (m); ++i) {
if (p[i].t == 1) {
for (int j = p[i].l; j <= p[i].r; ++j) {
sum[j] += p[i].v;
}
} else {
long long mx = -INF;
for (int j = p[i].l; j <= p[i].r; ++j) {
mx = max(mx, a[j] + sum[j]);
}
if (mx != p[i].v) {
puts("NO");
return 0;
}
}
}
for (int i = 0; i < (n); ++i) {
if (a[i] < -A) {
puts("NO");
return 0;
}
}
puts("YES");
for (int i = 0; i < (n); ++i) {
printf("%d ", (int)a[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:256000000")
using namespace std;
const int N = 5010;
int a[N], b[N], d[N], t[N], l[N], r[N], x[N];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) a[i] = 1000000000;
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &t[i], &l[i], &r[i], &x[i]);
--l[i], --r[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
d[j] += x[i];
}
} else {
bool OK = 0;
for (int j = l[i]; j <= r[i]; j++) {
a[j] = min(a[j], x[i] - d[j]);
}
}
}
memcpy(b, a, sizeof(a));
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
b[j] += x[i];
}
} else {
if (*max_element(b + l[i], b + r[i] + 1) != x[i]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int t, l, r, x;
} p[5010];
int n, m;
int mx[5010], b[5010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d%d%d", &p[i].t, &p[i].l, &p[i].r, &p[i].x);
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; i++) mx[i] = 1000000000;
for (int i = 1; i <= m; i++)
if (p[i].t == 1)
for (int j = p[i].l; j <= p[i].r; j++) b[j] += p[i].x;
else {
for (int j = p[i].l; j <= p[i].r; j++) mx[j] = min(mx[j], p[i].x - b[j]);
}
bool flag = true;
for (int i = 1; i <= n; i++)
if (abs(mx[i]) > 1000000000) flag = false;
memset(b, 0, sizeof(b));
for (int i = 1; i <= m && flag; i++)
if (p[i].t == 1)
for (int j = p[i].l; j <= p[i].r; j++) b[j] += p[i].x;
else {
flag = false;
for (int j = p[i].l; j <= p[i].r; j++)
if (mx[j] + b[j] == p[i].x) flag = true;
}
if (flag) {
puts("YES");
for (int i = 1; i <= n; i++) {
printf("%d", mx[i]);
if (i < n)
printf(" ");
else
puts("");
}
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void desperate_optimization(int precision) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(precision);
}
const int N = 5000;
long long arr[N + 5];
vector<pair<pair<long long, long long>, pair<long long, long long> > > q;
inline long long valid(int x, long long y) {
for (int i = q.size() - 1; i >= 0; i--) {
int type = q[i].first.first;
int l = q[i].first.second;
int r = q[i].second.first;
long long ad = q[i].second.second;
if (l <= x && x <= r) {
if (type == 2) y = min(y, ad);
if (type == 1) y -= ad;
}
}
return y;
}
long long ST[4 * N + 5];
long long lazy[4 * N + 5];
inline void build(int idx, int l, int r) {
if (l == r) {
ST[idx] = arr[l];
return;
}
int mid = (l + r) / 2;
build(2 * idx, l, mid), build(2 * idx + 1, mid + 1, r);
ST[idx] = max(ST[2 * idx], ST[2 * idx + 1]);
}
inline void pushdown(int idx, int l, int r) {
if (lazy[idx] == 0) return;
if (l != r) {
lazy[2 * idx] += lazy[idx];
lazy[2 * idx + 1] += lazy[idx];
}
ST[idx] += lazy[idx];
lazy[idx] = 0;
}
inline long long query(int idx, int l, int r, int le, int ri) {
pushdown(idx, l, r);
if (r < le || ri < l) return -1e18;
if (le <= l && r <= ri) return ST[idx];
int mid = (l + r) / 2;
return max(query(2 * idx, l, mid, le, ri),
query(2 * idx + 1, mid + 1, r, le, ri));
}
inline void update(int idx, int l, int r, int le, int ri, long long v) {
pushdown(idx, l, r);
if (r < le || ri < l) return;
if (le <= l && r <= ri) {
lazy[idx] += v;
pushdown(idx, l, r);
return;
}
int mid = (l + r) / 2;
update(2 * idx, l, mid, le, ri, v),
update(2 * idx + 1, mid + 1, r, le, ri, v);
ST[idx] = max(ST[2 * idx], ST[2 * idx + 1]);
}
void hora(int tc) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int type, a, b, c;
scanf("%d%d%d%d", &type, &a, &b, &c);
q.push_back({{type, a}, {b, c}});
}
for (int i = 1; i <= n; i++) {
long long res = valid(i, 1e8);
if (res > 1e9 || res < -1e9) {
printf("NO\n");
return;
}
arr[i] = res;
}
build(1, 1, n);
for (int i = 0; i < m; i++) {
int type = q[i].first.first;
int l = q[i].first.second;
int r = q[i].second.first;
long long ad = q[i].second.second;
if (type == 2) {
long long x = query(1, 1, n, l, r);
if (x != ad) {
printf("NO\n");
return;
}
} else {
update(1, 1, n, l, r, ad);
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%lld ", arr[i]);
}
}
int main() {
desperate_optimization(10);
int ntc = 1;
for (int tc = 1; tc <= ntc; tc++) hora(tc);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[5100], l[5100], r[5100], d[5100], a[5100], s[5100], n, m;
void init() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) a[i] = 1e9;
for (int i = (1); i <= (m); ++i) {
scanf("%d%d%d%d", &t[i], &l[i], &r[i], &d[i]);
if (t[i] == 1)
for (int j = (l[i]); j <= (r[i]); ++j) s[j] += d[i];
else {
for (int j = (l[i]); j <= (r[i]); ++j) a[j] = min(a[j], d[i] - s[j]);
}
}
for (int i = (1); i <= (n); ++i) s[i] = a[i];
}
void work() {
for (int i = (1); i <= (m); ++i)
if (t[i] == 1)
for (int j = (l[i]); j <= (r[i]); ++j) a[j] += d[i];
else {
int k = -1e9;
for (int j = (l[i]); j <= (r[i]); ++j) k = max(k, a[j]);
if (k != d[i]) {
puts("NO");
return;
}
}
puts("YES");
for (int i = (1); i <= (n - 1); ++i) printf("%d ", s[i]);
printf("%d", s[n]);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[5005], ans[5005];
int cmd[5005], l[5005], r[5005], num[5005];
bool vis[5005], flag;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) scanf("%d%d%d%d", &cmd[i], &l[i], &r[i], &num[i]);
for (int i = 1; i <= n; i++) p[i] = -10000000;
for (int i = m - 1; i >= 0; i--) {
if (cmd[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) p[j] -= num[i];
} else {
for (int j = l[i]; j <= r[i]; j++) {
if (vis[j] && p[j] <= num[i]) continue;
p[j] = num[i];
vis[j] = 1;
}
}
}
for (int i = 1; i <= n; i++) ans[i] = p[i];
for (int i = 0; i < m; i++) {
if (cmd[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) p[j] += num[i];
} else {
int ma = -1000000000;
for (int j = l[i]; j <= r[i]; j++) ma = max(ma, p[j]);
if (ma != num[i]) {
flag = 1;
break;
}
}
}
if (flag)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400010;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int num[5005], X[5005], A[5005], B[5005], C[5005];
int main() {
int n, m, x, a, b, c;
cin >> n >> m;
bool flag = 0;
for (int i = 1; i <= n; i++) num[i] = -1000000000;
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &x, &a, &b, &c);
X[i] = x, A[i] = a, B[i] = b, C[i] = c;
if (x == 1) {
for (int j = a; j <= b; j++)
if (num[j] != -1000000000) num[j] += c;
} else {
for (int j = a; j <= b; j++) {
if (num[j] >= c || num[j] == -1000000000) num[j] = c;
}
}
}
for (int i = m - 1; i >= 0; i--) {
if (X[i] == 1) {
for (int j = A[i]; j <= B[i]; j++) num[j] -= C[i];
} else {
int t = num[A[i]];
for (int j = A[i]; j <= B[i]; j++) t = max(t, num[j]);
if (t != C[i]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", max(num[i], -1000000000));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[5001], o[5001], ans[5001];
int t[5001], l[5001], r[5001], d[5001];
int main() {
int n, m, i, j, flag, maxz;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) p[i] = -10000000;
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &t[i], &l[i], &r[i], &d[i]);
}
flag = 0;
for (i = m; i >= 1; i--) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) p[j] -= d[i];
} else {
for (j = l[i]; j <= r[i]; j++) {
if (o[j] && p[j] < d[i]) continue;
p[j] = d[i];
o[j] = 1;
}
}
}
for (i = 1; i <= n; i++) ans[i] = p[i];
for (i = 1; i <= m; i++) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) p[j] += d[i];
} else {
maxz = -1000000000;
for (j = l[i]; j <= r[i]; j++) {
maxz = max(maxz, p[j]);
}
if (maxz != d[i]) flag = 1;
}
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (i = 1; i <= n; i++) {
if (i == 1)
printf("%d", ans[i]);
else
printf(" %d", ans[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e8;
int n, m, t[5050], d[5050], a[5050], l[5050], r[5050], ans[5050];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) a[i] = INF;
for (int i = 1; i <= m; ++i) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; ++j) a[j] += d[i];
else
for (int j = l[i]; j <= r[i]; ++j) a[j] = min(a[j], d[i]);
}
for (int i = 1; i <= m; ++i)
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; ++j) a[j] -= d[i];
for (int i = 1; i <= n; ++i) ans[i] = a[i];
for (int i = 1; i <= m; ++i) {
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; ++j) a[j] += d[i];
else {
long long mx = -99999999;
for (int j = l[i]; j <= r[i]; ++j)
if (mx < a[j]) mx = a[j];
if (mx != d[i]) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int p[5005], ans[5005];
int cmd[5005], l[5005], r[5005], num[5005];
bool vis[5005], flag;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) scanf("%d%d%d%d", &cmd[i], &l[i], &r[i], &num[i]);
for (int i = 1; i <= n; i++) p[i] = 0;
for (int i = m - 1; i >= 0; i--) {
if (cmd[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) p[j] -= num[i];
} else {
for (int j = l[i]; j <= r[i]; j++) {
if (vis[j] && p[j] <= num[i]) continue;
p[j] = num[i];
vis[j] = 1;
}
}
}
for (int i = 1; i <= n; i++) ans[i] = p[i];
for (int i = 0; i < m; i++) {
if (cmd[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) p[j] += num[i];
} else {
int ma = -100000000;
for (int j = l[i]; j <= r[i]; j++) ma = max(ma, p[j]);
if (ma != num[i]) {
flag = 1;
break;
}
}
}
if (flag)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
int q[5005], l[5005], r[5005], k[5005], add[5005], sx[5005];
int main() {
int n, m, i, j, ok;
while (~scanf("%d%d", &n, &m)) {
for (i = 1; i <= n; i++) {
sx[i] = 1000000000;
add[i] = 0;
}
for (i = 0; i < m; i++) {
scanf("%d%d%d%d", &q[i], &l[i], &r[i], &k[i]);
if (q[i] == 1) {
for (j = l[i]; j <= r[i]; j++) add[j] += k[i];
} else {
for (j = l[i]; j <= r[i]; j++)
if (sx[j] > k[i] - add[j]) sx[j] = k[i] - add[j];
}
}
for (i = 1; i <= n; i++) {
add[i] = 0;
}
ok = 1;
for (i = 0; i < m; i++) {
if (q[i] == 1) {
for (j = l[i]; j <= r[i]; j++) add[j] += k[i];
} else {
for (j = l[i]; j <= r[i]; j++)
if (sx[j] == k[i] - add[j]) break;
if (j > r[i]) {
ok = 0;
break;
}
}
}
if (!ok)
printf("NO\n");
else {
printf("YES\n");
for (i = 1; i <= n; i++) {
printf("%d", sx[i]);
if (i != n) printf(" ");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int vec[5010];
int cont[5010] = {0};
int main() {
int i, j, N, M, t, l, r, x, val, z, k;
scanf("%d %d", &N, &M);
for (i = 1; i <= N; i++) {
vec[i] = 1000000000;
}
k = 0;
for (i = val = 1; i <= M; i++) {
scanf("%d %d %d %d", &t, &l, &r, &x);
if (t == 1) {
for (; l <= r; l++) {
cont[l] += x;
k = 1;
}
} else {
for (z = 0; l <= r; l++) {
if (vec[l] >= x - cont[l]) {
z = 1;
vec[l] = x - cont[l];
}
}
val &= z;
if (val == 0) {
printf("NO");
return 0;
}
}
}
if (k || M == 1) {
printf("YES\n");
for (i = 1; i <= N; i++) printf("%d ", vec[i]);
} else
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int maxn = 10000;
struct point {
int t, l, r, d;
};
int n, m, b[maxn], ok, mx;
point a[maxn];
pair<int, int> ans[maxn];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> a[i].t >> a[i].l >> a[i].r >> a[i].d;
for (int i = 1; i <= n; i++) ans[i].first = inf, ans[i].second = false;
for (int i = m; i >= 1; i--) {
if (a[i].t == 2)
for (int j = a[i].l; j <= a[i].r; j++) {
ans[j].first = min(ans[j].first, a[i].d);
ans[j].second = true;
}
else
for (int j = a[i].l; j <= a[i].r; j++) {
ans[j].first -= a[i].d;
if (ans[j].second == false) ans[j].first = min(ans[j].first, inf);
}
}
for (int i = 1; i <= n; i++) b[i] = ans[i].first;
ok = true;
for (int i = 1; i <= m; i++) {
if (a[i].t == 2) {
mx = -inf;
for (int j = a[i].l; j <= a[i].r; j++) mx = max(mx, b[j]);
if (mx != a[i].d) ok = false;
} else {
for (int j = a[i].l; j <= a[i].r; j++) b[j] += a[i].d;
}
}
if (ok) {
puts("YES");
for (int i = 1; i <= n; i++) cout << ans[i].first << ' ';
} else {
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[5000];
int mask[5000];
int mask2[5000];
struct zapr {
int t;
int l;
int r;
int o;
};
zapr arr2[5000];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
arr[i] = 1000000000;
}
for (int i = 0; i < m; i++) {
cin >> arr2[i].t >> arr2[i].l >> arr2[i].r >> arr2[i].o;
int t, l, r, o;
t = arr2[i].t;
l = arr2[i].l;
r = arr2[i].r;
o = arr2[i].o;
if (t == 1) {
for (int j = l - 1; j <= r - 1; j++) {
mask[j] += o;
}
} else {
for (int j = l - 1; j <= r - 1; j++) {
arr[j] = min(arr[j], o - mask[j]);
}
}
}
for (int i = 0; i < m; i++) {
int t, l, r, o;
t = arr2[i].t;
l = arr2[i].l;
r = arr2[i].r;
o = arr2[i].o;
if (t == 1) {
for (int j = l - 1; j <= r - 1; j++) {
mask2[j] += o;
}
} else {
int maxx = -1000000001;
for (int j = l - 1; j <= r - 1; j++) {
maxx = max(maxx, arr[j] + mask2[j]);
}
if (maxx != o) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
int a[5005], b[5005];
int f[5005], l[5005], r[5005], v[5005];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i] = 100000000;
for (int i = 1; i <= m; i++) {
f[i] = read();
l[i] = read();
r[i] = read();
v[i] = read();
}
for (int k = 1; k <= m; k++) {
if (f[k] == 1)
for (int i = l[k]; i <= r[k]; i++) b[i] += v[k];
else
for (int i = l[k]; i <= r[k]; i++) a[i] = min(a[i], v[k] - b[i]);
}
for (int i = 1; i <= n; i++) b[i] = a[i];
for (int k = 1; k <= m; k++) {
if (f[k] == 1)
for (int i = l[k]; i <= r[k]; i++) b[i] += v[k];
else {
int mx = -100000000;
for (int i = l[k]; i <= r[k]; i++) mx = max(mx, b[i]);
if (mx != v[k]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
long long a[5005][5], last = 0, b[5005] = {0};
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i][1] >> a[i][2] >> a[i][3] >> a[i][4];
}
int c[5005] = {0}, d[5005] = {0};
for (int i = 1; i <= n; i++) b[i] = (long long)1e9;
for (int i = 1; i <= m; i++) {
if (a[i][1] == 1)
for (int j = a[i][2]; j <= a[i][3]; j++) c[j] += a[i][4];
else {
for (int j = a[i][2]; j <= a[i][3]; j++) {
b[j] = min(b[j], a[i][4] - c[j]);
}
}
}
for (int i = 1; i <= n; i++) d[i] = b[i];
long long flag = 0;
for (int i = 1; i <= m; i++) {
if (a[i][1] == 1)
for (int j = a[i][2]; j <= a[i][3]; j++) b[j] += a[i][4];
else {
long long Max = b[a[i][2]];
for (int j = a[i][2]; j <= a[i][3]; j++) {
Max = max(Max, b[j]);
}
if (Max != a[i][4]) flag++;
}
}
for (int i = 1; i <= n; i++)
if (abs(d[i]) > (long long)1e9) flag++;
if (flag)
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << d[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5023;
const int MAXM = 5023;
const long long INF = 1e9 + 1e4 * MAXN;
long long diff[MAXM][MAXN], max_a[MAXN];
struct command {
int type, left, right, third;
} command[MAXN];
int main() {
int n, m;
cin >> n >> m;
memset(diff, 0, sizeof(diff));
fill_n(max_a, n, -INF);
for (int i = 0; i < m; ++i) {
int t, l, r, p;
cin >> t >> l >> r >> p;
command[i].type = t;
command[i].left = --l;
command[i].right = --r;
command[i].third = p;
if (i != 0) {
copy(diff[i - 1], diff[i - 1] + n, diff[i]);
}
if (t == 1) {
for (int j = l; j <= r; ++j) {
diff[i][j] += p;
}
} else {
for (int j = l; j <= r; ++j) {
max_a[j] =
max_a[j] == -INF ? p - diff[i][j] : min(max_a[j], p - diff[i][j]);
}
}
}
for (int i = 0; i < m; ++i) {
int l = command[i].left;
int r = command[i].right;
if (command[i].type == 1) {
continue;
}
long long mm = max_a[l] + diff[i][l];
for (int j = l; j <= r; ++j) {
mm = max(mm, max_a[j] + diff[i][j]);
}
if (mm != command[i].third) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; ++i) {
cout << max(max_a[i], (long long)-1e9) << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 5025;
const int INF = (1 << 29);
int Maxi[kMaxN], S[kMaxN], A[kMaxN], B[kMaxN], T[kMaxN];
int n, m, maxi;
int main() {
scanf("%d%d", &n, &m);
int a, b, c, type;
bool ok = 1;
for (int i = 0; i < n; ++i) Maxi[i] = INF;
for (int i = 0; i < m; ++i) {
cin >> type >> a >> b >> c;
a--;
b--;
A[i] = a;
B[i] = b;
S[i] = c;
T[i] = type;
if (type == 1) {
for (int i = a; i <= b; ++i) {
Maxi[i] += c;
}
} else {
bool ok2 = 0;
for (int i = a; i <= b; ++i) {
if (Maxi[i] >= c) {
ok2 = 1;
Maxi[i] = c;
}
}
ok = ok && ok2;
}
}
for (int i = m - 1; i >= 0; --i) {
if (T[i] == 1) {
for (int j = A[i]; j <= B[i]; ++j) {
Maxi[j] -= S[i];
}
} else {
maxi = INT_MIN;
for (int j = A[i]; j <= B[i]; ++j) {
maxi = max(maxi, Maxi[j]);
}
if (maxi != S[i]) ok = 0;
}
}
if (!ok)
puts("NO");
else {
puts("YES");
for (int i = 0; i < n; ++i) {
printf("%d%s", Maxi[i], i == n - 1 ? "\n" : " ");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using llu = long long unsigned;
using ld = long double;
const int inf = 0x3c3c3c3c;
const ll infl = 0x3c3c3c3c3c3c3c3c;
const int MAX_N = 5e3 + 9;
struct Inst {
int t, l, r, o;
};
int init[MAX_N];
int ans[MAX_N];
Inst inst[MAX_N];
int main() {
cin.tie(NULL);
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int t, l, r, o;
cin >> t >> l >> r >> o;
inst[i] = {t, l, r, o};
}
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = m - 1; j >= 0; j--) {
int t = inst[j].t;
int l = inst[j].l;
int r = inst[j].r;
int v = inst[j].o;
if (t == 1 && flag && l <= i && i <= r) ans[i] -= v;
if (t == 2 && l <= i && i <= r) {
if (flag) {
if (ans[i] > v) ans[i] = v;
} else {
ans[i] = v;
flag = true;
}
}
}
}
for (int i = 1; i <= n; i++) init[i] = ans[i];
for (int i = 0; i < m; i++) {
int l = inst[i].l, r = inst[i].r;
int v = inst[i].o;
if (inst[i].t == 1) {
for (int i = l; i <= r; i++) init[i] += v;
} else {
int maxV = init[l];
for (int i = l; i <= r; i++) maxV = max(maxV, init[i]);
if (v != maxV) return !printf("NO");
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 5009;
const int MOD = 1e9 + 7;
int n, QN;
int cmd[MX], ll[MX], rr[MX], vv[MX], arr[MX], flag[MX], sol[MX];
bool done[MX];
int main() {
cin >> n >> QN;
for (int j = 1; j <= n; j++) arr[j] = 1e9;
for (int j = 1; j <= QN; j++) {
cin >> cmd[j] >> ll[j] >> rr[j] >> vv[j];
}
for (int xx = 1; xx <= QN; xx++) {
int st = ll[xx], en = rr[xx], V = vv[xx];
if (cmd[xx] == 2)
for (int j = st; j <= en; j++) arr[j] = min(arr[j], V - flag[j]);
else
for (int j = st; j <= en; j++) flag[j] += V;
}
for (int j = 1; j <= n; j++) sol[j] = arr[j];
for (int xx = 1; xx <= QN; xx++) {
int st = ll[xx], en = rr[xx], V = vv[xx];
if (cmd[xx] == 2) {
int mx = -(1 << 30);
for (int j = st; j <= en; j++) mx = max(mx, arr[j]);
if (mx != V) {
puts("NO");
return 0;
}
} else
for (int j = st; j <= en; j++) arr[j] += V;
}
cout << "YES" << endl;
for (int j = 1; j <= n; j++) cout << sol[j] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int T[5001], L[5001], R[5001], D[5001], A[5001], B[5001], n, m, i, j;
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) A[i] = 5e7;
for (i = 1; i <= m; i++) cin >> T[i] >> L[i] >> R[i] >> D[i];
for (i = m; i >= 1; i--) {
if (T[i] == 1) {
for (j = L[i]; j <= R[i]; j++) A[j] -= D[i];
} else {
for (j = L[i]; j <= R[i]; j++) A[j] = min(A[j], D[i]);
}
}
for (i = 1; i <= n; i++) B[i] = A[i];
for (i = 1; i <= m; i++) {
if (T[i] == 1) {
for (j = L[i]; j <= R[i]; j++) B[j] += D[i];
} else {
for (j = L[i]; j <= R[i]; j++)
if (B[j] == D[i]) break;
if (j > R[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << A[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
const int N = 5010;
int n, m;
long long v[N];
long long a[N];
int t[N], d[N];
int l[N], r[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) v[i] = 2 * inf;
for (int i = m - 1; i >= 0; --i) cin >> t[i] >> l[i] >> r[i] >> d[i];
for (int op = 0; op < m; ++op) {
if (t[op] == 1) {
for (int i = l[op] - 1; i < r[op]; ++i) v[i] -= d[op];
} else {
for (int i = l[op] - 1; i < r[op]; ++i)
v[i] = v[i] < d[op] ? v[i] : d[op];
;
}
}
for (int i = 0; i < n; ++i) a[i] = v[i] < inf / 2 ? v[i] : inf / 2;
for (int op = m - 1; op >= 0; --op)
if (t[op] == 1) {
for (int i = l[op] - 1; i < r[op]; ++i) a[i] += d[op];
} else {
int m = a[l[op] - 1];
for (int i = l[op]; i < r[op]; ++i) m = m > a[i] ? m : a[i];
if (m != d[op]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++)
cout << ((v[i] < inf / 2) ? v[i] : inf / 2) << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5000;
const int MaxM = 5000;
template <class T>
inline void tension(T &a, const T &b) {
if (b < a) a = b;
}
inline int getint() {
char c;
while (c = getchar(), ('0' > c || c > '9') && c != '-')
;
if (c != '-') {
int res = c - '0';
while (c = getchar(), '0' <= c && c <= '9') res = res * 10 + c - '0';
return res;
} else {
int res = 0;
while (c = getchar(), '0' <= c && c <= '9') res = res * 10 + c - '0';
return -res;
}
}
int main() {
int n, m;
static int type[MaxM], le[MaxM], ri[MaxM], d[MaxM];
cin >> n >> m;
for (int i = 0; i < m; i++)
type[i] = getint(), le[i] = getint(), ri[i] = getint(), d[i] = getint();
static int a[MaxN + 1];
for (int i = 1; i <= n; i++) a[i] = 1000000000;
for (int i = 0; i < m; i++) {
if (type[i] == 1) {
for (int j = le[i]; j <= ri[i]; j++) a[j] += d[i];
} else {
for (int j = le[i]; j <= ri[i]; j++) tension(a[j], d[i]);
}
}
for (int i = m - 1; i >= 0; i--) {
if (type[i] == 1) {
for (int j = le[i]; j <= ri[i]; j++) a[j] -= d[i];
} else {
bool ok = false;
for (int j = le[i]; j <= ri[i]; j++)
if (a[j] == d[i]) {
ok = true;
break;
}
if (!ok) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5e3 + 10;
struct TnT {
int t, l, r, w;
} T[M];
long long a[M], b[M];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &T[i].t, &T[i].l, &T[i].r, &T[i].w);
}
for (int i = 1; i <= n; i++) {
a[i] = 25 * 100000000000;
}
int flag = 0;
for (int i = m - 1; i >= 0; i--) {
if (T[i].t == 1) {
for (int j = T[i].l; j <= T[i].r; j++) {
a[j] -= T[i].w;
}
} else {
for (int j = T[i].l; j <= T[i].r; j++) {
a[j] = min(a[j], (long long)T[i].w);
}
}
}
for (int i = 1; i <= n; i++) {
b[i] = a[i];
}
for (int i = 0; i < m; i++) {
if (T[i].t == 1) {
for (int j = T[i].l; j <= T[i].r; j++) {
b[j] += T[i].w;
}
} else {
int count = 0;
for (int j = T[i].l; j <= T[i].r; j++) {
if (b[j] > T[i].w) {
flag = 1;
break;
}
if (b[j] == T[i].w) count++;
}
if (!count) {
flag = 1;
break;
}
}
if (flag) break;
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) {
a[i] = min((long long)1000000000, a[i]);
a[i] = max((long long)-1000000000, a[i]);
printf("%I64d ", a[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
long long w;
};
long long MOD = 1000000007;
long long _MOD = 1000000009;
double EPS = 1e-10;
double INF = FLT_MAX;
int main() {
int n, m;
cin >> n >> m;
vector<int> t(m), l(m), r(m), d(m);
for (int i = 0; i < m; i++) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
l[i]--;
}
vector<int> a(n, 2000000000);
for (int i = m - 1; i >= 0; i--) {
if (t[i] == 1)
for (int x = l[i]; x < r[i]; x++) a[x] -= d[i];
if (t[i] == 2)
for (int x = l[i]; x < r[i]; x++) a[x] = min(a[x], d[i]);
}
for (int x = 0; x < n; x++) {
a[x] = min(a[x], 1000000000);
a[x] = max(a[x], -1000000000);
}
vector<int> _a = a;
bool ok = true;
for (int i = 0; i < m; i++) {
if (t[i] == 1)
for (int x = l[i]; x < r[i]; x++) a[x] += d[i];
if (t[i] == 2) {
int ma = INT_MIN;
for (int x = l[i]; x < r[i]; x++) ma = max(ma, a[x]);
if (ma != d[i]) ok = false;
}
}
if (ok) {
cout << "YES" << endl;
for (int x = 0; x < n; x++) cout << _a[x] << ' ';
cout << endl;
} else
cout << "NO" << endl;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.