text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int main() {
int i, one, two, three;
char ch[150];
while (scanf("%s", ch) == 1) {
one = 0;
two = 0;
three = 0;
for (i = 0; ch[i] != '\0'; i++) {
if (ch[i] == '1')
one++;
else if (ch[i] == '2')
two++;
else if (ch[i] == '3')
three++;
}
if (one != 0) {
for (i = 0; i < one - 1; i++) printf("1+");
if ((two == 0) && (three == 0))
printf("1");
else
printf("1+");
}
if (two != 0) {
for (i = 0; i < two - 1; i++) printf("2+");
if (three == 0)
printf("2");
else
printf("2+");
}
if (three != 0) {
for (i = 0; i < three - 1; i++) printf("3+");
printf("3");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int a[100];
char s[105], i, k = 0, j, temp;
scanf("%s", s);
for (i = 0; i < strlen(s); i += 2) a[k++] = (int)(s[i] - '0');
for (i = 0; i < k; i++)
for (j = (i + 1); j < k; j++) {
if (a[i] >= a[j]) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
k = 0;
for (i = 1; i < strlen(s); i += 2) {
printf("%d%c", a[k], s[i]);
k++;
}
printf("%d", a[k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j;
string s, s1 = "", s2 = "";
cin >> s;
for (int i = 0; i < s.length(); i++)
if (s[i] != '+') s1 += s[i];
sort(s1.begin(), s1.end());
for (int i = 0; i < s1.length(); i++) {
s2 += s1[i];
s2 += "+";
}
s2.erase(s2.begin() + s2.length() - 1);
cout << s2;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int a[10], i;
int main() {
cin >> s;
for (int i = 0; i <= s.length() - 1; i++) {
if (s[i] == '1') {
a[1]++;
} else if (s[i] == '2') {
a[2]++;
} else if (s[i] == '3') {
a[3]++;
}
}
while (a[1] > 0) {
if ((a[2] > 0) || (a[1] - 1 > 0) || (a[3] > 0)) {
cout << "1+";
} else {
cout << "1";
}
a[1]--;
}
while (a[2] > 0) {
if ((a[3] > 0) || (a[2] - 1 > 0)) {
cout << "2+";
} else {
cout << "2";
}
a[2]--;
}
while (a[3] > 0) {
if (a[3] - 1 > 0) {
cout << "3+";
} else {
cout << "3";
}
a[3]--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i, j, arr[s.size() / 2 + 1];
for (i = 0, j = 0; i < s.size(); i += 2, j++) arr[j] = s.at(i);
sort(arr, arr + j);
for (i = 0, j = 0; i < s.size(); i += 2, j++) s.at(i) = arr[j];
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1')
a++;
else if (s[i] == '2')
b++;
else if (s[i] == '3')
c++;
}
while (1) {
if (!a && !b && !c) break;
if (a) {
if (a == 1 && b == 0 && c == 0)
cout << "1" << endl;
else
cout << "1+";
a--;
} else if (b) {
if (b == 1 && a == 0 && c == 0)
cout << "2" << endl;
else
cout << "2+";
b--;
} else if (c) {
if (c == 1 && b == 0 && a == 0)
cout << "3" << endl;
else
cout << "3+";
c--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s == "1") {
cout << "1" << endl;
} else if (s == "2") {
cout << "2" << endl;
} else if (s == "3") {
cout << "3" << endl;
} else {
for (int i = 0; i < s.length() - 2; i += 2) {
for (int j = 0; j < s.length() - 2; j += 2) {
if (s[j] > s[j + 2]) {
swap(s[j], s[j + 2]);
}
}
}
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.size() == 1)
cout << s << endl;
else {
string ans;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') ans = ans + s[i] + '+';
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == '2') ans = ans + s[i] + '+';
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == '3') ans = ans + s[i] + '+';
}
for (int i = 0; i < ans.size() - 1; i++) {
cout << ans[i];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 10;
int a[maxn];
int b[maxn];
int c[maxn];
int cnt[maxn];
int n, m;
bool mark[maxn];
int q[maxn][5];
bool Bomb;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> q[i][1];
if (q[i][1] == 1) {
cin >> q[i][2] >> q[i][3] >> q[i][4];
for (int j = q[i][2]; j <= q[i][3]; j++) cnt[j] += q[i][4];
} else {
cin >> q[i][2] >> q[i][3] >> q[i][4];
bool flag = 0;
for (int j = q[i][2]; j <= q[i][3]; j++) {
if (!mark[j]) {
flag = true;
a[j] = q[i][4] - cnt[j];
b[j] = q[i][4];
mark[j] = true;
cnt[j] = 0;
} else {
if (cnt[j] + b[j] >= q[i][4]) {
flag = true;
int t = b[j] + cnt[j];
t -= q[i][4];
a[j] -= t;
b[j] = q[i][4];
} else
b[j] += cnt[j];
cnt[j] = 0;
}
}
if (!flag) Bomb = true;
}
}
for (int i = 1; i <= n; i++) c[i] = a[i];
if (Bomb) {
cout << "NO";
return 0;
} else {
for (int i = 1; i <= m; i++) {
if (q[i][1] == 1)
for (int j = q[i][2]; j <= q[i][3]; j++) a[j] += q[i][4];
else {
int mx = -1000000001;
for (int j = q[i][2]; j <= q[i][3]; j++) mx = max(mx, a[j]);
if (mx != q[i][4]) Bomb = true;
}
}
if (Bomb) {
cout << "NO";
return 0;
} else {
bool F = 0;
for (int i = 1; i <= n; i++)
if (c[i] > 1000000000 || c[i] < -1000000000) F = true;
if (F) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << c[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] = -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 = -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>
using namespace std;
const int MAXN = 1e5 + 5;
const double EPS = 1e-7;
const int INF = 1000000000 + 5;
const int MAXN2 = 5000 + 5;
int val[MAXN2][MAXN2];
int n, m;
int sz = 1;
int q[MAXN][3];
int res[MAXN];
int main() {
cin >> n >> m;
int t, l, r, d;
for (int i = 0; i < n; i++) {
res[i] = INF;
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &t, &l, &r, &d);
if (t == 1) {
l--;
r--;
for (int j = l; j <= r; j++) {
val[sz][j] += d;
}
} else {
l--;
r--;
q[sz][0] = l;
q[sz][1] = r;
q[sz][2] = d;
sz++;
for (int j = 0; j < n; j++) {
val[sz][j] = val[sz - 1][j];
}
}
}
for (int i = 1; i < sz; i++) {
for (int j = q[i][0]; j <= q[i][1]; j++) {
res[j] = min(res[j], q[i][2] - val[i][j]);
}
}
for (int i = 0; i < n; i++) {
if (res[i] == INF) res[i] = 0;
}
int v;
bool was, good;
for (int i = 1; i < sz; i++) {
was = false;
good = true;
for (int j = q[i][0]; j <= q[i][1]; j++) {
v = res[j] + val[i][j];
if (v == q[i][2]) was = true;
if (v > q[i][2]) good = false;
}
if (!(was && good)) {
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;
int main() {
int n, m;
cin >> n >> m;
long long inf = 300000000000;
long long a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
a[i] = 0;
b[i] = 0;
c[i] = inf;
}
int t[m], l[m], r[m], d[m];
for (int i = 0; i < m; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> l[i] >> r[i] >> d[i];
for (int j = l[i] - 1; j < r[i]; j++) {
a[j] += d[i];
}
} else {
cin >> l[i] >> r[i] >> d[i];
for (int j = l[i] - 1; j < r[i]; j++) {
c[j] = min(c[j], d[i] - a[j]);
}
}
}
for (int i = 0; i < n; i++) {
if (c[i] == inf) {
b[i] = -2000000;
c[i] = -2000000;
} else
b[i] = c[i];
}
long long ma, posma;
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i] - 1; j < r[i]; j++) {
b[j] += d[i];
}
} else {
ma = b[l[i] - 1];
for (int j = l[i] - 1; j < r[i]; j++) {
posma = b[j];
if (posma > ma) ma = posma;
}
if (ma != d[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (i) cout << ' ';
cout << c[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class sp {
public:
int q;
sp *w;
sp(int e, sp *r) {
q = e;
w = r;
}
};
int main() {
int q, w, w1 = 0, e, r, t, y, u, a[5000], d[5000], f[5000];
sp *s[5000], *c;
cin >> q >> w;
for (e = 0; e < q; e++) {
a[e] = 500000000;
f[e] = 0;
s[e] = 0;
}
for (e = 0; e < w; e++) {
cin >> r >> t >> y >> u;
t--;
if (r == 1)
for (; t < y; t++) {
a[t] += u;
f[t] += u;
}
else {
d[w1] = 0;
for (; t < y; t++) {
if (a[t] > u) {
a[t] = u;
for (c = s[t]; c; c = c->w) d[c->q]--;
s[t] = new sp(w1, 0);
d[w1]++;
}
if (a[t] == u) {
s[t] = new sp(w1, s[t]);
d[w1]++;
}
}
w1++;
}
}
for (w = 0; w < w1; w++)
if (d[w] == 0) {
cout << "NO";
goto stop;
}
cout << "YES\n";
for (w = 0; w < q; w++) cout << a[w] - f[w] << " ";
stop:
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, t[5005], l[5005], r[5005], d[5005], add[5005], maxi[5005],
ans[5005], temp, inf = 1000000000;
scanf("%lld %lld", &n, &m);
for (long long int i = 1; i <= n; i++) {
add[i] = 0;
maxi[i] = inf;
}
for (long long int i = 0; i < m; i++) {
scanf("%lld %lld %lld %lld", &t[i], &l[i], &r[i], &d[i]);
if (t[i] == 1)
for (long long int j = l[i]; j <= r[i]; j++) add[j] += d[i];
else
for (long long int j = l[i]; j <= r[i]; j++)
maxi[j] = min(maxi[j], d[i] - add[j]);
}
for (long long int i = 1; i <= n; i++) ans[i] = maxi[i];
for (long long int i = 0; i < m; i++) {
if (t[i] == 1)
for (long long int j = l[i]; j <= r[i]; j++) maxi[j] += d[i];
else {
temp = -inf;
for (long long int j = l[i]; j <= r[i]; j++) temp = max(temp, maxi[j]);
if (temp != d[i]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (long long int i = 1; i <= n; i++) {
if (i > 1) putchar(' ');
printf("%lld", ans[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[5005], b[5005];
struct operation {
int t, l, r, m;
} op[5005];
bool find() {
int k;
for (int i = 0; i < 5005; i++) a[i] = 1000000000;
memset(b, 0, sizeof(b));
for (int i = 1; i <= m; i++) {
if (op[i].t == 1) {
for (int p = op[i].l; p <= op[i].r; p++) b[p] += op[i].m;
} else {
for (int p = op[i].l; p <= op[i].r; p++) {
a[p] = min(a[p], op[i].m - b[p]);
}
}
}
memset(b, 0, sizeof(b));
for (int i = 1; i <= m; i++) {
if (op[i].t == 1) {
for (int p = op[i].l; p <= op[i].r; p++) b[p] += op[i].m;
} else {
k = -100000000;
for (int p = op[i].l; p <= op[i].r; p++) {
k = max(k, a[p] + b[p]);
}
if (k != op[i].m) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &op[i].t, &op[i].l, &op[i].r, &op[i].m);
}
if (find()) {
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
} else {
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846264338327950288419716939937511;
const double eps = 1e-9;
char ch_ch_ch[1 << 20];
inline string gs() {
scanf("%s", ch_ch_ch);
return string(ch_ch_ch);
}
inline string gl() {
gets(ch_ch_ch);
return string(ch_ch_ch);
}
inline int gi() {
int x;
scanf("%d", &x);
return x;
}
const int inf = 1000000000;
int n, m;
vector<int> tp;
vector<int> l;
vector<int> r;
vector<int> val;
vector<int> a;
vector<int> was;
vector<int> res;
void solution() {
n = gi();
m = gi();
for (int i = 0; i < (m); ++i) {
tp.push_back(gi());
l.push_back(gi() - 1);
r.push_back(gi() - 1);
val.push_back(gi());
}
a.resize(n, 0);
was.resize(n, 0);
for (int i = m - 1; i >= 0; --i) {
if (tp[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) a[j] -= val[i];
} else {
for (int j = l[i]; j <= r[i]; ++j)
if (!was[j]) {
a[j] = val[i];
was[j] = 1;
} else {
if (a[j] > val[i]) a[j] = val[i];
}
}
}
res = a;
for (int i = 0; i < (n); ++i)
if (a[i] < -inf) {
cout << "NO\n" << endl;
}
for (int i = 0; i < (n); ++i)
if (a[i] > inf) a[i] = inf;
for (int i = 0; i < (m); ++i) {
if (tp[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) a[j] += val[i];
} else {
bool cnt = 0;
for (int j = l[i]; j <= r[i]; ++j)
if (a[j] > val[i]) {
cout << "NO\n";
return;
} else if (a[j] == val[i])
cnt++;
if (cnt == 0) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n";
for (int i = 0; i < (n); ++i) printf("%d%c", res[i], i + 1 == n ? '\n' : ' ');
}
int main(int argc, char** argv) {
solution();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5555;
const int INF = 1000000000;
int a[N], s[N];
set<int> S[N];
int C[N];
int main() {
int n, m;
set<int>::iterator it;
cin >> n >> m;
for (int i = 1; i <= n; ++i) a[i] = INF;
for (int c = 1; c <= m; ++c) {
int t, l, r, v;
cin >> t >> l >> r >> v;
if (t == 1) {
for (int i = l; i <= r; ++i) a[i] += v, s[i] += v;
} else {
int ok = 1;
for (int i = l; i <= r; ++i) {
if (a[i] == v) {
C[c]++;
S[i].insert(c);
}
if (a[i] > v) {
a[i] = v;
for (it = S[i].begin(); it != S[i].end(); ++it)
if (!(--C[*it])) ok = 0;
S[i].clear();
C[c]++;
S[i].insert(c);
}
}
if (!C[c]) ok = 0;
if (!ok) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) cout << a[i] - s[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
int num[5001];
int resp[5001];
int operacion[5001][4];
int n, m;
int main() {
int i, j, exito = 1;
int l, r, t;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) num[i] = 50000000;
for (i = 0; i < m; i++) {
for (j = 0; j < 4; j++) scanf("%d", &operacion[i][j]);
}
for (i = m - 1; i >= 0; i--) {
if (operacion[i][0] == 2) {
l = operacion[i][1];
r = operacion[i][2];
t = operacion[i][3];
for (j = l; j <= r; j++)
if (num[j] > t) num[j] = t;
} else if (operacion[i][0] == 1) {
l = operacion[i][1];
r = operacion[i][2];
t = operacion[i][3];
for (j = l; j <= r; j++) num[j] -= t;
}
}
for (i = 1; i <= n; i++) resp[i] = num[i];
for (i = 0; i < m; i++) {
if (operacion[i][0] == 2) {
l = operacion[i][1];
r = operacion[i][2];
t = num[l];
for (j = l + 1; j <= r; j++)
if (num[j] > t) t = num[j];
if (t != operacion[i][3]) exito = 0;
;
} else if (operacion[i][0] == 1) {
l = operacion[i][1];
r = operacion[i][2];
t = operacion[i][3];
for (j = l; j <= r; j++) num[j] += t;
}
}
if (exito) {
puts("YES");
for (j = 1; j <= n; j++) {
if (j > 1) putchar(' ');
printf("%d", resp[j]);
}
} else {
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1E-9;
int a[10000 + 13], c[10000 + 13], l[10000 + 13], r[10000 + 13], d[10000 + 13];
bool used[10000 + 13];
int main() {
int n, m;
bool ok;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> c[i] >> l[i] >> r[i] >> d[i];
if (c[i] == 1) {
for (int j = l[i]; j < r[i] + 1; j++)
if (used[j]) a[j] += d[i];
} else {
ok = false;
for (int j = l[i]; j < r[i] + 1; j++) {
if (!used[j])
used[j] = true, a[j] = d[i], ok = true;
else if (used[j] && a[j] >= d[i])
a[j] = d[i], ok = true;
}
if (!ok) {
cout << "NO";
return 0;
}
}
}
int maxi;
for (int i = m - 1; i >= 0; i--)
if (c[i] == 1)
for (int j = l[i]; j < r[i] + 1; j++) a[j] -= d[i];
else {
ok = false;
for (int j = l[i]; j < r[i] + 1; j++)
if (!ok || maxi < a[j]) maxi = a[j], ok = true;
if (maxi != d[i]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++)
if (!used[i])
cout << 0 << " ";
else
cout << a[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct op {
long long a, b, c, d;
};
int main() {
int n, m;
cin >> n >> m;
long long arr[5004];
long long mval[5004];
for (int i = 0; i < 5004; ++i) {
arr[i] = 0;
mval[i] = 1000000000ll;
}
op ops[5004];
for (int i = 0; i < m; ++i) {
cin >> ops[i].a >> ops[i].b >> ops[i].c >> ops[i].d;
if (ops[i].a == 1) {
for (int j = ops[i].b; j <= ops[i].c; ++j) arr[j] += ops[i].d;
} else {
for (int j = ops[i].b; j <= ops[i].c; ++j)
mval[j] = min(mval[j], ops[i].d - arr[j]);
}
}
long long now[5004];
for (int i = 0; i <= n; ++i) now[i] = mval[i];
for (int i = 0; i < m; ++i) {
if (ops[i].a == 1) {
for (int j = ops[i].b; j <= ops[i].c; ++j) now[j] += ops[i].d;
} else {
long long ans = -1000000000000ll;
for (int j = ops[i].b; j <= ops[i].c; ++j) ans = max(ans, now[j]);
if (ans != ops[i].d) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << mval[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:20000000")
string problem_name = "a";
void init() { freopen((problem_name + ".in").c_str(), "rt", stdin); }
int l[5100], r[5100], v[5100];
int tp[5100];
int mas[5100];
int u[5100];
int res[5100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> tp[i] >> l[i] >> r[i] >> v[i];
}
for (int i = m - 1; i >= 0; i--) {
if (tp[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) mas[j] -= v[i];
} else {
for (int j = l[i]; j <= r[i]; j++) {
if (mas[j] > v[i])
mas[j] = v[i];
else if (!u[j]) {
u[j] = 1;
mas[j] = v[i];
}
u[j] = 1;
}
}
}
for (int i = 1; i <= n; i++) res[i] = mas[i];
int ok = 1;
for (int i = 0; i < m; i++) {
if (tp[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) mas[j] += v[i];
} else {
int mx = -(1e9);
for (int j = l[i]; j <= r[i]; j++) {
mx = max(mx, mas[j]);
}
if (mx != v[i]) ok = 0;
}
}
if (!ok) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
;
for (int i = 1; i <= n; i++) {
cout << res[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct inp {
int a, b, c, d;
};
int n, m, a[5005], inc[5005], maks[5005];
int kom;
int l, r, incc, makss;
vector<inp> v;
inp vv;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
inc[i] = 0;
maks[i] = 1000000000;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &kom);
vv.a = kom;
if (kom == 1) {
scanf("%d %d %d", &l, &r, &incc);
vv.b = l;
vv.c = r;
vv.d = incc;
for (int j = l; j <= r; j++) {
inc[j] += incc;
}
}
if (kom == 2) {
scanf("%d %d %d", &l, &r, &makss);
vv.b = l;
vv.c = r;
vv.d = makss;
for (int j = l; j <= r; j++) {
maks[j] = min(maks[j], makss - inc[j]);
}
}
v.push_back(vv);
}
for (int i = 1; i <= n; i++) {
a[i] = maks[i];
}
bool moze = true;
for (int i = 0; i < m; i++) {
if (v[i].a == 1) {
for (int j = v[i].b; j <= v[i].c; j++) {
a[j] += v[i].d;
}
}
if (v[i].a == 2) {
int tempmaks = a[v[i].b];
for (int j = v[i].b; j <= v[i].c; j++) {
tempmaks = max(tempmaks, a[j]);
}
if (tempmaks != v[i].d) {
moze = false;
break;
}
}
}
if (!moze)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << maks[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int mx = 5e3 + 1;
int ar[mx], ar2[mx], t[mx], l[mx], r[mx], d[mx], diff[mx];
bool chk(int m) {
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) ar2[j] += d[i];
} else {
int mx = ar2[l[i]];
for (int j = l[i] + 1; j <= r[i]; j++) mx = max(ar2[j], mx);
if (mx != d[i]) return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) ar[i] = inf;
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++) {
if (ar[j] != inf) ar[j] -= d[i];
}
} else {
bool ok = 1;
for (int j = l[i]; j <= r[i]; j++) {
if (ar[j] >= d[i]) {
ar[j] = d[i];
ok = 0;
}
}
if (ok) return cout << "NO" << '\n', 0;
}
}
for (int i = 1; i <= n; i++) {
if (ar[i] == inf) ar[i] = 0;
ar2[i] = ar[i];
}
if (chk(m)) {
cout << "YES" << '\n';
for (int i = 1; i <= n; i++) cout << ar[i] << " ";
cout << '\n';
} else
cout << "NO" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[5005];
int diff[5005];
int l[5005];
int t[5005];
int mex[5005];
int r[5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i += 1) {
b[i] = 1e9;
}
for (int i = 1; i <= q; i += 1) {
cin >> t[i] >> l[i] >> r[i] >> mex[i];
for (int j = l[i]; j <= r[i]; j += 1) {
if (t[i] == 1) {
diff[j] += mex[i];
} else {
b[j] = min(b[j], mex[i] - diff[j]);
}
}
}
for (int i = 1; i <= n; i += 1) {
diff[i] = 0;
}
for (int i = 1; i <= q; i++) {
int mn = -1e9;
for (int j = l[i]; j <= r[i]; j++) {
if (t[i] == 1) {
diff[j] += mex[i];
} else {
mn = max(mn, diff[j] + b[j]);
}
}
if (t[i] == 2 && mn != mex[i]) {
printf("NO");
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i += 1) {
cout << b[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[10000], ans[10000];
bool mark[10000];
int t[10000], l[10000], r[10000], d[10000];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> l[i] >> r[i] >> d[i];
for (int j = l[i] - 1; j < r[i]; j++) a[j] += d[i];
} else {
cin >> l[i] >> r[i] >> d[i];
for (int j = l[i] - 1; j < r[i]; j++)
if (mark[j])
ans[j] = min(ans[j], d[i] - a[j]);
else {
ans[j] = d[i] - a[j];
mark[j] = true;
}
bool flag = false;
for (int j = l[i] - 1; j < r[i]; j++)
if (ans[j] == d[i] - a[j]) flag = true;
if (!flag) {
cout << "NO" << endl;
return 0;
}
}
}
for (int i = 0; i < n; i++) a[i] = 0;
for (int i = 0; i < m; i++)
if (t[i] == 1)
for (int j = l[i] - 1; j < r[i]; j++) a[j] += d[i];
else {
bool flag = false;
for (int j = l[i] - 1; j < r[i]; j++)
if (ans[j] + a[j] == d[i]) flag = true;
for (int j = l[i] - 1; j < r[i]; j++)
if (ans[j] + a[j] > d[i]) flag = false;
if (!flag) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int inf = 1e9;
struct T {
int t, l, r, v;
} q[N];
int a[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < int(m); ++i) {
int t;
int l, r, v;
scanf("%d%d%d%d", &t, &l, &r, &v);
q[i] = {t, l - 1, r - 1, v};
}
for (int i = 0; i < int(n); ++i) a[i] = inf;
for (int i = 0; i < int(m); ++i) {
if (q[i].t == 1) {
for (int j = q[i].l; j <= q[i].r; ++j) a[j] += q[i].v;
} else {
for (int j = q[i].l; j <= q[i].r; ++j) a[j] = min(q[i].v, a[j]);
}
}
for (int i = m - 1; i >= 0; --i)
if (q[i].t == 1)
for (int j = q[i].l; j <= q[i].r; ++j) a[j] -= q[i].v;
for (int i = 0; i < int(n); ++i)
if (a[i] > inf || a[i] < -inf) {
puts("NO");
return 0;
}
for (int i = 0; i < int(m); ++i) {
if (q[i].t == 1) {
for (int j = q[i].l; j <= q[i].r; ++j) a[j] += q[i].v;
} else {
int mx = -inf;
for (int j = q[i].l; j <= q[i].r; ++j) mx = max(a[j], mx);
if (mx != q[i].v) {
puts("NO");
return 0;
}
}
}
for (int i = m - 1; i >= 0; --i)
if (q[i].t == 1)
for (int j = q[i].l; j <= q[i].r; ++j) a[j] -= q[i].v;
puts("YES");
for (int i = 0; i < int(n); ++i)
printf("%d%c", a[i], i + 1 == n ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
const int INF = 5e8;
int n, m;
int tp[MAXN];
int l[MAXN];
int r[MAXN];
int d[MAXN];
int MAX[MAXN];
int a[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) MAX[i] = INF;
for (int i = 1; i <= m; i++) scanf("%d%d%d%d", &tp[i], &l[i], &r[i], &d[i]);
for (int i = m; i >= 1; i--) {
if (tp[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) MAX[j] -= d[i];
} else {
for (int j = l[i]; j <= r[i]; j++) MAX[j] = min(MAX[j], d[i]);
}
}
for (int i = 1; i <= n; i++) a[i] = MAX[i];
for (int i = 1; i <= m; i++) {
if (tp[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) a[j] += d[i];
} else {
int res = -INF;
for (int j = l[i]; j <= r[i]; j++) res = max(res, a[j]);
if (res != d[i]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", MAX[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, l[100001], r[100001], maxi, lim[100001], val[100001], type[100001], i,
j, x, y, ans[100001], diff[100001];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) lim[i] = 1e9;
for (i = 1; i <= m; i++) {
cin >> type[i] >> l[i] >> r[i] >> val[i];
if (type[i] == 1) {
for (j = l[i]; j <= r[i]; j++) diff[j] += val[i];
} else {
for (j = l[i]; j <= r[i]; j++) lim[j] = min(lim[j], val[i] - diff[j]);
}
}
for (i = 1; i <= n; i++) ans[i] = lim[i];
for (i = 1; i <= m; i++) {
if (type[i] == 1) {
for (j = l[i]; j <= r[i]; j++) ans[j] += val[i];
} else {
maxi = -1;
for (j = l[i]; j <= r[i]; j++) {
if (ans[j] == val[i]) {
maxi = 0;
break;
}
}
if (maxi == -1) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << lim[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 5e3 + 10;
int n, m;
bool ok[N];
long long sum[N], ini[N], s[N];
struct qry {
int type, val, l, r;
qry(int type, int val, int l, int r) : type(type), val(val), l(l), r(r) {}
};
vector<qry> q;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int type, l, r, d;
scanf("%d %d %d %d", &type, &l, &r, &d);
q.push_back(qry(type, d, l, r));
if (type == 1)
for (int k = l; k <= r; k++) sum[k] += d;
if (type == 2) {
for (int k = l; k <= r; k++) {
if (!ok[k])
ini[k] = d - sum[k], ok[k] = 1;
else if (ok[k] && ini[k] + sum[k] > d)
ini[k] = d - sum[k];
}
}
}
for (int i = 1; i <= n; i++) {
if (!ok[i]) ini[i] = -1e9;
s[i] = ini[i];
}
for (int i = 0; i < m; i++) {
int type = q[i].type, l = q[i].l, r = q[i].r, val = q[i].val;
long long maior = -1e9;
if (type == 1)
for (int k = l; k <= r; k++) s[k] += val;
if (type == 2) {
for (int k = l; k <= r; k++) maior = max(maior, s[k]);
if (maior != val) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%I64d ", ini[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
int _MINUS;
const int MXN = 5010;
const int C = 262144;
const int INF = 1000000000;
int dx[MXN];
int n, m;
int res[MXN];
int resT[MXN];
void test() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (n); i++) res[i] = INF;
vector<pair<pair<int, int>, pair<int, int> > > zap;
for (int i = (1); i <= (m); i++) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
zap.push_back(make_pair(make_pair(l, r), make_pair(d, 1)));
for (int j = (l); j <= (r); j++) dx[j] += d;
} else {
int l, r, m;
scanf("%d %d %d", &l, &r, &m);
zap.push_back(make_pair(make_pair(l, r), make_pair(m, 2)));
for (int j = (l); j <= (r); j++) res[j] = min(res[j], m - dx[j]);
}
}
for (int i = (1); i <= (n); i++) resT[i] = res[i];
bool dec = 1;
for (__typeof((zap).begin()) it = ((zap).begin()); it != (zap).end(); ++it) {
int l, r, m;
pair<int, int> p1 = it->first;
l = p1.first;
r = p1.second;
m = (it->second).first;
int typ = (*it).second.second;
if (typ == 1) {
for (int j = (l); j <= (r); j++) {
resT[j] += m;
}
} else {
int MX = -INF;
for (int j = (l); j <= (r); j++) {
MX = max(MX, resT[j]);
}
if (MX != m) dec = 0;
}
}
printf(dec ? "YES\n" : "NO\n");
if (dec) {
for (int i = (1); i <= (n); i++) printf("%d ", res[i]);
}
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[5002][5002];
int q[5002][4];
int v[5002], t[5002];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) v[i] = 1e9;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", q[i], q[i] + 1, q[i] + 2, q[i] + 3);
for (int j = 1; j <= n; j++) {
if (q[i][0] == 1 && q[i][1] <= j && j <= q[i][2]) {
a[i][j] = a[i - 1][j] + q[i][3];
} else {
a[i][j] = a[i - 1][j];
}
}
if (q[i][0] == 2) {
for (int j = q[i][1]; j <= q[i][2]; j++) {
v[j] = min(v[j], q[i][3] - a[i][j]);
}
}
}
for (int i = 1; i <= n; i++)
if (v[i] == 1e9) v[i] = 1e9;
for (int i = 1; i <= n; i++) {
t[i] = v[i];
}
bool ans = true;
for (int i = 1; i <= m; i++) {
if (q[i][0] == 1) {
for (int j = q[i][1]; j <= q[i][2]; j++) {
t[j] += q[i][3];
}
} else {
int ma = -1e9;
for (int j = q[i][1]; j <= q[i][2]; j++) {
ma = max(ma, t[j]);
}
if (ma != q[i][3]) {
ans = false;
break;
}
}
}
if (ans) {
cout << "YES\n";
for (int i = 1; i <= n; i++) printf("%d ", v[i]);
} else {
cout << "NO";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans[6001], tmp[6001], mi[6001], ord[6001][4];
int main() {
cin >> n >> m;
int l, r, c, t;
for (int i = 0; i < n; i++) mi[i] = 1000000007;
for (int i = 0; i < m; i++) {
cin >> t >> l >> r >> c;
l--;
ord[i][0] = t, ord[i][1] = l, ord[i][2] = r, ord[i][3] = c;
if (t == 1)
for (int j = l; j < r; j++) tmp[j] += c;
else
for (int j = l; j < r; j++) mi[j] = min(mi[j], c - tmp[j]);
}
for (int i = 0; i < n; i++) {
ans[i] = mi[i];
if (mi[i] == 1000000007) ans[i] = 0;
}
for (int i = 0; i < m; i++) {
t = ord[i][0], l = ord[i][1], r = ord[i][2], c = ord[i][3];
if (t == 1)
for (int j = l; j < r; j++) mi[j] += c;
else {
int mx = -1000000007;
for (int j = l; j < r; j++) mx = max(mx, mi[j]);
if (mx != c) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5010], b[5010], w[5010], x[5010], y[5010], z[5010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) a[i] = 1000000000;
memset(b, 0, sizeof(b));
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &w[i], &x[i], &y[i], &z[i]);
x[i]--;
y[i]--;
if (w[i] == 1) {
for (int j = x[i]; j <= y[i]; j++) b[j] += z[i];
} else {
for (int j = x[i]; j <= y[i]; j++) a[j] = min(a[j], z[i] - b[j]);
}
}
for (int i = 0; i < n; i++) b[i] = a[i];
for (int i = 0; i < m; i++)
if (w[i] == 1) {
for (int j = x[i]; j <= y[i]; j++) b[j] += z[i];
} else {
int can = 0;
for (int j = x[i]; j <= y[i]; j++)
if (b[j] == z[i]) {
can = 1;
break;
}
if (!can) {
puts("NO");
return 0;
}
}
puts("YES");
for (int i = 0; i < n; i++) {
printf("%d", a[i]);
if (i + 1 == n)
puts("");
else
printf(" ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Abs(T first) {
return (first < 0 ? -first : first);
}
template <typename T>
T Sqr(T first) {
return (first * first);
}
string plural(string s) {
return (int((s).size()) && s[int((s).size()) - 1] == 'x' ? s + "en"
: s + "s");
}
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
bool Read(int &first) {
char c, r = 0, n = 0;
first = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r)) return (0);
if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
first = first * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) first = -first;
return (1);
}
int main() {
if (0) freopen("in.txt", "r", stdin);
int N, M;
int i, j, v, m, np = 0;
int V[5000];
int A[5000], B[5000], C[5000], D[5000], good[5000] = {0};
Read(N), Read(M);
for (i = 0; i < M; i++) {
Read(A[i]), Read(B[i]), Read(C[i]), Read(D[i]);
if (A[i] == 1) good[i] = 1;
}
for (i = 1; i <= N; i++) {
v = 0;
m = INF;
for (j = 0; j < M; j++)
if (A[j] == 1) {
if ((B[j] <= i) && (i <= C[j])) v -= D[j];
} else if ((B[j] <= i) && (i <= C[j]))
m = min(m, v + D[j]);
V[i - 1] = v = m;
for (j = 0; j < M; j++)
if (A[j] == 1) {
if ((B[j] <= i) && (i <= C[j])) v += D[j];
} else if ((B[j] <= i) && (i <= C[j]))
if (v == D[j]) good[j] = 1;
}
for (j = 0; j < M; j++)
if (!good[j]) goto No;
printf("YES\n");
for (i = 0; i < N; i++) printf("%d%c", V[i], i == N - 1 ? '\n' : ' ');
return (0);
No:;
printf("NO\n");
return (0);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456,268435456")
using namespace std;
int a[5000], b[5000], rr[4][5000];
bool check[5000];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
for (int j = 0; j < 4; j++) scanf("%d", &rr[j][i]);
memset(a, 0x3f, sizeof(a)), memset(b, 0x3f, sizeof(b));
for (int i = m - 1; i >= 0; i--)
if (rr[0][i] == 2)
for (int j = rr[1][i] - 1; j <= rr[2][i] - 1; j++) {
if (check[j] && a[j] < rr[3][i]) continue;
a[j] = rr[3][i], check[j] = 1;
}
else
for (int j = rr[1][i] - 1; j <= rr[2][i] - 1; j++)
if (check[j]) a[j] -= rr[3][i];
for (int i = 0; i < n; i++) b[i] = a[i];
bool flag = 1;
for (int i = 0; i < m && flag; i++)
if (rr[0][i] == 2) {
int m2 = -1e9;
for (int j = rr[1][i] - 1; j <= rr[2][i] - 1; j++) m2 = max(m2, a[j]);
if (m2 != rr[3][i]) {
flag = 0;
break;
}
} else
for (int j = rr[1][i] - 1; j <= rr[2][i] - 1; j++) a[j] += rr[3][i];
if (flag) {
printf("YES\n");
for (int i = 0; i < n; i++)
if (check[i] == 0)
printf("%d ", -1e9);
else
printf("%d ", b[i]);
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1000000007LL);
long long n, m, i, j;
long long st[6000], cst[6000];
long long t[6000], l[6000], r[6000], s[6000];
int main(int argc, char** argv) {
cin >> n >> m;
for (i = 1; i <= n; ++i) st[i] = 1000000000LL;
for (i = 0; i < m; ++i) cin >> t[i] >> l[i] >> r[i] >> s[i];
for (i = m - 1; i >= 0; --i) {
if (t[i] == 1)
for (j = l[i]; j <= r[i]; ++j) st[j] -= s[i];
else
for (j = l[i]; j <= r[i]; ++j) st[j] = min(st[j], s[i]);
}
for (i = 1; i <= n; ++i) cst[i] = st[i];
int bad = 0;
for (i = 0; i < m; ++i) {
if (t[i] == 1)
for (j = l[i]; j <= r[i]; ++j) cst[j] += s[i];
else {
long long mmax = cst[l[i]];
for (j = l[i]; j <= r[i]; ++j) mmax = max(mmax, cst[j]);
if (mmax != s[i]) bad = 1;
}
}
if (bad == 1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (i = 1; i <= n; ++i) cout << min(1000000000LL, st[i]) << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N(5010);
int n, m;
int t[N], l[N], r[N], v[N], x[N], d[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) x[i] = 1000000000;
for (int i = 0; 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) d[j] += v[i];
} else {
for (int j = l[i]; j <= r[i]; ++j) x[j] = min(x[j], v[i] - d[j]);
}
}
memset(d, 0, sizeof(d));
for (int i = 0; i != m; ++i)
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) d[j] += v[i];
} else {
int m = -1 << 30;
for (int j = l[i]; j <= r[i]; ++j) m = max(m, x[j] + d[j]);
if (m != v[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i)
if (i == n)
printf("%d\n", x[i]);
else
printf("%d ", x[i]);
return 0;
}
|
#include <bits/stdc++.h>
bool ch[5000] = {0};
bool ex, ans = true;
int a[5000] = {0}, b[5000] = {0};
int c[5000][5000] = {0}, ccnt[5000] = {0};
int count[5000] = {0};
int n, m, cnt = 0;
int main() {
int i, j, k;
int t, l, r, d;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d%d%d", &t, &l, &r, &d);
if (t == 1) {
for (j = l - 1; j < r; j++) b[j] += d;
} else {
cnt++;
ex = false;
for (j = l - 1; j < r; j++) {
if (!ch[j]) {
a[j] = d - b[j];
c[j][0] = cnt, ccnt[j] = 1;
count[cnt]++;
ch[j] = true;
ex = true;
} else {
if (a[j] > d - b[j]) {
for (k = 0; k < ccnt[j]; k++) {
count[c[j][k]]--;
if (count[c[j][k]] == 0) {
ans = false;
break;
}
}
if (!ans) break;
a[j] = d - b[j];
c[j][0] = cnt, ccnt[j] = 1;
count[c[j][0]]++;
ex = true;
} else if (a[j] == d - b[j]) {
c[j][ccnt[j]++] = cnt;
count[cnt]++;
ex = true;
}
}
}
if (!ex || !ans) {
ans = false;
break;
}
}
}
if (!ans) {
printf("NO");
} else {
printf("YES\n");
for (i = 0; i < n; i++) printf("%d ", a[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[5005];
int data[5005];
int n, m;
struct opt {
int k, l, r, b;
} oo[5005];
int min(int x, int y) {
if (x < y) return x;
return y;
}
int jc[5005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) data[i] = 1000000000;
for (int j = 1; j <= m; j++) {
scanf("%d%d%d%d", &oo[j].k, &oo[j].l, &oo[j].r, &oo[j].b);
if (oo[j].k == 1) {
for (int i = oo[j].l; i <= oo[j].r; i++) cnt[i] += oo[j].b;
} else {
for (int i = oo[j].l; i <= oo[j].r; i++)
data[i] = min(data[i], oo[j].b - cnt[i]);
}
}
for (int i = 1; i <= n; i++) jc[i] = data[i];
for (int j = 1; j <= m; j++) {
if (oo[j].k == 1) {
for (int i = oo[j].l; i <= oo[j].r; i++) data[i] += oo[j].b;
} else {
int MAX = -1000000000;
for (int i = oo[j].l; i <= oo[j].r; i++)
if (data[i] > MAX) MAX = data[i];
if (MAX != oo[j].b) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", jc[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1000000000;
const int Maxn = 5005;
int n, m;
int qa[Maxn], qb[Maxn], qc[Maxn], qd[Maxn];
int a[Maxn], b[Maxn];
bool Check() {
for (int i = 1; i <= n; i++) {
a[i] = min(a[i], Inf);
b[i] = a[i];
}
for (int i = 0; i < m; i++)
if (qa[i] == 1)
for (int j = qb[i]; j <= qc[i]; j++) b[j] += qd[i];
else {
int mx = -2 * Inf;
for (int j = qb[i]; j <= qc[i]; j++) mx = max(mx, b[j]);
if (mx != qd[i]) return false;
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d %d %d %d", &qa[i], &qb[i], &qc[i], &qd[i]);
for (int i = 1; i <= n; i++) a[i] = Inf;
for (int i = m - 1; i >= 0; i--)
if (qa[i] == 1)
for (int j = qb[i]; j <= qc[i]; j++) a[j] -= qd[i];
else
for (int j = qb[i]; j <= qc[i]; j++) a[j] = min(a[j], qd[i]);
if (Check()) {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d%c", a[i], i + 1 <= n ? ' ' : '\n');
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
const char en = '\n';
using namespace std;
struct operacia {
long long t;
long long l;
long long r;
long long d;
};
vector<long long> K, T;
vector<operacia> V;
int main() {
long long n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long t, l, r, d;
cin >> t >> l >> r >> d;
V.push_back({t, l, r, d});
}
reverse(V.begin(), V.end());
K.resize(n + 47, 1000000000);
for (auto it = V.begin(); it != V.end(); it++) {
if (it->t == 1) {
for (long long i = it->l; i <= it->r; i++) K[i] -= it->d;
}
if (it->t == 2) {
for (long long i = it->l; i <= it->r; i++) K[i] = min(K[i], it->d);
}
}
T = K;
reverse(V.begin(), V.end());
bool ok = true;
for (auto it = V.begin(); it != V.end(); it++) {
if (it->t == 1)
for (long long i = it->l; i <= it->r; i++) T[i] += it->d;
else {
long long mi = -1000000000;
for (long long i = it->l; i <= it->r; i++) mi = max(mi, T[i]);
if (mi != it->d) {
ok = false;
break;
}
}
}
if (ok == true) {
cout << "YES" << endl;
for (int i = 1; i < n; i++)
cout << min(max(K[i], (long long)-1000000000), (long long)1000000000)
<< " ";
cout << min(max(K[n], (long long)-1000000000), (long long)1000000000)
<< endl;
} else
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 5;
struct node {
int op;
int l;
int r;
int d;
} cmd[maxn];
;
int a[maxn];
int b[maxn];
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++)
cin >> cmd[i].op >> cmd[i].l >> cmd[i].r >> cmd[i].d;
for (int i = 1; i <= n; i++) a[i] = 100000000;
for (int i = 1; i <= m; i++) {
if (cmd[i].op == 1) {
for (int j = cmd[i].l; j <= cmd[i].r; j++) b[j] += cmd[i].d;
} else {
for (int j = cmd[i].l; j <= cmd[i].r; j++) {
a[j] = min(a[j], cmd[i].d - b[j]);
}
}
}
for (int i = 1; i <= n; i++) b[i] = a[i];
for (int i = 1; i <= m; i++) {
if (cmd[i].op == 1) {
for (int j = cmd[i].l; j <= cmd[i].r; j++) b[j] += cmd[i].d;
} else {
int flag = INT_MIN;
for (int j = cmd[i].l; j <= cmd[i].r; j++) flag = max(flag, b[j]);
if (flag != cmd[i].d) {
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;
vector<int> diff(5010, 0), b(5010, 1000000000), a(5010);
int inst[5010][4];
int main() {
int n, m, i, j, k;
cin >> n >> m;
for (i = 0; i < m; i++) {
int t, l, r, x;
cin >> t >> l >> r >> x;
l--;
r--;
inst[i][0] = t;
inst[i][1] = l;
inst[i][2] = r;
inst[i][3] = x;
if (t == 1) {
for (j = l; j <= r; j++) {
diff[j] += x;
}
} else {
for (j = l; j <= r; j++) {
b[j] = min(b[j], x - diff[j]);
}
}
}
int flag = 0;
for (i = 0; i < n; i++) a[i] = b[i];
for (i = 0; i < m; i++) {
if (inst[i][0] == 1) {
for (j = inst[i][1]; j <= inst[i][2]; j++) {
b[j] += inst[i][3];
}
} else {
int maxi = b[inst[i][1]];
for (j = inst[i][1] + 1; j <= inst[i][2]; j++) {
maxi = max(maxi, b[j]);
}
if (maxi != inst[i][3]) {
flag = 1;
break;
}
}
}
if (flag == 1) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long int resposta[5000 + 1];
long int vec_max(int l, int r) {
long int max = -1000000001;
for (int i = l; i <= r; i++) {
if (max < resposta[i]) {
max = resposta[i];
}
}
return max;
}
int vec_soma(int l, int r, long int valor) {
for (int i = l; i <= r; i++) {
resposta[i] += valor;
}
return 0;
}
int main() {
int vetor_tam = 0;
int op_num = 0;
int operacao = 0;
int l = 0, r = 0;
long int saida = 0;
long int operando = 0;
long int somas[5000 + 1];
long int vetor_max[5000 + 1];
vector<tuple<int, int, int, long int> > operacoes;
bool possivel = false;
cin >> vetor_tam >> op_num;
for (int i = 0; i <= vetor_tam; i++) {
vetor_max[i] = 1000000001 - 1;
somas[i] = 0;
}
for (int i = 0; i < op_num; i++) {
cin >> operacao >> l >> r >> operando;
operacoes.push_back(make_tuple(operacao, l, r, operando));
if (operacao == 1) {
for (int j = l; j <= r; j++) {
somas[j] += operando;
if (vetor_max[j] + operando >= 1000000001) {
vetor_max[j] = 1000000001 - 1;
}
if (vetor_max[j] + operando <= -1000000001) {
cout << "NO" << endl;
return 0;
} else {
vetor_max[j] += operando;
}
}
} else {
possivel = false;
for (int j = l; j <= r; j++) {
if (vetor_max[j] >= operando) {
vetor_max[j] = operando;
possivel = true;
}
}
if (!possivel) {
cout << "NO" << endl;
return 0;
}
}
}
if (0) {
for (int i = 1; i <= vetor_tam; i++) {
cout << "SOMAS[" << i << "]: " << somas[i] << endl;
}
for (int i = 1; i <= vetor_tam; i++) {
cout << "VETOR_MAX[" << i << "]: " << vetor_max[i] << endl;
}
for (auto a : operacoes) {
cout << "OPERACOES: (" << get<0>(a) << ", " << get<1>(a) << ", "
<< get<2>(a) << ", " << get<3>(a) << ")" << endl;
}
}
for (int i = 1; i <= vetor_tam; i++) {
resposta[i] = vetor_max[i] - somas[i];
if (resposta[i] <= -1000000001) {
cout << "cagou no " << i << " !" << endl;
} else if (resposta[i] >= 1000000001) {
resposta[i] = 0;
}
}
for (auto a : operacoes) {
if (get<0>(a) == 1) {
vec_soma(get<1>(a), get<2>(a), get<3>(a));
} else {
if (vec_max(get<1>(a), get<2>(a)) != get<3>(a)) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= vetor_tam; i++) {
saida = vetor_max[i] - somas[i];
if (saida <= -1000000001) {
cout << "cagou!" << endl;
} else if (saida >= 1000000001) {
cout << "0 ";
} else {
cout << saida << " ";
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
long long high[5000];
long long diff[5000];
int tm[5000];
int lm[5000];
int rm[5000];
int mm[5000];
int main() {
const int n = getInt();
const int m = getInt();
for (int i = 0; i < (int)(n); i++) high[i] = 1000000000ll;
for (int i = 0; i < (int)(m); i++) {
const int t = tm[i] = getInt();
const int l = lm[i] = getInt() - 1;
const int r = rm[i] = getInt() - 1;
const int m = mm[i] = getInt();
if (t == 1) {
for (int j = l; j <= r; j++) {
diff[j] += m;
}
} else {
for (int j = l; j <= r; j++) {
high[j] = min(high[j], m - diff[j]);
}
}
}
bool ans = true;
for (int i = 0; i < (int)(n); i++) diff[i] = 0;
for (int i = 0; i < (int)(m); i++) {
const int t = tm[i];
const int l = lm[i];
const int r = rm[i];
const int m = mm[i];
if (t == 1) {
for (int j = l; j <= r; j++) {
diff[j] += m;
}
} else {
long long h = -1000000000000ll;
for (int j = l; j <= r; j++) {
h = max(h, high[j] + diff[j]);
}
if (h != m) {
ans = false;
}
}
}
if (ans) {
puts("YES");
printf("%lld", high[0]);
for (int i = 0; i < (int)(n - 1); i++) printf(" %lld", high[i + 1]);
puts("");
} else {
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct o {
long long x, y, z, t;
};
long long n, m, a[1000000] = {0}, b[10000000] = {0};
o c[1000000] = {0};
bool used[10000000] = {0};
int main() {
cin >> n >> m;
for (int k = 1; k <= n; ++k) a[k] = 1000000000;
for (int k1 = 1; k1 <= m; ++k1) {
long long t, l, r, a1;
cin >> t >> l >> r >> a1;
c[k1].x = t;
c[k1].y = l;
c[k1].z = r;
c[k1].t = a1;
if (t == 2) {
long long y = 1000000000;
for (int k = l; k <= r; ++k) {
if (!used[k]) {
a[k] = min(a1 - b[k], a[k]);
used[k] = 0;
}
}
} else
for (int k = l; k <= r; ++k) {
b[k] = b[k] + a1;
used[k] = 0;
}
}
bool j = 1;
for (int k = 1; k <= n; ++k) b[k] = a[k];
for (int k = 1; k <= m; ++k) {
if (c[k].x == 2) {
long long maxc = -1000000000;
for (int i = c[k].y; i <= c[k].z; ++i) maxc = max(maxc, b[i]);
if (maxc != c[k].t) {
j = 0;
break;
}
} else
for (int i = c[k].y; i <= c[k].z; ++i) b[i] += c[k].t;
}
if (j) {
cout << "YES" << endl;
for (int k = 1; k <= n; ++k) {
cout << a[k];
if (k < n) cout << ' ';
}
return 0;
} else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct op {
int type, l, r, x;
};
op ops[5001];
int mm[5001], ans[5001];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int type, l, r, x;
cin >> ops[i].type >> ops[i].l >> ops[i].r >> ops[i].x;
}
for (int i = 1; i <= n; ++i) mm[i] = 1e9;
for (int i = m - 1; i >= 0; --i) {
if (ops[i].type == 1)
for (int j = ops[i].l; j <= ops[i].r; ++j) mm[j] -= ops[i].x;
else
for (int j = ops[i].l; j <= ops[i].r; ++j) mm[j] = min(mm[j], ops[i].x);
}
for (int i = 1; i <= n; ++i) {
ans[i] = mm[i];
if (ans[i] > 1000000000) ans[i] = 1000000000;
}
for (int i = 0; i < m; ++i) {
if (ops[i].type == 1)
for (int j = ops[i].l; j <= ops[i].r; ++j) mm[j] += ops[i].x;
else {
int vmax = -2e9;
for (int j = ops[i].l; j <= ops[i].r; ++j) vmax = max(vmax, mm[j]);
if (vmax != ops[i].x) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) cout << ans[i] << ((i == n) ? "\n" : " ");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<pair<pair<pair<int, int>, long long>, vector<long long> > > ranges;
long long ans[5001];
long long best[5001];
int main() {
cin >> N >> M;
vector<long long> offset(N + 1);
for (int i = 0; i < M; ++i) {
int a, b, c;
long long d;
cin >> a >> b >> c >> d;
if (a == 1) {
for (int j = b; j <= c; ++j) {
offset[j] += d;
}
} else {
ranges.push_back(make_pair(make_pair(make_pair(b, c), d), offset));
}
}
bool possible = true;
for (int i = 1; i <= N; ++i) {
ans[i] = 1000000000;
best[i] = 1000000000;
for (int j = 0; j < ranges.size(); ++j) {
int left = ranges[j].first.first.first;
int right = ranges[j].first.first.second;
long long val = ranges[j].first.second;
ranges[j].second;
if (left <= i && i <= right) {
ans[i] = min(ans[i], val - ranges[j].second[i]);
}
}
}
for (int j = 0; j < ranges.size(); ++j) {
int left = ranges[j].first.first.first;
int right = ranges[j].first.first.second;
long long val = ranges[j].first.second;
bool b = false;
for (int i = left; i <= right; ++i) {
if (ans[i] + ranges[j].second[i] == val) {
b = true;
} else if (ans[i] + ranges[j].second[i] > val) {
possible = false;
}
}
if (!b) {
possible = false;
}
}
if (possible) {
cout << "YES" << endl;
for (int i = 1; i <= N; ++i) {
if (i != 1) {
cout << " ";
}
cout << ans[i];
}
cout << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:16777216")
const double EPS = 1e-7;
double iabs(const double a) { return (a < -EPS) ? -a : a; }
double imin(const double a, const double b) { return (a - b > EPS) ? b : a; }
double imax(const double a, const double b) { return (a - b > EPS) ? a : b; }
template <class I>
I iabs(const I a) {
return (a < 0) ? -a : a;
}
template <class I>
I imin(const I a, const I b) {
return (a < b) ? a : b;
}
template <class I>
I imax(const I a, const I b) {
return (a < b) ? b : a;
}
template <class I>
inline I mod_pow(const I& x, const long long p, const I& m) {
if (p == 0) return 1;
I mult = (p & 1) ? x : 1;
I t = mod_pow(x, p / 2, m) % m;
return (((mult * t) % m) * t) % m;
}
template <class T>
inline T ipow(const T& x, const long long p) {
if (p == 0) return 1;
T mult = (p & 1) ? x : 1;
T h = ipow(x, p / 2);
return h * h * mult;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <class T>
T next_power_of_two(T v) {
if (v < 0) return 0;
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v |= v >> 32;
v++;
return v;
}
string bin(unsigned int i) {
string res = "";
while (i != 0) {
res += ('0' + (i % 2));
i = i / 2;
}
return string(res.rbegin(), res.rend());
}
template <int SIZE>
class DSU {
public:
int parent[SIZE];
int rank[SIZE];
int count;
void clear() {
for (int i = 0; i < SIZE; i++) {
this->parent[i] = -1;
this->rank[i] = 0;
}
this->count = 0;
}
DSU() { this->clear(); }
void make(int x) {
this->parent[x] = x;
this->rank[x] = 1;
this->count++;
}
bool in_a_set(int x) { return this->parent[x] != -1; }
int find(int x) {
if (x == this->parent[x]) return x;
return this->parent[x] = find(this->parent[x]);
}
void combine(int x, int y) {
x = this->find(x);
y = this->find(y);
if (x != y) {
if (this->rank[x] > this->rank[y])
this->parent[x] = y;
else
this->parent[y] = x;
this->count--;
}
}
};
class BigInt {
public:
const static unsigned int N = 1000;
const static unsigned int base = 10;
unsigned int len;
short sign;
unsigned int digits[N];
BigInt(const BigInt& bi) {
this->len = bi.len;
this->sign = bi.sign;
for (unsigned int i = 0; i < this->len; ++i) (*this)[i] = bi[i];
}
BigInt(long long n) {
this->len = 0;
this->sign = (n >= 0) ? 1 : -1;
this->digits[0] = 0;
while (n) {
this->digits[this->len] = n % this->base;
n /= this->base;
this->len++;
}
if (this->len == 0) this->len = 1;
}
BigInt(string s) {
this->sign = (s[0] == '-') ? 1 : -1;
this->digits[0] = 0;
if (s[0] == '-') s = s.substr(1, s.length() - 1);
this->len = s.length();
for (unsigned int i = 0; i < this->len; i++)
(*this)[i] = s[this->len - i - 1] - '0';
}
string toString() const {
stringstream ss;
for (int i = this->len - 1; i >= 0; --i) ss << (*this)[i];
return ss.str();
}
unsigned int& operator[](const unsigned int i) { return digits[i]; }
unsigned int operator[](const unsigned int i) const {
if (i < this->len) return this->digits[i];
return 0;
}
bool iszero() const {
if (this->len <= 1 && this->digits[0] == 0) return true;
return false;
}
BigInt& operator=(const BigInt& rval) {
if (this != &rval) {
this->len = rval.len;
this->sign = rval.sign;
for (unsigned int i = 0; i < this->len; ++i) (*this)[i] = rval[i];
}
return *this;
}
BigInt operator+(const BigInt& rhs) const {
BigInt s(0);
unsigned long long r = 0, d, i;
for (i = 0; i < max(this->len, rhs.len); i++) {
d = (*this)[i] + rhs[i] + r;
r = d / this->base;
s[i] = d % this->base;
}
s.len = max(this->len, rhs.len);
if (r) s[s.len++] = r;
return s;
}
BigInt operator+(unsigned long long rhs) const {
BigInt s(*this);
unsigned long long r = 0, d, i = 0;
while (rhs != 0 || r != 0) {
d = s[i] + (rhs % s.base) + r;
rhs /= s.base;
r = d / s.base;
s[i] = d % s.base;
i++;
}
if (i > s.len) s.len = i;
return s;
}
BigInt operator*(unsigned long long rhs) const {
if (rhs == 0) return BigInt(0);
BigInt s(*this);
unsigned long long r = 0, d, i;
for (i = 0; i < s.len; ++i) {
d = s[i] * rhs + r;
r = d / this->base;
s[i] = d % this->base;
}
while (r) s[s.len++] = r % this->base, r /= this->base;
return s;
}
BigInt operator*(const BigInt& rhs) const {
BigInt s(0);
if (rhs.iszero()) return s;
unsigned long long r, d, i, j, k;
for (i = 0; i < this->N; i++) s[i] = 0;
for (i = 0; i < this->len; i++) {
r = 0;
for (j = 0, k = i; j < rhs.len; j++, k++) {
d = (*this)[i] * rhs[j] + r + s[k];
r = d / this->base;
s[k] = d % this->base;
}
while (r) s[k++] = r % this->base, r /= this->base;
if (k > s.len) s.len = k;
}
while (s.len > 1 && s[s.len - 1] == 0) s.len--;
return s;
}
unsigned int operator%(unsigned int rhs) {
BigInt t(*this);
unsigned long long pow = 1;
unsigned long long mod = 0;
for (unsigned int i = 0; i < this->len && pow != 0; i++) {
mod = (((*this)[i] % rhs) * pow + mod) % rhs;
pow = (pow * this->base) % rhs;
}
return mod;
}
};
vector<long long> genprimes(const int n) {
vector<long long> res;
res.push_back(2);
long long m, t, j;
for (int i = 3; i <= n; i += 2) {
j = 0;
m = res.size();
t = (long long)sqrt(i * 1.0) + 1;
while (j < m && res[j] < t && i % res[j] != 0) j++;
if (j == m || res[j] >= t) res.push_back(i);
}
return res;
}
long long reverse_intereger(long long a) {
int res = 0;
while (a != 0) res = 10 * res + (a % 10), a /= 10;
return res;
}
int main() {
long long n, m, t, l, r, d, lowerBound = -1000000000, upperBound = 1000000000;
vector<pair<long long, pair<pair<long, long>, long long> > > oper;
bool isPossible = true, atLeastOne;
long long curVal[5011], initVal[5011];
for (int i = 0; i < 5011; ++i) {
curVal[i] = upperBound;
initVal[i] = upperBound;
}
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> t >> l >> r >> d;
oper.push_back(make_pair(t, make_pair(make_pair(l, r), d)));
}
int i = m - 1;
while (isPossible && i >= 0) {
t = oper[i].first;
l = oper[i].second.first.first;
r = oper[i].second.first.second;
d = oper[i].second.second;
if (t == 1) {
for (; l <= r && isPossible; ++l) {
curVal[l] -= d;
initVal[l] -= d;
}
} else {
atLeastOne = false;
for (; l <= r && isPossible; ++l) {
if (curVal[l] == d) {
atLeastOne = true;
} else if (curVal[l] > d) {
atLeastOne = true;
curVal[l] = d;
initVal[l] = d;
}
}
if (!atLeastOne) {
isPossible = false;
}
}
i--;
}
if (isPossible) {
for (int q = 1; q < n + 1; ++q) {
if (curVal[q] < lowerBound) {
curVal[q] = lowerBound;
initVal[q] = lowerBound;
}
if (curVal[q] > upperBound) {
curVal[q] = upperBound;
initVal[q] = upperBound;
}
}
i = 0;
for (; isPossible && i < m; ++i) {
t = oper[i].first;
l = oper[i].second.first.first;
r = oper[i].second.first.second;
d = oper[i].second.second;
if (t == 1) {
for (; l <= r && isPossible; ++l) {
curVal[l] += d;
}
} else {
atLeastOne = false;
for (; l <= r && isPossible; ++l) {
if (curVal[l] == d) {
atLeastOne = true;
} else if (curVal[l] > d) {
isPossible = false;
}
}
if (!atLeastOne) {
isPossible = false;
}
}
}
}
if (isPossible) {
cout << "YES" << endl;
cout << initVal[1];
for (int q = 2; q < n + 1; ++q) {
cout << " " << initVal[q];
}
} else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int mx[5010];
int sum[5010];
int arr[5010];
int q[5010][4];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) mx[i] = 1000000000;
for (int i = 0; i < m; i++) {
for (int j = 0; j < 4; j++) cin >> q[i][j];
q[i][1]--, q[i][2]--;
if (q[i][0] == 1)
for (int j = q[i][1]; j <= q[i][2]; j++) sum[j] += q[i][3];
else
for (int j = q[i][1]; j <= q[i][2]; j++)
mx[j] = min(mx[j], q[i][3] - sum[j]);
}
for (int i = 0; i < n; i++) arr[i] = mx[i];
bool can = true;
for (int i = 0; i < m; i++) {
if (q[i][0] == 1)
for (int j = q[i][1]; j <= q[i][2]; j++) arr[j] += q[i][3];
else {
int val = arr[q[i][1]];
for (int j = q[i][1]; j <= q[i][2]; j++) val = max(val, arr[j]);
if (val != q[i][3]) can = false;
}
}
if (can) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << mx[i] << ' ';
cout << endl;
} else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
T _max(T a, T b) {
return (!(a < b) ? a : b);
}
template <class T>
T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
T sq(T x) {
return x * x;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
long long mx[5100], add[5100];
int t[5100], st[5100], fn[5100], d[5100];
int main() {
int i, n, m, j;
cin >> n >> m;
for (j = 1; j <= n; j++) mx[j] = 1000000000;
for (i = 0; i < m; i++) {
scanf("%d %d %d %d", &t[i], &st[i], &fn[i], &d[i]);
if (t[i] == 1) {
for (j = st[i]; j <= fn[i]; j++) add[j] += d[i];
} else {
for (j = st[i]; j <= fn[i]; j++) {
mx[j] = min(mx[j], d[i] - add[j]);
}
}
}
bool fl = 1;
long long mn;
memcpy(add, mx, sizeof(mx));
for (j = 1; j <= n; j++)
if (_abs(mx[j]) > 1000000000) fl = 0;
for (i = 0; i < m && fl; i++) {
if (t[i] == 1) {
for (j = st[i]; j <= fn[i]; j++) add[j] += d[i];
} else {
mn = -100000000000000ll;
for (j = st[i]; j <= fn[i]; j++) mn = max(add[j], mn);
if (mn != d[i]) fl = 0;
}
}
if (fl) {
cout << "YES\n" << mx[1];
for (j = 2; j <= n; j++) cout << ' ' << mx[j];
puts("");
} else
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[10100];
int b[10100];
struct node {
int type;
int l, r, d;
} op[10100];
int vis[10101];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> op[i].type >> op[i].l >> op[i].r >> op[i].d;
int f = 0;
for (int i = m - 1; i >= 0; i--) {
if (op[i].type == 1) {
for (int j = op[i].l; j <= op[i].r; j++) {
a[j] -= op[i].d;
}
}
if (op[i].type == 2) {
for (int j = op[i].l; j <= op[i].r; j++) {
if (!vis[j])
a[j] = op[i].d, vis[j] = 1;
else {
if (a[j] > op[i].d) a[j] = op[i].d;
}
}
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > 1e9) flag = 1;
b[i] = a[i];
}
if (flag == 1) {
printf("NO\n");
return 0;
}
for (int i = 0; i < m; i++) {
int maxx = -1e9;
if (op[i].type == 1) {
for (int j = op[i].l; j <= op[i].r; j++) {
b[j] += op[i].d;
}
}
if (op[i].type == 2) {
for (int j = op[i].l; j <= op[i].r; j++) {
maxx = max(maxx, b[j]);
}
if (maxx != op[i].d) {
flag = 1;
break;
}
}
}
if (flag == 1)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
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];
--b[i];
--c[i];
}
vector<int> odp(n, INF), r(n, 0);
for (int i = 0; i < m; ++i) {
if (a[i] == 1) {
for (int j = b[i]; j <= c[i]; ++j) r[j] += d[i];
} else {
for (int j = b[i]; j <= c[i]; ++j) odp[j] = min(odp[j], d[i] - r[j]);
}
}
bool ok = true;
vector<int> t;
t = odp;
for (int i = 0; i < m; ++i) {
if (a[i] == 1) {
for (int j = b[i]; j <= c[i]; ++j) t[j] += d[i];
} else {
int maxi = -INF;
for (int j = b[i]; j <= c[i]; ++j) maxi = max(maxi, t[j]);
if (maxi != d[i]) ok = false;
}
}
if (ok) {
cout << "YES" << endl;
for (int i = 0; i < n; ++i) cout << odp[i] << " ";
} else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int _bufint;
inline int in() {
scanf("%d", &_bufint);
return _bufint;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
const double eps = 1e-6;
const long long LINF = ~((1ll) << 63);
const int INF = ~(1 << 31);
const int maxn = 100000008;
struct query {
int t, l, r, d;
query(int _t, int _l, int _r, int _d) {
t = _t;
l = _l;
r = _r;
d = _d;
}
};
vector<query> q;
int main() {
int n = in(), m = in();
vector<long long> v(n, maxn), delta(n, 0), res;
for (int i = 0; i < m; ++i) {
int t = in(), l = in(), r = in(), d = in();
q.push_back(query(t, l, r, d));
if (t == 1) {
for (int j = l - 1; j < r; ++j) {
v[j] += d, delta[j] -= d;
}
} else {
for (int j = l - 1; j < r; ++j) {
v[j] = min((long long)d, v[j]);
}
}
}
for (int i = 0; i < n; ++i) {
v[i] += delta[i];
}
res = v;
for (int i = 0; i < m; ++i) {
int t = q[i].t, l = q[i].l, r = q[i].r, d = q[i].d;
if (t == 1) {
for (int j = l - 1; j < r; ++j) {
v[j] += d;
}
} else {
long long cur = -INF;
for (int j = l - 1; j < r; ++j) {
cur = max(v[j], cur);
}
if (cur != d) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 0; i < n; ++i) {
printf("%d ", (int)(res[i]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5001;
const int MAXM = 1000000000;
int Q[MAXN], L[MAXN], R[MAXN], P[MAXN], ADD[MAXN] = {0}, Ans[MAXN],
Result[MAXN];
int N, M;
bool Achieve;
int main() {
cin >> N >> M;
fill(Ans + 1, Ans + N + 1, MAXM);
for (int i = 0; i < M; i++) {
cin >> Q[i] >> L[i] >> R[i] >> P[i];
if (Q[i] == 1) {
for (int j = L[i]; j <= R[i]; j++) ADD[j] += P[i];
} else {
for (int j = L[i]; j <= R[i]; j++) Ans[j] = min(Ans[j], P[i] - ADD[j]);
}
}
Achieve = 1;
copy(Ans + 1, Ans + N + 1, Result + 1);
for (int i = 0; i < M; i++) {
if (Q[i] == 1) {
for (int j = L[i]; j <= R[i]; j++) Ans[j] += P[i];
} else {
bool achieve = 0;
for (int j = L[i]; j <= R[i]; j++) {
if (Ans[j] > P[i]) {
achieve = 0;
break;
}
if (Ans[j] == P[i]) achieve = 1;
}
if (!achieve) {
Achieve = 0;
break;
}
}
}
if (Achieve) {
cout << "YES\n";
for (int i = 1; i < N; i++) cout << Result[i] << " ";
cout << Result[N] << endl;
} else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5002, NP = 1e9;
int Add[MAXN], MyResult[MAXN], MyCheck[MAXN];
bool check(int n, vector<pair<int, pair<int, pair<int, int> > > > A) {
for (int i = 0; i < A.size(); i++) {
int t = A[i].first, s = A[i].second.first, e = A[i].second.second.first,
v = A[i].second.second.second;
if (t == 1) {
for (int i = s - 1; i <= e - 1; i++) {
MyCheck[i] += v;
}
} else {
int mx = MyCheck[s - 1];
for (int i = s - 1; i <= e - 1; i++) mx = max(mx, MyCheck[i]);
if (mx != v) return 0;
}
}
return 1;
}
int main() {
int t, n, m, s, e, v;
vector<pair<int, pair<int, pair<int, int> > > > A;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) MyCheck[i] = MyResult[i] = NP;
while (m--) {
scanf("%d%d%d%d", &t, &s, &e, &v);
A.push_back(make_pair(t, make_pair(s, make_pair(e, v))));
if (t == 1) {
for (int i = s - 1; i <= e - 1; i++) Add[i] += v;
} else {
for (int i = s - 1; i <= e - 1; i++)
MyResult[i] = min(MyResult[i], v - Add[i]);
}
}
for (int i = 0; i < n; i++) MyCheck[i] = MyResult[i];
if (check(n, A)) {
printf("YES\n");
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", MyResult[i]);
}
printf("\n");
} else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int AMAX = 1e9;
int main() {
int m, n, i, j, x, y, k = 0, k2;
cin >> n >> m;
vector<int> a(n + 1, AMAX), add(n + 1), l(m + 1), r(m + 1), d(m + 1),
t(m + 1);
for (i = 1; i <= m; i++) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) add[j] += d[i];
} else {
for (j = l[i]; j <= r[i]; j++) a[j] = min(a[j], d[i] - add[j]);
}
}
for (i = 1; i <= n; i++) add[i] = 0;
for (i = 1; i <= m; i++) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) add[j] += d[i];
} else {
int maxx = -1000000000;
for (j = l[i]; j <= r[i]; j++) {
maxx = max(maxx, a[j] + add[j]);
}
if (maxx != d[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Query {
int t, l, r, x;
};
int n, m;
int incr[5555];
long long a[5555], b[5555];
Query q[5555];
int main() {
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", &q[i].t, &q[i].l, &q[i].r, &q[i].x);
if (q[i].t == 1)
for (int j = q[i].l; j <= q[i].r; j++) incr[j] += q[i].x;
else
for (int j = q[i].l; j <= q[i].r; j++)
a[j] = min(a[j], (long long)q[i].x - incr[j]);
}
for (int i = 1; i <= n; i++) b[i] = a[i];
for (int i = 1; i <= m; i++) {
if (q[i].t == 1)
for (int j = q[i].l; j <= q[i].r; j++) a[j] += q[i].x;
else {
long long m = -1e18;
for (int j = q[i].l; j <= q[i].r; j++) m = max(m, a[j]);
if (m != q[i].x) {
printf("NO");
return 0;
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%I64d ", b[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[5001], e[5001];
int main() {
int n, m;
cin >> n >> m;
int a[m], b[m], c[m], d[m];
for (int i = 1; i <= n; i++) ans[i] = 100000000;
for (int i = 0; i < m; i++) cin >> a[i] >> b[i] >> c[i] >> d[i];
for (int i = m - 1; i >= 0; i--) {
if (a[i] == 2)
for (int j = b[i]; j <= c[i]; j++) ans[j] = min(ans[j], d[i]);
else
for (int j = b[i]; j <= c[i]; j++) ans[j] -= d[i];
}
for (int i = 1; i <= n; i++) e[i] = ans[i];
for (int i = 0; i < m; i++) {
if (a[i] == 1)
for (int j = b[i]; j <= c[i]; j++) e[j] += d[i];
else {
bool w = false;
for (int j = b[i]; j <= c[i]; j++)
if (e[j] == d[i])
w = true;
else if (e[j] > d[i]) {
cout << "NO" << endl;
return 0;
}
if (!w) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct event {
int t, l, r, v;
};
void solve() {
int n, q;
cin >> n >> q;
vector<event> e(q);
vector<int64_t> a(n, INT_MAX), upd(n, 0);
for (int i = 0; i < q; ++i) {
cin >> e[i].t;
cin >> e[i].l;
cin >> e[i].r;
cin >> e[i].v;
--e[i].l;
--e[i].r;
if (e[i].t == 1) {
for (int j = e[i].l; j < e[i].r + 1; ++j) {
upd[j] += e[i].v;
}
}
}
for (int i = q - 1; i >= 0; --i) {
if (e[i].t == 2) {
for (int j = e[i].l; j < e[i].r + 1; ++j) {
a[j] = min(a[j], e[i].v - upd[j]);
}
} else {
for (int j = e[i].l; j < e[i].r + 1; ++j) {
upd[j] -= e[i].v;
}
}
}
vector<int64_t> tmp(a);
for (int i = 0; i < q; ++i) {
if (e[i].t == 1) {
for (int j = e[i].l; j < e[i].r + 1; ++j) {
tmp[j] += e[i].v;
}
} else {
int64_t here = INT_MIN;
for (int j = e[i].l; j < e[i].r + 1; ++j) {
here = max(here, tmp[j]);
}
if (here != e[i].v) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n";
for (int64_t i : a) {
if (i == INT_MAX)
cout << rand() % 1000 << " ";
else
cout << i << " ";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000000;
const int N = 5010;
int str[N];
int ans[N];
bool have[N];
struct T {
int op, l, r, val;
} line[N];
int main() {
int n, m, i, j;
int op, l, r, val;
int tmp;
bool ok;
while (~scanf("%d%d", &n, &m)) {
for (i = 0; i < m; i++) {
scanf("%d%d%d%d", &line[i].op, &line[i].l, &line[i].r, &line[i].val);
}
memset(have, false, sizeof(have));
for (i = m - 1; i >= 0; i--) {
if (line[i].op == 2) {
for (j = line[i].l; j <= line[i].r; j++) {
if (have[j]) {
str[j] = min(str[j], line[i].val);
} else {
have[j] = true;
str[j] = line[i].val;
}
}
} else {
for (j = line[i].l; j <= line[i].r; j++) {
if (have[j]) {
str[j] -= line[i].val;
}
}
}
}
for (i = 1; i <= n; i++) {
if (have[i]) {
ans[i] = str[i];
} else {
ans[i] = 0;
}
}
ok = false;
for (i = 0; i < m; i++) {
if (line[i].op == 2) {
for (j = line[i].l, tmp = str[j]; j <= line[i].r; j++) {
tmp = max(tmp, str[j]);
}
if (tmp != line[i].val) {
ok = true;
break;
}
} else {
for (j = line[i].l; j <= line[i].r; j++) {
str[j] += line[i].val;
}
}
}
if (ok) {
printf("NO\n");
} else {
puts("YES");
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[5005], n, m;
int ans[5005];
struct operation {
int type, l, r, t;
} op[5005];
void init() {
for (int i = 1; i <= n; i++) val[i] = 1000000000;
}
void backward() {
for (int i = m; i >= 1; i--) {
if (op[i].type == 1) {
for (int j = op[i].l; j <= op[i].r; j++) {
if (val[j] != 1000000000) val[j] -= op[i].t;
}
} else {
for (int j = op[i].l; j <= op[i].r; j++) {
val[j] = min(val[j], op[i].t);
}
}
}
for (int i = 1; i <= n; i++) ans[i] = val[i];
}
bool forward() {
for (int i = 1; i <= m; i++) {
if (op[i].type == 1) {
for (int j = op[i].l; j <= op[i].r; j++) {
val[j] += op[i].t;
}
} else {
int ans = val[op[i].l];
for (int j = op[i].l; j <= op[i].r; j++) ans = max(ans, val[j]);
if (ans != op[i].t) return false;
}
}
return true;
}
void solve() {
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &op[i].type, &op[i].l, &op[i].r, &op[i].t);
}
init();
backward();
if (forward()) {
puts("YES");
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%d", ans[i]);
}
puts("");
} else
puts("NO");
}
int main() {
while (~scanf("%d%d", &n, &m)) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int type;
int a, b, c;
};
pair<int, int> dp[5000 + 8];
int path[5000 + 8];
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
data A[m + 8];
for (int i = 0; i < m; i++) {
scanf("%d", &A[i].type);
scanf("%d", &A[i].a);
scanf("%d", &A[i].b);
scanf("%d", &A[i].c);
}
int M = -1000000001;
for (int i = 0; i < n + 1; i++) {
dp[i].first = dp[i].second = M;
dp[i].second = M;
}
for (int i = 0; i < m; i++) {
if (A[i].type == 1) {
for (int j = A[i].a; j < A[i].b + 1; j++) {
path[j] += A[i].c;
}
} else {
for (int j = A[i].a; j < A[i].b + 1; j++) {
if (dp[j].first == M) {
dp[j].first = A[i].c - path[j];
} else {
if (dp[j].first > A[i].c - path[j]) {
dp[j].first = A[i].c - path[j];
}
}
}
}
}
int maxi;
for (int i = 0; i < n + 1; i++) {
dp[i].second = dp[i].first;
}
for (int i = 0; i < m; i++) {
if (A[i].type == 1) {
for (int j = A[i].a; j < A[i].b + 1; j++) {
dp[j].first += A[i].c;
}
} else if (A[i].type == 2) {
maxi = INT_MIN;
for (int j = A[i].a; j < A[i].b + 1; j++) {
maxi = max(maxi, dp[j].first);
}
if (maxi != A[i].c) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) {
if (dp[i + 1].second == M) {
printf("%d ", -1);
;
} else
printf("%d ", dp[i + 1].second);
;
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m;
int M[5050] = {0}, R[5050] = {0}, Q[5050][4] = {0};
int t, l, r, d;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) R[i] = 1000000000;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &t, &l, &r, &d);
Q[i][0] = t, Q[i][1] = l, Q[i][2] = r, Q[i][3] = d;
if (t == 1)
for (int j = l; j <= r; j++) M[j] += d;
else {
for (int j = l; j <= r; j++)
if (R[j] > d - M[j]) R[j] = d - M[j];
}
}
for (int i = 1; i <= n; i++) M[i] = 0;
bool flag = false;
for (int i = 1; i <= m; i++) {
l = Q[i][1], r = Q[i][2], d = Q[i][3];
if (Q[i][0] == 1)
for (int j = l; j <= r; j++) M[j] += d;
else {
int j;
for (j = l; j <= r; j++)
if (R[j] == d - M[j]) break;
if (j > r) {
flag = true;
break;
}
}
}
printf("%s\n", flag ? "NO" : "YES");
if (!flag) {
for (int i = 1; i <= n; i++) printf("%d ", R[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, l, r, m;
} op[5010];
int a[5010], b[5010], 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()) {
printf("NO\n");
} else {
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d ", a[i]);
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[5005], D[5005];
int T[5005], L[5005], R[5005], M[5005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
A[i] = 1000000000;
}
memset(D, 0, sizeof(D));
for (int k = 0; k < m; k++) {
int t, l, r, d;
scanf("%d %d %d %d", &t, &l, &r, &d);
T[k] = t;
L[k] = --l;
R[k] = r;
M[k] = d;
if (t == 1) {
for (int i = l; i < r; i++) {
D[i] += d;
}
} else {
int can = 0;
for (int i = l; i < r; i++) {
if (A[i] >= d - D[i]) {
can = 1;
A[i] = d - D[i];
}
}
if (!can) {
printf("NO\n");
return 0;
}
}
}
memset(D, 0, sizeof(D));
for (int k = 0; k < m; k++) {
int t = T[k], l = L[k], r = R[k], d = M[k];
if (t == 1) {
for (int i = l; i < r; i++) {
D[i] += d;
}
} else {
int can = 0;
for (int i = l; i < r; i++) {
if (A[i] == d - D[i]) {
can = 1;
}
}
if (!can) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) {
if (i != 0) {
printf(" ");
}
printf("%d", A[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> t(m), l(m), r(m), d(m);
for (long long i = 0; i < m; i++) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
l[i]--;
r[i]--;
}
vector<long long> cur(n, 0), base(n, 0);
for (long long i = 0; i < m; i++) {
if (t[i] == 1) {
for (long long j = l[i]; j <= r[i]; j++) cur[j] += d[i];
} else {
long long maxidx = -1, maxx = INT_MIN;
for (long long j = l[i]; j <= r[i]; j++) {
long long nbase = d[i] - (cur[j]);
if (nbase <= base[j] || base[j] == 0) base[j] = nbase;
}
}
}
long long f = 1;
vector<long long> ans = base;
for (long long i = 0; i < m; i++) {
if (t[i] == 1) {
for (long long j = l[i]; j <= r[i]; j++) base[j] += d[i];
} else {
long long maxx = INT_MIN;
for (long long j = l[i]; j <= r[i]; j++) {
maxx = max(maxx, base[j]);
}
if (maxx != d[i]) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (long long i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bz = -10000000000;
long long t[50001], ll[50001], rr[50001], dd[50001];
long long tu[50001];
int main() {
long long n, m;
cin >> n >> m;
for (long long a = 1; a <= n; a++) tu[a] = bz;
for (long long a = 1; a <= m; a++) cin >> t[a] >> ll[a] >> rr[a] >> dd[a];
for (long long a = 1; a <= m; a++) {
if (t[a] == 1) {
for (long long b = ll[a]; b <= rr[a]; b++) {
if (tu[b] == bz)
continue;
else
tu[b] += dd[a];
}
} else {
long long jc = 1;
for (long long b = ll[a]; b <= rr[a]; b++) {
if (tu[b] == bz) {
tu[b] = dd[a];
jc = 0;
} else {
if (tu[b] >= dd[a]) {
tu[b] = dd[a];
jc = 0;
}
}
}
if (jc) {
cout << "NO";
return 0;
}
}
}
for (long long a = 1; a <= n; a++)
if (tu[a] == bz) tu[a] = 0;
for (long long a = m; a >= 1; a--) {
if (t[a] == 2) {
long long jc = 1;
for (long long b = ll[a]; b <= rr[a]; b++) {
if (tu[b] == dd[a]) jc = 0;
}
if (jc) {
cout << "NO";
return 0;
}
continue;
}
for (long long b = ll[a]; b <= rr[a]; b++)
if (tu[a] != bz) tu[b] -= dd[a];
}
cout << "YES" << endl;
long long jc = 0;
for (long long a = 1; a <= n; a++) {
if (tu[a] == bz) tu[a] = 0;
if (!jc) {
cout << tu[a];
jc = 1;
} else {
cout << " " << tu[a];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 9;
int inc[N], arr[N];
int a[N], b[N], c[N], d[N], sum[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) inc[i] = 1000000001;
for (int i = 0; i < m; ++i) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
if (a[i] == 1) {
for (int j = b[i]; j <= c[i]; ++j) {
sum[j] += d[i];
}
continue;
}
for (int j = b[i]; j <= c[i]; ++j) {
inc[j] = min(inc[j], d[i] - sum[j]);
}
}
for (int i = 1; i <= n; ++i) {
sum[i] = 0;
if (inc[i] == 1000000001) inc[i] = 0;
}
for (int i = 0; i < m; ++i) {
if (a[i] == 1) {
for (int j = b[i]; j <= c[i]; ++j) {
sum[j] += d[i];
}
} else {
int cnt = 0;
for (int j = b[i]; j <= c[i]; ++j) {
if (sum[j] + inc[j] > d[i]) {
cout << "NO\n";
return 0;
}
if (sum[j] + inc[j] < d[i]) ++cnt;
}
if (cnt == c[i] - b[i] + 1) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) {
cout << inc[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5001], b[5001], c[5000][4];
bool check[5001];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d %d %d %d", &c[i][0], &c[i][1], &c[i][2], &c[i][3]);
for (int i = 1; i <= n; i++) a[i] = -1e9;
for (int i = m - 1; i >= 0; i--)
if (c[i][0] == 1) {
for (int j = c[i][1]; j <= c[i][2]; j++)
if (check[j]) a[j] -= c[i][3];
} else {
for (int j = c[i][1]; j <= c[i][2]; j++)
if (check[j] && a[j] < c[i][3])
continue;
else
a[j] = c[i][3], check[j] = 1;
}
for (int i = 1; i <= n; i++) b[i] = a[i];
bool cc = 0;
for (int i = 0; i < m; i++)
if (c[i][0] == 1)
for (int j = c[i][1]; j <= c[i][2]; j++) a[j] += c[i][3];
else {
int m2 = -1e9;
for (int j = c[i][1]; j <= c[i][2]; j++)
if (check[j]) m2 = max(m2, a[j]);
if (m2 != c[i][3]) {
cc = 1;
break;
}
}
if (cc)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++)
if (check[i] == 0)
printf("%d ", -1e9);
else
printf("%d ", b[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * (1e3) + 10;
long long arr[MAXN], tmp[MAXN], l[MAXN], r[MAXN], t[MAXN], num[MAXN];
int m, n;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) arr[i] = 1e9;
for (int i = 1; i <= m; i++)
scanf("%I64d%I64d%I64d%I64d", &t[i], &l[i], &r[i], &num[i]);
for (int i = m; i > 0; i--) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) arr[j] -= num[i];
} else if (t[i] == 2) {
for (int j = l[i]; j <= r[i]; j++) {
if (arr[j] > num[i]) arr[j] = num[i];
}
}
}
for (int i = 1; i <= n; i++) tmp[i] = arr[i];
for (int i = 1; i <= m; i++) {
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; j++) tmp[j] += num[i];
else if (t[i] == 2) {
long long max = -1e9;
for (int j = l[i]; j <= r[i]; j++)
if (max < tmp[j]) max = tmp[j];
if (max != num[i]) {
printf("NO\n");
return 0;
}
}
}
for (int i = 1; i <= n; i++)
if (arr[i] > 1e9 || arr[i] < -1e9) arr[i] = 0;
printf("YES\n");
for (int i = 1; i < n; i++) printf("%I64d ", arr[i]);
printf("%I64d\n", arr[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2 * ((1 << 30) - 1) + 1;
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int ceil(int a, int b) { return (a + b - 1) / b; }
typedef struct {
int type;
int a;
int b;
int x;
} Step;
int main(void) {
int n, m;
cin >> n >> m;
int diff[n], max_a[n];
bool det[n];
memset(diff, 0, sizeof(diff));
memset(max_a, 0, sizeof(max_a));
memset(det, false, sizeof(det));
vector<Step> v;
for (int i = 0; i < m; i++) {
int type, a, b, x;
cin >> type >> a >> b >> x;
--a;
--b;
if (type == 1) {
for (int j = a; j <= b; j++) diff[j] += x;
} else {
for (int j = a; j <= b; j++) {
max_a[j] = det[j] ? min(max_a[j], x - diff[j]) : x - diff[j];
det[j] = true;
}
}
Step s = {type, a, b, x};
v.push_back(s);
}
vector<int> arr(max_a, max_a + n);
for (int i = 0; i < m; i++) {
Step s = v[i];
if (s.type == 1) {
for (int j = s.a; j <= s.b; j++) arr[j] += s.x;
} else {
int mx = arr[s.a];
for (int j = s.a + 1; j <= s.b; j++) mx = max(mx, arr[j]);
if (mx != s.x) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << max_a[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int res[101000], a[101000], t[101000], l[101000], r[101000], d[101000],
m[101000];
int n, M;
int main() {
cin >> n >> M;
for (int i = 1; i <= M; i++) {
cin >> t[i];
if (t[i] == 1)
cin >> l[i] >> r[i] >> d[i];
else
cin >> l[i] >> r[i] >> m[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];
if (t[i] == 2)
for (int j = l[i]; j <= r[i]; j++) a[j] = m[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++)
if (a[j] > m[i]) a[j] = m[i];
}
for (int i = 1; i <= n; i++) res[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];
if (t[i] == 2) {
int amax = a[l[i]];
for (int j = l[i]; j <= r[i]; j++) amax = max(a[j], amax);
if (amax != m[i]) {
cout << "NO";
return 0;
};
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << res[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int t[5001];
int a[5001];
int b[5001];
int val[5001];
int upper[5001];
int sums[5001];
int main(int argc, char *argv[]) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", &t[i], &a[i], &b[i], &val[i]);
}
while ((m > 1) && (t[m - 1] == 1)) {
--m;
}
for (int i = 0; i <= n; ++i) {
upper[i] = 2000000000;
}
for (int i = m - 1; i >= 0; --i) {
if (t[i] == 2) {
for (int j = a[i]; j <= b[i]; ++j) {
upper[j] = ((upper[j]) < (val[i]) ? (upper[j]) : (val[i]));
}
} else {
for (int j = a[i]; j <= b[i]; ++j) {
if (upper[j] != 2000000000) {
upper[j] -= val[i];
}
}
}
}
memset(sums, 0, sizeof(sums));
for (int i = 0; i < m; ++i) {
if (t[i] == 2) {
bool ok = false;
for (int j = a[i]; j <= b[i]; ++j) {
if (upper[j] == 2000000000) {
upper[j] = val[i] - sums[j];
ok = true;
} else if (upper[j] + sums[j] >= val[i]) {
ok = true;
}
}
if (!ok) {
printf("NO\n");
return 0;
}
} else {
for (int j = a[i]; j <= b[i]; ++j) {
sums[j] += val[i];
}
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i) {
if (upper[i] == 2000000000) {
printf("0 ");
} else {
printf("%d ", upper[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int least[5005];
int val[5005];
vector<pair<pair<int, int>, pair<int, int> > > vec;
int main() {
srand((unsigned int)time(NULL));
int n, m;
scanf("%d%d", &n, &m);
fill(least, least + 5005, 1000000000);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
int l, r, v;
if (x == 1) {
scanf("%d%d%d", &l, &r, &v);
for (int j = l; j <= r; j++) val[j] += v;
} else {
scanf("%d%d%d", &l, &r, &v);
for (int j = l; j <= r; j++) {
least[j] = min(least[j], v - val[j]);
}
}
vec.push_back(make_pair(make_pair(x, l), make_pair(r, v)));
}
memset(val, 0, sizeof(val));
for (int i = 0; i < m; i++) {
int x = vec[i].first.first;
int l = vec[i].first.second;
int r = vec[i].second.first;
int v = vec[i].second.second;
if (x == 1) {
scanf("%d%d%d", &l, &r, &v);
for (int j = l; j <= r; j++) val[j] += v;
} else {
bool ok = false;
for (int j = l; j <= r; j++) {
if (val[j] + least[j] > v) {
ok = 0;
break;
}
if (val[j] + least[j] == v) ok = 1;
}
if (!ok) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", least[i], i == n ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> mx(n + 1, 100000000);
vector<int> t;
vector<int> l;
vector<int> r;
vector<int> a;
vector<int> add(n + 1);
for (int j = 0; j < m; j++) {
int ax, bx, cx, dx;
cin >> ax >> bx >> cx >> dx;
t.push_back(ax);
l.push_back(bx);
r.push_back(cx);
a.push_back(dx);
if (ax == 1) {
for (int i = bx; i <= cx; i++) add[i] += dx;
} else {
bool any = false;
for (int i = bx; i <= cx; i++)
if (mx[i] + add[i] >= dx) {
any = true;
break;
}
if (!any) {
cout << "NO";
return 0;
}
for (int i = bx; i <= cx; i++) mx[i] = min(mx[i], dx - add[i]);
}
}
add.assign(n + 1, 0);
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) add[j] += a[i];
} else {
bool any = false;
for (int j = l[i]; j <= r[i]; j++)
if (mx[j] + add[j] >= a[i]) {
any = true;
break;
}
if (!any) {
cout << "NO";
return 0;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << mx[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[5001];
int arr[5001], ans[5001];
int t[5001], l[5001], r[5001], d[5001];
int main() {
int cnt = 0;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) ans[i] = 1000000001;
for (int i = 0; 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) arr[j] += d[i];
} else {
for (int j = l[i]; j <= r[i]; ++j) {
ans[j] = min(ans[j], d[i] - arr[j]);
vis[j] = 1;
}
}
}
bool flag = 0;
for (int i = 1; i <= n; ++i) arr[i] = 0;
for (int i = 0; i < m; ++i) {
if (t[i] == 2) {
int maxx = ans[l[i]] + arr[l[i]];
for (int j = l[i] + 1; j <= r[i]; ++j)
if (ans[j] + arr[j] > maxx) maxx = ans[j] + arr[j];
if (maxx ^ d[i]) {
cout << "NO" << endl;
return 0;
}
} else {
for (int j = l[i]; j <= r[i]; ++j) arr[j] += d[i];
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) {
if (vis[i])
cout << ans[i] << " ";
else
cout << "0"
<< " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n, 1e9), memo(n, 0);
vector<int> t(m), d(m), l(m), r(m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d", &t[i], &l[i], &r[i], &d[i]);
l[i]--;
if (t[i] == 1) {
for (int j = l[i]; j < r[i]; j++) memo[j] += d[i];
} else {
for (int j = l[i]; j < r[i]; j++) a[j] = min(a[j], d[i] - memo[j]);
}
}
vector<int> ans = a;
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j < r[i]; j++) a[j] += d[i];
} else {
if (*max_element(a.begin() + l[i], a.begin() + r[i]) != d[i]) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 0; i < ((int)(ans).size()); i++) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Operation {
int t, l, r, v;
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<Operation> ops(m);
vector<int> a(n, 1e9);
vector<int> change(n);
for (int j = 0; j < m; j++) {
Operation &op = ops[j];
scanf("%d%d%d%d", &op.t, &op.l, &op.r, &op.v);
op.l--;
op.r--;
if (op.t == 1) {
for (int i = op.l; i <= op.r; i++) change[i] += op.v;
} else {
for (int i = op.l; i <= op.r; i++) a[i] = min(a[i], op.v - change[i]);
}
}
vector<int> b(a);
for (int j = 0; j < m; j++) {
Operation &op = ops[j];
if (op.t == 1) {
for (int i = op.l; i <= op.r; i++) b[i] += op.v;
} else {
if (op.v != *max_element(b.begin() + op.l, b.begin() + op.r + 1)) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 0; i < n; i++) {
printf("%d ", a[i]);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n >> q;
long long t[q], l[q], r[q], v[q], ans[n + 1], b[n + 1];
for (int i = 1; i <= n; ++i) ans[i] = 1e9, b[i] = 0ll;
for (int i = 0; i < q; ++i) cin >> t[i] >> l[i] >> r[i] >> v[i];
for (int i = 0; i < q; ++i) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) b[j] += v[i];
} else {
for (int j = l[i]; j <= r[i]; ++j) ans[j] = min(ans[j], v[i] - b[j]);
}
}
for (int i = 1; i <= n; ++i) b[i] = 0ll;
for (int i = 0; i < q; ++i) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; ++j) b[j] += v[i];
} else {
long long MAX = -1e9;
for (int j = l[i]; j <= r[i]; ++j) MAX = max(MAX, ans[j] + b[j]);
if (MAX != v[i]) return cout << "NO\n", 0;
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct zz {
int type, l, r, data;
} a[(5005)];
int n, m, limit[(5005)], t[(5005)];
inline void t_add(int l, int r, int delta) {
for (register int i = l; i <= r; ++i) t[i] += delta;
}
void limit_get() {
for (register int i = 1; i <= n; ++i) t[i] = 0;
for (register int i = 1; i <= n; ++i) limit[i] = 1000000000;
for (int i = 1; i <= m; ++i) {
if (a[i].type == 1)
t_add(a[i].l, a[i].r, a[i].data);
else
for (int j = a[i].l; j <= a[i].r; ++j)
if (a[i].data - t[j] < limit[j]) limit[j] = a[i].data - t[j];
}
}
bool limit_check() {
for (register int i = 1; i <= n; ++i) t[i] = 0;
for (int i = 1; i <= m; ++i) {
if (a[i].type == 1)
t_add(a[i].l, a[i].r, a[i].data);
else {
int maxnum = -(1050000000);
for (int j = a[i].l; j <= a[i].r; ++j)
if (limit[j] + t[j] > maxnum) maxnum = limit[j] + t[j];
if (maxnum != a[i].data) return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i)
scanf("%d%d%d%d", &a[i].type, &a[i].l, &a[i].r, &a[i].data);
limit_get();
if (limit_check()) {
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", limit[i]);
} else
puts("NO");
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] = 100000000;
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 qq = 5005;
const int MAXN = 1e9;
struct Node {
int t, l, r, x;
} node[qq];
int a[qq], b[qq], n, m;
bool solve() {
for (int i = 1; i <= n; ++i) a[i] = 1e9;
memset(b, 0, sizeof(b));
for (int i = 1; i <= m; ++i)
if (node[i].t == 1)
for (int j = node[i].l; j <= node[i].r; ++j) b[j] += node[i].x;
else
for (int j = node[i].l; j <= node[i].r; ++j)
a[j] = min(a[j], node[i].x - b[j]);
memset(b, 0, sizeof(b));
int k;
for (int i = 1; i <= m; ++i)
if (node[i].t == 1)
for (int j = node[i].l; j <= node[i].r; ++j) b[j] += node[i].x;
else {
k = -MAXN;
for (int j = node[i].l; j <= node[i].r; ++j) k = max(k, a[j] + b[j]);
if (k != node[i].x) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i)
scanf("%d%d%d%d", &node[i].t, &node[i].l, &node[i].r, &node[i].x);
if (!solve())
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct quer {
int type;
int r, l;
int val;
};
vector<quer> inp;
vector<long long> bords;
void modbd(quer q) {
if (q.type == 1) {
for (int a = q.l; a <= q.r; ++a) {
bords[a] += q.val;
}
} else {
for (int a = q.l; a <= q.r; ++a) {
bords[a] = min(bords[a], (long long)q.val);
}
}
}
bool lookup(quer q) {
if (q.type == 1) {
for (int a = q.l; a <= q.r; ++a) {
bords[a] -= q.val;
}
} else {
long long mv = -2e15;
for (int a = q.l; a <= q.r; ++a) {
mv = max(bords[a], mv);
}
if (mv != q.val) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
quer b;
scanf("%d%d%d%d", &b.type, &b.l, &b.r, &b.val);
b.l -= 1;
b.r -= 1;
inp.push_back(b);
}
bords = vector<long long>(n, 1e9);
for (int i = 0; i < m; ++i) {
modbd(inp[i]);
}
bool bad = false;
for (int i = m - 1; i >= 0; --i) {
if (!lookup(inp[i])) {
bad = true;
break;
}
}
if (bad) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 0; i < bords.size(); ++i) {
long long pv = bords[i];
long long inf = 1000000000;
if (pv > inf) {
pv = inf;
}
if (pv < -inf) {
pv = -inf;
}
int resv = pv;
printf("%d ", resv);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long arr[5050];
long long ke[5050];
long long go[5050];
struct kk {
int a, b, c, d;
};
kk f[5050];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) arr[i] = LLONG_MAX;
for (int i = 0; i < m; i++) {
long long t, k, l, m;
cin >> t >> k >> l >> m;
f[i].a = t;
f[i].b = k;
f[i].c = l;
f[i].d = m;
if (t == 1) {
for (int j = k - 1; j < l; j++) go[j] += m;
} else {
for (int j = k - 1; j < l; j++) {
arr[j] = (arr[j] > m - go[j] ? m - go[j] : arr[j]);
}
}
}
for (int i = 0; i < n; i++)
if (arr[i] == LLONG_MAX) arr[i] = 0;
for (int i = 0; i < n; i++) ke[i] = arr[i];
for (int i = 0; i < m; i++) {
if (f[i].a == 1) {
for (int j = f[i].b - 1; j < f[i].c; j++) ke[j] += f[i].d;
} else {
long long maxx = -LLONG_MAX;
for (int j = f[i].b - 1; j < f[i].c; j++)
maxx = (maxx < ke[j] ? ke[j] : maxx);
if (maxx != f[i].d) {
printf("NO");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
getchar();
getchar();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 100;
int q, n, a[maxn], lim[maxn];
int t, l, r, d;
struct node {
int t, l, r, d;
};
vector<node> g;
int main() {
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
lim[i] = 1000000000;
}
memset(a, 0, sizeof(a));
for (int i = 1; i <= q; ++i) {
cin >> t >> l >> r >> d;
g.push_back(node{t, l, r, d});
if (t == 1) {
for (; l <= r; ++l) {
a[l] += d;
}
} else {
for (; l <= r; ++l) {
lim[l] = min(lim[l], d - a[l]);
}
}
}
memcpy(a, lim, sizeof(lim));
for (auto i : g) {
if (i.t == 1) {
for (int j = i.l; j <= i.r; ++j) {
lim[j] += i.d;
}
} else {
bool vis = 0;
for (int j = i.l; j <= i.r; ++j) {
if (lim[j] == i.d) {
vis = 1;
break;
}
}
if (!vis) {
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;
const int N = 6000, MAX = 0x7FFFFFF;
int n, m, i, j, ans, a[N], b[N], k[N], l[N], r[N], d[N];
bool ok = true;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) a[i] = MAX;
for (i = 1; i <= m; i++) scanf("%d%d%d%d", k + i, l + i, r + i, d + i);
for (i = m; i > 0; i--)
if (k[i] == 1) {
for (j = l[i]; j <= r[i]; j++)
if (a[j] != MAX) a[j] -= d[i];
} else
for (j = l[i]; j <= r[i]; j++) a[j] = min(d[i], a[j]);
for (i = 1; i <= n; i++) b[i] = (a[i] == MAX) ? 0 : a[i];
for (i = 1; i <= m; i++)
if (k[i] == 2) {
ans = -MAX;
for (j = l[i]; j <= r[i]; j++) ans = max(ans, a[j]);
if (ans != d[i]) ok = false;
} else
for (j = l[i]; j <= r[i]; j++) a[j] += d[i];
if (ok) {
printf("YES\n%d", b[1]);
for (i = 2; i <= n; i++) printf(" %d", b[i]);
printf("\n");
} else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int flag[5555] = {0};
int res[5555] = {0};
int pro[5555][4] = {0};
int sum = 0, qusiba[5555] = {0};
vector<int> v[5555];
int main() {
cin >> n >> m;
int go = 0;
for (int i = 0; i < m; i++) {
cin >> pro[i][0] >> pro[i][1] >> pro[i][2] >> pro[i][3];
if (pro[i][0] == 2) go = i, sum++;
}
int k = sum;
while (go >= 0) {
if (pro[go][0] == 2) {
for (int i = pro[go][1]; i <= pro[go][2]; i++) {
if (v[i].size() > 0) {
if (res[i] > pro[go][3]) {
for (int w = 0; w < v[i].size(); w++) qusiba[v[i][w]]--;
v[i].clear();
v[i].push_back(k);
qusiba[k]++;
res[i] = pro[go][3];
} else if (res[i] == pro[go][3])
v[i].push_back(k), qusiba[k]++;
} else
v[i].push_back(k), res[i] = pro[go][3], qusiba[k]++;
}
k--;
} else {
for (int i = pro[go][1]; i <= pro[go][2]; i++) {
if (v[i].size() > 0) res[i] -= pro[go][3];
}
}
go--;
}
int f = 0;
for (int i = 1; i <= sum; i++)
if (qusiba[i] == 0) {
f = 1;
break;
}
if (f) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << res[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:256000000")
template <class T>
T sqr(T a) {
return a * a;
}
int a, n, k, ot[10000];
struct zap {
int t, l, r, d;
};
int was[10000];
zap m[100000];
void init() {
scanf("%d%d", &n, &k);
swap(n, k);
for (int i = 0; i < n; ++i) {
scanf("%d%d%d%d", &m[i].t, &m[i].l, &m[i].r, &m[i].d);
m[i].t--;
m[i].l--;
m[i].r--;
}
}
void solve() {
int q;
for (int I = 0; I < 3; ++I) {
q = 0;
for (int i = 0; i < n; ++i) {
if (m[i].t) {
int p = -1e9;
for (int j = m[i].l; j <= m[i].r; ++j) p = max(ot[j], p);
if (p == m[i].d) continue;
q = 1;
for (int j = m[i].l; j <= m[i].r; ++j) {
if (!was[j]) {
ot[j] = m[i].d;
was[j] = 1;
continue;
}
if (ot[j] < m[i].d) continue;
ot[j] = m[i].d;
}
} else {
for (int j = m[i].l; j <= m[i].r; ++j) {
if (abs(ot[j] + m[i].d) > 1e9) {
cout << "NO";
return;
}
ot[j] += m[i].d;
}
}
}
for (int i = n - 1; i >= 0; --i) {
if (m[i].t) {
int p = -1e9;
for (int j = m[i].l; j <= m[i].r; ++j) p = max(ot[j], p);
if (p == m[i].d)
;
continue;
q = 1;
for (int j = m[i].l; j <= m[i].r; ++j) {
if (!was[j]) {
ot[j] = m[i].d;
was[j] = 1;
continue;
}
if (ot[j] < m[i].d) continue;
ot[j] = m[i].d;
}
} else {
for (int j = m[i].l; j <= m[i].r; ++j) ot[j] -= m[i].d;
}
}
}
if (q) {
printf("NO");
} else {
printf("YES\n");
for (int i = 0; i < k; ++i) printf("%d ", ot[i]);
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class tu {
public:
tu(int a, int b, int c, int d) {
t = a;
i = b;
j = c;
v = d;
}
int t;
int i, j;
long long v;
};
long long ans[5009], ans2[5009];
vector<tu> ve;
int main() {
int n1, n2;
int a[4];
cin >> n1 >> n2;
for (int i = 0; i < n2; i++) {
for (int i = 0; i < 4; i++) {
cin >> a[i];
}
a[1]--;
a[2]--;
ve.push_back(tu(a[0], a[1], a[2], a[3]));
}
for (int i = 0; i < n1; i++) {
ans[i] = (long long)1e18;
}
for (int i = n2 - 1; i >= 0; i--) {
if (ve[i].t == 1) {
for (int j = ve[i].i; j <= ve[i].j; j++) {
ans[j] = ans[j] - ve[i].v;
}
} else {
for (int j = ve[i].i; j <= ve[i].j; j++) {
ans[j] = min(ans[j], ve[i].v);
}
}
}
for (int i = 0; i < n1; i++) ans2[i] = ans[i] = min(ans[i], (long long)1e9);
for (int i = 0; i < n2; i++) {
if (ve[i].t == 1) {
for (int j = ve[i].i; j <= ve[i].j; j++) {
ans[j] = ans[j] + ve[i].v;
}
} else {
long long maxi = -(long long)1e18;
for (int j = ve[i].i; j <= ve[i].j; j++) {
maxi = max(ans[j], maxi);
}
if (maxi != ve[i].v) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n");
for (int i = 0; i < n1; i++) {
cout << ans2[i] << (i == n1 - 1 ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e16;
vector<long long> ans(5010, inf);
long long n, m;
vector<long long> a(5010), b(5010), c(5010), d(5010);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j;
cin >> n >> m;
for (i = 0; i < m; i++) cin >> a[i] >> b[i] >> c[i] >> d[i];
for (i = 1; i <= n; i++) {
for (j = m - 1; j >= 0; j--) {
if (i < b[j] || i > c[j])
continue;
else {
if (a[j] == 1) {
ans[i] -= d[j];
} else {
ans[i] = min(ans[i], d[j]);
}
}
}
}
vector<long long> ANS(5010, 0);
ANS = ans;
for (i = 0; i < m; i++) {
if (a[i] == 1) {
for (j = b[i]; j <= c[i]; j++) ans[j] += d[i];
} else {
long long rez = -inf;
for (j = b[i]; j <= c[i]; j++) rez = max(rez, ans[j]);
if (rez != d[i]) {
cout << "NO";
return 0;
}
}
}
const long long A = 1e9 - 1;
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << min(ANS[i], A) << " ";
return 0;
}
|
#include <bits/stdc++.h>
int N, M, a[5005], b[5005], l[5005], r[5005], m[5005], t[5005];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) b[i] = 1e9;
for (int i = 1; i <= M; i++) {
scanf("%d%d%d%d", &t[i], &l[i], &r[i], &m[i]);
for (int j = l[i]; j <= r[i]; j++)
if (t[i] == 1)
a[j] += m[i];
else
b[j] = std::min(b[j], m[i] - a[j]);
}
for (int i = 1; i <= N; i++) a[i] = 0;
for (int i = 1; i <= M; i++) {
int mi = -1e9;
for (int j = l[i]; j <= r[i]; j++)
if (t[i] == 1)
a[j] += m[i];
else
mi = std::max(mi, a[j] + b[j]);
if (t[i] == 2 && mi != m[i]) {
puts("NO");
return 0;
}
}
puts("YES");
for (int i = 1; i <= N; i++) printf("%d%c", b[i], i == N ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
int num[5005], out[5005], n, m;
struct node {
int t, l, r, d;
} dd[5005];
int main() {
scanf("%d%d", &n, &m);
int flag = 0;
for (int i = 1; i <= m; i++)
scanf("%d%d%d%d", &dd[i].t, &dd[i].l, &dd[i].r, &dd[i].d);
for (int i = 0; i <= n; i++) num[i] = out[i] = 1000000000;
for (int i = m; i >= 1; i--) {
if (dd[i].t == 1) {
for (int j = dd[i].l; j <= dd[i].r; j++) {
num[j] -= dd[i].d;
out[j] = num[j];
}
} else if (dd[i].t == 2) {
for (int j = dd[i].l; j <= dd[i].r; j++)
num[j] = min(num[j], dd[i].d), out[j] = num[j];
}
}
for (int i = 1; i <= m; i++) {
if (dd[i].t == 1) {
for (int j = dd[i].l; j <= dd[i].r; j++) num[j] += dd[i].d;
} else if (dd[i].t == 2) {
int tmp = 0;
for (int j = dd[i].l; j <= dd[i].r; j++) {
if (num[j] > dd[i].d) flag = 1;
if (num[j] == dd[i].d) tmp = 1;
}
if (!tmp) flag = 1;
}
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) {
if (out[i] > 1000000000)
printf("1000000000 ");
else
printf("%d ", out[i]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, type, value;
} query[5005];
vector<int> ans1(5005, 1e9), ans2(5005);
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i)
cin >> query[i].type >> query[i].l >> query[i].r >> query[i].value;
for (int i = m; i >= 1; --i) {
if (query[i].type == 1) {
for (int j = query[i].l; j <= query[i].r; ++j)
if (ans1[j] != 1e9) ans1[j] -= query[i].value;
} else {
for (int j = query[i].l; j <= query[i].r; ++j)
if (ans1[j] > query[i].value) ans1[j] = query[i].value;
}
}
for (int i = 1; i <= n; ++i) ans2[i] = ans1[i];
for (int i = 1; i <= m; ++i) {
if (query[i].type == 1) {
for (int j = query[i].l; j <= query[i].r; ++j) ans1[j] += query[i].value;
} else {
int max_val = -1e9;
for (int j = query[i].l; j <= query[i].r; ++j)
max_val = max(max_val, ans1[j]);
if (max_val != query[i].value) {
cout << "NO";
return;
}
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << ans2[i] << " ";
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e5 + 15;
const long long Q = 1e9;
int zn[M], ans[M], d[M];
vector<pair<pair<int, int>, pair<int, int> > > po;
int main() {
srand(time(NULL));
int n, m, i, j, t, mi, l, r, q;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
zn[i] = Q;
}
for (i = 0; i < m; i++) {
scanf("%d%d%d%d", &t, &l, &r, &q);
if (t == 1) {
for (j = l; j <= r; j++) d[j] += q;
}
if (t == 2) {
for (j = l; j <= r; j++) zn[j] = min(zn[j], q - d[j]);
}
po.push_back(make_pair(make_pair(t, l), make_pair(r, q)));
}
for (i = 1; i <= n; i++) ans[i] = zn[i];
for (i = 0; i < m; i++) {
t = po[i].first.first;
l = po[i].first.second;
r = po[i].second.first;
q = po[i].second.second;
if (t == 1) {
for (j = l; j <= r; j++) zn[j] += q;
}
if (t == 2) {
mi = -Q;
for (j = l; j <= r; j++) mi = max(zn[j], mi);
if (mi != q) {
printf("NO");
return 0;
}
}
}
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void printub(int ub[], int n) {
for (int i = 0; i < n; ++i) {
cout << (ub[i] < INT_MAX ? ub[i] : 0);
if (i < n - 1) cout << " ";
}
cout << endl;
}
int main() {
int n, m;
cin >> n >> m;
int ub[n];
int d[n];
int type2[m][3];
int neededD[m][n];
int n2 = 0;
memset(d, 0, sizeof(d));
memset(neededD, 0, sizeof(neededD));
for (int i = 0; i < n; ++i) ub[i] = INT_MAX;
for (int i = 0; i < m; ++i) {
int c, l, r, v;
cin >> c >> l >> r >> v;
l--;
r--;
if (c == 1) {
for (int j = l; j <= r; ++j) d[j] += v;
} else {
type2[n2][0] = l;
type2[n2][1] = r;
type2[n2][2] = v;
for (int j = l; j <= r; ++j) {
neededD[n2][j] = d[j];
ub[j] = min(ub[j], v - d[j]);
}
n2++;
}
}
bool pass = true;
for (int i = 0; i < n2; ++i) {
bool sat = false;
for (int j = type2[i][0]; j <= type2[i][1]; ++j)
sat = sat || (ub[j] == type2[i][2] - neededD[i][j]);
if (!sat) pass = false;
}
if (!pass) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
printub(ub, n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5002, NP = 1000000000;
int Add[MAXN], MyResult[MAXN], MyCheck[MAXN];
bool check(int n, vector<pair<int, pair<int, pair<int, int> > > > A) {
for (int i = 0; i < n; i++)
if (MyCheck[i] > NP || MyCheck[i] < -NP) return 0;
for (int i = 0; i < A.size(); i++) {
int t = A[i].first, s = A[i].second.first, e = A[i].second.second.first,
v = A[i].second.second.second;
if (t == 1) {
for (int i = s - 1; i <= e - 1; i++) {
MyCheck[i] += v;
}
} else {
int mx = MyCheck[s - 1];
for (int i = s - 1; i <= e - 1; i++) mx = max(mx, MyCheck[i]);
if (mx != v) return 0;
}
}
return 1;
}
int main() {
int t, n, m, s, e, v;
vector<pair<int, pair<int, pair<int, int> > > > A;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) MyCheck[i] = MyResult[i] = NP;
while (m--) {
scanf("%d%d%d%d", &t, &s, &e, &v);
A.push_back(make_pair(t, make_pair(s, make_pair(e, v))));
if (t == 1) {
for (int i = s - 1; i <= e - 1; i++) Add[i] += v;
} else {
for (int i = s - 1; i <= e - 1; i++)
MyResult[i] = min(MyResult[i], v - Add[i]);
}
}
for (int i = 0; i < n; i++) MyCheck[i] = MyResult[i];
if (check(n, A)) {
printf("YES\n");
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", MyResult[i]);
}
printf("\n");
} else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int val[5002];
int orig[5002];
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) val[i] = 1500000000;
int t[5002];
int l[5002];
int r[5002];
int d[5002];
for (int op = 0; op < m; op++) {
cin >> t[op] >> l[op] >> r[op] >> d[op];
}
for (int op = m - 1; op >= 0; op--) {
if (t[op] == 1) {
for (int i = l[op]; i <= r[op]; i++) {
val[i] -= d[op];
}
} else if (t[op] == 2) {
for (int i = l[op]; i <= r[op]; i++) {
val[i] = min(val[i], d[op]);
}
}
}
for (int i = 0; i <= n; i++) {
val[i] = min(val[i], 1000000000);
orig[i] = val[i];
if (val[i] < -1000000000) {
cout << "NO" << endl;
return 0;
}
}
for (int op = 0; op < m; op++) {
if (t[op] == 1) {
for (int i = l[op]; i <= r[op]; i++) {
val[i] += d[op];
}
} else {
bool reachmax = false;
for (int i = l[op]; i <= r[op]; i++) {
if (val[i] == d[op]) reachmax = true;
}
if (!reachmax) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
cout << orig[1];
for (int i = 2; i <= n; i++) {
cout << " " << orig[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct op {
int t, l, r, dop;
};
int n, m, maxup[5000], nowc[5000];
op mas[5000];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
maxup[i] = 1e9;
}
for (int i = 0; i < m; ++i) {
cin >> mas[i].t >> mas[i].l >> mas[i].r >> mas[i].dop;
if (mas[i].t == 2) {
for (int j = mas[i].l - 1; j < mas[i].r; ++j) {
maxup[j] = min(maxup[j], mas[i].dop - nowc[j]);
}
} else {
for (int j = mas[i].l - 1; j < mas[i].r; ++j) {
nowc[j] += mas[i].dop;
}
}
}
for (int i = 0; i < n; ++i) {
nowc[i] = maxup[i];
}
for (int i = 0; i < m; ++i) {
if (mas[i].t == 2) {
bool truly = false;
for (int j = mas[i].l - 1; j < mas[i].r; ++j) {
if (nowc[j] == mas[i].dop) {
truly = true;
break;
}
}
if (!truly) {
cout << "NO";
return 0;
}
} else {
for (int j = mas[i].l - 1; j < mas[i].r; ++j) {
nowc[j] += mas[i].dop;
}
}
}
cout << "YES\n";
for (int i = 0; i < n; ++i) {
cout << maxup[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, a[N], c[N], Z[N], L[N], R[N], D[N], z, l, r, d, flag;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) a[i] = 1000000000, c[i] = 0;
for (int k = 1; k <= m; ++k) {
scanf("%d%d%d%d", &z, &l, &r, &d);
Z[k] = z, L[k] = l, R[k] = r, D[k] = d;
for (int i = l; i <= r; ++i)
if (z == 1)
c[i] += d;
else
a[i] = min(a[i], d - c[i]);
}
for (int i = 1; i <= n; ++i) c[i] = 0;
for (int k = 1; k <= m; ++k) {
z = Z[k], l = L[k], r = R[k], d = D[k], flag = z != 2;
for (int i = l; i <= r; ++i)
if (z == 1)
c[i] += d;
else if (a[i] + c[i] == d)
flag = 1;
if (!flag) return puts("NO"), 0;
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.