text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n], x[n];
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) x[i] = 5e8;
int dt[m], dl[m], dr[m], dd[m];
for (int j = 0; j < m; j++) {
int t, l, d, r;
cin >> t >> l >> r >> d;
l--;
r--;
if (t == 1)
for (int i = l; i <= r; i++) a[i] += d;
else
for (int i = l; i <= r; i++) x[i] = min(x[i], d - a[i]);
dt[j] = t, dl[j] = l, dr[j] = r, dd[j] = d;
}
int backup[n];
for (int i = 0; i < n; i++) backup[i] = x[i];
bool ok = true;
for (int j = 0; j < m; j++) {
int t = dt[j], l = dl[j], d = dd[j], r = dr[j];
int maxi = -(5e8);
if (t == 1)
for (int i = l; i <= r; i++) backup[i] += d;
else {
for (int i = l; i <= r; i++) maxi = max(maxi, backup[i]);
if (maxi != d) {
ok = false;
break;
}
}
}
if (ok) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << x[i] << " ";
} else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
int mayor(int a, int b);
int men[5001], opt[5001], aux[5001], t[5001], l[5001], r[5001], d[5001];
int main() {
int n, m, i, j, ban, max;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
men[i] = -100000000;
}
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &t[i], &l[i], &r[i], &d[i]);
}
ban = 0;
for (i = m; i >= 1; i--) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) {
men[j] -= d[i];
}
} else {
for (j = l[i]; j <= r[i]; j++) {
if (opt[j] && men[j] < d[i]) {
continue;
}
men[j] = d[i];
opt[j] = 1;
}
}
}
for (i = 1; i <= n; i++) {
aux[i] = men[i];
}
for (i = 1; i <= m; i++) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) {
men[j] += d[i];
}
} else {
max = -100000000;
for (j = l[i]; j <= r[i]; j++) {
max = mayor(max, men[j]);
}
if (max != d[i]) {
ban = 1;
}
}
}
if (ban) {
printf("NO\n");
} else {
printf("YES\n");
for (i = 1; i <= n; i++) {
printf("%d%c", aux[i], i == n ? '\n' : ' ');
}
}
return 0;
}
int mayor(int a, int b) {
if (a > b) {
return a;
}
return b;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9, PI = 2 * acos(0.0);
const int maxn = 2 * 100000 + 10, MOD = 1000 * 1000 * 1000 + 7,
INF = 1000 * 1000 * 1000;
pair<long long, long long> a[maxn];
void increaseArr(int l, int r, int d) {
int i;
for (i = l; i <= r; i++) {
a[i].second += d;
}
}
void setUpper(int l, int r, int m) {
int i;
for (i = l; i <= r; i++) {
a[i].first = min(a[i].first, (long long)m - a[i].second);
}
}
bool isOk(int l, int r, int m) {
long long maxi = -INF;
for (int i = l; i <= r; i++) {
maxi = max(maxi, a[i].first + a[i].second);
}
if (maxi == m) return true;
return false;
}
vector<pair<pair<long long, long long>, pair<long long, long long> > > oper;
int main() {
int n, m;
while (cin >> n >> m) {
oper.clear();
for (int i = 1; i <= n; i++) {
a[i].first = INF;
a[i].second = 0;
}
for (int i = 0; i < m; i++) {
int op;
cin >> op;
if (op == 1) {
int l, r, d;
cin >> l >> r >> d;
oper.push_back(make_pair(pair<long long, long long>(op, l),
pair<long long, long long>(r, d)));
increaseArr(l, r, d);
} else {
int l, r, m;
cin >> l >> r >> m;
oper.push_back(make_pair(pair<long long, long long>(op, l),
pair<long long, long long>(r, m)));
setUpper(l, r, m);
}
}
for (int i = 1; i <= n; i++) a[i].second = 0;
bool flag = true;
for (int i = 0; i < m; i++) {
int op = oper[i].first.first;
if (op == 1) {
int l, r, d;
l = oper[i].first.second;
r = oper[i].second.first;
d = oper[i].second.second;
increaseArr(l, r, d);
} else {
int l, r, m;
l = oper[i].first.second;
r = oper[i].second.first;
m = oper[i].second.second;
flag &= isOk(l, r, m);
}
}
if (flag) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << a[i].first << ' ';
}
cout << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[5001], s[5001], e[5001], k[5001], a[5001], aa[5001];
int main() {
int n, m;
cin >> n >> m;
fill(a, a + n, 1e9);
for (int i = 0; i < m; i++) {
cin >> t[i] >> s[i] >> e[i] >> k[i];
--s[i], --e[i];
}
for (int i = m - 1; i >= 0; i--) {
if (t[i] == 2) {
for (int j = s[i]; j <= e[i]; j++) {
a[j] = min(a[j], k[i]);
}
} else {
for (int j = s[i]; j <= e[i]; j++) a[j] -= k[i];
}
}
for (int i = 0; i < n; i++) {
a[i] = min(a[i], (int)1e9);
a[i] = max(a[i], (int)-1e9);
}
memcpy(aa, a, sizeof(aa));
for (int i = 0; i < m; i++) {
int mx = -1e9;
for (int j = s[i]; j <= e[i]; j++) {
if (t[i] == 2)
mx = max(mx, a[j]);
else
a[j] += k[i];
}
if (mx != k[i] && t[i] == 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << aa[i] << " \n"[i == n - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5;
struct NOOD {
int flag;
int l;
int r;
int v;
} num[MaxN + 5];
int ans[MaxN + 5], p[MaxN + 5];
bool ok[MaxN + 5], flag;
int Max;
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &num[i].flag, &num[i].l, &num[i].r, &num[i].v);
}
for (int i = 1; i <= n; i++) ans[i] = -100000000;
for (int i = m; i >= 1; i--) {
if (num[i].flag == 1) {
for (int j = num[i].l; j <= num[i].r; j++) ans[j] -= num[i].v;
} else {
for (int j = num[i].l; j <= num[i].r; j++) {
if (ok[j] && ans[j] < num[i].v) continue;
ans[j] = num[i].v;
ok[j] = 1;
}
}
}
for (int i = 1; i <= n; i++) p[i] = ans[i];
for (int i = 1; i <= m; i++) {
if (num[i].flag == 1) {
for (int j = num[i].l; j <= num[i].r; j++) p[j] += num[i].v;
} else {
Max = -100000000;
for (int j = num[i].l; j <= num[i].r; j++) Max = max(Max, p[j]);
if (Max != num[i].v) flag = 1;
}
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\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] = VAL;
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 main() {
long long n, m, k, i, j, arr[5001][4], last = 0, res[5001], tt[5001];
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2] >> arr[i][3];
if (arr[i][0] == 2) last = i;
}
for (i = 1; i <= n; i++) res[i] = 1000000000;
for (i = last; i >= 0; i--) {
if (arr[i][0] == 2) {
k = 0;
for (j = arr[i][1]; j <= arr[i][2]; j++) {
if (res[j] >= arr[i][3]) {
k++;
res[j] = arr[i][3];
}
}
if (!k) {
cout << "NO" << endl;
return 0;
}
} else {
for (j = arr[i][1]; j <= arr[i][2]; j++) {
if (res[j] != 1000000000) res[j] -= arr[i][3];
}
}
}
for (j = 1; j <= n; j++) tt[j] = res[j];
for (i = 0; i < m; i++) {
if (arr[i][0] == 2) {
k = -1000000000000LL;
for (j = arr[i][1]; j <= arr[i][2]; j++) {
if (tt[j] > k) k = tt[j];
}
if (k != arr[i][3]) {
cout << "NO" << endl;
return 0;
}
} else {
for (j = arr[i][1]; j <= arr[i][2]; j++) {
if (tt[j] != 1000000000) tt[j] += arr[i][3];
}
}
}
cout << "YES" << endl;
for (j = 1; j < n; j++) cout << res[j] << " ";
cout << res[j] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[5100];
long long c[5100];
long long b[5100];
long long z[5100][4];
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
long long t, l, r, d, m;
cin >> n >> k;
for (long long i = 0; i <= n; i++) a[i] = 1000000000;
for (long long K = 0; K < k; K++) {
cin >> t;
z[K][0] = t;
if (t == 1) {
cin >> l >> r >> d;
z[K][1] = l;
z[K][2] = r;
z[K][3] = d;
for (long long i = l; i <= r; i++) b[i] += d;
} else {
cin >> l >> r >> m;
z[K][1] = l;
z[K][2] = r;
z[K][3] = m;
for (long long i = l; i <= r; i++)
if (a[i] > (m - b[i])) {
a[i] = m - b[i];
}
}
}
for (long long i = 1; i <= n; i++) {
if (abs(a[i]) <= 1000000000)
c[i] = a[i];
else {
if (a[i] > 0)
c[i] = 1000000000;
else
c[i] = -1000000000;
a[i] = c[i];
}
}
for (long long i = 0; i < k; i++) {
t = z[i][0];
if (t == 1) {
l = z[i][1];
r = z[i][2];
d = z[i][3];
for (long long i = l; i <= r; i++) a[i] += d;
} else {
l = z[i][1];
r = z[i][2];
m = z[i][3];
bool flag = 0;
for (long long i = l; i <= r; i++) {
if (a[i] == m) {
flag = true;
break;
}
}
if (!flag) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (long long i = 1; i <= n; i++) cout << c[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m;
int a[5010], type[5010], x[5010], y[5010], z[5010];
inline void fail() {
printf("NO\n");
exit(0);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) a[i] = int(1e8);
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &type[i], &x[i], &y[i], &z[i]);
if (type[i] == 1)
for (j = x[i]; j <= y[i]; j++) a[j] += z[i];
else {
int F = 0;
for (j = x[i]; j <= y[i]; j++)
if (a[j] >= z[i]) F = 1, a[j] = z[i];
if (!F) fail();
}
}
for (i = m; i; i--)
if (type[i] == 1)
for (j = x[i]; j <= y[i]; j++) a[j] -= z[i];
else {
int ma = int(-1e8);
for (j = x[i]; j <= y[i]; j++) ma = max(ma, a[j]);
if (ma != z[i]) fail();
}
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long limMax = 1e9;
int a[5500], b[5500];
bool vis[5500];
int op[5500], lef[5500], righ[5500], res[5500];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) {
vis[i] = false;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &op[i], &lef[i], &righ[i], &res[i]);
}
bool flag = true;
for (int i = m; i >= 1; i--) {
if (op[i] == 1) {
for (int j = lef[i]; j <= righ[i]; j++) {
if (vis[j]) {
a[j] -= res[i];
if (a[j] > limMax || a[j] < -limMax) {
flag = false;
break;
}
}
}
} else {
int maxn = res[i];
for (int j = lef[i]; j <= righ[i]; j++) {
if (vis[j]) {
a[j] = min(a[j], maxn);
} else {
vis[j] = true;
a[j] = maxn;
}
}
}
}
if (!flag) {
puts("NO");
} else {
for (int i = 1; i <= n; i++) {
if (vis[i]) b[i] = a[i];
}
for (int i = 1; i <= m; i++) {
if (op[i] == 1) {
for (int j = lef[i]; j <= righ[i]; j++) {
b[j] += res[i];
if (b[j] > limMax || b[j] < -limMax) {
flag = false;
break;
}
}
} else {
int maxn = b[lef[i]];
for (int j = lef[i] + 1; j <= righ[i]; j++) {
maxn = max(maxn, b[j]);
}
if (maxn != res[i]) {
flag = false;
break;
}
}
}
if (!flag) {
puts("NO");
} else {
puts("YES");
for (int i = 1; i <= n; i++) {
if (vis[i])
printf("%d", a[i]);
else
printf("%d", 1);
printf("%c", i != n ? ' ' : '\n');
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 5050;
const int MVAL = 2000000000;
struct data {
int t, l, r, d;
};
int a[MN];
int b[MN];
vector<data> query;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int i;
for ((i) = 0; (i) < (int)(n); ++(i)) a[i] = MVAL;
for ((i) = 0; (i) < (int)(m); ++(i)) {
int t, l, r, d;
scanf("%d %d %d %d", &t, &l, &r, &d);
--l, --r;
query.push_back({t, l, r, d});
if (t == 1) {
for (int j = l; j <= r; ++j) b[j] += d;
} else {
for (int j = l; j <= r; ++j) a[j] = min(a[j], d - b[j]);
}
}
memcpy(b, a, sizeof a);
for ((i) = 0; (i) < (int)(m); ++(i)) {
if (query[i].t == 1) {
for (int j = query[i].l; j <= query[i].r; ++j) a[j] += query[i].d;
} else {
int maxi = -MVAL;
for (int j = query[i].l; j <= query[i].r; ++j) maxi = max(maxi, a[j]);
if (maxi != query[i].d) {
puts("NO");
return 0;
}
}
}
puts("YES");
for ((i) = 0; (i) < (int)(n); ++(i)) {
if (i) printf(" ");
if (b[i] == MVAL) {
printf("101");
continue;
}
printf("%d", b[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
long long n, m, a[N + 1], b[N + 1], type[N], l[N], r[N], x[N];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = 1e9;
for (int j = 1; j <= m; j++) {
cin >> type[j] >> l[j] >> r[j] >> x[j];
if (type[j] == 1)
for (int i = l[j]; i <= r[j]; i++) b[i] += x[j];
else {
bool ok = false;
for (int i = l[j]; i <= r[j]; i++) {
if (a[i] >= x[j] - b[i]) ok = true;
a[i] = min(a[i], x[j] - b[i]);
}
if (!ok) {
cout << "NO";
return 0;
}
}
}
for (int i = 1; i <= n; i++) b[i] = a[i];
bool ok = true;
for (int i = 1; i <= m; i++) {
if (type[i] == 1)
for (int j = l[i]; j <= r[i]; j++) a[j] += x[i];
else {
long long mx = a[l[i]];
for (int j = l[i] + 1; j <= r[i]; j++) mx = max(mx, a[j]);
if (mx != x[i]) {
ok = false;
break;
}
}
}
if (!ok)
cout << "NO";
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << b[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[5010], B[5010], l[5010], r[5010], t[5010], x[5010];
int main() {
int i, j, k, tt, ll, rr, xx, n, m, flag = true;
scanf("%d%d", &n, &m);
for (i = 0; i <= n; i++) A[i] = 1000000000;
memset(B, 0, sizeof(B));
for (i = 0; i < m; i++) {
scanf("%d%d%d%d", &tt, &ll, &rr, &xx);
l[i] = ll;
r[i] = rr;
x[i] = xx;
t[i] = tt;
if (tt == 1) {
for (j = ll; j <= rr; j++) B[j] += xx;
} else {
for (j = ll; j <= rr; j++) A[j] = min(A[j], xx - B[j]);
}
}
memcpy(B, A, sizeof(A));
for (i = 0; i < m; i++) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) B[j] += x[i];
} else {
int mx = -1000000000;
for (j = l[i]; j <= r[i]; j++) mx = max(mx, B[j]);
if (mx != x[i]) flag = false;
}
}
if (flag) {
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d ", A[i]);
printf("\n");
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dcmp(double a, double b) {
return fabs(a - b) <= 0.00000001 ? 0 : (a > b) ? 1 : -1;
}
int a[5000 + 9], b[5000 + 9], t[5000 + 9], l[5000 + 9], r[5000 + 9],
m[5000 + 9];
int main() {
int n, f;
cin >> n >> f;
for (int i = 1; i <= n; i++) b[i] = 1000000000;
for (int i = 1; i <= f; i++) {
cin >> t[i] >> l[i] >> r[i] >> m[i];
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) {
a[j] += m[i];
}
} else {
for (int j = l[i]; j <= r[i]; j++) {
b[j] = min(b[j], m[i] - a[j]);
}
}
}
for (int i = 1; i <= n; i++) a[i] = 0;
int mx;
for (int i = 1; i <= f; i++) {
if (t[i] == 2) {
mx = -1000000000;
for (int j = l[i]; j <= r[i]; j++) mx = max(mx, b[j] + a[j]);
if (mx != m[i]) {
cout << "NO\n";
return 0;
}
} else {
for (int j = l[i]; j <= r[i]; j++) a[j] += m[i];
}
}
cout << "YES\n";
for (int j = 1; j <= n; j++) cout << b[j] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct q {
int t, l, r, v;
} A[10001];
int mx[10001];
int sum[10001];
int B[10001];
int n, m;
bool valid() {
for (int i = 1; i <= n; ++i) B[i] = mx[i];
for (int i = 1; i <= m; ++i) {
if (A[i].t == 1) {
for (int j = A[i].l; j <= A[i].r; ++j) B[j] += A[i].v;
} else {
int mx = -1000000001;
for (int j = A[i].l; j <= A[i].r; ++j) mx = max(mx, B[j]);
if (mx != A[i].v) return false;
}
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) sum[i] = -1000000000, mx[i] = 2000000000;
bool ok = 1;
for (int i = 1; i <= m; ++i) {
scanf("%d %d %d %d", &A[i].t, &A[i].l, &A[i].r, &A[i].v);
if (A[i].t == 1) {
for (int j = A[i].l; j <= A[i].r; ++j) {
sum[j] += A[i].v;
}
} else {
for (int j = A[i].l; j <= A[i].r; ++j) {
mx[j] = min(mx[j], A[i].v - sum[j]);
if (mx[j] < 0) {
ok = 0;
break;
}
}
if (!ok) break;
}
}
for (int i = 1; i <= n; ++i) mx[i] -= 1000000000;
if (!ok || !valid())
printf("NO");
else {
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", mx[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5002;
const int INF = 1000000009;
int N, M;
int A[MAX_N][4], v[MAX_N], ans[MAX_N], a[MAX_N];
int main() {
cin >> N >> M;
for (int i = 1; i <= M; ++i) cin >> A[i][0] >> A[i][1] >> A[i][2] >> A[i][3];
for (int i = 1; i <= N; ++i) a[i] = INF;
for (int i = 1; i <= M; ++i) {
int t = A[i][0], x = A[i][1], y = A[i][2], val = A[i][3];
if (t == 1) {
for (int j = x; j <= y; ++j) v[j] += val;
} else {
for (int j = x; j <= y; ++j)
if (v[j] + ans[j] > val) {
ans[j] -= ans[j] + v[j] - val;
a[j] = ans[j];
} else if (v[j] + ans[j] < val) {
int temp = val - v[j] - ans[j];
if (ans[j] + temp < a[j]) {
ans[j] += temp;
a[j] = ans[j];
}
}
}
}
bool ok = 1;
for (int i = 1; i <= N; ++i) v[i] = ans[i];
for (int i = 1; i <= M; ++i) {
int t = A[i][0], x = A[i][1], y = A[i][2], val = A[i][3];
if (t == 1) {
for (int j = x; j <= y; ++j) v[j] += val;
} else {
int maxVal = v[x];
for (int j = x + 1; j <= y; ++j) maxVal = max(maxVal, v[j]);
if (maxVal != val) i = M, ok = 0;
}
}
if (ok) {
cout << "YES\n";
for (int i = 1; i <= N; ++i) cout << ans[i] << " ";
cout << "\n";
} else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[5200];
int str[5200];
int oper[5200][10];
int n, m;
int val[5200];
bool have[5200];
bool judge() {
int i, j, k;
int tmp;
for (i = 1; i <= m; i++) {
if (oper[i][1] == 2) {
tmp = -1100000000;
for (j = oper[i][2]; j <= oper[i][3]; j++) {
tmp = max(val[j], tmp);
}
if (tmp != oper[i][4]) return false;
} else {
for (j = oper[i][2]; j <= oper[i][3]; j++) {
val[j] += oper[i][4];
if (val[j] > 1000000000) {
return false;
}
}
}
}
return true;
}
int main() {
int i, j, k;
int tmp, cnt, len;
while (scanf("%d%d", &n, &m) != EOF) {
memset(have, false, sizeof(have));
memset(val, 0, sizeof(val));
for (i = 1; i <= m; i++) {
for (j = 1; j <= 4; j++) {
scanf("%d", &oper[i][j]);
}
}
for (i = m; i >= 1; i--) {
if (oper[i][1] == 2) {
for (j = oper[i][2]; j <= oper[i][3]; j++) {
if (!have[j]) {
val[j] = oper[i][4];
} else {
val[j] = min(oper[i][4], val[j]);
}
have[j] = true;
}
} else {
for (j = oper[i][2]; j <= oper[i][3]; j++) {
if (have[j]) val[j] -= oper[i][4];
}
}
}
for (i = 1; i <= n; i++) {
if (have[i])
ans[i] = val[i];
else
ans[i] = 0;
}
if (judge()) {
puts("YES");
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
puts("");
} else {
puts("NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int INF = 1000000000;
int n, m;
int t[N], l[N], r[N], v[N];
int add[N], atmost[N], sol[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) atmost[i] = INF;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d %d", t + i, l + i, r + i, v + i);
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) add[j] += v[i];
} else {
for (int j = l[i]; j <= r[i]; j++)
atmost[j] = min(atmost[j], v[i] - add[j]);
}
}
for (int i = 1; i <= n; i++) {
sol[i] = atmost[i];
}
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) sol[j] += v[i];
} else {
int mx = sol[l[i]];
for (int j = l[i] + 1; j <= r[i]; j++) mx = max(mx, sol[j]);
if (mx != v[i]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%d", atmost[i]);
if (i < n) printf(" ");
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
struct xjy {
int mid[4];
};
vector<xjy> s;
int main() {
int n, m;
cin >> n >> m;
int ans[n + 1], finans[n + 1];
for (int i = 0; i < m; i++) {
xjy mid;
cin >> mid.mid[0] >> mid.mid[1] >> mid.mid[2] >> mid.mid[3];
s.push_back(mid);
}
for (int i = 1; i <= n; i++) ans[i] = 1000000000;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i].mid[0] == 1) {
for (int j = s[i].mid[1]; j <= s[i].mid[2]; j++)
if (ans[j] != 1000000000) ans[j] -= s[i].mid[3];
} else {
for (int j = s[i].mid[1]; j <= s[i].mid[2]; j++)
if (ans[j] > s[i].mid[3]) ans[j] = s[i].mid[3];
}
}
for (int i = 1; i <= n; i++) finans[i] = ans[i];
for (int i = 0; i < s.size(); i++) {
if (s[i].mid[0] == 1) {
for (int j = s[i].mid[1]; j <= s[i].mid[2]; j++) {
ans[j] += s[i].mid[3];
}
} else {
int maxx = ans[s[i].mid[1]];
for (int j = s[i].mid[1]; j <= s[i].mid[2]; j++) {
maxx = max(ans[j], maxx);
}
if (maxx != s[i].mid[3]) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << finans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct query {
int t;
int l;
int r;
int m;
} q[5010];
int N, M, L;
int D[5010];
int Sol[5010];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) Sol[i] = 1000000000;
while (M--) {
int t;
scanf("%d", &t);
if (t == 1) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
++L;
q[L].t = t;
q[L].l = l;
q[L].r = r;
q[L].m = d;
for (; l <= r; ++l) D[l] += d;
} else {
int l, r, m;
scanf("%d%d%d", &l, &r, &m);
++L;
q[L].t = t;
q[L].l = l;
q[L].r = r;
q[L].m = m;
for (int i = l; i <= r; ++i) {
Sol[i] = min(Sol[i], m - D[i]);
}
}
}
memset(D, 0, sizeof(D));
for (int i = 1; i <= L; ++i) {
if (q[i].t == 1) {
for (int j = q[i].l; j <= q[i].r; ++j) D[j] += q[i].m;
} else {
int m = Sol[q[i].l] + D[q[i].l];
for (int j = q[i].l; j <= q[i].r; ++j) m = max(m, Sol[j] + D[j]);
if (m != q[i].m) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= N; ++i) printf("%d ", Sol[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gInt() {
int i;
scanf("%d", &i);
return i;
}
long long int gLong() {
long long int i;
scanf("%lld", &i);
return i;
}
double gDouble() {
double i;
scanf("%lf", &i);
return i;
}
void quit() {
fflush(stdout);
exit(0);
}
int rngminl[5005];
int rngminr[5005];
int rngminv[5005];
int rngmax[5005];
int hist[5005][5005];
int added[5005];
int n, m;
int main(int argc, char** argv) {
n = gInt();
m = gInt();
for (int i = 0; i < n; i++) rngmax[i] = 1000000000;
int t = 0;
while (m--) {
int type = gInt();
int l = gInt() - 1;
int r = gInt();
int val = gInt();
if (type == 1) {
for (int i = l; i < r; i++) added[i] += val;
} else {
rngminl[t] = l;
rngminr[t] = r;
rngminv[t] = val;
for (int i = l; i < r; i++) {
int newrngmax = val - added[i];
if (newrngmax < rngmax[i]) {
rngmax[i] = newrngmax;
}
}
for (int i = l; i < r; i++) hist[t][i] = added[i];
t++;
}
}
for (int i = 0; i < t; i++) {
int l = rngminl[i];
int r = rngminr[i];
int v = rngminv[i];
bool good = false;
for (int j = l; j < r; j++) {
if (rngmax[j] + hist[i][j] >= v) {
good = true;
break;
}
}
if (!good) {
printf("NO\n");
quit();
}
}
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d ", rngmax[i]);
printf("\n");
quit();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int max[5002], mc[5002][4], ad[5002];
for (int i = 1; i <= m; i++) {
cin >> mc[i][0] >> mc[i][1] >> mc[i][2] >> mc[i][3];
}
for (int i = 1; i <= n; i++) {
max[i] = 1000000000;
ad[i] = 0;
}
for (int i = 1; i <= m; i++) {
if (mc[i][0] == 1) {
for (int j = mc[i][1]; j <= mc[i][2]; j++) ad[j] += mc[i][3];
} else {
for (int j = mc[i][1]; j <= mc[i][2]; j++) {
if (max[j] > mc[i][3] - ad[j]) max[j] = mc[i][3] - ad[j];
}
}
}
for (int i = 1; i <= n; i++) ad[i] = 0;
bool f = true;
for (int i = 1; i <= m; i++) {
if (mc[i][0] == 1) {
for (int j = mc[i][1]; j <= mc[i][2]; j++) ad[j] += mc[i][3];
} else {
bool flag = false;
for (int j = mc[i][1]; j <= mc[i][2]; j++) {
if (max[j] + ad[j] >= mc[i][3]) {
flag = true;
break;
}
}
if (!flag) {
f = false;
break;
}
}
}
if (f) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", max[i]);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int cnt = 1000 * 1000 * 1000;
struct mt {
int t, l, r, x;
};
int a[5001];
int s[5001];
mt op[5001];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> op[i].t >> op[i].l >> op[i].r >> op[i].x;
for (int i = 1; i <= n; i++) s[i] = cnt;
for (int i = 0; i < m; i++)
if (op[i].t == 1)
for (int j = op[i].l; j <= op[i].r; j++) a[j] += op[i].x;
else
for (int j = op[i].l; j <= op[i].r; j++) {
s[j] = max(-cnt, min(s[j], op[i].x - a[j]));
}
for (int i = 0; i <= n; i++) a[i] = 0;
for (int i = 0; i < m; i++) {
if (op[i].t == 1)
for (int j = op[i].l; j <= op[i].r; j++) a[j] += op[i].x;
else {
bool f = 0;
for (int j = op[i].l; j <= op[i].r; j++)
if (a[j] + s[j] == op[i].x)
f = 1;
else if (a[j] + s[j] > op[i].x) {
cout << "NO";
return 0;
}
if (!f) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << s[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[5555], l[5555], r[5555], d[5555], m[5555];
long long a[5555];
int n, M;
long long b[5555];
int main() {
scanf("%d %d", &n, &M);
for (int i = (0); i < (M); ++i) {
scanf("%d", t + i);
if (t[i] == 1) {
scanf("%d %d %d", l + i, r + i, d + i);
} else
scanf("%d %d %d", l + i, r + i, m + i);
l[i]--;
r[i]--;
}
for (int i = (0); i < (n); ++i) {
long long bnd = 1000000000, chg = 0;
for (int j = 0; j < M; j++) {
if (l[j] <= i && i <= r[j]) {
if (t[j] == 1)
chg += d[j];
else {
bnd = min(bnd, m[j] - chg);
}
}
}
a[i] = b[i] = bnd;
}
bool ok = true;
for (int i = (0); i < (M); ++i) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) b[j] += d[i];
}
if (t[i] == 2) {
long long res = -1000000000;
for (int j = l[i]; j <= r[i]; j++) {
res = max(res, b[j]);
}
if (res != m[i]) {
ok = false;
break;
}
}
}
if (ok) {
printf("YES\n");
for (int i = (0); i < (n); ++i) printf("%d ", (int)a[i]);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5000 + 10;
int d[M];
int maxv[M];
int a[M];
struct QUERY {
int t;
int l;
int r;
int x;
} query[M];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
maxv[i] = 1000000000;
}
for (int q = 0; q < m; q++) {
int t;
cin >> t;
int l, r, x;
cin >> l >> r >> x;
query[q].l = l;
query[q].r = r;
query[q].t = t;
query[q].x = x;
if (t == 1) {
for (int i = l; i <= r; i++) {
d[i] += x;
}
} else {
for (int i = l; i <= r; i++) {
int val = x - d[i];
maxv[i] = min(maxv[i], val);
}
}
}
for (int i = 1; i <= n; i++) {
a[i] = maxv[i];
}
bool ok = true;
for (int q = 0; q < m; q++) {
int l = query[q].l;
int r = query[q].r;
int x = query[q].x;
if (query[q].t == 1) {
for (int i = l; i <= r; i++) {
maxv[i] += x;
}
} else {
int maxval = maxv[l];
for (int i = l; i <= r; i++) {
maxval = max(maxval, maxv[i]);
}
if (maxval != x) {
ok = false;
}
}
}
if (ok) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
cout << endl;
} else {
cout << "NO" << endl;
}
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, d, l, t, r, a[6000], b[6000], w[6000][4];
cin >> n >> m;
for (int i = 1; i <= n; i++) {
a[i] = 1000000000;
b[i] = 0;
}
bool flag = true;
for (int i = 1; i <= m; i++) {
cin >> t >> l >> r >> d;
w[i][0] = t;
w[i][1] = l;
w[i][2] = r;
w[i][3] = d;
if (t == 1) {
for (int k = l; k <= r; k++) {
a[k] += d;
b[k] -= d;
}
} else {
bool f = 0;
for (int k = l; k <= r; k++)
if (a[k] >= d) {
a[k] = d;
f = 1;
}
if (f == 0) flag = false;
}
}
if (!flag) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) {
a[i] += b[i];
b[i] = a[i];
}
for (int i = 1; i <= m; i++) {
if (w[i][0] == 1) {
for (int k = w[i][1]; k <= w[i][2]; k++) b[k] += w[i][3];
} else {
int max = b[w[i][1]];
for (int k = w[i][1] + 1; k <= w[i][2]; k++)
if (b[k] > max) max = b[k];
if (max != w[i][3]) {
flag = false;
break;
}
}
}
if (!flag) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5010], b[5010], t[5010], l[5010], r[5010], m[5010];
int n, k;
int main() {
cin >> n >> k;
fill(b, b + (n + 5), 1e8);
for (int i = 1; i <= k; i++) {
cin >> t[i] >> l[i] >> r[i] >> m[i];
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) a[j] += m[i];
else
for (int j = l[i]; j <= r[i]; j++) b[j] = min(b[j], m[i] - a[j]);
}
fill(a, a + (n + 5), 0);
for (int i = 1; i <= k; i++) {
int M = -1e9;
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) a[j] += m[i];
else {
for (int j = l[i]; j <= r[i]; j++) M = max(M, a[j] + b[j]);
if (M != m[i]) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
const int inf = 1e9;
int n, m;
int x[N], t[N];
struct xxx {
int t, l, r, d;
} q[N];
inline bool check() {
for (int i = 0; i < m; i++) {
int mak = -inf - 1;
for (int j = q[i].l; j <= q[i].r; j++) {
if (q[i].t == 1) {
t[j] += q[i].d;
} else {
mak = max(mak, t[j]);
}
}
if (q[i].t == 2 and mak != q[i].d) {
return false;
}
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &q[i].t, &q[i].l, &q[i].r, &q[i].d);
}
for (int i = 1; i <= n; i++) {
x[i] = inf;
}
for (int i = m - 1; i >= 0; i--) {
for (int j = q[i].l; j <= q[i].r; j++) {
if (q[i].t == 1) {
x[j] -= q[i].d;
} else {
x[j] = min(x[j], q[i].d);
}
}
}
for (int i = 1; i <= n; i++) {
x[i] = min(max(x[i], -inf), inf);
t[i] = x[i];
}
if (check()) {
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%d ", x[i]);
}
printf("\n");
} else {
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << ' ' << *it << " = " << a;
err(++it, args...);
}
inline void op() { cout << '\n'; }
template <typename T, typename... Types>
inline void op(T var1, Types... var2) {
cout << var1 << ' ';
op(var2...);
}
inline void ip() {}
template <typename T, typename... Types>
inline void ip(T& var1, Types&... var2) {
cin >> var1;
ip(var2...);
}
template <typename T, typename U>
inline void min_self(T& x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void max_self(T& x, U y) {
if (x < y) x = y;
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ' ';
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << "[" << v.first << ", " << v.second << "]";
return out << ")";
}
template <class A, class B>
istream& operator>>(istream& in, pair<A, B>& a) {
return in >> a.first >> a.second;
}
template <class A>
istream& operator>>(istream& in, vector<A>& a) {
for (A& i : a) in >> i;
return in;
}
template <class Container>
void split(const std::string& str, Container& cont, char delim = ',') {
stringstream ss(str);
string token;
while (std::getline(ss, token, delim)) {
cont.push_back(token);
}
}
int px[4] = {-1, 0, 1, 0};
int py[4] = {0, -1, 0, 1};
struct edge {
int u, v, wt;
edge(int a = 0, int b = 0, int c = 0) : u(a), v(b), wt(c) {}
bool operator<(edge const& other) { return wt < other.wt; }
friend ostream& operator<<(ostream& out, const edge& x) {
return out << "(" << x.u << ", " << x.v << ", " << x.wt << ")";
}
};
int n, res = 0, m;
const int maxn = 5005, inf = 1e9;
int a[maxn], diff[maxn], maxi[maxn];
struct box {
int type, l, r, x;
};
void abcd() {
int t, l, r, x;
ip(n, m);
for (int i = 1; i <= n; i++) maxi[i] = inf;
vector<box> q(m);
for (int k = 0; k <= m - 1; k++) {
ip(t, l, r, x);
q[k].type = t;
q[k].l = l;
q[k].r = r;
q[k].x = x;
if (t == 1) {
for (int i = l; i <= r; i++) diff[i] += x;
} else {
for (int i = l; i <= r; i++) min_self(maxi[i], x - diff[i]);
}
}
for (int i = 1; i <= n; i++) a[i] = maxi[i];
for (int k = 0; k <= m - 1; k++) {
if (q[k].type == 1) {
for (int i = q[k].l; i <= q[k].r; i++) a[i] += q[k].x;
} else {
int tmp = -inf;
for (int i = q[k].l; i <= q[k].r; i++) max_self(tmp, a[i]);
if (tmp != q[k].x) {
op("NO");
return;
}
}
}
op("YES");
for (int i = 1; i <= n; i++) cout << maxi[i] << ' ';
cout << '\n';
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
abcd();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[5555], l[5555], r[5555], s[5555], ans[5555], f[5555];
int i, j, k, n;
int main() {
scanf("%d %d", &n, &k);
for (i = 1; i <= k; i++) scanf("%d %d %d %d", d + i, l + i, r + i, s + i);
for (i = 1; i <= n; i++) ans[i] = 1e9;
for (i = 1; i <= k; i++) {
if (d[i] == 1)
for (j = l[i]; j <= r[i]; j++) f[j] += s[i];
else
for (j = l[i]; j <= r[i]; j++) ans[j] = min(ans[j], s[i] - f[j]);
}
bool ok = 1;
for (i = 1; i <= n; i++) f[i] = ans[i];
for (i = 1; i <= k; i++) {
if (d[i] == 1)
for (j = l[i]; j <= r[i]; j++) f[j] += s[i];
else {
bool k = 0;
for (j = l[i]; j <= r[i]; j++)
if (f[j] == s[i]) k = 1;
if (!k) ok = 0;
}
}
for (i = 1; i <= n; i++)
if (ans[i] < -1e9 || ans[i] > 1e9) ok = 0;
if (!ok)
puts("NO");
else {
puts("YES");
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const double eps = 1e-8;
const int maxn = 6000;
int ans[maxn];
int op[maxn];
int a[maxn];
int b[maxn];
int c[maxn];
int ans1[maxn];
int sum[maxn];
int main() {
int n, m;
while (cin >> n >> m) {
memset(sum, 0, sizeof(sum));
for (int i = (1); i <= (n); ++i) ans[i] = INF;
for (int i = (1); i <= (m); ++i)
scanf("%d%d%d%d", &op[i], &a[i], &b[i], &c[i]);
int flag = 1;
for (int i = (1); i <= (m); ++i) {
if (op[i] == 1) {
for (int j = (a[i]); j <= (b[i]); ++j) sum[j] += c[i];
}
if (op[i] == 2) {
for (int j = (a[i]); j <= (b[i]); ++j) {
ans[j] = min(ans[j], c[i] - sum[j]);
}
}
}
for (int i = (1); i <= (n); ++i) ans1[i] = ans[i];
for (int i = (1); i <= (m); ++i) {
if (op[i] == 1) {
for (int j = (a[i]); j <= (b[i]); ++j) ans[j] += c[i];
}
if (op[i] == 2) {
int Max = -INF;
for (int j = (a[i]); j <= (b[i]); ++j) Max = max(Max, ans[j]);
if (Max == c[i])
continue;
else {
flag = 0;
break;
}
}
}
if (flag) {
cout << "YES" << endl;
for (int i = (1); i <= (n); ++i) cout << ans1[i] << " ";
cout << endl;
} else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5010;
int n, m, t[Maxn], l[Maxn], r[Maxn], p[Maxn], ans[Maxn], d[Maxn];
bool sat[Maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d%d%d", &t[i], &l[i], &r[i], &p[i]);
for (int i = 1; i <= n; i++) ans[i] = 1e9;
for (int i = 1; i <= m; i++)
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) d[j] += p[i];
else
for (int j = l[i]; j <= r[i]; j++) ans[j] = min(ans[j], p[i] - d[j]);
memset(d, 0, sizeof(d));
bool flag = true;
for (int i = 1; i <= m; i++)
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) d[j] += p[i];
else {
int tmp = ans[l[i]] + d[l[i]];
for (int j = l[i] + 1; j <= r[i]; j++) tmp = max(tmp, ans[j] + d[j]);
if (tmp != p[i]) flag = false;
}
if (!flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i < n; i++) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dv {
int lenh, l, r, x, stt;
};
int n, k, m;
int comp(dv l, dv r) { return l.l < r.l; }
int dd[5555], so[5555], save[5555], vt[5555], change[5555];
vector<dv> a, b;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
dd[i] = 0;
so[i] = 0;
change[i] = 0;
}
dv t;
for (int i = 0; i < m; i++) {
cin >> t.lenh >> t.l >> t.r >> t.x;
t.stt = i;
a.push_back(t);
}
for (int i = m - 1; i >= 0; i--) {
if (a[i].lenh == 1)
for (int j = a[i].l; j <= a[i].r; j++) so[j] -= a[i].x;
else {
for (int j = a[i].l; j <= a[i].r; j++) {
if (!dd[j] || so[j] > a[i].x) {
dd[j] = 1;
so[j] = a[i].x;
}
}
}
}
for (int i = 1; i <= n; i++) {
if (!dd[i]) so[i] = 0;
}
for (int i = 1; i <= n; i++) save[i] = so[i];
for (int i = 0; i < a.size(); i++) {
if (a[i].lenh == 1)
for (int j = a[i].l; j <= a[i].r; j++) so[j] += a[i].x;
else {
int tam;
tam = so[a[i].l];
for (int j = a[i].l; j <= a[i].r; j++) tam = max(tam, so[j]);
if (tam != a[i].x) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << save[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int n, m, a[10000], sum[10000], op[10000], l[10000], r[10000], num[10000],
b[10000];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = 999999999;
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &op[i], &l[i], &r[i], &num[i]);
if (op[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) sum[j] += num[i];
} else {
for (int j = l[i]; j <= r[i]; j++)
if (a[j] + sum[j] > num[i]) a[j] = num[i] - sum[j];
}
}
memcpy(b, a, sizeof(a));
for (int i = 1; i <= m; i++) {
if (op[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) b[j] += num[i];
} else {
int m = -0x3f3f3f3f;
for (int j = l[i]; j <= r[i]; j++) m = max(m, b[j]);
if (m != num[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
cout << a[1];
for (int i = 2; i <= n; i++) cout << " " << a[i];
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int v[5001];
long long int vv[5001];
int c[4][5001];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
int in;
for (int j = 0; j < 4; j++) {
cin >> in;
c[j][i] = in;
if (j == 1 || j == 2) c[j][i]--;
}
}
for (int i = 0; i < n; i++) v[i] = 1 << 29;
for (int i = k - 1; i >= 0; i--) {
if (c[0][i] == 1) {
for (int j = c[1][i]; j <= c[2][i]; j++) v[j] -= c[3][i];
} else {
for (int j = c[1][i]; j <= c[2][i]; j++) {
if (v[j] > c[3][i]) v[j] = c[3][i];
}
}
}
for (int i = 0; i < n; i++) vv[i] = v[i];
for (int i = 0; i < k; i++) {
if (c[0][i] == 1) {
for (int j = c[1][i]; j <= c[2][i]; j++) vv[j] += c[3][i];
} else {
bool flg = false;
for (int j = c[1][i]; j <= c[2][i]; j++) {
if (vv[j] >= c[3][i]) {
flg = true;
break;
}
}
if (flg == false) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << v[i];
if (i == n - 1)
cout << "\n";
else
cout << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 1e5 + 10;
long long t[MAXN], l[MAXN], r[MAXN], num[MAXN];
long long add[MAXN], pre[MAXN];
int m, n;
inline long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) pre[i] = 1e9;
for (int i = 1; i <= m; i++)
scanf("%I64d%I64d%I64d%I64d", &t[i], &l[i], &r[i], &num[i]);
memset(add, 0, sizeof(add));
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) add[j] += num[i];
} else if (t[i] == 2) {
for (int j = l[i]; j <= r[i]; j++) {
pre[j] = min(pre[j], num[i] - add[j]);
}
}
}
memset(add, 0, sizeof(add));
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) add[j] += num[i];
} else if (t[i] == 2) {
int ma = -1e9;
for (int j = l[i]; j <= r[i]; j++) {
if (ma < pre[j] + add[j]) ma = pre[j] + add[j];
}
if (ma != num[i]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i < n; i++) printf("%I64d ", pre[i]);
printf("%d\n", pre[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5005], b[5005], c[5005], d[5005], l[5005], r[5005];
int main() {
int n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
b[i] = 1000000000;
}
for (i = 1; i <= m; i++) {
scanf("%d%d%d%d", &c[i], &l[i], &r[i], &d[i]);
for (j = l[i]; j <= r[i]; j++) {
if (c[i] == 1)
a[j] += d[i];
else
b[j] = min(b[j], d[i] - a[j]);
}
}
memset(a, 0, sizeof(a));
for (i = 1; i <= m; i++) {
int mm = -1000000000;
for (j = l[i]; j <= r[i]; j++) {
if (c[i] == 1)
a[j] += d[i];
else
mm = max(mm, b[j] + a[j]);
}
if (c[i] == 2 && mm != d[i]) break;
}
if (i > m) {
printf("YES\n");
for (i = 1; i < n; i++) {
printf("%d ", b[i]);
}
printf("%d\n", b[n]);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int n, m, ans[5001], l[5001], r[5001], mi[5001], d[5001], t[5001], diff[5001];
int main() {
memset(diff, 0, sizeof diff);
cin >> n >> m;
for (int i = 1; i <= n; i++) ans[i] = INF;
for (int i = 0; i < m; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> l[i] >> r[i] >> d[i];
for (int x = l[i]; x <= r[i]; x++) {
diff[x] += d[i];
}
} else {
cin >> l[i] >> r[i] >> mi[i];
for (int x = l[i]; x <= r[i]; x++) {
ans[x] = min(ans[x], mi[i] - diff[x]);
}
}
}
for (int i = 1; i <= n; i++) diff[i] = ans[i];
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int x = l[i]; x <= r[i]; x++) {
ans[x] += d[i];
}
} else {
int mx = -INF;
for (int x = l[i]; x <= r[i]; x++) {
mx = max(ans[x], mx);
}
if (mx < mi[i]) {
cout << "NO" << endl;
exit(0);
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (i > 1) cout << " ";
cout << diff[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[5005], orgnum[5005];
bool vis[5005];
int op[5005], l[5005], r[5005], d[5005];
int main() {
int n, opcnt;
memset(vis, false, sizeof(vis));
memset(num, 0, sizeof(num));
cin >> n >> opcnt;
for (int i = 0; i < opcnt; ++i) {
cin >> op[i] >> l[i] >> r[i] >> d[i];
}
for (int i = opcnt - 1; i >= 0; --i) {
if (op[i] == 2) {
for (int j = l[i]; j <= r[i]; ++j) {
if (!vis[j]) {
vis[j] = true;
num[j] = d[i];
} else {
num[j] = min(num[j], d[i]);
}
}
} else {
for (int j = l[i]; j <= r[i]; ++j) {
if (vis[j]) {
num[j] -= d[i];
}
}
}
}
for (int i = 1; i <= n; ++i) orgnum[i] = num[i];
bool ok = true;
for (int i = 0; i < opcnt; ++i) {
if (op[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) {
num[j] += d[i];
}
}
if (op[i] == 2) {
int curmax = -1000000000;
for (int j = l[i]; j <= r[i]; ++j) curmax = max(curmax, num[j]);
if (curmax != d[i]) {
ok = false;
break;
}
}
}
if (!ok) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) {
if (i != 1) cout << " ";
if (vis[i]) {
cout << orgnum[i];
} else {
cout << 0;
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, pair<int, int> > a[60000];
int ans[60000], b[60000], n, m, maxx;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++)
cin >> a[i].first.first >> a[i].first.second >> a[i].second.first >>
a[i].second.second;
for (int i = 1; i <= n; i++) ans[i] = (int)(1e9);
for (int i = m; i >= 1; i--) {
if (a[i].first.first == 1) {
for (int j = a[i].first.second; j <= a[i].second.first; j++)
if (ans[j] < (int)(1e9)) ans[j] -= a[i].second.second;
} else {
for (int j = a[i].first.second; j <= a[i].second.first; j++)
if (ans[j] > a[i].second.second) ans[j] = a[i].second.second;
}
}
for (int i = 1; i <= n; i++) b[i] = ans[i];
for (int i = 1; i <= m; i++) {
if (a[i].first.first == 1) {
for (int j = a[i].first.second; j <= a[i].second.first; j++)
if (ans[j] < (int)(1e9)) ans[j] += a[i].second.second;
} else {
maxx = -(int)(1e9);
for (int j = a[i].first.second; j <= a[i].second.first; j++)
if (ans[j] > maxx) maxx = ans[j];
if (maxx != a[i].second.second) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << b[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 100005;
struct Pt {
int t, l, r, v;
};
Pt cmds[5005];
long long data[5005];
long long L[5005], R[5005];
int check_max(int n, int l, int r, int v) {
int all_less = 1;
for (int i = l; i <= r; ++i) {
all_less = all_less && R[i] < v - data[i];
R[i] = min(R[i], v - data[i]);
if (R[i] < L[i]) return 0;
}
if (all_less) return 0;
return 1;
}
int check_max1(int n, int l, int r, int v) {
int all_less = 1;
for (int i = l; i <= r; ++i) {
all_less = all_less && R[i] < v - data[i];
}
if (all_less) return 0;
return 1;
}
int main() {
const int n = Rint(), m = Rint();
for (int i = 1; i <= n; ++i) L[i] = -1000000000, R[i] = 1000000000;
int ok = 1;
for (int id = 0; id < m; ++id) {
const int cmd = Rint(), l = Rint(), r = Rint(), v = Rint();
cmds[id].t = cmd;
cmds[id].l = l;
cmds[id].r = r;
cmds[id].v = v;
if (cmd == 1) {
for (int i = l; i <= r; ++i) {
data[i] += v;
}
} else {
if (!check_max(n, l, r, v)) {
ok = 0;
break;
}
}
}
if (!ok) {
puts("NO");
return 0;
}
ok = 1;
memset(data, 0, sizeof data);
for (int id = 0; id < m; ++id) {
const int cmd = cmds[id].t, l = cmds[id].l, r = cmds[id].r, v = cmds[id].v;
if (cmd == 1) {
for (int i = l; i <= r; ++i) {
data[i] += v;
}
} else {
if (!check_max1(n, l, r, v)) {
ok = 0;
break;
}
}
}
if (!ok) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%I64d ", R[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class op {
public:
int t, l, r, d;
op(){};
};
int main(void) {
int a[5010];
int f[5010];
for (int i = 0; i < (int)(5010); i++) {
a[i] = 0;
f[i] = 0;
}
int n, m;
cin >> n >> m;
op b[5010];
for (int i = 0; i < (int)(m); i++)
cin >> b[i].t >> b[i].l >> b[i].r >> b[i].d;
for (int i = m - 1; i >= 0; i--) {
if (b[i].t == 1) {
for (int k = b[i].l; k <= b[i].r; k++) a[k] -= b[i].d;
} else {
for (int k = b[i].l; k <= b[i].r; k++) {
if (!f[k] || a[k] > b[i].d) {
a[k] = b[i].d;
f[k] = 1;
}
}
}
}
int test[5010];
for (int i = 0; i < (int)(n + 1); i++) {
if (!f[i]) a[i] = 0;
test[i] = a[i];
}
for (int i = 0; i < (int)(m); i++) {
if (b[i].t == 1) {
for (int k = b[i].l; k <= b[i].r; k++) a[k] += b[i].d;
} else {
int ma = -1e9 - 1;
for (int k = b[i].l; k <= b[i].r; k++) {
ma = max(ma, a[k]);
}
if (ma != b[i].d) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (i == 1)
cout << test[i];
else
cout << " " << test[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, op, i, j;
scanf("%d %d", &n, &op);
int l[5005], r[5005], m[5005], t[5005];
for (i = 1; i <= op; i++) scanf("%d %d %d %d", &t[i], &l[i], &r[i], &m[i]);
vector<long long> ans(n + 5, 100000000);
for (i = op; i >= 1; i--) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) ans[j] -= m[i];
} else {
for (j = l[i]; j <= r[i]; j++)
if (ans[j] > m[i]) ans[j] = m[i];
}
}
vector<long long> tmp = ans;
for (i = 1; i <= op; i++) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) tmp[j] += m[i];
} else {
long long mx = -1000000000;
for (j = l[i]; j <= r[i]; j++) mx = max(mx, tmp[j]);
if (mx != m[i]) {
printf("NO");
return 0;
}
}
}
cout << "YES\n";
cout << ans[1] << " ";
for (i = 2; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int t[5005], l[5005], r[5005], d[5005];
int a[5005], b[5005];
bool flag = 1;
int main() {
memset(a, 0x3f, sizeof(a));
scanf("%d%d", &n, &m);
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++) b[j] += d[i];
}
if (t[i] == 2) {
for (int j = l[i]; j <= r[i]; j++) a[j] = min(a[j], d[i] - b[j]);
}
}
for (int i = 1; i <= n; i++)
if (a[i] == 0x3f3f3f3f) a[i] = 1000000000;
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) {
k = -0x3f3f3f3f;
for (int j = l[i]; j <= r[i]; j++) k = max(k, a[j]);
if (k != d[i]) flag = 0;
}
}
if (flag) {
memset(a, 0x3f, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) b[j] += d[i];
}
if (t[i] == 2) {
for (int j = l[i]; j <= r[i]; j++) a[j] = min(a[j], d[i] - b[j]);
}
}
for (int i = 1; i <= n; i++)
if (a[i] == 0x3f3f3f3f) a[i] = 1000000000;
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
} else
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> re(n, 1000000000);
vector<int> plus(n, 0);
vector<int> A(m), B(m), C(m), D(m);
for (int i = 0; i < m; i++) {
cin >> A[i] >> B[i] >> C[i] >> D[i];
int a = A[i], b = B[i], c = C[i], d = D[i];
if (a == 1) {
for (int k = b - 1; k < c; k++) {
plus[k] += d;
}
} else {
bool found = false;
for (int k = b - 1; k < c; k++) {
int most = d - plus[k];
if (most <= re[k]) {
re[k] = most;
found = true;
}
}
if (!found) {
cout << "NO";
return 0;
}
}
}
vector<int> p(n, 0);
for (int i = 0; i < m; i++) {
int a = A[i], b = B[i], c = C[i], d = D[i];
if (a == 1) {
for (int k = b - 1; k < c; k++) {
p[k] += d;
}
} else {
bool found = false;
for (int k = b - 1; k < c; k++) {
int most = d - p[k];
if (most <= re[k]) {
found = true;
}
}
if (!found) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i : re) {
cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int inf = 1e9;
int main() {
int n, q;
cin >> n >> q;
vector<int> t(q), l(q), r(q), v(q);
vector<int> added(n), ub(n, inf);
for (int j = 0; j < q; ++j) {
cin >> t[j] >> l[j] >> r[j] >> v[j];
l[j]--;
if (t[j] == 1) {
for (int i = l[j]; i < r[j]; ++i) {
added[i] += v[j];
}
} else {
for (int i = l[j]; i < r[j]; ++i) {
ub[i] = min(ub[i], v[j] - added[i]);
}
}
}
vector<int> ans = ub;
for (int i = 0; i < q; ++i) {
if (t[i] == 1) {
for (int j = l[i]; j < r[i]; ++j) {
ans[j] += v[i];
}
} else {
int maxi = -inf;
for (int j = l[i]; j < r[i]; ++j) {
maxi = max(maxi, ans[j]);
}
if (maxi != v[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; ++i) {
cout << ub[i] << " \n"[i + 1 == n];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6000;
const int inf = 60000000;
int l[maxn], r[maxn], answer[maxn];
int a[maxn][5];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &a[i][1], &a[i][2], &a[i][3], &a[i][4]);
}
for (int i = 1; i <= n; i++) {
l[i] = -inf;
r[i] = inf;
}
int flag = 0, ok = 0, one = 0;
for (int i = m; i >= 1; i--) {
flag = 0;
if (a[i][1] == 1) {
for (int j = a[i][2]; j <= a[i][3]; j++) {
l[j] -= a[i][4];
r[j] -= a[i][4];
}
} else {
for (int j = a[i][2]; j <= a[i][3]; j++) {
if (l[j] > a[i][4]) {
ok = 1;
} else if (r[j] >= a[i][4]) {
flag = 1;
r[j] = a[i][4];
}
}
if (flag == 0) {
ok = 1;
}
}
}
for (int i = 1; i <= n; i++) {
answer[i] = r[i];
}
if (ok == 1) {
printf("NO\n");
} else {
for (int i = 1; i <= m; i++) {
if (a[i][1] == 1) {
for (int j = a[i][2]; j <= a[i][3]; j++) {
r[j] += a[i][4];
}
} else {
int maxx = -inf;
for (int j = a[i][2]; j <= a[i][3]; j++) {
if (r[j] > maxx) {
maxx = r[j];
}
}
if (maxx != a[i][4]) {
one = 1;
printf("NO\n");
break;
}
}
}
if (one == 0) {
printf("YES\n");
printf("%d", answer[1]);
for (int t = 2; t <= n; t++) {
printf(" %d", answer[t]);
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, v[5100][4];
bool solved[5100];
int val[5100];
void f(int p);
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> v[i][1] >> v[i][2] >> v[i][3] >> v[i][4];
for (int i = 1; i <= n; i++) f(i);
for (int i = 1; i <= m; i++) {
if (v[i][1] == 2 && !solved[i]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << val[i] << ' ';
return 0;
}
void f(int p) {
int initial = 1e9, add = 0;
for (int i = 1; i <= m; i++) {
if (v[i][1] == 1 && v[i][2] <= p && v[i][3] >= p) {
add += v[i][4];
}
if (v[i][1] == 2 && v[i][2] <= p && v[i][3] >= p) {
if (v[i][4] < initial + add) initial = v[i][4] - add;
}
}
val[p] = initial;
add = 0;
for (int i = 1; i <= m; i++) {
if (v[i][1] == 1 && v[i][2] <= p && v[i][3] >= p) add += v[i][4];
if (v[i][1] == 2 && v[i][2] <= p && v[i][3] >= p &&
v[i][4] == initial + add)
solved[i] = 1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int delta[5555];
int maxs[5555];
struct query {
int t, l, r, d;
query(){};
query(int T, int L, int R, int D) : t(T), l(L), r(R), d(D) {}
void get(int &T, int &L, int &R, int &D) {
T = t;
L = l;
R = r;
D = d;
}
};
query qs[5555];
int main() {
int n, t, m, l, r, d;
bool good = true;
cin >> n >> m;
for (int j = (1); j <= (n); ++j) {
delta[j] = 0;
maxs[j] = 100000000;
}
for (int i = 0; i < (m); ++i) {
cin >> t >> l >> r >> d;
qs[i] = query(t, l, r, d);
}
for (int i = 0; i < (m); ++i) {
qs[i].get(t, l, r, d);
if (t == 1) {
for (int j = (l); j <= (r); ++j) delta[j] += d;
} else {
for (int j = (l); j <= (r); ++j) {
if (maxs[j] + delta[j] > d) maxs[j] = d - delta[j];
}
}
}
for (int j = (1); j <= (n); ++j) delta[j] = 0;
for (int i = 0; i < (m); ++i) {
qs[i].get(t, l, r, d);
if (t == 1) {
for (int j = (l); j <= (r); ++j) delta[j] += d;
} else {
int m = -1000000000;
for (int j = (l); j <= (r); ++j) {
if (maxs[j] + delta[j] > m) m = maxs[j] + delta[j];
}
if (m != d) good = false;
}
}
if (good) {
cout << "YES\n";
for (int j = (1); j <= (n); ++j) cout << maxs[j] << " ";
cout << "\n";
} else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6000;
int t[maxn], l[maxn], r[maxn], d[maxn], a[maxn], b[maxn];
int n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = 5e7;
for (int i = 1; i <= m; i++) cin >> t[i] >> l[i] >> r[i] >> d[i];
for (int i = m; i >= 1; 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 <= n; i++) b[i] = a[i];
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) b[j] += d[i];
} else {
int flag = 0;
for (int j = l[i]; j <= r[i]; j++)
if (b[j] == d[i]) flag = 1;
if (!flag) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
printf("%d", a[i]);
if (i != n)
printf(" ");
else
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int tab[n], pow[n], t[m], a[m], b[m], w[m];
for (int i = 0; i < n; i++) {
tab[i] = 100000000;
pow[i] = 0;
}
for (int i = 0; i < m; i++) {
cin >> t[i] >> a[i] >> b[i] >> w[i];
if (t[i] == 1) {
for (int j = a[i] - 1; j < b[i]; j++) pow[j] += w[i];
} else {
for (int j = a[i] - 1; j < b[i]; j++) tab[j] = min(tab[j], w[i] - pow[j]);
}
}
int maks;
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = a[i] - 1; j < b[i]; j++) tab[j] += w[i];
} else {
maks = -1000000000;
for (int j = a[i] - 1; j < b[i]; j++) maks = max(maks, tab[j]);
if (maks != w[i]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int j = 0; j < n; j++) cout << tab[j] - pow[j] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct el {
long long added;
long long current;
unordered_set<int> resolved;
bool ass;
el() : added(0), current(0), ass(false) {}
};
int smax[5005] = {0};
el elems[5005];
int main() {
int n, m, ti, li, ri, di;
vector<int> all_maxes;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d %d %d", &ti, &li, &ri, &di);
if (ti == 1) {
for (int j = li - 1; j <= ri - 1; ++j) {
elems[j].current += di;
elems[j].added += di;
}
} else if (ti == 2) {
all_maxes.push_back(i);
for (int j = li - 1; j <= ri - 1; ++j) {
el &curr = elems[j];
int &mmx = smax[i];
if (!curr.ass) {
curr.current = di;
curr.ass = true;
curr.resolved.insert(i);
++mmx;
} else {
if (curr.current == di) {
curr.resolved.insert(i);
++mmx;
} else if (curr.current > di) {
for (auto it = curr.resolved.begin(); it != curr.resolved.end();
++it)
--smax[*it];
curr.resolved.clear();
curr.current = di;
curr.resolved.insert(i);
++mmx;
}
}
}
}
}
for (auto it = all_maxes.cbegin(); it != all_maxes.cend(); ++it) {
if (smax[*it] <= 0) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (int i = 0; i < n; ++i) {
printf("%d ", elems[i].current - elems[i].added);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
const int INF = 1e9;
struct s {
int t, li, ri, d;
s(){};
s(int t1, int l1, int r1, int d1) { t = t1, li = l1, ri = r1, d = d1; }
};
vector<s> Q;
int A[maxn], B[maxn];
int diff[maxn];
inline void solve(void) {
int n, m, x, l, r, f;
cin >> n >> m;
for (int i = (0); i < (m); i++) {
cin >> x >> l >> r >> f;
Q.push_back(s(x, l, r, f));
}
for (int i = 1; i <= n; i++) A[i] = INF;
for (int i = 0; i < m; i++) {
int t = Q[i].t, l = Q[i].li, r = Q[i].ri, m = Q[i].d;
if (t == 2) {
for (int j = l; j <= r; j++) A[j] = min(A[j], m - diff[j]);
}
if (t == 1) {
for (int j = l; j <= r; j++) diff[j] += m;
}
}
for (int i = 1; i <= n; i++) B[i] = A[i];
for (int i = 0; i < m; i++) {
int t = Q[i].t, l = Q[i].li, r = Q[i].ri, m = Q[i].d;
if (t == 1)
for (int j = l; j <= r; j++) A[j] += m;
if (t == 2) {
int M = -INF;
for (int j = l; j <= r; j++) M = max(A[j], M);
if (M != m) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << B[i] << " ";
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char* argv[]) {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 5000;
long long m, n, ans[MN], d[MN], op[MN], lo[MN], hi[MN], v[MN];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) ans[i] = 1e9;
for (int k = 0; k < m; k++) {
cin >> op[k] >> lo[k] >> hi[k] >> v[k];
lo[k]--;
hi[k]--;
if (op[k] == 1) {
for (int p = lo[k]; p < hi[k] + 1; p++) d[p] += v[k];
} else {
int ok = 0;
for (int p = lo[k]; p < hi[k] + 1; p++) {
ok |= (ans[p] + d[p] >= v[k]);
ans[p] = min(v[k] - d[p], ans[p]);
}
if (!ok) {
cout << "NO\n";
return 0;
}
}
}
int foi = 1;
memset(d, 0, sizeof d);
for (int k = 0; foi && k < m; k++) {
if (op[k] == 1) {
for (int p = lo[k]; p < hi[k] + 1; p++) d[p] += v[k];
} else {
int ok = 0;
for (int p = lo[k]; p < hi[k] + 1; p++) ok |= (ans[p] + d[p] >= v[k]);
foi &= ok;
}
}
if (foi) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
} else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, z, a[5050], l[5050], r[5050], d[5050], t[5050], b[5050];
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) scanf("%d%d%d%d", &t[i], &l[i], &r[i], &d[i]);
for (i = 1; i <= n; i++) a[i] = 100000000;
for (i = m - 1; i >= 0; i--)
for (j = l[i]; j <= r[i]; j++)
if (t[i] == 1)
a[j] -= d[i];
else
a[j] = min(a[j], d[i]);
for (j = 1; j <= n; j++) b[j] = a[j];
for (i = 0; i < m; i++)
if (t[i] == 2) {
z = a[l[i]];
for (j = l[i] + 1; j <= r[i]; j++) z = max(z, a[j]);
if (z != d[i]) {
cout << "NO";
return 0;
}
} else
for (j = l[i]; j <= r[i]; j++) a[j] += d[i];
cout << "YES\n";
for (j = 1; j <= n; j++) printf("%d ", b[j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int psum[5010], max_val[5010];
long long int mmin(long long int a, long long int b) {
if (a < b) return a;
return b;
}
int main() {
long long int qry[5010], l[5010], r[5010], d[5010], x, y, v, N, M, psum[5010],
max_val[5010];
cin >> N >> M;
for (int i = 0; i < 5004; i++) {
psum[i] = 0;
max_val[i] = 1000000000;
}
for (int i = 1; i <= M; i++) {
cin >> qry[i] >> l[i] >> r[i] >> d[i];
if (qry[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) psum[j] += d[i];
} else {
for (int j = l[i]; j <= r[i]; j++)
max_val[j] = mmin(max_val[j], d[i] - psum[j]);
}
}
for (int i = 1; i <= N; i++) {
if (max_val[i] < -1000000000 || max_val[i] > 1000000000) {
printf("NO\n");
return 0;
}
}
long long int curr_max;
for (int i = 0; i < 5010; i++) psum[i] = 0;
for (int i = 1; i <= M; i++) {
if (qry[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) psum[j] += d[i];
} else {
curr_max = -10000000000;
for (int j = l[i]; j <= r[i]; j++) {
if (curr_max < (max_val[j] + psum[j])) curr_max = max_val[j] + psum[j];
}
if (curr_max != d[i]) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= N - 1; i++) printf("%lld ", max_val[i]);
printf("%lld\n", max_val[N]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void do_nothing() {}
void solve() {
int n, m;
cin >> n >> m;
vector<int> shifts(n, 0);
const int LAMAX = 2 * 1000000000;
vector<int> lims(n, LAMAX);
vector<array<int, 4> > ops(m);
for (int(iop) = 0; (iop) < (m); (iop)++) {
int t, l, r, v;
cin >> t >> l >> r >> v;
ops[iop][0] = t;
ops[iop][1] = l;
ops[iop][2] = r;
ops[iop][3] = v;
}
for (int(iop) = 0; (iop) < (m); (iop)++) {
int t = ops[iop][0];
int l = ops[iop][1];
int r = ops[iop][2];
int v = ops[iop][3];
l--;
r--;
if (t == 1) {
for (int i = (l); i < (int)(r + 1); i++) shifts[i] += v;
} else {
for (int i = (l); i < (int)(r + 1); i++)
lims[i] = min(lims[i], v - shifts[i]);
}
}
for (int(i) = 0; (i) < (n); (i)++)
if (lims[i] == LAMAX) lims[i] = 0;
std::fill(shifts.begin(), shifts.end(), 0);
bool ok = true;
for (int(iop) = 0; (iop) < (m); (iop)++) {
int t = ops[iop][0];
int l = ops[iop][1];
int r = ops[iop][2];
int v = ops[iop][3];
l--;
r--;
if (t == 1) {
for (int i = (l); i < (int)(r + 1); i++) shifts[i] += v;
} else {
bool thisok = false;
for (int i = (l); i < (int)(r + 1); i++)
if (lims[i] + shifts[i] == v) {
thisok = true;
break;
}
if (!thisok) {
ok = false;
break;
}
}
}
if (!ok) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int(i) = 0; (i) < (n); (i)++) cout << lims[i] << " ";
cout << "\n";
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const int maxn = 5005;
struct node {
int t, l, r, m;
} op[maxn];
int n, m;
int num[maxn], add[maxn];
int main() {
int flag, flag1;
while (cin >> n >> m) {
for (int i = 1; i <= m; i++)
cin >> op[i].t >> op[i].l >> op[i].r >> op[i].m;
for (int i = 1; i <= n; i++) num[i] = inf;
memset(add, 0, sizeof(add));
for (int i = m; i >= 1; i--) {
if (op[i].t == 1)
for (int j = op[i].l; j <= op[i].r; j++) num[j] -= op[i].m;
else
for (int j = op[i].l; j <= op[i].r; j++) num[j] = min(num[j], op[i].m);
}
for (int i = 1; i <= m; i++) {
flag1 = flag = 0;
for (int j = op[i].l; j <= op[i].r; j++) {
if (op[i].t == 1)
add[j] += op[i].m;
else {
if (add[j] + num[j] > op[i].m) {
flag = 1;
break;
}
if (add[j] + num[j] == op[i].m) flag1 = 1;
}
}
if (!flag1 && op[i].t == 2) flag = 1;
if (flag) break;
}
if (flag)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 1; i <= n; i++) {
if (num[i] >= inf) num[i] = 1e9;
if (i != n)
cout << num[i] << " ";
else
cout << num[i] << "\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
int m;
int dif;
int ans;
while (scanf("%d %d", &n, &c) == 2) {
vector<int> num;
for (int i = 0; i < n; i++) {
scanf("%d", &m);
num.push_back(m);
}
dif = ans = 0;
for (int i = 1; i < num.size(); i++) {
if (num[i - 1] - num[i] > dif) {
dif = num[i - 1] - num[i];
ans = num[i - 1] - num[i] - c;
}
}
if (ans < 0)
printf("0\n");
else
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, m = 0;
cin >> n >> c;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
m = max(m, a[i] - a[i + 1] - c);
}
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100010;
vector<long long> ans;
int main() {
int n, c;
cin >> n >> c;
int a[111];
int max = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int tmp = a[i];
if (tmp - a[i + 1] - c > max) {
max = tmp - a[i + 1] - c;
}
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1E-9;
int main() {
int n, c, a[1000], res = -10000000 + 13;
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int tmp = a[i] - c - a[i + 1];
if (tmp > res) res = tmp;
if (res < 0) res = 0;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAX_N = 100 + 10;
int n, c, x[MAX_N];
int main() {
ios::sync_with_stdio(0);
while (cin >> n >> c) {
for (int i = 0; i < n; i++) {
cin >> x[i];
}
int profit = 0;
for (int i = 0; i < n - 1; i++) {
int get = x[i];
get -= x[i + 1];
get -= c;
profit = max(profit, get);
}
printf("%d\n", profit);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, m;
int a[100100];
int main() {
cin >> n >> c;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n - 1; i++) {
m = max(m, a[i] - a[i + 1] - c);
}
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long max1 = -9999999999999, i, t, x, y, c, n;
cin >> n >> c;
cin >> x;
for (i = 0; i < n - 1; i++) {
cin >> y;
max1 = max1 > x - y ? max1 : x - y;
x = y;
}
if (max1 - c < 0)
cout << 0 << endl;
else
cout << max1 - c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[1000];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int diff = INT_MIN;
int curr_i;
for (int i = 0; i < n - 1; i++) {
if (diff < arr[i] - arr[i + 1] - k) {
diff = arr[i] - arr[i + 1] - k;
}
}
if (diff > 0)
cout << diff << endl;
else
cout << "0";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, c, ar[1005] = {0};
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> ar[i];
long x, ans = 0, ll;
for (int i = 0; i < n - 1; i++) {
x = (ar[i] - ar[i + 1] - c);
ans = max(ans, x);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, ans = 0;
scanf("%d%d%d", &n, &m, &a);
for (int i = 1; i < n; i++) {
scanf("%d", &b);
ans = max(a - b - m, ans);
a = b;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Max = INT_MIN, Min = INT_MAX;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m, mx = 0;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
if ((a[i] - a[i + 1] - m) > mx) {
mx = (a[i] - a[i + 1] - m);
}
}
cout << ((mx > 0) ? mx : 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, max = 0;
cin >> a >> b;
int *mas = new int[a];
cin >> mas[0];
for (int i = 1; i < a; ++i) {
cin >> mas[i];
if (max < mas[i - 1] - mas[i] - b) {
max = mas[i - 1] - mas[i] - b;
}
}
cout << max << endl;
delete[] mas;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1111];
long long res;
int main() {
int n, c;
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
res = max(a[i] - a[i + 1] - c, res);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (cin >> n >> k) {
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int mx = 0;
for (int i = 0; i < n - 1; i++) {
if (arr[i] - arr[i + 1] - k > mx) {
mx = arr[i] - arr[i + 1] - k;
}
}
cout << mx << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int v[n];
for (int i = 0; i < n; i++) cin >> v[i];
int sol = 0;
for (int i = 0; i < n - 1; i++) {
sol = max(sol, v[i] - v[i + 1] - c);
}
cout << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int numOfDays, lendingPrice;
cin >> numOfDays >> lendingPrice;
int arrOfPrices[numOfDays];
int maxDifference = -100000000;
int maxDifferenceStartIndex = 0;
for (int i = 0; i < numOfDays; i++) {
cin >> arrOfPrices[i];
}
for (int i = 0; i < numOfDays - 1; i++) {
if (arrOfPrices[i] - arrOfPrices[i + 1] > maxDifference) {
maxDifference = arrOfPrices[i] - arrOfPrices[i + 1];
maxDifferenceStartIndex = i;
}
}
int ans = arrOfPrices[maxDifferenceStartIndex] -
arrOfPrices[maxDifferenceStartIndex + 1] - lendingPrice;
if (ans >= 0)
cout << ans;
else
cout << 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 1007;
const long long modulo = 1000000007;
const long long INF = 1e9;
const double EPS = 1e-6;
char a[size][size];
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i > 0) ans = max(ans, a[i - 1] - a[i] - k);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int a[n];
int max = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
if (a[i] - a[i + 1] > max) {
max = a[i] - a[i + 1];
}
}
if (max - c < 0) {
cout << 0;
} else
cout << max - c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int days, rentPrice, currDayPrice = 0, afterCurrDayPrice = 0, minus,
prices[100];
minus = 0;
cin >> days >> rentPrice;
for (int i = 1; i < days + 1; i++) {
cin >> prices[i];
}
for (int i = 1; i < days + 1; i++) {
if (i == days) break;
int diff = prices[i] - prices[i + 1];
if (diff > minus) {
minus = diff;
currDayPrice = prices[i];
afterCurrDayPrice = prices[i + 1];
}
}
int earn = (currDayPrice - afterCurrDayPrice) - rentPrice;
if ((currDayPrice + afterCurrDayPrice) == 0) earn = 0;
cout << ((earn > 0) ? earn : 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 100010;
vector<int> v;
int main() {
int a, c, n, t;
cin >> n >> c;
t = n;
while (t--) {
cin >> a;
v.push_back(a);
}
int res = 0;
for (int i = 0; i < n - 1; ++i) {
int diff = (v[i] - v[i + 1] - c);
res = max(res, diff);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, a[110], c, i, d[110], max;
scanf("%d%d", &n, &c);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) {
d[i] = a[i] - a[i + 1];
}
max = -1001;
for (i = 0; i < n - 1; i++) {
if (d[i] > max) {
max = d[i];
}
}
max = max - c;
if (max < 0)
printf("0\n");
else
printf("%d\n", max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n, c;
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
int max = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] - a[i + 1] > max) max = a[i] - a[i + 1];
}
if (max - c > 0)
printf("%d\n", max - c);
else
printf("0\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d = -99999999, e, f, mas[105];
cin >> a >> b;
for (c = 0; c < a; c++) {
cin >> mas[c];
}
for (c = 0; c < a - 1; c++) {
if (d < mas[c] - mas[c + 1]) {
d = mas[c] - mas[c + 1];
}
}
if (d - b < 0)
cout << 0;
else
cout << d - b;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, c, arr[105], diff = 0, s;
scanf("%d %d", &n, &c);
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
for (i = 0; i < n - 1; i++) {
if ((arr[i] - arr[i + 1]) > 0) {
if ((arr[i] - arr[i + 1]) > diff) {
diff = arr[i] - arr[i + 1];
s = i + 1;
}
}
}
printf("%d", (diff - c > 0 ? diff - c : 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, arr[105], maxx = 0;
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n - 1; i++) {
if (arr[i] - arr[i + 1] > maxx) maxx = arr[i] - arr[i + 1];
}
if (maxx - c > 0)
cout << maxx - c;
else
cout << "0";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int a[n];
int mn = -1;
int indexMin = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) mn = max(mn, a[i] - a[i + 1]);
if (mn == -1 || mn - c < 0)
cout << "0";
else
cout << mn - c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, arr[105];
int ans;
int main() {
int i, j;
cin >> n >> c;
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
for (i = 2; i <= n; i++) {
ans = max(ans, arr[i - 1] - arr[i]);
}
cout << max(ans - c, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500], c, i, n, big;
int main() {
while (~scanf(" %d %d", &n, &c)) {
for (i = 0; i < n; i++) {
scanf(" %d", &a[i]);
}
big = 0;
for (i = 0; i < n - 1; i++) {
if (a[i] - a[i + 1] - c > big) big = a[i] - a[i + 1] - c;
}
printf("%d\n", big);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
scanf("%d%d", &n, &c);
int a[n], b[n - 1];
scanf("%d", &a[0]);
for (int i = 1; i < n; i++) {
scanf("%d", &a[i]);
b[i - 1] = a[i - 1] - a[i] - c;
}
int max = 0;
for (int i = 0; i < n - 1; i++) {
if (b[i] > max) max = b[i];
}
printf("%d\n", max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d%d", &a, &b);
vector<int> d(a);
for (int i = 0; i < a; i++) {
scanf("%d", &d[i]);
}
int l = 0, k = 0;
for (int i = 0; i < a - 1; i++) {
l = d[i] - d[i + 1];
k = max(k, l);
}
l = k - b;
if (l <= 0) {
cout << 0;
} else {
cout << l;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& o, const pair<A, B>& p) {
return o << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it)
o << *it << ", ";
return o << "]";
}
template <class T>
ostream& operator<<(ostream& o, const set<T>& v) {
o << "[";
for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it)
o << *it << ", ";
return o << "]";
}
template <class T>
inline void MAX(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline void MIN(T& a, T b) {
if (a > b) a = b;
}
template <class T>
inline bool read(T& x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int main() {
vector<int> x;
int n = ({
int a;
scanf("%d", &a);
a;
}),
c = ({
int a;
scanf("%d", &a);
a;
});
for (__typeof((n)-1) i = (0); i <= (n)-1; ++i)
x.push_back(({
int a;
scanf("%d", &a);
a;
}));
int ans = 0;
for (__typeof((n - 1) - 1) i = (0); i <= (n - 1) - 1; ++i) {
int tt = x[i] - x[i + 1] - c;
if (tt > ans) ans = tt;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
string str;
long long solve() {
long long c;
cin >> n >> c;
long long x[n];
for (long long i = 0; i <= n - 1; ++i) cin >> x[i];
for (long long i = 0; i <= n - 2; ++i) {
ans = max(ans, x[i] - x[i + 1] - c);
}
cout << ans;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int X[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int Y[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int N = 1e5 + 10;
int n, c, a[N];
int main() {
cin >> n >> c;
for (int i = 0; i < n; ++i) cin >> a[i];
int ans = 0;
for (int i = 0; i + 1 < n; ++i) ans = max(ans, a[i] - a[i + 1] - c);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, b, rasn = -100000;
cin >> d >> b;
vector<int> rin(d);
for (int i = 0; i < d; ++i) {
cin >> rin[i];
}
for (int i = 0; i < d - 1; ++i) {
if (rin[i] - rin[i + 1] - b >= rasn) {
rasn = rin[i] - rin[i + 1] - b;
}
}
if (rasn < 0) {
cout << 0;
return 0;
}
cout << rasn;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int resp[n];
for (int i = 0; i < n; i++) {
cin >> resp[i];
}
vector<int> profit;
for (int i = 1; i < n; i++) {
int a = (resp[i - 1] - resp[i] - c);
profit.push_back(a);
}
sort(profit.begin(), profit.end());
if (profit[profit.size() - 1] > 0) {
cout << profit[profit.size() - 1];
} else {
cout << 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, c, temp;
cin >> n >> c;
pair<int, int> p;
vector<int> v;
for (int i = 0; i < int(n); ++i) {
cin >> temp;
v.push_back(temp);
}
p.first = v[0];
p.second = v[1];
if (n > 2) {
for (int i = 1; i < n - 1; ++i) {
if (p.first - p.second < v[i] - v[i + 1]) {
p.first = v[i];
p.second = v[i + 1];
}
}
}
int ans = p.first - p.second - c;
ans = (ans > 0) ? ans : 0;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, i, mx, c, a[200];
int main() {
while (~scanf("%ld%ld", &n, &c)) {
for (i = 0; i < n; i++) scanf("%ld", &a[i]);
mx = 0;
for (i = 1; i < n; i++) {
if ((a[i - 1] - a[i]) > mx) mx = a[i - 1] - a[i];
}
mx -= c;
if (mx > 0)
printf("%ld\n", mx);
else
printf("0\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int countSetBits(int n) {
int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
void swap(char &c2, char &c1) {
char temp = c2;
c2 = c1;
c1 = temp;
}
int main() {
int n, a[100], b[100], k, sum = 0, ma = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) b[i] = a[i] - a[i + 1];
for (int i = 0; i < n - 1; i++) {
ma = max(ma, b[i]);
}
cout << max(ma - k, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, ar[101], mx = 0;
cin >> a >> b;
for (int x = 0; x < a; x++) {
cin >> ar[x];
}
for (int x = 0; x < a - 1; x++) {
mx = max(mx, ar[x] - ar[x + 1] - b);
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, c;
while (cin >> n >> c) {
long i, a[100001] = {0}, d = 0, mx = 0;
for (int i = 0, _n = n; i < _n; i++) {
cin >> a[i];
}
for (i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
d = a[i] - a[i + 1];
mx = max(d, mx);
}
}
if (mx - c >= 0)
cout << mx - c;
else
cout << "0";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool debug = false;
int n, m, k, l;
const int inf = 1000 * 1000 * 1000;
const int MAKSN = 1000 + 13;
vector<int> v;
int ans = 0;
int poprz;
void readIn() {
scanf("%d %d", &n, &m);
scanf("%d", &poprz);
for (int i = 0; i < (int)n - 1; i++) {
scanf("%d", &k);
ans = max(poprz - k, ans);
poprz = k;
}
printf("%d\n", max(ans - m, 0));
}
void solve() {}
int main() {
readIn();
solve();
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, c, amount = 0, i = 0, element, max = 0, tmp;
std::vector<int> prices;
std::cin >> n >> c;
do {
std::cin >> element;
prices.push_back(element);
i++;
} while (i < n);
for (int j = 0; j < prices.size() - 1; j++) {
amount = prices[j];
if (prices[j + 1] <= amount) {
tmp = amount - prices[j + 1] - c;
if (tmp > max) max = tmp;
}
}
std::cout << max;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.