text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
const int MAXQ = 262144;
long long tree[MAXQ * 2 + 10];
long long btree[MAXQ * 2 + 10];
void tree_change(int v, int val, int l, int r, int pos, int limit) {
if (l == r) {
tree[v] = ((limit) < (tree[v] + val) ? (limit) : (tree[v] + val));
return;
}
int tm = (l + r) >> 1;
int lchild = (v << 1) + 1;
if (pos <= tm)
tree_change(lchild, val, l, tm, pos, limit);
else
tree_change(lchild + 1, val, tm + 1, r, pos, limit);
tree[v] = tree[lchild] + tree[lchild + 1];
}
long long tree_sum(int v, int cl, int cr, int l, int r) {
if (l > r) return 0;
if (cl == l && cr == r) return tree[v];
int tm = (cl + cr) >> 1;
int lchild = (v << 1) + 1;
return tree_sum(lchild, cl, tm, l, ((r) < (tm) ? (r) : (tm))) +
tree_sum(lchild + 1, tm + 1, cr, ((l) > (tm + 1) ? (l) : (tm + 1)), r);
}
void btree_change(int v, int val, int l, int r, int pos, int limit) {
if (l == r) {
btree[v] = ((limit) < (btree[v] + val) ? (limit) : (btree[v] + val));
return;
}
int tm = (l + r) >> 1;
int lchild = (v << 1) + 1;
if (pos <= tm)
btree_change(lchild, val, l, tm, pos, limit);
else
btree_change(lchild + 1, val, tm + 1, r, pos, limit);
btree[v] = btree[lchild] + btree[lchild + 1];
}
long long btree_sum(int v, int cl, int cr, int l, int r) {
if (l > r) return 0;
if (cl == l && cr == r) return btree[v];
int tm = (cl + cr) >> 1;
int lchild = (v << 1) + 1;
return btree_sum(lchild, cl, tm, l, ((r) < (tm) ? (r) : (tm))) +
btree_sum(lchild + 1, tm + 1, cr, ((l) > (tm + 1) ? (l) : (tm + 1)),
r);
}
int main() {
int n, k, a, b, q, qtype, di, ai, pi;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i <= (2 * MAXQ + 2); i++) tree[i] = 0;
for (int i = 0; i < q; i++) {
scanf("%d", &qtype);
if (qtype == 1) {
scanf("%d %d", &di, &ai);
tree_change(0, ai, 0, n - 1, di - 1, a);
btree_change(0, ai, 0, n - 1, di - 1, b);
} else {
scanf("%d", &pi);
pi--;
long long bs = btree_sum(0, 0, n - 1, 0, pi - 1);
printf("%I64d\n", bs + tree_sum(0, 0, n - 1, pi + k, n - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int N, K, A, B, Q;
int tree[2][4 * MAXN], leaf[4 * MAXN];
void update(int x, int l, int r, int p, int v) {
if (p < l || p > r || l > r) return;
if (l == r) {
leaf[x] += v;
tree[0][x] = min(leaf[x], B);
tree[1][x] = min(leaf[x], A);
return;
}
int mid = (l + r) / 2;
if (p <= mid)
update(2 * x, l, mid, p, v);
else
update(2 * x + 1, mid + 1, r, p, v);
tree[0][x] = tree[0][2 * x] + tree[0][2 * x + 1];
tree[1][x] = tree[1][2 * x] + tree[1][2 * x + 1];
}
int query(int x, int l, int r, bool z, int a, int b) {
if (b < l || r < a || l > r) return 0;
if (a <= l && r <= b) {
if (z)
return tree[1][x];
else
return tree[0][x];
}
int mid = (l + r) / 2;
return query(2 * x, l, mid, z, a, b) + query(2 * x + 1, mid + 1, r, z, a, b);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> K >> A >> B >> Q;
while (Q--) {
int type, d, a, p;
cin >> type;
if (type == 1) {
cin >> d >> a;
update(1, 1, MAXN, d, a);
} else {
cin >> p;
cout << query(1, 1, MAXN, 0, 0, p - 1) + query(1, 1, MAXN, 1, p + K, N)
<< endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inline gcd(long long x, long long y) {
return !y ? (long long)abs(x) : gcd(y, x % y);
}
long long inline lcm(long long a, long long b) {
return ((long long)abs((a / gcd(a, b)) * b));
}
double inline cartesian_dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long bigmod(long long b, long long p, long long m) {
if (!p)
return 1 % m;
else if (p & 1)
return (((b % m) + m) % m * bigmod(b, p - 1, m)) % m;
else {
long long ret = bigmod(b, p / 2, m);
return (ret * ret) % m;
}
}
long long inverse(long long a, long long m) { return bigmod(a, m - 2, m); }
long long extended(long long a, long long m) {
long long oldr = a, r = m, oldans = 1, ans = 0, quotient;
while (r) {
quotient = oldr / r;
oldr = oldr - r * quotient;
swap(oldr, r);
oldans = oldans - ans * quotient;
swap(oldans, ans);
}
return ((oldans % m) + m) % m;
}
const double PI = acos(-1.0);
const double eps = 10E-12;
int n, k, a, b, q;
struct node {
int small, big;
node() {
small = 0;
big = 0;
}
} tree[5 * (int)2e5 + 9];
void update(int root, int bg, int en, int idx, int val) {
if (bg > idx || en < idx) return;
if (bg == en && idx == bg) {
tree[root].small =
(tree[root].small + val) > b ? b : (tree[root].small + val);
tree[root].big = (tree[root].big + val) > a ? a : (tree[root].big + val);
return;
}
int m = (bg + en) / 2;
update(root * 2, bg, m, idx, val);
update(root * 2 + 1, m + 1, en, idx, val);
tree[root].small = tree[root * 2].small + tree[root * 2 + 1].small;
tree[root].big = tree[root * 2].big + tree[root * 2 + 1].big;
}
int query(int root, int bg, int en, int l, int r, int id) {
if (bg > r || en < l) return 0;
if (bg >= l && en <= r) {
if (id == 1)
return tree[root].small;
else
return tree[root].big;
}
int m = (bg + en) / 2;
return query(root * 2, bg, m, l, r, id) +
query(root * 2 + 1, m + 1, en, l, r, id);
}
int main() {
scanf("%d %d", &n, &k);
scanf("%d %d %d", &a, &b, &q);
while (q--) {
int id;
scanf("%d", &id);
if (id == 1) {
int day, order;
scanf("%d %d", &day, &order);
update(1, 1, n, day, order);
} else {
int day, ans = 0;
scanf("%d", &day);
if (day > 1) ans += query(1, 1, n, 1, day - 1, 1);
if (day + k <= n) ans += query(1, 1, n, day + k, n, 2);
printf("%d", ans);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, A, B, q;
vector<long long> ta;
void aupdate(long long v, long long l, long long r, long long p, long long x) {
if (l == r) {
ta[v] = min(ta[v] + x, A);
} else {
long long m = (l + r) / 2;
if (p <= m) {
aupdate(v * 2, l, m, p, x);
} else {
aupdate((v * 2) + 1, m + 1, r, p, x);
}
ta[v] = ta[v * 2] + ta[(v * 2) + 1];
}
}
long long asum(long long v, long long l1, long long r1, long long l,
long long r) {
if (l1 == l && r1 == r) {
return ta[v];
} else {
long long m = (l1 + r1) / 2;
if (r <= m) {
return asum(v * 2, l1, m, l, r);
} else {
if (l > m) {
return asum((v * 2) + 1, m + 1, r1, l, r);
} else {
return asum(v * 2, l1, m, l, m) +
asum((v * 2) + 1, m + 1, r1, m + 1, r);
}
}
}
}
vector<long long> tb;
void bupdate(long long v, long long l, long long r, long long p, long long x) {
if (l == r) {
tb[v] = min(B, tb[v] + x);
} else {
long long m = (l + r) / 2;
if (p <= m) {
bupdate(v * 2, l, m, p, x);
} else {
bupdate((v * 2) + 1, m + 1, r, p, x);
}
tb[v] = tb[v * 2] + tb[(v * 2) + 1];
}
}
long long bsum(long long v, long long l1, long long r1, long long l,
long long r) {
if (l1 == l && r1 == r) {
return tb[v];
} else {
long long m = (l1 + r1) / 2;
if (r <= m) {
return bsum(v * 2, l1, m, l, r);
} else {
if (l > m) {
return bsum((v * 2) + 1, m + 1, r1, l, r);
} else {
return bsum(v * 2, l1, m, l, m) +
bsum((v * 2) + 1, m + 1, r1, m + 1, r);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> A >> B >> q;
ta.resize(n * 4);
tb.resize(n * 4);
fill(ta.begin(), ta.end(), 0);
fill(tb.begin(), tb.end(), 0);
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long d, a;
cin >> d >> a;
d--;
aupdate(1, 0, n - 1, d, a);
bupdate(1, 0, n - 1, d, a);
} else {
long long p;
cin >> p;
p--;
long long ans;
if (k == n) {
ans = 0;
} else {
if (p == n - k) {
ans = bsum(1, 0, n - 1, 0, p - 1);
} else {
if (p == 0) {
ans = asum(1, 0, n - 1, k, n - 1);
} else {
ans = bsum(1, 0, n - 1, 0, p - 1) + asum(1, 0, n - 1, p + k, n - 1);
}
}
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 200009;
long long int table1[SIZE];
long long int table2[SIZE];
long long int now[SIZE];
int n, k, q;
long long int a, b;
void update(long long int table[], int idx, long long int v) {
while (idx <= n) {
table[idx] += v;
idx += idx & -idx;
}
}
long long int query(long long int table[], int idx) {
long long int ret = 0;
while (idx > 0) {
ret += table[idx];
idx -= idx & -idx;
}
return ret;
}
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int dd, aa;
cin >> dd >> aa;
update(table1, dd, min(aa + now[dd], b) - min(now[dd], b));
update(table2, dd, min(aa + now[dd], a) - min(now[dd], a));
now[dd] += aa;
} else {
int p;
cin >> p;
cout << query(table1, p - 1) + query(table2, n) - query(table2, p + k - 1)
<< '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const int nax = 1e6 + 5;
const int pot = 256 * 1024;
void upd(int* tr, int r, int day, int diff) {
day += pot;
tr[day] = min(r, tr[day] + diff);
for (int x = day / 2; x >= 1; x /= 2) tr[x] = tr[2 * x] + tr[2 * x + 1];
}
long long s(int* tr, int low, int high) {
if (low > high) return 0;
low += pot;
high += pot;
long long ans = tr[low];
if (low != high) ans += tr[high];
while (low < high - 1) {
if (low % 2 == 0) ans += tr[low + 1];
if (high % 2 == 1) ans += tr[high - 1];
low /= 2;
high /= 2;
}
return ans;
}
int tr1[2 * pot], tr2[2 * pot];
int r1, r2;
void upd(int day, int diff) {
upd(tr1, r1, day, diff);
upd(tr2, r2, day, diff);
}
int main() {
int n, gap, q;
scanf("%d%d%d%d%d", &n, &gap, &r1, &r2, &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int day, diff;
scanf("%d%d", &day, &diff);
upd(day, diff);
} else {
assert(type == 2);
int day;
scanf("%d", &day);
printf("%lld\n", s(tr2, 1, day - 1) + s(tr1, day + gap, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long fast_exp(long long base, long long exp, long long mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
exp /= 2;
}
return res;
}
int n, k, a, b, q;
int ta[211111];
int tb[211111];
long long bita[211111];
long long flaga[211111];
long long bitb[211111];
long long flagb[211111];
void upd(long long* arr, int p, int v) {
for (; p <= n; p += (p & (-p))) arr[p] += v;
}
long long sum(long long* arr, int b) {
long long sm = 0;
for (; b > 0; b -= (b & (-b))) sm += arr[b];
return sm;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> b >> q;
while (q--) {
int type, d, ai;
cin >> type;
if (type == 1) {
cin >> d >> ai;
long long value = sum(bita, d) - sum(bita, d - 1);
if (value + ai <= a && !ta[d])
upd(bita, d, ai);
else {
ta[d] = 1;
upd(bita, d, -value);
long long fl = sum(flaga, d) - sum(flaga, d - 1);
if (fl == 0) upd(flaga, d, 1);
}
value = sum(bitb, d) - sum(bitb, d - 1);
if (value + ai <= b && !tb[d])
upd(bitb, d, ai);
else {
tb[d] = 1;
upd(bitb, d, -value);
long long fl = sum(flagb, d) - sum(flagb, d - 1);
if (fl == 0) upd(flagb, d, 1);
}
} else {
int p;
cin >> p;
long long before = sum(bitb, p - 1) + b * sum(flagb, p - 1);
long long after = sum(bita, n) - sum(bita, p + k - 1) +
(sum(flaga, n) - sum(flaga, p + k - 1)) * a;
cout << (before + after) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 210000;
int fl[maxn], fr[maxn], a[maxn];
int fsum(int *f, int i) {
int s = 0;
for (; i >= 0; i &= i + 1, --i) s += f[i];
return s;
}
void fadd(int *f, int i, int x) {
for (; i < maxn; i |= i + 1) f[i] += x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, k, A, B, q;
cin >> n >> k >> A >> B >> q;
for (int i = 0; i < (int)(q); ++i) {
int t;
cin >> t;
if (t == 1) {
int d, t;
cin >> d >> t;
fadd(fl, d, -min(a[d], B));
fadd(fr, d, -min(a[d], A));
a[d] += t;
fadd(fl, d, min(a[d], B));
fadd(fr, d, min(a[d], A));
} else {
int p;
cin >> p;
cout << fsum(fl, p - 1) + fsum(fr, n) - fsum(fr, p + k - 1) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[505];
vector<int> P, N;
int main() {
int id = 0, pos = 0, neg = 0;
while (cin >> s[id]) {
if (s[id] == "=") break;
if (s[id] == "?") {
if (id == 0 || s[id - 1] == "+")
pos++;
else
neg++;
}
id++;
cin >> s[id];
if (s[id] == "=") break;
id++;
}
int n;
cin >> n;
int dif = pos - neg;
for (int i = 0; i < pos; i++) P.push_back(1);
for (int i = 0; i < neg; i++) N.push_back(1);
if (dif < n) {
int i = 0;
while (dif < n && i < pos) {
if (dif + n - 1 < n) {
dif += n - 1;
P[i++] = n;
} else {
P[i++] = 1 + n - dif;
dif = n;
}
}
if (dif != n) {
cout << "Impossible" << endl;
return 0;
}
} else if (dif > n) {
int i = 0;
while (dif > n && i < neg) {
if (dif - n + 1 > n) {
dif -= n - 1;
N[i++] = n;
} else {
N[i++] = 1 + dif - n;
dif = n;
}
}
if (dif != n) {
cout << "Impossible" << endl;
return 0;
}
}
cout << "Possible" << endl;
for (int i = 0, j = 0, k = 0; i <= id; i++) {
if (s[i] == "?") {
if (i == 0 || s[i - 1] == "+")
cout << P[j++];
else
cout << N[k++];
} else
cout << " " << s[i];
}
cout << " " << n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[110];
int b[110];
int main() {
string s;
getline(cin, s);
int num = 0, ten = 1;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '=') break;
if (s[i] <= '9' && s[i] >= '0') {
int x = s[i] - '0';
num += x * ten;
ten *= 10;
}
}
int cnt = 0;
a[0] = 1;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+') {
a[++cnt] = 1;
} else if (s[i] == '-') {
a[++cnt] = 0;
}
}
int x = 0;
for (int i = 0; i <= cnt; i++) {
b[i] = 1;
if (a[i])
x += b[i];
else
x -= b[i];
}
x = num - x;
for (int i = 0; i <= cnt; i++) {
if (x < 0) {
if (a[i] == 0 && b[i] < num) {
int k = min(num - b[i], -x);
b[i] += k;
x += k;
}
} else if (x > 0) {
if (a[i] == 1 && b[i] < num) {
int k = min(num - b[i], x);
b[i] += k;
x -= k;
}
} else
break;
}
x = 0;
for (int i = 0; i <= cnt; i++) {
if (a[i])
x += b[i];
else
x -= b[i];
}
if (x != num) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+' || s[i] == '-' || s[i] == '=') {
cout << b[cnt++] << " " << s[i] << " ";
}
}
cout << num << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1002];
int i, j;
int k;
int n, q1, q2;
int an1[102], an2[102];
bool tiv(int x) {
if (a[x] < '0') return false;
if (a[x] > '9') return false;
return true;
}
int main() {
cin.getline(a, 1000);
k = (int)(strlen(a));
for (i = 0; i < k; i++) {
if (i != 0 && a[i - 2] == '=') break;
if (i == 0 || a[i - 2] == '+')
q1++;
else
q2++;
i += 3;
}
i = 0;
while (!tiv(i)) i++;
vector<int> v;
for (i = i; i < k; i++) v.push_back(a[i] - '0');
int p = 1;
for (i = (int)v.size() - 1; i >= 0; i--) {
n += p * (v[i]);
p *= 10;
}
int sum = q1 * n - q2 * n;
for (i = 0; i < q1; i++) an1[i] = n;
for (i = 0; i < q2; i++) an2[i] = n;
if (sum > n) {
for (i = 0; i < q1; i++) {
if (sum - (an1[i] - 1) <= n) {
an1[i] -= sum - n;
sum = n;
break;
} else {
sum -= an1[i] - 1;
an1[i] = 1;
}
}
} else if (sum < n) {
for (i = 0; i < q2; i++) {
if (sum + (an2[i] - 1) >= n) {
an2[i] -= n - sum;
sum = n;
break;
} else {
sum += an2[i] - 1;
an2[i] = 1;
}
}
}
if (sum != n)
cout << "Impossible" << endl;
else {
cout << "Possible" << endl;
int k1 = 0, k2 = 0;
for (i = 0; i < k; i++) {
if (a[i] == '=') {
cout << "= " << n << endl;
break;
}
if (a[i] == '?') {
if (i == 0 || a[i - 2] == '+') {
cout << an1[k1++];
} else {
cout << an2[k2++];
}
continue;
}
cout << a[i];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string rebus;
getline(cin, rebus);
int n = 0, num_plus = 1, num_minus = 0;
for (char c : rebus) {
if (c == '+')
++num_plus;
else if (c == '-')
++num_minus;
else if (c >= '0' && c <= '9')
n = 10 * n + c - '0';
}
if (n > n * num_plus - num_minus || n < num_plus - n * num_minus) {
cout << "Impossible\n";
return 0;
}
int res = num_plus - n * num_minus;
vector<int> plus(num_plus, 1), minus(num_minus, n);
for (int i = 0; i < num_plus; ++i) {
if (res < 1) {
plus[i] += n - 1;
res += n - 1;
} else {
plus[i] += n - res;
res += n - res;
}
}
for (int i = 0; i < num_minus; ++i) {
if (res < 1) {
minus[i] -= n - 1;
res += n - 1;
} else {
minus[i] -= n - res;
res += n - res;
}
}
cout << "Possible\n";
char op = '+';
int i = 0, j = 0;
for (char c : rebus) {
if (c == '+' || c == '-') op = c;
if (c == '?') {
if (op == '+')
cout << plus[i++];
else
cout << minus[j++];
} else {
cout << c;
}
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mais = 1, menos, n, qnt;
vector<char> sinal;
string eq;
char x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
getline(cin, eq);
for (int i = 0; i < eq.size(); ++i) {
if (eq[i] == '?')
qnt++;
else if (eq[i] == '-') {
menos++;
sinal.push_back('-');
} else if (eq[i] == '+') {
mais++;
sinal.push_back('+');
} else if (eq[i] == '=') {
string sla;
for (int j = i + 2; j < eq.size(); ++j) sla += eq[j];
n = atoi(sla.c_str());
break;
}
}
long long int L = mais - (long long int)menos * n,
R = (long long int)mais * n - menos;
if (L <= n && n <= R) {
cout << "Possible\n";
vector<int> nums(mais + menos);
long long int sum = L;
for (int i = 0; i < mais; ++i) {
int add = (int)min(n - 1LL, n - sum);
nums[i] = 1 + add;
sum += add;
}
for (int i = 0; i < menos; ++i) {
int sub = (int)min(n - 1LL, n - sum);
nums[mais + i] = n - sub;
sum += sub;
}
cout << nums[0];
int indices[2] = {1, mais};
for (int i = 0; i < sinal.size(); ++i) {
int x = nums[indices[sinal[i] == '+' ? 0 : 1]++];
cout << " " << sinal[i] << " " << x;
}
cout << " = " << n << "\n";
} else
cout << "Impossible\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<bool> pos;
bool p = true;
int cp = 0;
int n;
while (true) {
string s;
cin >> s;
if (s == "=") {
cin >> n;
break;
}
if (s == "+") {
p = true;
}
if (s == "-") {
p = false;
}
if (s == "?") {
pos.push_back(p);
if (p) {
cp++;
}
}
}
int cn = pos.size() - cp;
int mx = cp * n - cn;
int mn = -cn * n + cp;
if (n > mx || n < mn) {
cout << "Impossible";
return 0;
}
cout << "Possible\n";
int c = 0;
for (int i = 0; i < pos.size(); i++) {
p = pos[i];
if (p) {
cp--;
int l = n - c;
int d = cp - cn;
int t = min(n, max(1, l - d));
c += t;
if (i != 0) {
cout << " + ";
}
cout << t;
} else {
cn--;
int l = n - c;
int d = cp - cn;
int t = min(n, max(1, d - l));
c -= t;
cout << " - ";
cout << t;
}
}
cout << " = " << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
bool type[110];
int ans[110];
int n;
string S;
int main() {
type[0] = true;
int cnt = 1;
int pe = 1, ne = 0;
cin >> S;
while (cin >> S) {
if (S[0] == '=') break;
if (S[0] == '+') {
type[cnt] = true;
pe++;
} else {
type[cnt] = false;
ne++;
}
cnt++;
cin >> S;
}
cin >> n;
int ma = pe * n - ne;
int mi = pe - ne * n;
int sum = n;
if (n > ma || n < mi) {
cout << "Impossible" << endl;
return 0;
} else {
for (int i = 0; i < cnt; i++) {
ans[i] = 1;
if (type[i])
n--;
else
n++;
}
for (int i = 0; i < cnt; i++) {
if (n == 0) break;
if (n < 0 && type[i] == false) {
int t = sum - 1;
ans[i] += min(t, -n);
n += min(t, -n);
}
if (n > 0 && type[i] == true) {
int t = sum - 1;
ans[i] += min(t, n);
n -= min(t, n);
}
}
cout << "Possible" << endl;
cout << ans[0] << " ";
for (int i = 1; i < cnt; i++) {
if (type[i])
cout << "+ ";
else
cout << "- ";
cout << ans[i] << " ";
}
cout << "= " << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1000000007;
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
class TaskA {
public:
void solve(istream& cin, ostream& cout) {
char c, d;
cin >> c >> d;
vector<char> R{'+'};
int plus = 1, minus = 0;
while (d != '=') {
R.push_back(d);
if (d == '-')
++minus;
else
++plus;
cin >> c >> d;
}
int n;
cin >> n;
if (plus * n < minus + n || (minus * n < plus - n)) {
cout << "Impossible" << endl;
} else {
cout << "Possible" << endl;
int cur = -n;
for (int i = 0; i < R.size(); ++i) {
if (i != 0) cout << ' ' << R[i] << ' ';
cerr << R[i] << ' ' << cur << ' ' << plus << ' ' << minus << ' ' << n
<< ' ' << i << endl;
if (i == R.size() - 1) {
cout << abs(cur);
} else if (R[i] == '+') {
--plus;
if (cur + 1 + plus * n < minus) {
cout << n;
cur += n;
} else {
cout << 1;
cur += 1;
}
} else {
--minus;
if (cur - 1 - minus * n > -plus) {
cout << n;
cur -= n;
} else {
cout << 1;
cur -= 1;
}
}
}
cout << " = " << n << endl;
}
}
};
int main() {
ios_base::sync_with_stdio(false);
TaskA solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
ios::sync_with_stdio(0);
string s;
v.push_back(1);
while (cin >> s) {
if (s == "=") break;
if (s == "-") v.push_back(-1);
if (s == "+") v.push_back(+1);
}
int n;
cin >> n;
int mn = 0;
for (auto &x : v) {
if (x < 0) x *= n;
mn += x;
}
int sum = mn;
if (mn > n) {
cout << "Impossible" << endl;
return 0;
};
for (auto &x : v) {
x += min(n - 1, n - sum);
sum += min(n - 1, n - sum);
}
if (sum != n) {
cout << "Impossible" << endl;
return 0;
};
cout << "Possible" << endl;
cout << v[0] << " ";
for (int i = 1; i < v.size(); i++)
if (v[i] < 0)
cout << "- " << -1 * v[i] << " ";
else
cout << "+ " << v[i] << " ";
cout << "= " << n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char r;
long long l, add = 1, give = 0;
int main() {
vector<char> indecator;
while (r != '=') {
cin >> r;
if (r == '+') {
add++;
indecator.push_back('+');
} else if (r == '-') {
give++;
indecator.push_back('-');
}
}
cin >> l;
vector<long long> adds(add);
vector<long long> gives(give);
for (int i = 0; i < add; i++) {
adds[i] = l;
}
for (int j = 0; j < give; j++) {
gives[j] = l;
}
long long SUM = l * (add - give);
if (SUM >= l) {
int i = 0;
long long test = SUM - l;
while (test != 0 && i != add) {
if (test - l >= -1) {
adds[i++] = 1;
test = test - l + 1;
} else {
adds[i] = adds[i++] - test;
test = 0;
}
}
if (test == 0) {
cout << "Possible\n";
int a = 0, b = 0;
cout << adds[a++] << ' ';
for (auto it = indecator.begin(); it != indecator.end(); it++) {
if (*it == '+') {
cout << "+ " << adds[a++] << ' ';
} else {
cout << "- " << gives[b++] << ' ';
}
}
cout << "= " << l;
return 0;
} else {
cout << "Impossible\n";
}
} else {
int i = 0;
long long test = l - SUM;
while (test != 0 && i != give) {
if (test - l >= -1) {
gives[i++] = 1;
test = test - l + 1;
} else {
gives[i] = gives[i++] - test;
test = 0;
}
}
if (test == 0) {
cout << "Possible\n";
int a = 0, b = 0;
cout << adds[a++] << ' ';
for (auto it = indecator.begin(); it != indecator.end(); it++) {
if (*it == '+') {
cout << "+ " << adds[a++] << ' ';
} else {
cout << "- " << gives[b++] << ' ';
}
}
cout << "= " << l;
return 0;
} else {
cout << "Impossible\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bin_pow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long t = bin_pow(a, b / 2);
return t * t % 1000000007;
} else
return a * bin_pow(a, b - 1) % 1000000007;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long a = 1, b = 0, n, g, sum = 0;
string s = "";
char c;
cin >> c;
s += '+';
while (true) {
cin >> c;
if (c == '+') a++, s += '+';
if (c == '-') b++, s += '-';
if (c == '=') break;
}
cin >> n;
if (n <= a * n - b && n >= a - n * b) {
cout << "Possible\n";
vector<long long> f;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+')
g = 1, a--;
else
g = -1, b--;
for (int j = 1; j <= n; j++) {
if (n - sum - g * j <= a * n - b && n - sum - g * j >= a - n * b) {
sum += g * j, f.push_back(j);
break;
}
}
}
cout << f[0] << " ";
for (int i = 1; i < s.size(); i++) cout << s[i] << " " << f[i] << " ";
cout << "= " << n;
} else
cout << "Impossible";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2];
int mark[110], cnt, res[110];
int inc, de, n;
int main() {
scanf("%s", s);
mark[cnt++] = 1;
++inc;
while (scanf("%s", s) == 1 && s[0] != '=') {
if (s[0] == '-') {
mark[cnt++] = -1;
++de;
} else {
mark[cnt++] = 1;
++inc;
}
scanf("%s", s);
}
scanf("%d", &n);
int t = n;
bool flag = true;
for (int i = 0; i < cnt; ++i)
if (mark[i] == -1) {
--de;
res[i] = min(n, n * inc - de - t);
t += res[i];
if (res[i] < 1) {
flag = false;
break;
}
}
if (t > n * inc) flag = false;
for (int i = 0; i < cnt; ++i)
if (mark[i] == 1) {
--inc;
res[i] = min(n, t - inc);
t -= res[i];
if (res[i] < 1) {
flag = false;
break;
}
}
if (t != 0) flag = false;
if (!flag)
puts("Impossible");
else {
puts("Possible");
for (int i = 0; i < cnt; ++i) {
if (i == 0)
printf("%d ", res[i]);
else
printf("%c %d ", mark[i] == 1 ? '+' : '-', res[i]);
}
printf("= %d\n", n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str1, str2;
char ch[100010];
int op[100010];
int main() {
gets(ch);
int N = strlen(ch);
int k = 0;
int n;
for (int i = 0; i < N; i += 2) {
if (ch[i] == '?') {
} else if (ch[i] == '+') {
op[k++] = 1;
} else if (ch[i] == '-') {
op[k++] = -1;
} else if (ch[i] == '=') {
n = 0;
for (int j = i + 2; j < N; j++) {
n *= 10;
n += ch[j] - '0';
}
}
}
int sum = n, un = 1;
for (int i = 0; i < k; i++) {
if (op[i] > 0) {
sum += n;
un += 1;
} else {
sum -= 1;
un -= n;
}
}
if (sum >= n && un <= n) {
printf("Possible\n");
int a = n;
int b = 1;
for (int i = 0; i < k; i++) {
if (op[i] < 0)
a++;
else
b++;
}
int d = k + 1 - b;
int c = d;
if (a < b) {
c += b - a;
a = b;
}
printf("%d ", a / b);
a -= a / b;
b--;
for (int i = 0; i < k; i++) {
if (op[i] > 0) {
printf("+ ");
printf("%d ", a / b);
a -= a / b;
b--;
} else {
printf("- ");
printf("%d ", c / d);
c -= c / d;
d--;
}
}
printf("= %d\n", n);
} else
printf("Impossible\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long int n, add = 1, sub;
vector<char> ops;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
getline(cin, s);
ops.push_back('+');
for (long long int i = 0; i < (long long int)s.length(); ++i) {
if (s[i] == ' ' || s[i] == '?' || s[i] == '=') continue;
if (isdigit(s[i])) {
n = (n * 10) + (s[i] - '0');
continue;
}
if (s[i] == '+')
add++;
else
sub++;
ops.push_back(s[i]);
}
long long int maxnet = n * add - sub, minet = add - n * sub;
if (n > maxnet || n < minet) {
cout << "Impossible\n";
return 0;
}
vector<long long int> res;
long long int cur = 0;
for (long long int i = 0; i < (long long int)ops.size(); ++i) {
if (ops[i] == '+')
add--;
else
sub--;
long long int dir = ((ops[i] == '+') ? 1 : -1);
for (long long int j = 1; j <= n; ++j) {
long long int maxn = cur + (j * dir) + add * n - sub,
minn = cur + (j * dir) + add - sub * n;
if (minn <= n && n <= maxn) {
res.push_back(j);
cur += dir * j;
break;
}
}
}
cout << "Possible\n";
for (long long int i = 0; i < (long long int)res.size(); ++i) {
cout << res[i] << ' ';
if (i < (long long int)ops.size() - 1) cout << ops[i + 1] << ' ';
}
cout << "= ";
cout << n << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
getline(cin, s);
bool add = true;
int cnt[2] = {0};
int n = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ') continue;
if (s[i] == '+')
add = true;
else if (s[i] == '-')
add = false;
else if (s[i] == '?')
cnt[add]++;
else if (s[i] == '=') {
i++;
i++;
while (i < s.length()) {
n *= 10;
n += s[i] - '0';
i++;
}
}
}
int maxnum = cnt[1] * n - cnt[0];
int minnum = cnt[1] - cnt[0] * n;
if (n > maxnum || n < minnum) {
printf("Impossible\n");
return 0;
}
printf("Possible\n");
int dec = 1;
int each = (n + cnt[0] * dec) / cnt[1];
int rem = (n + cnt[0] * dec) % cnt[1];
while (each == 0) {
dec++;
each = (n + cnt[0] * dec) / cnt[1];
rem = (n + cnt[0] * dec) % cnt[1];
}
add = true;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ') cout << s[i];
if (s[i] == '+') {
add = true;
cout << s[i];
} else if (s[i] == '-') {
add = false;
cout << s[i];
} else if (s[i] == '?') {
if (add) {
if (rem) {
cout << each + 1;
rem--;
} else
cout << each;
} else
cout << dec;
} else if (s[i] == '=') {
while (i < s.length()) {
cout << s[i];
i++;
}
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1010];
int main() {
int n, l, r;
for (int i = 0;; i++) {
cin >> a[i];
if (a[i] == '=') {
l = i;
break;
}
}
cin >> n;
int q = 0, w = 0;
for (int i = 0; i <= l; i++) {
if (a[i] == '-') q++;
if (a[i] == '+') w++;
}
if (q > n * w or n * q + n <= w) {
printf("Impossible");
return 0;
} else
printf("Possible\n");
if (q > w) {
for (int i = 0; i <= l; i++) {
if (i == 0) {
int t = n + q - n * w;
r = 0;
if (t < 1) t = 1, r = abs(n + q - n * w - 1);
cout << t << " ";
continue;
}
if (a[i] != '?') cout << a[i] << " ";
if (a[i - 1] == '-') {
int e;
e = r + 1;
r = 0;
if (e > n) r = e - n, e = n;
cout << e << " ";
}
if (a[i - 1] == '+') cout << n << " ";
}
cout << n;
}
if (q < w) {
for (int i = 0; i <= l; i++) {
if (i == 0) {
int t = n * q + n - w;
r = 0;
if (t > n) t = n, r = n * q - w;
cout << t << " ";
continue;
}
if (a[i] != '?') cout << a[i] << " ";
if (a[i] == ' ') cout << a[i] << " ";
if (a[i - 1] == '-') cout << n << " ";
if (a[i - 1] == '+') {
int e;
e = r + 1;
r = 0;
if (e > n) r = e - n, e = n;
cout << e << " ";
}
}
cout << n;
}
if (q == w) {
for (int i = 0; i <= l; i++) {
if (i == 0) cout << n << " ";
if (a[i] != '?') cout << a[i] << " ";
if (a[i - 1] == '-') cout << 1 << " ";
if (a[i - 1] == '+') cout << 1 << " ";
}
cout << n;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> pl, mn;
string buf;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
getline(cin, s);
int cnt_pl = 1, cnt_mn = 0;
buf += '+';
for (int i = 0; i < ((int)(s.size())); i++) {
if (s[i] == '+') {
buf += '+';
cnt_pl++;
}
if (s[i] == '-') {
buf += '-';
cnt_mn++;
}
}
pl.assign(cnt_pl, 0);
mn.assign(cnt_mn, 0);
int ind = 0;
while (s[ind] != '=') {
ind++;
}
ind++;
while (s[ind] == ' ') {
ind++;
}
int n = 0;
for (int i = ind; i < ((int)(s.size())); i++) {
if (s[i] < '0' || '9' < s[i]) {
continue;
}
n *= 10;
n += s[i] - '0';
}
int bufn = n;
n -= (cnt_pl - cnt_mn);
int ind_mn = 0, ind_pl = 0;
while (n != 0) {
if (n < 0) {
while (ind_mn < ((int)(mn.size())) && mn[ind_mn] == bufn - 1) {
ind_mn++;
}
if (ind_mn == ((int)(mn.size()))) {
cout << "Impossible\n";
return 0;
} else {
mn[ind_mn]++;
}
n++;
} else {
while (ind_pl < ((int)(pl.size())) && pl[ind_pl] == bufn - 1) {
ind_pl++;
}
if (ind_pl == ((int)(pl.size()))) {
cout << "Impossible\n";
return 0;
} else {
pl[ind_pl]++;
}
n--;
}
}
cout << "Possible\n";
ind_pl = 0;
ind_mn = 0;
for (int i = 0; i < ((int)(buf.size())); i++) {
if (i != 0) {
cout << buf[i] << " ";
}
if (buf[i] == '+') {
cout << pl[ind_pl++] + 1;
} else {
cout << mn[ind_mn++] + 1;
}
cout << " ";
}
cout << "= " << bufn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct cww {
cww() {
ios::sync_with_stdio(false);
cin.tie(0);
}
} star;
const int MAX = 1000;
bool dp[111][2 * MAX];
int main() {
vector<string> S;
string s;
while (cin >> s) {
S.push_back(s);
}
int n = stoi(S.back());
s.clear();
for (string el : S) {
if (el == "+" || el == "-") s += el;
}
int sz = s.size();
dp[0][MAX] = true;
for (int i = 0; i < sz; i++) {
char op = s[i];
for (int j = 0; j < 2 * MAX; j++)
if (dp[i][j]) {
for (int k = 1; k <= min(n, 100); k++) {
int next = j;
if (op == '+')
next += k;
else
next -= k;
if (0 <= next && next < 2 * MAX) dp[i + 1][next] = true;
}
}
}
for (int i = 0; i < 2 * MAX; i++)
if (dp[sz][i]) {
int value = i - MAX;
int first = n - value;
if (1 <= first && first <= n) {
cout << "Possible" << endl;
vector<int> ans;
int now = i;
for (int j = sz; j > 0; j--) {
char op = s[j - 1];
for (int k = 1; k <= min(n, 100); k++) {
int prev = now;
if (op == '+')
prev -= k;
else
prev += k;
if (0 <= prev && prev < 2 * MAX && dp[j - 1][prev]) {
ans.push_back(k);
now = prev;
break;
}
}
}
ans.push_back(first);
reverse(ans.begin(), ans.end());
for (int i = 0; i < sz; i++) {
cout << ans[i] << " " << s[i] << " ";
}
cout << ans[sz] << " = " << n << endl;
return 0;
}
}
cout << "Impossible" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n, m, k;
int num[105], sgn[105];
int main() {
getline(cin, s);
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9') {
n = atoi(s.substr(i).c_str());
break;
}
sgn[m++] = 1;
for (int i = 1; s[4 * i - 2] != '='; i++)
sgn[m++] = s[4 * i - 2] == '+' ? 1 : -1;
for (int i = 0; i < m; i++) {
num[i] = sgn[i] == 1 ? n : 1;
k += num[i] * sgn[i];
}
if (k < n) {
cout << "Impossible\n";
return 0;
}
for (int i = 0; i < m; i++) {
if (sgn[i] == 1) {
while (k > n && num[i] > 1) num[i]--, k--;
} else {
while (k > n && num[i] < n) num[i]++, k--;
}
}
if (n != k)
cout << "Impossible\n";
else {
cout << "Possible\n";
int cnt = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '?')
cout << num[cnt++];
else
cout << s[i];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char arth[100] = {'+'};
int main() {
char c = 'h';
int cindex = 0;
int addN = 1;
int subN = 0;
while (c != '=') {
cin >> c;
if (c == '?' || c == '=') continue;
if (c == '+') {
arth[cindex] = '+';
cindex++;
addN++;
} else {
arth[cindex] = '-';
cindex++;
subN++;
}
}
cin >> n;
int lFactor = 1;
for (; lFactor <= n; lFactor++) {
int total = n + lFactor * subN;
int quotient = total / addN;
int remainder = total % addN;
if (quotient <= 0) continue;
if (quotient > n || (quotient == n && remainder > 0)) {
cout << "Impossible";
} else if (remainder == 0) {
cout << "Possible" << endl;
cout << quotient << " ";
for (int i = 0; i < cindex; i++) {
cout << arth[i] << " ";
if (arth[i] == '+')
cout << quotient << " ";
else
cout << lFactor << " ";
}
cout << "= " << n;
} else {
int numN = 1;
for (; numN <= addN; numN++) {
int mod = remainder % numN;
int firsts = quotient + remainder / numN;
int lastAdd = firsts + mod;
if (lastAdd > n) continue;
cout << "Possible" << endl;
int k = numN;
cout << quotient << " ";
for (int i = 0; i < cindex; i++) {
cout << arth[i] << " ";
if (arth[i] == '+') {
if (k == 1) {
cout << lastAdd << " ";
k--;
} else if (k > 0) {
cout << firsts << " ";
k--;
} else {
cout << quotient << " ";
}
} else
cout << lFactor << " ";
}
cout << "= " << n;
break;
}
if (numN > addN) {
cout << "Impossible";
}
}
break;
}
if (lFactor > n) cout << "Impossible";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int SIZ_TREE = 3e5 + 10;
char ch[100];
bool f[N];
int n;
int cnt1, f1[N];
int cnt2, f2[N];
void init() {
bool s = true;
cnt1 = cnt2 = 0;
while (true) {
scanf("%s", ch);
if (ch[0] == '=') {
scanf("%d", &n);
break;
}
if (ch[0] == '?') {
if (s)
cnt1++;
else
cnt2++;
} else {
s = (ch[0] == '+');
f[cnt1 + cnt2] = s;
}
}
}
void work() {
if (cnt1 * n - cnt2 < n || cnt1 - cnt2 * n > n) {
printf("Impossible\n");
return;
}
int now = cnt1 - cnt2;
for (int i = 1; i <= cnt1; i++) f1[i] = 1;
for (int i = 1; i <= cnt2; i++) f2[i] = 1;
int d;
for (int i = 1; i <= cnt1 && now < n; i++) {
d = min(n - now, n - f1[i]);
f1[i] += d;
now += d;
}
for (int i = 1; i <= cnt2 && now > n; i++) {
d = min(now - n, n - f2[i]);
f2[i] += d;
now -= d;
}
int i1 = 1, i2 = 0;
printf("Possible\n");
printf("%d ", f1[1]);
for (int i = 1; i < cnt1 + cnt2; i++) {
if (f[i])
printf("+ %d ", f1[++i1]);
else
printf("- %d ", f2[++i2]);
}
printf("= %d\n", n);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int ans;
int plus = 1, minus = 0;
vector<char> signs;
vector<int> plusNumbers, minusNumbers;
while (cin >> s) {
if (s == "=") break;
if (s == "+")
plus++;
else if (s == "-")
minus++;
else
continue;
signs.push_back(s[0]);
}
cin >> ans;
int n = ans;
int maxAns = plus * n - minus;
int minAns = plus - n * minus;
if (ans <= maxAns && minAns <= ans) {
puts("Possible");
int inc = ans - minAns;
for (int i = 0; i < plus; i++) plusNumbers.push_back(1);
for (int i = 0; i < minus; i++) minusNumbers.push_back(n);
for (int i = 0; i < plus; i++) {
int canInc = n - 1;
if (canInc >= inc) {
plusNumbers[i] += inc;
cout << plusNumbers[0] << " ";
int plusIdx = 1;
int minusIdx = 0;
for (int j = 0; j < signs.size(); j++) {
cout << signs[j] << " ";
if (signs[j] == '+')
cout << plusNumbers[plusIdx++] << " ";
else
cout << minusNumbers[minusIdx++] << " ";
}
cout << "= " << ans << endl;
return 0;
} else {
plusNumbers[i] += canInc;
inc -= canInc;
}
}
for (int i = 0; i < minus; i++) {
int canInc = n - 1;
if (canInc >= inc) {
minusNumbers[i] -= inc;
cout << plusNumbers[0] << " ";
int plusIdx = 1;
int minusIdx = 0;
for (int j = 0; j < signs.size(); j++) {
cout << signs[j] << " ";
if (signs[j] == '+')
cout << plusNumbers[plusIdx++] << " ";
else
cout << minusNumbers[minusIdx++] << " ";
}
cout << "= " << ans << endl;
return 0;
} else {
minusNumbers[i] -= canInc;
inc -= canInc;
}
}
} else
puts("Impossible");
return 0;
}
|
#include <bits/stdc++.h>
const double eps = 1e-10;
const float epsf = 1e-6;
using namespace std;
inline long long int __gcd(long long int a, long long int b) {
if (a == 0 || b == 0) {
return max(a, b);
}
long long int tempa, tempb;
while (1) {
if (a % b == 0)
return b;
else {
tempa = a;
tempb = b;
a = tempb;
b = tempa % tempb;
}
}
}
inline int compfloat(float& x, float& y) {
if (fabs(x - y) < epsf)
return 0;
else if (x - y > 0)
return 1;
return -1;
}
inline int compdouble(double x, double y) {
if (fabs(x - y) < eps)
return 0;
else if (x - y > 0)
return 1;
else
return -1;
}
bool prime(long long int k) {
for (long long int i = 2; i * i <= k; i++)
if (k % i == 0) {
return false;
}
return true;
}
void pdash(int n = 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 30; j++) {
cout << "-";
}
cout << "\n";
}
}
long long int power(long long int x, long long int y) {
long long int result = 1;
while (y > 0) {
if (y & 1) {
result = (result * x);
}
y = y >> 1;
x = (x * x);
}
return result;
}
long long int power(long long int x, long long int y, long long int z) {
long long int result = 1;
x = x % z;
while (y > 0) {
if (y & 1) {
result = (result * x) % z;
}
y = y >> 1;
x = (x * x) % z;
}
return result;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrF(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
long long int f[n + 1];
f[0] = 1;
for (long long int i = 1; i <= n; i++) f[i] = f[i - 1] * i % p;
return (f[n] * modInverse(f[r], p) % p * modInverse(f[n - r], p) % p) % p;
}
void cordinate_compression(vector<int>& v) {
vector<int> p = v;
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
for (int i = 0; i < (int)((v).size()); i++)
v[i] = (int)(lower_bound(p.begin(), p.end(), v[i]) - p.begin());
}
void solve() {
string str;
long long int n = 0;
getline(cin, str);
string ans = "p";
long long int pos, neg;
pos = 1;
neg = 0;
for (int i = 0; i < (int)((str).size()); i += 4) {
if (str[i + 2] == '=') {
n = stoi(string(str.begin() + (i + 4), str.end()));
break;
} else {
if (str[i + 2] == '+') {
ans += "p";
pos++;
} else {
ans += "n";
neg++;
}
}
}
long long int lambda = (n - (pos - neg));
vector<long long int> positive(pos, 1);
vector<long long int> negative(neg, 1);
if (lambda < -neg * (n - 1) or lambda > pos * (n - 1)) {
cout << "Impossible\n";
return;
}
if (lambda > 0) {
for (int i = 0; i < (int)((positive).size()) and lambda; i++) {
long long int a = min(lambda, n - 1);
positive[i] += a;
lambda -= a;
}
}
if (lambda < 0) {
lambda *= -1;
for (int i = 0; i < (int)((negative).size()) and lambda; i++) {
long long int a = min(lambda, n - 1);
negative[i] += a;
lambda -= a;
}
}
cout << "Possible\n";
cout << positive.back() << " ";
positive.pop_back();
ans = string(ans.begin() + 1, ans.end());
for (int i = 0; i < (int)((ans).size()); i++) {
if (ans[i] == 'p') {
cout << "+ " << positive.back() << " ";
positive.pop_back();
} else if (ans[i] == 'n') {
cout << "- " << negative.back() << " ";
negative.pop_back();
}
}
cout << "= " << n << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> va, vb;
int main() {
string s;
getline(cin, s);
int n = 0;
int a = 1, b = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] >= '0' && s[i] <= '9') n = n * 10 + s[i] - '0';
if (s[i] == '-') b++;
if (s[i] == '+') a++;
}
for (int i = 0; i < a; i++) va.push_back(1);
for (int i = 0; i < b; i++) vb.push_back(1);
int now = a - b;
int it = 0;
while (now < n) {
if (it == (int)va.size()) {
cout << "Impossible";
return 0;
}
if (va[it] + n - now > n) {
now = now - va[it] + n;
va[it] = n;
it++;
} else {
va[it] += n - now;
now = n;
}
}
while (now > n) {
if (it == (int)vb.size()) {
cout << "Impossible";
return 0;
}
if (vb[it] - n + now > n) {
now = now + vb[it] - n;
vb[it] = n;
it++;
} else {
vb[it] += -n + now;
now = n;
}
}
cout << "Possible\n";
int u = 0, d = 0;
now = 1;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == '?') {
if (now == 1) {
cout << va[u];
u++;
} else {
cout << vb[d];
d++;
}
continue;
}
if (s[i] == '+') now = 1;
if (s[i] == '-') now = 0;
cout << s[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
vector<int> vec;
int cnt = 0, cp = 0, cm = 0, n, cur, cur1;
cin >> c;
while (c != '=') {
if (c == '?') cnt++;
if (c == '+') vec.push_back(1);
if (c == '-') vec.push_back(0);
cin >> c;
}
cin >> n;
cur = n;
cur1 = 1;
for (int i = 0; i < cnt - 1; i++) {
if (vec[i] == 1) {
cur += n;
cur1 += 1;
} else {
cur -= 1;
cur1 -= n;
}
}
if (cur < n || cur1 > n) {
cout << "Impossible";
return 0;
}
cout << "Possible" << endl;
cout << max(1, n - (cur - n)) << " ";
if (n - (cur - n) >= 1)
cur = n;
else
cur -= n - 1;
for (int i = 0; i < cnt - 1; i++) {
if (vec[i] == 1) {
cout << "+ ";
cout << max(1, n - (cur - n)) << " ";
if (n - (cur - n) >= 1)
cur = n;
else
cur -= n - 1;
} else {
cout << "- ";
cout << min(n, 1 + cur - n) << " ";
if (1 + cur - n >= n)
cur -= n - 1;
else
cur = n;
}
}
cout << "= " << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d, marime_minima, marime_maxima;
int n,
afara_ninge_linistit_si_n_casa_arde_focul_iar_noi_pe_langa_mama_stand_de_mult_uitaram_jocul,
sum;
vector<char> operatie_de_marire;
int pula, un_pumn_in_cap_it_dau;
char c;
inline void DaCuBanii() {
while (cin >> c) {
if (c == '?')
afara_ninge_linistit_si_n_casa_arde_focul_iar_noi_pe_langa_mama_stand_de_mult_uitaram_jocul++;
if (c == '=') {
if (afara_ninge_linistit_si_n_casa_arde_focul_iar_noi_pe_langa_mama_stand_de_mult_uitaram_jocul ==
0) {
cout << "Impossible\n";
exit(0);
}
cin >> n;
break;
}
if (c == '+') {
pula++;
operatie_de_marire.push_back(c);
}
if (c == '-') {
un_pumn_in_cap_it_dau++;
operatie_de_marire.push_back(c);
}
}
}
inline void SaMoareDusmanii() {
if (pula == un_pumn_in_cap_it_dau) {
cout << "Possible\n";
cout << n << " ";
for (__typeof((operatie_de_marire).begin()) it =
(operatie_de_marire).begin();
it != (operatie_de_marire).end(); it++)
cout << *it << " " << 1 << " ";
cout << "= " << n;
exit(0);
}
marime_maxima = n;
marime_minima = 1;
for (__typeof((operatie_de_marire).begin()) it = (operatie_de_marire).begin();
it != (operatie_de_marire).end(); it++) {
if (*it == '+') {
marime_maxima += n;
marime_minima++;
} else {
marime_maxima--;
marime_minima -= n;
}
}
if (n >= marime_minima && n <= marime_maxima)
cout << "Possible\n";
else {
cout << "Impossible\n";
exit(0);
}
sum = n;
if (pula > un_pumn_in_cap_it_dau) {
sum += n * un_pumn_in_cap_it_dau;
d = sum - pula - 1;
cout << min(n - 1, d) + 1 << " ";
d -= min(n - 1, d);
for (__typeof((operatie_de_marire).begin()) it =
(operatie_de_marire).begin();
it != (operatie_de_marire).end(); it++) {
if (*it == '-')
cout << "- " << n << " ";
else {
cout << "+ " << min(n - 1, d) + 1 << " ";
d -= min(n - 1, d);
}
}
cout << "= " << n;
exit(0);
}
}
inline void DaiSaPuta() {
sum = pula * n;
d = sum - un_pumn_in_cap_it_dau;
cout << n << " ";
for (__typeof((operatie_de_marire).begin()) it = (operatie_de_marire).begin();
it != (operatie_de_marire).end(); it++) {
if (*it == '+')
cout << "+ " << n << " ";
else {
cout << "- " << min(n - 1, d) + 1 << " ";
d -= min(n - 1, d);
}
}
cout << "= " << n;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
DaCuBanii();
SaMoareDusmanii();
DaiSaPuta();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int II() {
int q;
scanf("%d", &q);
return q;
}
long long LII() {
long long q;
scanf("%lld", &q);
return q;
}
long long search(long long baki, long long sum, long long mot, long long N) {
long long l = 1, r = N;
long long re = 1;
while (l <= r) {
long long mid = (l + r) / 2;
if ((sum + mid + baki) <= mot) {
re = mid;
l = mid + 1;
} else
r = mid - 1;
}
return re;
}
long long search_neg(long long baki, long long neg_sum, long long pos_sum,
long long N) {
long long l = 1, r = N, re = 1;
while (l <= r) {
long long mid = (l + r) / 2;
if ((neg_sum + mid + baki) <= (pos_sum - N)) {
re = mid;
l = mid + 1;
} else
r = mid - 1;
}
return re;
}
void solve() {
long long pos = 0, neg = 0;
vector<char> v;
long long N;
v.push_back('+');
while (1) {
char c1, c2;
cin >> c1 >> c2;
if (c2 == '=') {
cin >> N;
break;
}
v.push_back(c2);
}
for (auto it : v) {
if (it == '+')
pos++;
else
neg++;
}
if ((((pos * N) - neg) < N) or (pos - (N * neg)) > N) {
cout << "Impossible" << endl;
return;
}
long long mot = N + neg;
vector<long long> v1;
long long sum = 0;
for (long long i = 1; i <= pos; i++) {
long long q = search(pos - i, sum, mot, N);
sum += q;
v1.push_back(q);
}
long long neg_sum = 0;
vector<long long> v2;
for (long long i = 1; i <= neg; i++) {
long long q = search_neg(neg - i, neg_sum, sum, N);
neg_sum += q;
v2.push_back(q);
}
if ((sum - neg_sum) != N) {
cout << "Impossible" << endl;
return;
}
long long w1 = 0, w2 = 0;
cout << "Possible" << endl;
for (long long i = 0; i < v.size(); i++) {
if (v[i] == '+') {
if (i == 0) {
cout << v1.back() << " ";
} else {
cout << "+ " << v1.back() << " ";
}
w1 += v1.back();
v1.pop_back();
} else {
cout << "- " << v2.back() << " ";
w2 += v2.back();
v2.pop_back();
}
}
cout << "= " << N << endl;
}
int32_t main() {
long long tt;
tt = 1;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 222;
int sign[MAX];
int a[MAX];
int n;
int total;
int getAns() {
int ans = 0;
for (int i = 0; i < total; ++i) {
ans += sign[i] == 1 ? -a[i] : a[i];
}
return ans;
}
int toInteger(string str) {
stringstream ss(str);
int ret;
ss >> ret;
return ret;
}
void show() {
for (int i = 0; i < total; ++i) {
if (sign[i] == 0) {
if (i != 0) cout << " + ";
cout << a[i];
} else {
cout << " - ";
cout << a[i];
}
}
cout << " = " << getAns() << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string line;
getline(cin, line);
int pos = 0;
int neg = 0;
bool negative = false;
total = 0;
for (int i = 0; i < ((int)(line).size()); ++i) {
if (line[i] == '?') {
if (negative) {
sign[total++] = 1;
neg++;
} else {
sign[total++] = 0;
pos++;
}
negative = false;
} else {
if (line[i] == '-')
negative = true;
else if (line[i] == '+')
negative = false;
}
}
int it = ((int)(line).size()) - 1;
while (isdigit(line[it])) it--;
it++;
n = toInteger(line.substr(it));
for (int i = 0; i < total; ++i) {
a[i] = sign[i] == 1 ? n : 1;
}
int low = getAns();
for (int i = 0; i < total; ++i) {
a[i] = sign[i] == 1 ? 1 : n;
}
int high = getAns();
bool possible = false;
if (low <= n && high >= n) possible = true;
if (possible) {
cout << "Possible" << endl;
int res = getAns();
int begin = 0;
while (res != n) {
for (int i = begin; i < total; ++i) {
if (sign[i] == 1 && a[i] < n) {
a[i]++;
res--;
break;
}
if (sign[i] == 0 && a[i] > 1) {
a[i]--;
res--;
break;
}
begin++;
}
}
show();
} else {
cout << "Impossible" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LEN = 1000100;
int c, c1, num, kol, n, kol1;
string st;
vector<int> q;
int main() {
q.push_back(1);
c++;
while (cin >> st) {
if (st == "+")
q.push_back(1), c++;
else if (st == "-")
q.push_back(-1), c1++;
else if (st == "=") {
cin >> num;
break;
}
}
n = num;
num += c1;
if (c * n < num || c > num + c1 * (n - 1)) {
cout << "Impossible";
return 0;
}
kol = num % c;
kol1 = c - num;
cout << "Possible" << endl;
for (int i = 0; i < q.size(); i++) {
if (q[i] == -1) {
cout << 1 + min(max(kol1, 0), n - 1) << " ";
kol1 -= min(max(kol1, 0), n - 1);
} else {
cout << max(1, num / c + int(kol > 0)) << " ";
kol--;
}
if (i + 1 < q.size()) {
if (q[i + 1] == -1)
cout << "- ";
else
cout << "+ ";
}
}
cout << "= ";
cout << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
ios::sync_with_stdio(false);
int ans;
vector<int> Q;
Q.push_back(1);
int sum = 1;
char mark;
cin >> mark;
while (cin >> mark) {
if (mark == '+') {
sum++;
Q.push_back(1);
cin >> mark;
} else if (mark == '-') {
sum--;
Q.push_back(-1);
cin >> mark;
} else {
cin >> ans;
break;
}
}
int delta = ans - sum;
int k = 0;
while (delta != 0 && k < Q.size()) {
if (Q[k] > 0 && delta > 0) {
if (delta >= ans - 1) {
Q[k] = ans;
delta -= ans - 1;
} else {
Q[k] += delta;
delta = 0;
}
} else if (Q[k] < 0 && delta < 0) {
if (delta <= -(ans - 1)) {
Q[k] = -ans;
delta += ans - 1;
} else {
Q[k] += delta;
delta = 0;
}
}
k++;
}
if (delta == 0) {
cout << "Possible\n";
cout << Q[0] << " ";
for (int i = 1; i < Q.size(); i++) {
if (Q[i] > 0) {
cout << "+ " << Q[i] << " ";
} else
cout << "- " << -Q[i] << " ";
}
cout << "= " << ans << endl;
} else
cout << "Impossible\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9 + 7;
const long long INFL = 8e18L + 7;
const double INFD = 1e300;
void run();
int main() {
if (strlen("") > 0) {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
run();
return 0;
}
const int N = 1e6 + 7;
int n, k;
bool a[N];
int b[N];
int num[2];
void run() {
a[0] = 1;
for (int i = 1;;) {
string s;
cin >> s;
if (s == "=") {
k = i;
break;
} else if (s != "?") {
a[i] = s == "+";
++i;
}
}
cin >> n;
int p = accumulate(a, a + k, 0);
int m = k - p;
int summin = 1 * p - n * m;
int summax = n * p - 1 * m;
bool ok = summin <= n && n <= summax;
printf("%s\n", ok ? "Possible" : "Impossible");
if (ok) {
for (int i = 0; i < k; ++i) b[i] = a[i] ? 1 : -n;
int sum = accumulate(b, b + k, 0);
for (int i = 0; i < k; ++i)
if (sum + n - 1 <= n) {
b[i] = a[i] ? n : 1;
sum += n - 1;
} else {
b[i] += n - sum;
break;
}
printf("%d", b[0]);
for (int i = 1; i < k; ++i) printf(" %c %d", a[i] ? '+' : '-', abs(b[i]));
printf(" = %d\n", n);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char ch[2];
queue<char> q;
fgets(ch, 2, stdin);
long int n = 0;
int plus = 1;
int minus = 0;
while (ch[0]) {
if (ch[0] == '+') {
q.push(ch[0]);
plus++;
} else if (ch[0] == '-') {
q.push(ch[0]);
minus++;
} else if (ch[0] == '=') {
cin >> n;
break;
}
fgets(ch, 2, stdin);
}
if (plus == minus) {
if (q.size() == 1 || n == 1) {
cout << "Impossible\n";
return 0;
} else {
cout << "Possible\n";
cout << n;
plus--;
int flag = 0;
while (q.size() != 0) {
if (q.front() == '-') {
cout << " - 1";
flag = 1;
}
if (q.front() == '+') {
flag = 0;
if (plus == (minus - 1)) {
cout << " + 2";
plus--;
} else {
cout << " + 1";
plus--;
}
}
q.pop();
}
cout << " = " << n << "\n";
}
} else if (plus < minus) {
if ((plus * n - n) < minus) {
cout << "Impossible\n";
return 0;
}
if (n == 1) {
cout << "Impossible\n";
return 0;
}
cout << "Possible\n";
cout << n;
plus--;
int save = plus;
int k = minus % save;
int flag = 0;
while (q.size() != 0) {
if (q.front() == '-') {
cout << " - 1";
flag = 1;
}
if (q.front() == '+') {
flag = 0;
if (plus >= (save - k + 1)) {
cout << " + " << minus / save + 1;
plus--;
} else {
cout << " + " << minus / save;
plus--;
}
}
q.pop();
}
cout << " = " << n << "\n";
return 0;
} else {
if ((plus - (minus * n)) > n) {
cout << "Impossible\n";
return 0;
}
if (plus > n) {
cout << "Possible\n";
int k = 0;
cout << "1";
k++;
int save = minus % (plus - n);
if ((minus / (plus - n)) != 0) {
while (q.size() != 0) {
if (q.front() == '-') {
cout << " - 1";
}
if (q.front() == '+') {
if (k < n) {
cout << " + 1";
k++;
} else if (k < (n + save)) {
cout << " + " << (minus / (plus - n) + 1);
k++;
} else
cout << " + " << minus / (plus - n);
}
q.pop();
}
cout << " = " << n << "\n";
return 0;
} else {
int i = 2;
for (i = 2; i <= n; i++) {
if ((i * minus) / (plus - n) != 0) break;
}
save = (i * minus) % (plus - n);
while (q.size() != 0) {
if (q.front() == '-') {
cout << " - " << i;
}
if (q.front() == '+') {
if (k < n) {
cout << " + 1";
k++;
} else if (k < (n + save)) {
cout << " + " << ((i * minus) / (plus - n) + 1);
k++;
} else
cout << " + " << (i * minus) / (plus - n);
}
q.pop();
}
cout << " = " << n << "\n";
return 0;
}
}
cout << "Possible\n";
int k = 0;
int save = n % (plus - minus);
cout << n / (plus - minus) + save;
k++;
while (q.size() != 0) {
if (q.front() == '-') {
cout << " - 1";
}
if (q.front() == '+') {
if ((plus - k) > minus) {
cout << " + " << n / (plus - minus);
k++;
} else
cout << " + 1";
}
q.pop();
}
cout << " = " << n << "\n";
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
vector<int> pos;
vector<int> neg;
int ans[110];
char ope[110];
int n;
void Init() {
int k = 1;
string::size_type flag;
n = 0;
for (string::size_type i = 0; i < str.size(); ++i) {
if (str[i] == '=') {
flag = i;
break;
}
}
for (string::size_type i = 0; i < flag;) {
if (i == 0) {
ope[k] = '+';
pos.push_back(k++);
if (i + 4 >= flag) break;
i += 4;
} else {
if (str[i - 2] == '+') {
ope[k] = '+';
pos.push_back(k++);
} else {
ope[k] = '-';
neg.push_back(k++);
}
if (i + 4 >= flag) break;
i += 4;
}
}
for (string::size_type i = flag + 2; i < str.size(); ++i)
n = n * 10 + str[i] - '0';
}
void Slove() {
int left, right;
left = static_cast<int>(pos.size()) - n * static_cast<int>(neg.size());
right = n * static_cast<int>(pos.size()) - static_cast<int>(neg.size());
if (n < left || n > right) {
cout << "Impossible";
return;
}
for (vector<int>::size_type i = 0; i < pos.size(); ++i) ans[pos[i]] = 1;
for (vector<int>::size_type i = 0; i < neg.size(); ++i) ans[neg[i]] = 1;
int sum = static_cast<int>(pos.size() - neg.size());
int s, e;
s = e = 0;
while (sum != n) {
if (sum > n) {
ans[neg[e++]] -= max(1 - n, n - sum);
sum += max(1 - n, n - sum);
} else {
ans[pos[s++]] += min(n - 1, n - sum);
sum += min(n - 1, n - sum);
}
}
cout << "Possible" << endl;
int t = static_cast<int>(pos.size() + neg.size());
for (int i = 1; i <= t; ++i) {
if (i == 1)
cout << ans[1];
else
cout << " " << ope[i] << " " << ans[i];
}
cout << " = " << n << endl;
}
int main() {
getline(cin, str);
Init();
Slove();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e6), mod = int(1e9) + 7;
int n;
string second;
int x[N], y[N];
int main() {
getline(cin, second);
int k = second.size();
int a = 0, b = 0;
bool ok = 0;
a = 1;
for (int i = 0; i < k; i++) {
if (second[i] == '=') ok = 1;
if (ok && second[i] >= '0' && second[i] <= '9')
n = n * 10 + second[i] - '0';
if (second[i] == '+') a++;
if (second[i] == '-') b++;
}
int s1 = -1, s2 = -1;
for (int i = 1; i < N; i++) {
if (a <= i && n * a >= i && b <= i - n && n * b >= i - n) {
s1 = i;
s2 = i - n;
break;
}
}
if (s1 == -1) {
puts("Impossible");
return 0;
}
puts("Possible");
for (int i = 1; i <= a; i++) {
int v = min(s1 - a + i, n);
s1 -= v;
x[i] = v;
}
for (int i = 1; i <= b; i++) {
int v = min(s2 - b + i, n);
s2 -= v;
y[i] = v;
}
a = b = 0;
for (int i = 0; i < k; i++) {
if (second[i] == '?') {
if (i == 0 || second[i - 2] == '+') {
printf("%d", x[++a]);
} else
printf("%d", y[++b]);
} else
printf("%c", second[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1000000007ll;
const long long mod1 = 1000000009ll;
const long long mod2 = 1100000009ll;
int INF = (int)1e9 + 5;
long long INFINF = (long long)1e18;
int sign[200];
int main() {
string s;
getline(cin, s);
int plus, minus;
int k = 0;
plus = 1;
minus = 0;
int l = s.length();
int num = 0;
for (int i = 0; i < l; i++) {
if (s[i] == '+') {
plus++;
sign[k++] = 1;
} else if (s[i] == '-') {
minus++;
sign[k++] = -1;
}
if (s[i] == '=') {
for (int j = i + 2; j <= l - 1; j++) num = num * 10 + (s[j] - '0');
break;
}
}
if (plus - num * minus > num || plus * num - minus < num) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
int till_sum = 0;
for (int i = 0; i < k; i++) {
int sig = 1;
if (i > 0) sig = sign[i - 1];
if (sig == 1)
plus--;
else
minus--;
for (int j = 1; j <= num; j++) {
if (till_sum + j * sig + plus - num * minus <= num &&
till_sum + j * sig + num * plus - minus >= num) {
cout << j << " " << (sign[i] == 1 ? '+' : '-') << " ";
till_sum += j * sig;
break;
}
}
}
cout << abs(num - till_sum) << " = " << num << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ri() {
int x;
scanf("%d", &x);
return x;
}
template <typename T>
inline bool smax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool smin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
vector<int> f(int sum, int n) {
vector<int> v(n);
for (int i = 0; i < (n); i++) {
v[i] = sum / n;
if (i < sum % n) v[i]++;
}
return v;
}
int main() {
string s = "+";
char c;
int n;
while (true) {
cin >> c;
if (c != '=') {
if (c != '?') s += c;
} else {
cin >> n;
break;
}
}
int m = s.length();
int a = 0, b = 0;
for (int i = 0; i < (m); i++)
if (s[i] == '+')
a++;
else
b++;
if (b * n + n < a || b + n > a * n) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
vector<int> res;
for (int i = (b); i < (b * n + 1); i++) {
int j = i + n;
if (a <= j && j <= a * n) {
auto va = f(j, a), vb = f(i, b);
for (int xa = 0, xb = 0, k = 0; k < m; k++) {
if (s[k] == '+')
res.push_back(va[xa++]);
else
res.push_back(vb[xb++]);
}
break;
}
}
for (int i = 0; i < (m); i++) {
if (i) cout << s[i] << ' ';
cout << res[i] << ' ';
}
cout << "= " << n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char x;
vector<bool> add;
vector<int> yy, zz;
int nn, n, y = 1, z;
bool o = 1;
int main() {
scanf("%c", &x);
scanf("%c", &x);
while (1) {
scanf("%c", &x);
if (x == '=') break;
if (x == '+') {
add.push_back(1);
y++;
} else {
add.push_back(0);
z++;
}
scanf("%c", &x);
scanf("%c", &x);
scanf("%c", &x);
}
scanf("%d", &n);
nn = n;
if (y - z <= n) {
n -= y - z;
for (int a = 0; a < y; a++) {
yy.push_back(1 + n / (y - a));
n -= n / (y - a);
if (yy.back() > nn) o = 0;
}
for (int a = 0; a < z; a++) zz.push_back(1);
} else {
n = y - z - n;
for (int a = 0; a < z; a++) {
zz.push_back(1 + n / (z - a));
n -= n / (z - a);
if (zz.back() > nn) o = 0;
}
for (int a = 0; a < y; a++) yy.push_back(1);
}
if (n) o = 0;
if (!o) {
printf("Impossible\n");
return 0;
}
printf("Possible\n%d ", yy[--y]);
for (int a = 0; a < add.size(); a++) {
if (add[a])
printf("+ %d ", yy[--y]);
else
printf("- %d ", zz[--z]);
}
printf("= %d\n", nn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 100005;
const int M = 10;
const string s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char b[N];
int a[N];
int main() {
string second;
getline(cin, second);
int n = 0, k = 0;
for (int i = 0; i < second.size(); i++)
if (second[i] >= '0' && second[i] <= '9') {
k = k * 10 + (second[i] - '0');
} else if (second[i] == '?')
n++;
else if (second[i] == '+' || second[i] == '-')
b[n] = second[i];
a[1] = k;
int k1 = 0;
for (int i = 1; i < n; i++) {
if (b[i] == '+')
k1++;
else
k1--;
a[i + 1] = 1;
}
int p = k + k1;
for (int i = 1; i < n; i++)
if (b[i] == '+' && k > p) {
int h = min(k - p, k - a[i + 1]);
p += h;
a[i + 1] += h;
}
for (int i = 0; i < n; i++)
if ((b[i] == '-') && k < p) {
int h = min(p - k, k - a[i + 1]);
p -= h;
a[i + 1] += h;
}
if (k < p) {
int h = min(p - k, a[1] - 1);
p -= h;
a[1] -= h;
}
int t = a[1];
for (int i = 1; i < n; i++)
if (b[i] == '-')
t -= a[i + 1];
else
t += a[i + 1];
if (t != k) {
cout << "Impossible"
<< "\n";
return 0;
}
cout << "Possible"
<< "\n";
cout << a[1] << " ";
for (int i = 1; i < n; i++) cout << b[i] << " " << a[i + 1] << " ";
cout << "= " << k << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e6 + 1;
int n;
string s;
int main() {
cin.tie(0)->sync_with_stdio(0);
getline(cin, s);
n = s.size();
int plus = 1, neg = 0;
vector<int> v = {1};
int nn = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '+') {
plus++;
v.push_back(1);
}
if (s[i] == '-') {
neg++;
v.push_back(-1);
}
if ('0' <= s[i] && s[i] <= '9') {
nn = nn * 10 + s[i] - '0';
}
}
n = nn;
if (plus - n * neg > n || n > n * plus - neg) {
cout << "Impossible";
return 0;
}
cout << "Possible\n";
int sum = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i] == 1)
plus--;
else
neg--;
for (int c = 1; c <= n; c++) {
if (sum + c * v[i] + plus - n * neg > n ||
n > sum + c * v[i] + n * plus - neg) {
continue;
}
if (i == v.size() - 1) {
if (sum + c * v[i] != n) {
continue;
}
}
if (i) {
if (v[i] == 1) {
cout << " + ";
} else {
cout << " - ";
}
}
cout << c;
sum += c * v[i];
break;
}
}
cout << " = " << n;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[200][200];
int a, n, b;
int sum[200];
int main() {
a = 0;
b = 0;
int i = 0, j;
while (scanf("%s", s[i]) != EOF) {
i++;
if (s[i - 1][0] == '=') break;
}
scanf("%d", &n);
a = 1;
b = n;
sum[0] = a;
for (j = 1; j < i - 1; j += 2) {
if (s[j][0] == '+')
a += 1, b += n, sum[j + 1] = 1;
else
a -= n, b -= 1, sum[j + 1] = -n;
}
if (a <= n && n <= b) {
printf("Possible\n");
int temp = n - a;
for (j = 0; j < i - 1; j++) {
if (j % 2 == 0) {
if (temp > n - 1)
sum[j] += n - 1, temp -= n - 1;
else
sum[j] += temp, temp = 0;
if (sum[j] < 0)
printf("%d ", -sum[j]);
else
printf("%d ", sum[j]);
} else
printf("%s ", s[j]);
}
printf("= %d\n", n);
} else {
printf("Impossible\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sig[101], r, n, pos = 1, neg = 0;
bool equi = false;
void setup() {
sig[r = 1] = 1;
char c;
cin >> c;
while (true) {
cin >> c;
if (c == '=') {
cin >> n;
return;
}
sig[++r] = (c == '+' ? 1 : -1);
pos += (c == '+');
neg += (c == '-');
cin >> c;
}
}
void xuly() {
int maxVal = pos * n - neg;
int minVal = pos - neg * n;
if (n > maxVal || n < minVal) {
cout << "Impossible";
return;
}
cout << "Possible\n";
int sum = 0;
for (int i = 1; i <= r; i++) {
pos -= (sig[i] == 1);
neg -= (sig[i] == -1);
for (int j = 1; j <= n; j++) {
int thisVal = sig[i] * j;
maxVal = pos * n - neg + thisVal + sum;
minVal = pos - neg * n + thisVal + sum;
if (n > maxVal || n < minVal) continue;
sum += thisVal;
if (i > 1) cout << (sig[i] == 1 ? "+ " : "- ");
cout << j << ' ';
break;
}
}
cout << "= " << n;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int l = 0, k = 0;
string a;
bool atual = true;
istringstream buffer(s);
while (buffer >> a && a != "=") {
if (a == "-") {
atual = false;
continue;
}
if (a == "+") {
atual = true;
continue;
}
if (atual)
k++;
else
l++;
}
int n;
buffer >> n;
int saldo = -n;
int pos[k], neg[l];
for (int i = 0; i < k; i++) pos[i] = 1;
for (int i = 0; i < l; i++) neg[i] = 1;
saldo += k - l;
int i = 0, j = 0;
if (k * n < l + n || k > (l + 1) * n) {
printf("Impossible\n");
return 0;
}
printf("Possible\n");
while (saldo != 0) {
if (saldo < 0) {
if (-saldo >= n)
pos[i] += n - 1, i++, saldo += n - 1;
else
pos[i] += -saldo, i++, saldo = 0;
} else {
if (saldo >= n)
neg[j] += n - 1, j++, saldo -= n - 1;
else
neg[j] += saldo, j++, saldo = 0;
}
}
istringstream buf(s);
atual = true;
while (buf >> a && a != "=") {
if (a == "-") {
cout << a << " ";
atual = false;
continue;
}
if (a == "+") {
cout << a << " ";
atual = true;
continue;
}
if (atual) {
cout << pos[--k] << " ";
} else {
cout << neg[--l] << " ";
}
}
printf("= %d\n", n);
}
|
#include <bits/stdc++.h>
using namespace std;
char aim[1100];
long long a[110];
long long m[110];
long long tran(char str[], int pos) {
long long ans = 0;
for (int i = pos; i < strlen(str); i++) {
ans *= 10;
ans += str[i] - '0';
}
return ans;
}
long long cal(long long a, long long b) {
if (b < a) return 0;
return (a + b) * (b - a + 1) / 2;
}
int main() {
long long add = 0, reduce = 0;
gets(aim);
int n;
for (int i = 0;; i += 4) {
if (aim[i + 2] == '=') {
n = tran(aim, i + 4);
break;
}
if (aim[i + 2] == '+')
add++;
else
reduce++;
}
if (add + 1 - reduce * n > n || (add + 1LL) * n - reduce < n) {
cout << "Impossible" << endl;
return 0;
} else {
cout << "Possible" << endl;
for (int i = 0; i <= add; i++) a[i] = n;
for (int i = 0; i < reduce; i++) m[i] = 1;
long long temp = (add + 1LL) * n - reduce - n;
for (int i = add; i >= 0; i--) {
if (temp > n - 1) {
temp -= n - 1;
a[i] = 1;
} else {
a[i] = a[i] - temp;
temp = 0;
break;
}
}
if (temp > 0) {
for (int i = 0; i < reduce; i++) {
if (temp > n - 1) {
temp -= n - 1;
m[i] = n;
} else {
m[i] += temp;
break;
}
}
}
int tot1 = 1, tot2 = 0;
printf("%d", a[0]);
for (int i = 1; i < strlen(aim); i++) {
if (aim[i] == '?') {
if (aim[i - 2] == '+')
printf("%d", a[tot1++]);
else
printf("%d", m[tot2++]);
} else
printf("%c", aim[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(105);
int a[MAXN], add[MAXN];
int main() {
int n;
char c;
int numadd = 1, k = 1;
add[0] = 1;
while (scanf(" %c", &c) == 1) {
if (c == '=') {
scanf("%d", &n);
break;
} else if (c != '?') {
add[k++] = (c == '+');
numadd += (c == '+');
}
}
int sum = 0;
for (int i = 0; i < k; i++) {
if (add[i] == 1)
a[i] = n, sum += n;
else
a[i] = 1, sum--;
}
if (sum < n) {
printf("Impossible");
return 0;
}
int d;
for (int i = 0; i < k; i++) {
d = min(sum - n, n - 1);
if (add[i] == 1)
a[i] -= d;
else
a[i] += d;
sum -= d;
}
if (sum != n) {
printf("Impossible");
return 0;
}
printf("Possible\n");
for (int i = 0; i < k; i++) {
if (i != 0) printf("%c ", add[i] == 1 ? '+' : '-');
printf("%d ", a[i]);
}
printf("= %d", n);
}
|
#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;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
int main() {
string s;
getline(cin, s);
int l = s.length();
int pos = 1, neg = 0, ques = 0, n = 0;
for (int i = 0; i < l; ++i) {
if (s[i] == '+')
++pos;
else if (s[i] == '-')
++neg;
else if (s[i] == '?')
++ques;
else if (s[i] == '=') {
i += 2;
while (i < l) {
n *= 10;
n += s[i] - '0';
++i;
}
}
}
if (!(pos - n * neg <= n && n <= n * pos - neg)) {
;
cout << "Impossible";
return 0;
}
cout << "Possible" << '\n';
int sum = 0, sign;
for (int i = 0; i < l; ++i) {
if (s[i] == '=') {
cout << "= " << n;
break;
}
if (i == 0) {
--pos;
for (int j = 1; j <= n; ++j) {
if (sum + j + pos - n * neg <= n && n <= sum + j + n * pos - neg) {
sum += j;
cout << j << " ";
break;
}
}
} else if (s[i] != '?') {
if (s[i] == '+') {
sign = 1;
--pos;
cout << "+"
<< " ";
} else if (s[i] == '-') {
sign = -1;
--neg;
cout << "- ";
}
} else if (s[i] == '?') {
for (int j = 1; j <= n; ++j) {
if (sum + sign * j + pos - n * neg <= n &&
n <= sum + sign * j + n * pos - neg) {
sum += sign * j;
cout << j << " ";
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int get(string s) {
int a = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == ' ') continue;
a *= 10;
a += (s[i] - '0');
}
return a;
}
signed main() {
std::ios_base::sync_with_stdio(0), cin.tie(0);
vector<int> a;
int pos = 1, neg = 0;
a.push_back(1);
string s;
getline(cin, s);
int n = 0;
for (int i = 0; i < s.size(); ++i) {
char u = s[i];
if (u == ' ') continue;
if (u == '=') {
string cur = s.substr(i + 2);
n = get((cur));
break;
} else if (u == '?')
continue;
else if (u == '-')
neg++, a.push_back(-1);
else if (u == '+')
pos++, a.push_back(1);
}
int mn = pos - n * neg, mx = n * pos - neg;
if (!(mn <= n && n <= mx)) {
cout << "Impossible";
return 0;
}
cout << "Possible\n";
string ans;
int sum = 0;
for (int i = 0; i < a.size(); ++i) {
if (a[i] == 1) {
pos--;
} else {
neg--;
}
for (int x = 1; x <= n; ++x) {
if (sum + x * a[i] + pos - n * neg <= n &&
n <= sum + x * a[i] + pos * n - neg) {
ans += to_string(x);
if (i != a.size() - 1) {
ans += ' ';
if (a[i + 1] == 1)
ans += "+ ";
else
ans += "- ";
} else
ans += ' ';
sum += a[i] * x;
break;
}
}
}
ans += "= ";
ans += to_string(n);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mint;
map<int, string> mstr;
set<int> sint;
int a[500], chk = 1;
int main() {
ios::sync_with_stdio(0);
char str[500];
int k = 0, n, l = 0, i, j, x;
a[k++] = 1;
char c;
while (cin >> c && c != '=') {
if (c == '+') {
a[k++]++;
chk++;
} else if (c == '-') {
a[k++]--;
chk--;
}
str[l++] = c;
}
str[l++] = '=';
cin >> n;
for (i = 0; i < k; i++) {
while (chk < n && a[i] < n && a[i] > 0) chk++, a[i]++;
while (chk > n && a[i] < 0 && a[i] > -n) chk--, a[i]--;
}
if (chk != n)
cout << "Impossible\n";
else {
cout << "Possible\n";
for (i = 0, x = 0; i < l; i++) {
if (str[i] == '?') {
if (a[x] < 0) a[x] = -a[x];
cout << a[x] << " ";
x++;
} else {
cout << str[i];
cout << " ";
}
}
cout << n << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[1000];
int n;
int num1, num2;
int b[1000];
int main() {
gets(a);
int len = strlen(a);
num1 = 0;
num2 = 0;
int cnt = 1;
int pos;
int now = 1;
b[0] = 1;
for (int i = 0; i < len; i++) {
if (a[i] == '+') {
b[cnt++] = 1;
now++;
}
if (a[i] == '-') {
b[cnt++] = -1;
now--;
}
if (a[i] == '=') {
pos = i;
break;
}
}
n = 0;
for (int i = pos + 1; i < len; i++) {
if (a[i] <= '9' && a[i] >= '0') n = n * 10 + a[i] - '0';
}
for (int i = 0; i < cnt; i++) {
while (now < n && b[i] < n && b[i] > 0) now++, b[i]++;
while (now > n && b[i] > -n && b[i] < 0) now--, b[i]--;
}
if (now != n) {
printf("Impossible\n");
return 0;
}
printf("Possible\n");
int j = 0;
for (int i = 0; i < len; i++) {
if (a[i] != '?')
printf("%c", a[i]);
else {
printf("%d", abs(b[j++]));
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 1e6 + 10;
long long mod = 1e9 + 7;
const int base = 131;
const double pi = acos(-1);
const double eps = 1e-8;
inline long long ksm(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod, b >>= 1;
}
return ans;
}
long long vis[N], num[N];
long long n, m, k, x, y, z;
long long a[N], b[N], c[N];
long long cx, cy, cnt, ans, sum, flag, t, ff, q;
vector<int> v[N];
unordered_map<int, int> mp;
set<string> st;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a = 1, b = 0;
getline(cin, s);
for (int i = 0; s[i]; i++) {
if (s[i] == '+') a++;
if (s[i] == '-') b++;
if (isdigit(s[i])) {
n = n * 10 + s[i] - '0';
}
}
if (a > n + b * n || a * n - b < n)
cout << "Impossible" << endl;
else {
cout << "Possible" << endl;
t = (n + b) / a;
x = (n + b) % a;
y = a - x;
int pos = t, neg = 1;
if ((t + 1 > n && x >= 1) || (t > n) || t <= 0) {
t = (n + b * n) / a;
;
x = (n + b * n) % a;
y = a - x;
pos = t;
neg = n;
}
for (int i = 0; s[i]; i++) {
if (s[i] == '?') {
if (i == 0) {
if (x >= 1)
x--, cout << pos + 1;
else if (y)
y--, cout << pos;
} else {
if (s[i - 2] == '+') {
if (x >= 1)
x--, cout << pos + 1;
else if (y)
y--, cout << pos;
}
if (s[i - 2] == '-') {
cout << neg;
}
}
} else
cout << s[i];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
char str[10000];
int a[110];
gets(str);
int addnum = 0, subnum = 0, len = strlen(str), now = 1, num = 0;
int ans = 0;
a[num++] = 1;
for (int i = 0; i < len; i++) {
if (str[i] == '-')
subnum++, now--, a[num++] = -1;
else if (str[i] == '+')
addnum++, now++, a[num++] = 1;
else if (str[i] == '=') {
for (int j = i + 2; j < len; j++) ans = ans * 10 + str[j] - '0';
break;
}
}
for (int i = 0; i < num; i++) {
while (now < ans && a[i] > 0 && a[i] < ans) a[i]++, now++;
while (now > ans && a[i] < 0 && a[i] > -ans) a[i]--, now--;
}
if (now != ans)
printf("Impossible\n");
else {
printf("Possible\n");
for (int i = 0, j = 0; i < len && j <= num; i++) {
if (str[i] == '?')
cout << abs(a[j++]);
else
cout << str[i];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void getre() {
int x = 0;
printf("%d\n", 1 / x);
}
void gettle() {
int res = 1;
while (1) res <<= 1;
printf("%d\n", res);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
template <typename N>
inline int sgn(N a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gs(char *s) { scanf("%s", s); }
inline void gc(char &c) {
while ((c = getchar()) > 126 || c < 33)
;
}
inline void pc(char c) { putchar(c); }
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double pi = 3.14159265358979323846264338327950288L;
const double eps = 1e-6;
const int mo = 1;
int qp(int a, long long b) {
int n = 1;
do {
if (b & 1) n = 1ll * n * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return n;
}
int sg[555];
int num[555];
int tot = 0;
int n;
int main() {
sg[++tot] = 1;
char c;
while (gc(c), c != '=') {
if (c == '?')
continue;
else
sg[++tot] = c == '+' ? 1 : -1;
}
gn(n);
int suma = 0, sumi = 0;
for (int i = (1), _ed = (tot + 1); i < _ed; i++) {
if (sg[i] == 1)
suma += n, sumi += 1;
else
suma -= 1, sumi -= n;
}
if (n >= sumi && n <= suma) {
printf("Possible\n");
for (int i = (1), _ed = (tot + 1); i < _ed; i++)
if (sg[i] == 1)
num[i] = n;
else
num[i] = 1;
int cur = suma;
while (cur > n) {
for (int i = (1), _ed = (tot + 1); i < _ed; i++)
if (sg[i] == 1 && num[i] > 1) {
int del = min(cur - n, num[i] - 1);
num[i] -= del;
cur -= del;
} else if (sg[i] == -1 && num[i] < n) {
int del = min(cur - n, n - num[i]);
num[i] += del;
cur -= del;
}
}
for (int i = (1), _ed = (tot + 1); i < _ed; i++) {
if (i > 1) printf(" %c ", sg[i] == 1 ? '+' : '-');
printf("%d", num[i]);
}
printf(" = %d\n", n);
} else {
printf("Impossible\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p = 1, n, j, a[105];
char c;
int main() {
a[j++] = 1;
while (cin >> c && c != '=') {
if (c == '-') p--, a[j++] = -1;
if (c == '+') p++, a[j++] = 1;
}
cin >> n;
for (int i = 0; i < j; i++) {
while (p < n && a[i] > 0 && a[i] < n) a[i]++, p++;
while (p > n && a[i] < 0 && a[i] > -n) a[i]--, p--;
}
if (p != n) {
cout << "Impossible\n";
return 0;
}
cout << "Possible\n";
for (int i = 0; i < j; i++)
cout << (i ? (a[i] < 0 ? "- " : "+ ") : "") << abs(a[i]) << " ";
cout << "= " << n << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void print(long long int a[], long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
long long int power(long long int x) {
long long int u = 0;
while (x % 2 == 0) {
u++;
x = x / 2;
}
return u;
}
long long int powM(long long int x, long long int y, long long int m) {
if (m == 1) {
return 0;
}
long long int ans = 1, r = 1;
x %= m;
while (r > 0 && r <= y) {
if (r & y) {
ans *= x;
ans %= m;
}
r <<= 1;
x *= x;
x %= m;
}
return ans;
}
int powm(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
unsigned int b(unsigned int n) {
unsigned int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t1 = 1;
long long int M = 1e9 + 7;
while (t1--) {
string s = "";
char c;
cin >> c;
while (c != '=') {
if (c != ' ') {
s += c;
}
cin >> c;
}
s += c;
long long int n;
cin >> n;
long long int p, m;
p = 0;
m = 0;
s = '+' + s;
long long int k = s.size();
for (long long int i = 0; i < k; i++) {
if (s[i] == '+') {
p++;
}
if (s[i] == '-') {
m++;
}
}
long long int b;
if (m == 0) {
b = 1;
} else {
b = (p - n) / m;
if (b <= 0) {
b = 1;
} else {
if ((p - n) % m != 0) {
b++;
}
}
}
n += (b * m);
long long int u = n / p;
long long int r = n % p;
long long int o = 0;
vector<long long int> v;
for (long long int i = 0; i < k; i++) {
if (o < r) {
if (s[i] == '+') {
v.push_back(u + 1);
o++;
}
if (s[i] == '-') {
v.push_back(b);
}
} else {
if (s[i] == '+') {
v.push_back(u);
}
if (s[i] == '-') {
v.push_back(b);
}
}
}
long long int l = 1;
n -= (b * m);
for (long long int i = 0; i < v.size(); i++) {
if (v[i] > n || v[i] < 1) {
l = 0;
break;
}
}
if (!l) {
cout << "Impossible";
} else {
cout << "Possible\n";
long long int j = 0;
for (long long int i = 1; i < k; i++) {
if (s[i] == '?') {
cout << v[j] << " ";
j++;
} else {
cout << s[i] << " ";
}
}
cout << n;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<char> signs;
signs.push_back('+');
while (cin >> s, s[0] != '=') {
if (s[0] == '?') continue;
signs.push_back(s[0]);
}
int n;
cin >> n;
int plus = count(signs.begin(), signs.end(), '+');
int minus = count(signs.begin(), signs.end(), '-');
int minPos = plus;
int maxPos = plus * n;
int minNeg = minus;
int maxNeg = minus * n;
if (minNeg + n > maxPos || maxNeg + n < minPos) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
vector<int> nums(signs.size());
int l = max(minPos, minNeg + n);
int r = min(maxPos, maxNeg + n);
int takePos = l;
int takeNeg = takePos - n;
takeNeg -= minus;
takePos -= plus;
for (size_t i = 0; i < nums.size(); ++i) {
if (signs[i] == '+') {
nums[i] = 1 + min(n - 1, takePos);
takePos -= min(n - 1, takePos);
} else {
nums[i] = 1 + min(n - 1, takeNeg);
takeNeg -= min(n - 1, takeNeg);
}
}
cout << nums[0] << ' ';
for (size_t i = 1; i < nums.size(); ++i) {
cout << signs[i] << ' ' << nums[i] << ' ';
}
cout << '=' << ' ' << n << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e6 + 3;
void rd(int &x) {
int f = 1;
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
void pr(int x) { printf("%d\n", x); }
string s, t;
int n;
vector<string> g;
int main() {
getline(cin, s);
stringstream ss;
ss << s;
int sum = 0, fu = 0, zh = 0;
while (ss >> t) {
g.push_back(t);
if (t == "?") sum++;
if (t == "-") fu++;
}
zh = sum - fu;
t = g[g.size() - 1];
for (int i = (0); i < t.size(); i++) n = n * 10 + t[i] - '0';
int m = n + fu, fir;
if (fu) {
if (m > n * zh && zh > fu * n + n)
puts("Impossible");
else {
int avg, sum, yu;
if (zh > fu) {
sum = (fu + 1) * n;
avg = sum / zh;
yu = sum % zh;
if (avg == 0)
puts("Impossible");
else {
puts("Possible");
if (yu)
printf("%d", avg + 1), yu--;
else
printf("%d", avg);
for (int i = (1); i < g.size() - 1; i++) {
if (g[i] != "?")
cout << " " << g[i];
else {
if (g[i - 1] == "+") {
if (yu)
printf(" %d", avg + 1), yu--;
else
printf(" %d", avg);
} else
printf(" %d", n);
}
}
printf(" %d\n", n);
}
} else {
sum = n * (zh - 1);
avg = sum / fu;
yu = sum % fu;
if (avg == 0)
puts("Impossible");
else {
puts("Possible");
printf("%d", n);
for (int i = (1); i < g.size() - 1; i++) {
if (g[i] != "?")
cout << " " << g[i];
else {
if (g[i - 1] == "-") {
if (yu)
printf(" %d", avg + 1), yu--;
else
printf(" %d", avg);
} else
printf(" %d", n);
}
}
printf(" %d\n", n);
}
}
}
} else {
if (zh > n)
puts("Impossible");
else {
puts("Possible");
int x = zh - 1, fir = n - x;
printf("%d", fir);
for (int i = (1); i < g.size() - 1; i++) {
if (g[i] != "?")
cout << " " << g[i];
else
cout << " 1";
}
printf(" %d\n", n);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
int n;
vector<int> v;
char sign = '+';
int sum = 0;
while (1) {
cin >> c;
if (c == '+' or c == '-')
sign = c;
else if (c == '?') {
if (sign == '+')
v.push_back(1);
else
v.push_back(-1);
}
if (c == '=') break;
}
for (auto x : v) sum += x;
cin >> n;
vector<int> pos, neg;
for (long long i = 0; i < v.size(); i++) {
if (v[i] == 1)
pos.push_back(i);
else
neg.push_back(i);
}
while (sum < n) {
while (pos.size() > 0 and v[pos.back()] == n) pos.pop_back();
if (pos.size() == 0) {
cout << "Impossible";
return 0;
}
v[pos.back()]++;
sum++;
}
while (sum > n) {
while (neg.size() > 0 and v[neg.back()] == -n) neg.pop_back();
if (neg.size() == 0) {
cout << "Impossible";
return 0;
}
sum--;
v[neg.back()]--;
}
cout << "Possible\n";
for (long long i = 0; i < v.size(); i++) {
if (i != 0) {
if (v[i] > 0)
cout << "+ ";
else
cout << "- ";
}
cout << abs(v[i]) << " ";
}
cout << "= " << n;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long N;
string s;
vector<int> a, b(1);
while (cin >> s) {
if (s[0] == '?') {
a.push_back(1);
} else if (s[0] == '=') {
cin >> N;
break;
} else {
b.push_back(s[0] == '-');
}
}
long long p = count(b.begin(), b.end(), 0);
if (p - N * (b.size() - p) > N || N * p - (b.size() - p) < N) {
cout << "Impossible\n";
return 0;
}
long long cur = 2ll * p - b.size();
while (cur != N) {
if (cur > N) {
for (int i = 0; i < a.size(); i++) {
if (b[i] && a[i] < N) {
long long diff = min(N - a[i], cur - N);
a[i] += diff;
cur -= diff;
}
}
} else {
for (int i = 0; i < a.size(); i++) {
if (!b[i] && a[i] < N) {
long long diff = min(N - a[i], N - cur);
a[i] += diff;
cur += diff;
}
}
}
}
cout << "Possible\n";
for (int i = 0; i < a.size(); i++) {
cout << a[i] << ' ';
if (i + 1 != a.size()) cout << (b[i + 1] ? "- " : "+ ");
}
cout << "= " << N;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p = 1, n, j, a[105];
char c;
int main() {
a[j++] = 1;
while (cin >> c && c != '=') {
if (c == '-') p--, a[j++] = -1;
if (c == '+') p++, a[j++] = 1;
}
cin >> n;
for (int i = 0; i < j; i++) {
if (a[i] > 0)
while (p < n && a[i] < n) a[i]++, p++;
else
while (p > n && a[i] < 0 && a[i] > -n) a[i]--, p--;
}
if (p != n) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
cout << a[0] << " ";
for (int i = 1; i < j; i++)
if (a[i] < 0)
cout << " - " << -a[i];
else
cout << " + " << a[i];
cout << " = " << n;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string in;
getline(cin, in);
stringstream ss(in);
int pos = 1;
int neg = 0;
vector<char> logger;
while (true) {
char c;
ss >> c;
if (c == '=') break;
if (c == '+') {
logger.push_back('+');
pos++;
}
if (c == '-') {
logger.push_back('-');
neg++;
}
}
int n;
ss >> n;
if ((pos * n - neg * 1 < n) || (pos * 1 - neg * n > n)) {
cout << "Impossible" << endl;
} else {
cout << "Possible" << endl;
int pre = 0;
for (int i = 0; i < logger.size(); ++i) {
int sign = 1;
if ((i > 0) && (logger[i - 1] == '-')) {
sign = -1;
}
if (sign == 1)
pos--;
else
neg--;
for (int x = 1; x <= n; ++x) {
if ((pre + sign * x + pos * n - neg * 1 >= n) &&
(pre + sign * x + pos * 1 - neg * n <= n)) {
pre += sign * x;
cout << x << " " << logger[i] << " ";
break;
}
}
}
cout << abs(n - pre) << " = " << n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum, ans, i, num[110], now;
char ch, mk[110];
while (cin >> ch) {
sum = 0;
mk[0] = '+';
while (cin >> mk[++sum]) {
if (mk[sum] == '=') {
cin >> ans;
break;
} else
cin >> ch;
}
for (i = 0; i < sum; i++) num[i] = 1;
now = 0;
for (i = 0; i < sum; i++) {
if (mk[i] == '+')
now++;
else
now--;
}
now -= ans;
for (i = 0; i < sum; i++) {
if (mk[i] == '+') {
if (!now) continue;
if (now < 0) {
if (ans - num[i] >= -now) {
num[i] += -now;
now = 0;
} else {
now += ans - num[i];
num[i] = ans;
}
}
} else {
if (!now) continue;
if (now > 0) {
if (ans - num[i] >= now) {
num[i] += now;
now = 0;
} else {
now -= ans - num[i];
num[i] = ans;
}
}
}
}
if (now == 0) {
cout << "Possible" << endl;
cout << num[0] << ' ';
for (i = 1; i < sum; i++) {
cout << mk[i] << " " << num[i] << " ";
}
cout << "= " << ans << endl;
} else
cout << "Impossible" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const string POSSIBLE = "Possible";
const string IMPOSSIBLE = "Impossible";
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
vector<int> signs;
int n;
while (true) {
char c;
cin >> c;
if (c == '=') {
cin >> n;
break;
}
if (c == '?') {
signs.push_back(1);
} else if (c == '+') {
signs.push_back(1);
cin >> c;
} else if (c == '-') {
signs.push_back(-1);
cin >> c;
}
}
int m = signs.size();
vector<int> lf(m + 1);
vector<int> rg(m + 1);
lf[0] = rg[0] = 0;
for (int i = 0; i < m; ++i) {
int cl;
int cr;
if (signs[i] == -1) {
cl = -n;
cr = -1;
} else {
cl = 1;
cr = n;
}
lf[i + 1] = lf[i] + cl;
rg[i + 1] = rg[i] + cr;
}
if (!(n >= lf[m] && n <= rg[m])) {
cout << IMPOSSIBLE << endl;
return 0;
}
cout << POSSIBLE << endl;
vector<int> vals(m);
int v = n;
for (int i = m - 1; i >= 0; --i) {
int cl;
int cr;
if (signs[i] == -1) {
cl = -n;
cr = -1;
} else {
cl = 1;
cr = n;
}
int nvl = v - rg[i];
int nvr = v - lf[i];
nvl = max(nvl, cl);
nvr = min(nvr, cr);
vals[i] = nvl;
v = v - vals[i];
vals[i] = abs(vals[i]);
}
cout << vals[0] << " ";
for (int i = 1; i < m; ++i) {
if (signs[i] == -1) {
cout << "- ";
} else {
cout << "+ ";
}
cout << vals[i] << " ";
}
cout << "= " << n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char c;
int n, len, nump, nume, sum;
int po[110], ne[110], a[110];
void Display() {
printf("Possible\n");
int cur = 1;
printf("%d", a[0]);
for (int i = 1; i < len; i++)
if (po[cur] == i) {
printf(" + %d", a[i]);
cur++;
} else
printf(" - %d", a[i]);
printf(" = %d\n", n);
}
int main() {
len = nump = 1;
nume = po[0] = 0;
while (scanf(" %c", &c) && c != '=') {
if (c == '?') continue;
if (c == '+')
po[nump++] = len++;
else
ne[nume++] = len++;
}
scanf("%d", &n);
if (nump > nume) {
sum = nume * n + n;
if (nump > sum)
printf("Impossible\n");
else {
for (int i = 0; i < nume; i++) a[ne[i]] = n;
for (int i = 0; i < nump; i++) {
a[po[i]] = sum / (nump - i);
sum -= a[po[i]];
}
Display();
}
} else {
sum = nump * n - n;
if (sum < nume)
printf("Impossible\n");
else {
for (int i = 0; i < nump; i++) a[po[i]] = n;
for (int i = 0; i < nume; i++) {
a[ne[i]] = sum / (nume - i);
sum -= a[ne[i]];
}
Display();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LLINF = numeric_limits<long long>::max();
const unsigned long long ULLINF = numeric_limits<unsigned long long>::max();
const double PI = acos(-1.0);
vector<int> ans;
void solve(int n, int p, int maxN) {
if (!p) return;
int mx = n - (p - 1);
int cur = min(maxN, mx);
ans.push_back(cur);
solve(n - cur, p - 1, maxN);
}
vector<char> type;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
char c;
type.push_back(1);
int p = 1, m = 0;
cin >> c;
while (c != '=') {
if (c == '+') {
p++;
type.push_back('+');
} else if (c == '-') {
type.push_back('-');
m++;
}
cin >> c;
}
int n;
cin >> n;
if (!p) {
cout << "Impossible";
return 0;
}
if (!m) {
if (p > n) {
cout << "Impossible";
return 0;
}
cout << "Possible\n";
solve(n, p, n);
cout << ans.back() << " ";
ans.pop_back();
while (ans.size()) {
cout << "+ " << ans.back() << " ";
ans.pop_back();
}
cout << "= " << n;
return 0;
}
vector<int> positive, negative;
bool found = 0;
for (int pos = n; pos <= n * p; pos++) {
int neg = pos - n;
if (neg / m > 0 && n * m >= neg) {
if (p > pos) continue;
solve(pos, p, n);
positive = ans;
solve(neg, m, n);
negative = ans;
found = 1;
break;
}
}
if (!found) {
cout << "Impossible";
return 0;
}
cout << "Possible\n";
cout << positive.back() << " ";
positive.pop_back();
for (int i = 1; i < type.size(); i++) {
if (type[i] == '+') {
cout << "+ " << positive.back() << " ";
positive.pop_back();
} else {
cout << "- " << negative.back() << " ";
negative.pop_back();
}
}
cout << "= " << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100500;
vector<long long> arr;
long long n;
string s;
bool is_digit(char h) { return '0' <= h && h <= '9'; }
void parse() {
string t;
for (int i = 0; i < (int)s.size(); ++i)
if (s[i] != ' ') t += s[i];
s = t;
s = "+" + s;
for (int i = 0; i < (int)s.size(); ++i) {
if (s[i] == '?') arr.push_back(s[i - 1] == '+' ? 1 : -1);
}
int ptr = (int)s.size() - 1;
while (is_digit(s[ptr])) ptr--;
ptr++;
while (ptr < (int)s.size()) n = n * 10 + s[ptr++] - '0';
}
int main() {
getline(cin, s);
long long maxval = 0;
long long minval = 0;
parse();
for (int i = 0; i < (int)arr.size(); ++i) {
if (arr[i] == 1) {
minval += 1;
maxval += n;
} else {
minval -= n;
maxval -= 1;
}
}
if (n > maxval || n < minval) {
cout << "Impossible\n";
return 0;
}
long long rem = n;
for (int i = (int)arr.size() - 1; i >= 0; i--) {
long long cur;
if (arr[i] == 1) {
minval -= 1;
maxval -= n;
cur = max(1ll, rem - maxval);
rem -= cur;
arr[i] = cur;
} else {
minval += n;
maxval += 1;
cur = max(1ll, minval - rem);
rem += cur;
arr[i] = -cur;
}
}
cout << "Possible\n";
for (int i = 0; i < (int)arr.size(); ++i) {
if (arr[i] < 0)
cout << " - " << -arr[i];
else if (i)
cout << " + " << arr[i];
else
cout << arr[i];
}
cout << " = " << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 107;
char oper[maxn];
int q;
int l[maxn], r[maxn];
void dfs(int n, int last) {
if (n == 0) {
printf("%d", last);
return;
}
if (oper[n] == '+') {
int _ = 1, __ = q;
while (_ <= __) {
int mid = (_ + __) / 2;
int x = last - mid;
if (x < r[n - 1]) {
__ = mid - 1;
} else if (x > l[n - 1]) {
_ = mid + 1;
} else {
dfs(n - 1, last - mid);
printf(" %c %d", oper[n], mid);
return;
}
}
} else {
int _ = 1, __ = q;
while (_ <= __) {
int mid = (_ + __) / 2;
int x = last + mid;
if (x < r[n - 1]) {
_ = mid + 1;
} else if (x > l[n - 1]) {
__ = mid - 1;
} else {
dfs(n - 1, last + mid);
printf(" %c %d", oper[n], mid);
return;
}
}
}
}
int main() {
char s[2];
int n = 0;
while (true) {
scanf("%s", s);
if (s[0] == '?')
++n;
else if (s[0] == '=')
break;
else
oper[n] = s[0];
}
scanf("%d", &q);
if (n == 1)
printf("Possible\n%d = %d\n", q, q);
else {
l[0] = q;
r[0] = 1;
bool flag = true;
for (int i = 1; i < n; ++i) {
if (oper[i] == '-') {
l[i] = l[i - 1] - 1;
r[i] = r[i - 1] - q;
} else {
l[i] = l[i - 1] + q;
r[i] = r[i - 1] + 1;
}
}
if (q < r[n - 1] || q > l[n - 1])
printf("Impossible");
else {
printf("Possible\n");
dfs(n - 1, q);
printf(" = %d", q);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
char ss[maxn];
int n, tt[105];
int main() {
gets(ss);
int len = strlen(ss), i, j = 1, p = 1;
tt[0] = 1;
for (i = 0; i < len; i++) {
if (ss[i] == '+') {
p++;
tt[j++] = 1;
} else if (ss[i] == '-') {
p--;
tt[j++] = -1;
} else if (ss[i] == '=') {
break;
}
}
i += 2;
for (; i < len; i++) {
n = n * 10 + (ss[i] - '0');
}
for (i = 0; i < j; i++) {
if (tt[i] > 0) {
while (p < n && tt[i] < n) {
tt[i]++;
p++;
}
} else if (tt[i] < 0) {
while (p > n && tt[i] > -n) {
tt[i]--;
p--;
}
}
}
if (p != n) {
printf("Impossible\n");
} else {
printf("Possible\n");
for (i = 0, j = 0; i < len; i++) {
if (ss[i] == '?') {
printf("%d", abs(tt[j++]));
} else {
printf("%c", ss[i]);
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
using namespace std;
template <typename T>
vector<T> read_v(int n) {
vector<T> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
return v;
}
bool decrease(int a, int b) { return (a > b); }
struct pr {
int f, s;
};
char s[100];
int main() {
int k = 0, n, pos = 1, neg = 0;
while (true) {
char c;
scanf(" %c", &c);
scanf(" %c", &c);
if (c == '=') break;
if (c == '+') pos++;
if (c == '-') neg++;
s[k++] = c;
}
scanf("%d", &n);
if (pos - n * neg > n || n * pos - neg < n) {
printf("Impossible\n");
return 0;
}
printf("Possible\n");
int S = 0;
for (int i = 0; i < k; i++) {
int sgn = 1;
if (i > 0 && s[i - 1] == '-') sgn = -1;
if (sgn == 1) pos--;
if (sgn == -1) neg--;
for (int x = 1; x <= n; x++)
if (S + x * sgn + pos - n * neg <= n &&
S + x * sgn + n * pos - neg >= n) {
printf("%d %c ", x, s[i]);
S += x * sgn;
break;
}
}
printf("%d = %d", abs(n - S), n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a;
int num;
b[1] = 1;
while (true) {
char c;
cin >> c;
if (c == '=') {
cin >> num;
break;
}
if (c == '+' or c == '-') {
++b[c == '+'];
a += c;
}
}
if (b[0] == 0) {
int avg = num / b[1];
int need = num % b[1];
if (!avg or avg + (need > 0) > num) {
cout << "Impossible\n";
return 0;
}
cout << "Possible\n";
cout << avg + (need-- > 0) << " ";
for (long long int j = 0; j < b[1] - 1 + b[0]; j++) {
cout << a[j] << " " << avg + (need-- > 0) << " ";
}
cout << "= " << num;
return 0;
}
int cnt = 1;
while (true) {
int avgp = (num + cnt) / b[1], avgn = cnt / b[0];
int needp = (num + cnt) % b[1], needn = cnt % b[0];
if (avgp + (needp > 0) > num or avgn + (needn > 0) > num) {
break;
}
if (!avgp or !avgn) {
++cnt;
continue;
}
cout << "Possible\n";
cout << avgp + (needp-- > 0) << " ";
for (long long int j = 0; j < b[1] - 1 + b[0]; j++) {
cout << a[j] << " ";
if (a[j] == '+') {
cout << avgp + (needp-- > 0) << " ";
} else {
cout << avgn + (needn-- > 0) << " ";
}
}
cout << "= " << num;
return 0;
}
cout << "Impossible\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int mod = INF;
const int N = 1e6 + 7;
const int T = 1 << 20;
void solve() {
vector<string> wyrazy;
string temp;
while (cin >> temp) {
wyrazy.push_back(temp);
}
int n = stoi(wyrazy.back());
vector<int> tab((int)wyrazy.size());
int suma = 0;
tab[0] = n;
for (int i = 2; i < (int)wyrazy.size() - 2; i += 2) {
assert(wyrazy[i] == "?");
tab[i] = (wyrazy[i - 1] == "+" ? n : -1);
suma += tab[i];
}
for (int i = 0; i < (int)wyrazy.size() - 2; i += 2) {
while (tab[i] > 1 and suma > 0) {
tab[i]--;
suma--;
}
while (tab[i] > -n and tab[i] < 0 and suma > 0) {
tab[i]--;
suma--;
}
}
if (suma != 0) {
cout << "Impossible\n";
exit(0);
}
cout << "Possible\n";
for (int i = 0; i < (int)wyrazy.size(); i++) {
if (wyrazy[i] == "?")
cout << abs(tab[i]) << ' ';
else
cout << wyrazy[i] << ' ';
}
cout << '\n';
}
signed main() {
int test = 1;
for (int i = 0; i < test; i++) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int assign(vector<int> &o, vector<char> &s, int n, int pos, int neg) {
o.resize(s.size());
if (pos >= neg) {
if (pos > (neg + 1) * n) return n + 1;
for (int i = 0; i < s.size(); ++i)
if (s[i] == '+') o[i] = 1;
int diff = pos;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '-') {
o[i] = max(1, min(diff - neg + 1, n));
--neg;
diff -= o[i];
}
}
return diff;
}
if (neg > pos * n) return n + 1;
for (int i = 0; i < s.size(); ++i)
if (s[i] == '-') o[i] = 1;
int diff = -neg;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '+') {
o[i] = max(1, min(-diff - pos + 1, n));
--pos;
diff += o[i];
}
}
return diff;
}
int main() {
int n;
vector<char> s;
int pos = 0, neg = 0;
for (char a, b; scanf(" %c %c", &a, &b) == 2 && b != '='; s.push_back(b))
(b == '+' ? pos : neg) += 1;
scanf("%d", &n);
vector<int> operators;
int diff = assign(operators, s, n, pos, neg);
if (diff < 0 || diff >= n)
puts("Impossible");
else {
puts("Possible");
printf("%d", n - diff);
for (int i = 0; i < s.size(); ++i) printf(" %c %d", s[i], operators[i]);
printf(" = %d\n", n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1111, inf = 1111111111;
int n, a[max_n];
vector<int> v;
string s;
int main() {
v.push_back(1);
while (cin >> s) {
if (s == "=") {
cin >> s;
n = atoi(s.c_str());
break;
}
if (s == "+") {
v.push_back(1);
}
if (s == "-") {
v.push_back(-1);
}
}
for (int i = 0; i < v.size(); ++i) {
if (v[i] == 1) {
a[i] = n;
} else {
a[i] = 1;
}
}
int sum = 0;
for (int i = 0; i < v.size(); ++i) {
sum += a[i] * v[i];
}
if (sum < n) {
cout << "Impossible" << endl;
return 0;
}
for (int i = 0; i < v.size(); ++i) {
int x = min(n - 1, sum - n);
if (v[i] == 1) {
a[i] -= x;
} else {
a[i] += x;
}
sum -= x;
}
if (sum > n) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
for (int i = 0; i < v.size(); ++i) {
cout << a[i];
if (i + 1 < v.size()) {
if (v[i + 1] == 1) {
cout << " + ";
} else {
cout << " - ";
}
} else {
cout << " = " << n << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000000];
int ss[200];
int main() {
int i, jia = 1, jian = 0, n = 0, k, left, t, j;
gets(s);
k = strlen(s);
for (i = 0; i < k; i++) {
if (s[i] == '+') jia++;
if (s[i] == '-') jian++;
if (s[i] >= '0' && s[i] <= '9') n = s[i] - '0' + n * 10;
}
for (i = 0; i < jia; ++i) {
ss[i] = n;
}
for (i = 0; i < jian; ++i) {
ss[i + jia] = 1;
}
if (n * jia - jian < n || jia - n * jian > n)
printf("Impossible\n");
else {
printf("Possible\n");
left = n * jia - jian - n;
for (i = 0; i < jia; i++) {
if (left == 0) break;
if (left > n - 1) {
ss[i] = 1;
left -= n - 1;
} else {
ss[i] = n - left;
left = 0;
}
}
for (i = 0; i < jian; i++) {
if (left == 0) break;
if (left > n - 1) {
ss[i + jia] = n;
left -= n - 1;
} else {
ss[i + jia] = left + 1;
left = 0;
}
}
t = 0;
j = jia;
printf("%d", ss[t++]);
for (i = 0; i < k; i++) {
if (s[i] == '+') {
printf(" + %d", ss[t++]);
}
if (s[i] == '-') printf(" - %d", ss[j++]);
if (s[i] == '=') {
printf(" = %d\n", n);
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(int test_number);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.setf(ios::fixed);
cout.precision(9);
cerr.setf(ios::fixed);
cerr.precision(3);
int n = 1;
for (int i = 0; i < n; i++) {
solve(i + 1);
}
return 0;
}
const int MAXN = 1010;
string s;
int a[MAXN];
int pos[MAXN];
int neg[MAXN];
void fail() {
cout << "Impossible" << endl;
exit(0);
}
void solve(int test_number) {
getline(cin, s);
int cnt_pos, cnt_neg;
cnt_pos = cnt_neg = 0;
for (char c : s) {
if (c == '+')
cnt_pos++;
else if (c == '-')
cnt_neg++;
}
string x;
int cur = s.length() - 1;
while (s[cur] != ' ') {
x = s[cur] + x;
cur--;
}
int res = atoi(x.c_str());
while (s.back() != '=') s.erase(s.length() - 1, 1);
s.erase(s.length() - 1, 1);
x = "";
for (char c : s) {
if (c != ' ' && c != '?') x += c;
}
cnt_pos++;
for (int i = 0; i < cnt_pos; i++) {
pos[i] = 1;
}
for (int i = 0; i < cnt_neg; i++) {
neg[i] = 1;
}
int bal = (cnt_pos - cnt_neg) - res;
while (bal != 0) {
if (bal > 0) {
int p = 0;
for (int i = 0; i < cnt_neg; i++) {
if (neg[i] < neg[p]) p = i;
}
if (p >= cnt_neg) fail();
neg[p]++;
if (neg[p] > res) fail();
bal--;
} else {
int p = 0;
for (int i = 0; i < cnt_pos; i++) {
if (pos[i] < pos[p]) p = i;
}
if (p >= cnt_pos) fail();
pos[p]++;
if (pos[p] > res) fail();
bal++;
}
}
cout << "Possible" << endl;
int cp = 0, cn = 0;
int n = cnt_neg + cnt_pos;
cout << pos[0] << " ";
cp = 1;
for (int i = 0; i < n - 1; i++) {
cout << x[i] << ' ';
if (x[i] == '+')
cout << pos[cp++] << " ";
else
cout << neg[cn++] << " ";
}
cout << "= " << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000003;
int main() {
string s;
cin >> s;
std::vector<int> a;
a.push_back(1);
cin >> s;
while (s != "=") {
if (s == "-")
a.push_back(-1);
else
a.push_back(1);
cin >> s;
cin >> s;
}
int n;
cin >> n;
int ap = 0, am = 0;
for (auto x : a) {
if (x > 0)
ap++;
else
am++;
}
if (n * ap - am < n)
cout << "Impossible";
else if (ap - n * am > n)
cout << "Impossible";
else {
cout << "Possible" << endl;
int add = n - (ap - am);
string ans;
for (int i = 0; i < a.size(); i++) {
if (i > 0) {
if (a[i] > 0)
cout << "+ ";
else
cout << "- ";
}
if (a[i] > 0) {
if (add > 0) {
int d = min(n - 1, add);
cout << 1 + d << " ";
add -= d;
} else
cout << "1 ";
}
if (a[i] < 0) {
if (add < 0) {
int d = max(-n + 1, add);
cout << 1 - d << " ";
add -= d;
} else
cout << "1 ";
}
}
cout << "= " << n << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
char c;
int n;
vector<int> p, m;
vector<int> ans;
vector<int> bb;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
bool b = 1;
int idx = 0;
while (1) {
cin >> c;
if (c == '?') {
if (b)
p.push_back(idx), ans.push_back(1), bb.push_back(1);
else
m.push_back(idx), ans.push_back(1), bb.push_back(0);
idx++;
} else if (c == '+')
b = 1;
else if (c == '-')
b = 0;
else if (c == '=')
break;
}
cin >> n;
int n1 = p.size() - m.size() * n, n2 = p.size() * n - m.size();
if (n1 > n || n2 < n)
cout << "Impossible"
<< "\n";
else {
int left = p.size() - n - m.size();
int n1 = n + m.size();
for (int i = 0; i < (int)m.size(); i++) {
if (left <= 0) break;
if (left > n - 1)
ans[m[i]] = n, left -= n - 1, n1 += n - 1;
else
ans[m[i]] = 1 + left, n1 += left, left = 0;
}
n1 -= p.size();
for (int i = 0; i < (int)p.size(); i++) {
if (n1 == 0) break;
if (n1 > n - 1)
ans[p[i]] = n, n1 -= n - 1;
else
ans[p[i]] = 1 + n1, n1 = 0;
}
cout << "Possible"
<< "\n";
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i];
if (i + 1 < ans.size()) {
if (bb[i + 1])
cout << " + ";
else
cout << " - ";
}
}
cout << " = " << n << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> negat, posit;
long long stoi(string s, long long posisi) {
long long ret = 0, i, len;
len = s.length();
for (i = posisi; i < len; ++i) {
ret = ret * 10;
ret += s[i] - '0';
}
return ret;
}
int main() {
long long i, len, jmlpos = 1, jmlneg = 0, har, n, posisi, it1 = 0, it2 = 0, l,
r, mid, piv;
bool last = 0;
string st;
getline(cin, st);
len = st.length();
for (i = 0; i < len; ++i) {
if (st[i] == '+') {
jmlpos++;
} else if (st[i] == '-') {
jmlneg++;
}
if (st[i] == '=') {
break;
}
}
posisi = i + 2;
n = stoi(st, posisi);
for (i = 0; i < jmlpos; ++i) {
posit.push_back(1);
}
for (i = 0; i < jmlneg; ++i) {
negat.push_back(1);
}
if (jmlpos - jmlneg == n) {
last = 0;
cout << "Possible" << endl;
for (i = 0; i < len; ++i) {
if (st[i] == '?') {
if (last == 0) {
cout << posit[it1];
it1++;
} else if (last == 1) {
cout << negat[it2];
it2++;
}
} else if (st[i] == '+') {
last = 0;
cout << st[i];
} else if (st[i] == '-') {
last = 1;
cout << st[i];
} else
cout << st[i];
}
cout << endl;
} else if (jmlpos - jmlneg > n) {
piv = jmlpos - jmlneg;
for (i = 0; i < negat.size(); ++i) {
l = 0;
r = n - 1;
while (l <= r) {
mid = (l + r) / 2;
if (piv - mid >= n) {
l = mid + 1;
} else
r = mid - 1;
}
piv = piv - (l - 1);
negat[i] = l;
}
if (piv == n) {
last = 0;
cout << "Possible" << endl;
for (i = 0; i < len; ++i) {
if (st[i] == '?') {
if (last == 0) {
cout << posit[it1];
it1++;
} else if (last == 1) {
cout << negat[it2];
it2++;
}
} else if (st[i] == '+') {
last = 0;
cout << st[i];
} else if (st[i] == '-') {
last = 1;
cout << st[i];
} else
cout << st[i];
}
cout << endl;
} else
cout << "Impossible" << endl;
} else if (jmlpos - jmlneg < n) {
piv = jmlpos - jmlneg;
for (i = 0; i < posit.size(); ++i) {
l = 0;
r = n - 1;
while (l <= r) {
mid = (l + r) / 2;
if (piv + mid <= n) {
l = mid + 1;
} else
r = mid - 1;
}
piv = piv + (l - 1);
posit[i] = l;
}
if (piv == n) {
last = 0;
cout << "Possible" << endl;
for (i = 0; i < len; ++i) {
if (st[i] == '?') {
if (last == 0) {
cout << posit[it1];
it1++;
} else if (last == 1) {
cout << negat[it2];
it2++;
}
} else if (st[i] == '+') {
last = 0;
cout << st[i];
} else if (st[i] == '-') {
last = 1;
cout << st[i];
} else
cout << st[i];
}
cout << endl;
} else
cout << "Impossible" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1007;
char s[NMAX];
int nrm, nrp;
int main() {
gets(s + 2);
s[0] = '+';
s[1] = ' ';
int n = strlen(s) - 1;
for (int i = 0; i <= n; ++i) {
if (s[i] == '-') {
++nrm;
}
if (s[i] == '+') {
++nrp;
}
}
int sum = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] >= '0' && s[i] <= '9') {
sum = sum * 10 + s[i] - '0';
}
}
int S = sum;
sum += nrm;
int ok = 0;
if (sum % nrp > 0) {
ok = 1;
} else {
ok = 0;
}
if (sum / nrp + ok > S || sum / nrp < 1) {
sum -= nrm;
swap(nrm, nrp);
sum = nrm - sum;
ok = 0;
if (nrp == 0) {
cout << "Impossible";
return 0;
}
if (sum % nrp > 0) {
ok = 1;
} else {
ok = 0;
}
if (sum / nrp + ok > S || sum / nrp < 1 || sum < 0) {
cout << "Impossible";
} else {
cout << "Possible\n";
int cat = sum / nrp;
int rest = sum % nrp;
for (int i = 2; i <= n; ++i) {
if (s[i] == '?') {
if (s[i - 2] == '-') {
if (rest > 0) {
cout << cat + 1;
--rest;
} else {
cout << cat;
}
}
if (s[i - 2] == '+') {
cout << 1;
}
} else {
cout << s[i];
}
}
}
} else {
cout << "Possible\n";
int cat = sum / nrp;
int rest = sum % nrp;
for (int i = 2; i <= n; ++i) {
if (s[i] == '?') {
if (s[i - 2] == '+') {
if (rest > 0) {
cout << cat + 1;
--rest;
} else {
cout << cat;
}
}
if (s[i - 2] == '-') {
cout << 1;
}
} else {
cout << s[i];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<char> v;
int main() {
int num = 0;
int plus = 1;
int mins = 0;
char c = ' ';
while (c != '=') {
cin >> c;
v.push_back(c);
if (c == '-')
mins++;
else if (c == '+')
plus++;
else if (c == '?')
num++;
}
int a;
cin >> a;
int x = a;
a += mins;
if (a / plus != 0) {
if ((a / plus) <= x && a % plus == 0) {
cout << "Possible" << endl;
cout << a / plus << " ";
for (int i = 1; i < v.size(); ++i) {
if (v[i] == '+') {
cout << "+ " << a / plus << " ";
++i;
} else if (v[i] == '-') {
cout << "- " << 1 << " ";
++i;
} else if (v[i] == '=') {
cout << "= " << x << endl;
break;
}
}
} else if ((a / plus) < x && a % plus != 0) {
cout << "Possible" << endl;
int h = a % plus - 1;
cout << (a / plus) + 1 << " ";
for (int i = 1; i < v.size(); ++i) {
if (v[i] == '+') {
cout << "+ ";
if (h != 0)
cout << (a / plus) + 1 << " ", --h;
else
cout << (a / plus) << " ";
++i;
} else if (v[i] == '-') {
cout << "- " << 1 << " ";
++i;
} else if (v[i] == '=') {
cout << "= " << x << endl;
break;
}
}
} else {
cout << "Impossible" << endl;
return 0;
}
} else {
a -= mins;
int fra = plus - a;
if (mins != 0 && (fra / mins) <= x && fra % mins == 0) {
cout << "Possible" << endl;
cout << 1 << " ";
for (int i = 1; i < v.size(); ++i) {
if (v[i] == '+') {
cout << "+ " << 1 << " ";
++i;
} else if (v[i] == '-') {
cout << "- " << fra / mins << " ";
++i;
} else if (v[i] == '=') {
cout << "= " << x << endl;
break;
}
}
} else if (mins != 0 && (fra / mins) < x && fra % mins != 0) {
cout << "Possible" << endl;
int h = fra % mins;
cout << 1 << " ";
for (int i = 1; i < v.size(); ++i) {
if (v[i] == '+') {
cout << "+ ";
cout << 1 << " ";
++i;
} else if (v[i] == '-') {
if (h != 0) {
cout << "- " << (fra / mins) + 1 << " ";
--h;
} else
cout << "- " << (fra / mins) << " ";
++i;
} else if (v[i] == '=') {
cout << "= " << x << endl;
break;
}
}
} else {
cout << "Impossible" << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int pp[maxn], mm[maxn];
char s[maxn];
int main(void) {
int len = 0;
char c = getchar();
while (c != '\n') {
s[len++] = c;
c = getchar();
}
int p = 0, m = 0;
int ans = 0;
bool flg = false;
for (int i = 0; i < len; i++) {
if (s[i] == '-')
m++;
else if (s[i] == '+')
p++;
if (s[i - 2] == '=') flg = true;
if (flg) ans = ans * 10 + s[i] - '0';
}
p++;
int minn = ans + m;
int maxx = ans * p;
int cha = maxx - minn;
for (int i = 0; i < p; i++) pp[i] = ans;
for (int i = 0; i < m; i++) mm[i] = 1;
if (cha < 0)
cout << "Impossible" << endl;
else {
int t = 0;
while (cha && t < p) {
if (cha >= pp[t]) {
cha -= pp[t] - 1;
pp[t] = 1;
} else {
pp[t] -= cha;
cha = 0;
}
t++;
}
t = 0;
while (cha && t < m) {
if (cha >= ans - mm[t]) {
cha -= ans - mm[t];
mm[t] = ans;
} else {
mm[t] += cha;
cha = 0;
}
t++;
}
if (cha)
return cout << "Impossible" << endl, 0;
else
cout << "Possible" << endl;
int tt = 0;
t = 0;
for (int i = 0; i < len; i++) {
if (i == 0)
cout << pp[i];
else if (s[i] == '?' && s[i - 2] == '-')
cout << mm[t++];
else if (s[i] == '?' && s[i - 2] == '+')
cout << pp[++tt];
else
cout << s[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::string init_str;
std::getline(std::cin, init_str);
std::regex re("\[\+|\-]|[0-9]+");
std::vector<string> sign;
for (std::sregex_iterator
it = std::sregex_iterator(init_str.begin(), init_str.end(), re),
end;
it != end; ++it) {
sign.push_back(it->str());
}
int res = std::stoi(sign.back());
sign.pop_back();
vector<int> isigned, iunsigned;
if (init_str[0] == '?')
iunsigned.push_back(1);
else
isigned.push_back(1);
for (string& to : sign) {
if (to == "-")
isigned.push_back(1);
else
iunsigned.push_back(1);
}
int cur_res = iunsigned.size() - isigned.size();
size_t sig_idx = 0, unsig_idx = 0;
while (cur_res != res &&
(unsig_idx < iunsigned.size() || sig_idx < isigned.size())) {
if (cur_res < res && unsig_idx < iunsigned.size()) {
while (iunsigned[unsig_idx] < res && cur_res != res) {
iunsigned[unsig_idx]++;
cur_res++;
}
unsig_idx++;
} else if (cur_res > res && sig_idx < isigned.size()) {
while (isigned[sig_idx] < res && cur_res != res) {
isigned[sig_idx]++;
cur_res--;
}
sig_idx++;
} else {
sig_idx++;
unsig_idx++;
}
}
if (cur_res != res) {
cout << "Impossible";
return 0;
}
sig_idx = 0;
unsig_idx = 0;
cout << "Possible" << endl;
if (init_str[0] == '?') {
cout << std::to_string(iunsigned[unsig_idx]);
unsig_idx++;
} else {
cout << "- " + std::to_string(isigned[sig_idx]);
sig_idx++;
}
for (string& to : sign) {
if (to == "-") {
cout << " - " << isigned[sig_idx++];
} else {
cout << " + " << iunsigned[unsig_idx++];
}
}
cout << " = " << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int pcount = 1, ncount = 0;
vector<char> oplist;
while (true) {
char op;
cin >> op;
switch (op) {
case '+':
++pcount;
oplist.push_back(op);
continue;
case '-':
++ncount;
oplist.push_back(op);
continue;
case '?':
continue;
case '=':
goto OUT;
}
}
OUT:
int N;
cin >> N;
int pmin = pcount;
int pmax = pcount * N;
int nmin = ncount;
int nmax = ncount * N;
if (N < pmin - nmax || N > pmax - nmin) {
cout << "Impossible";
return 0;
}
cout << "Possible\n";
int ptotal, ntotal;
if (nmin + N >= pmin) {
ntotal = nmin;
ptotal = nmin + N;
} else {
ptotal = pmin;
ntotal = pmin - N;
}
if (ncount == 0) ncount = 1;
int pavg = ptotal / pcount;
int pfirst = ptotal % pcount;
int navg = ntotal / ncount;
int nfirst = ntotal % ncount;
if (pfirst > 0) {
cout << pavg + 1;
--pfirst;
} else {
cout << pavg;
}
for (auto op : oplist) {
switch (op) {
case '+':
cout << " + ";
if (pfirst > 0) {
cout << pavg + 1;
--pfirst;
} else
cout << pavg;
break;
case '-':
cout << " - ";
if (nfirst > 0) {
cout << navg + 1;
--nfirst;
} else
cout << navg;
break;
}
}
cout << " = " << N;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string inp, ans;
int plscnt = 0, mnscnt = 0, n = 0;
getline(cin, inp);
int i = 0;
while (i < inp.size()) {
if (inp[i] == '=') {
i += 2;
while (i < inp.size()) n = 10 * n + inp[i++] - '0';
break;
} else if (inp[i] == '+')
plscnt++;
else if (inp[i] == '-')
mnscnt++;
i++;
}
plscnt++;
int mn = plscnt - n * mnscnt;
int mx = n * (plscnt)-mnscnt;
if (n > mx || n < mn) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
i = 0;
int currsm = 0, sgn = 1;
while (inp[i] != '=') {
if (inp[i] == ' ') {
i++;
continue;
}
if (inp[i] == '+') {
sgn = 1;
cout << "+ ";
i++;
continue;
} else if (inp[i] == '-') {
sgn = -1;
cout << "- ";
i++;
continue;
}
sgn == 1 ? plscnt-- : mnscnt--;
for (int nxtnum = 1; nxtnum <= n; nxtnum++) {
if ((currsm + nxtnum * sgn + plscnt * n - mnscnt >= n) &&
(currsm + nxtnum * sgn + plscnt - n * mnscnt <= n)) {
cout << nxtnum << " ";
currsm += nxtnum * sgn;
break;
}
}
i++;
}
cout << "= " << n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, p = 0, ne = 0;
char ch = '0';
vector<char> ord{'+'};
while (cin >> ch && ch != '=') {
if (ch == '?') {
p++;
} else if (ch == '-') {
ne--;
ord.push_back('-');
}
if (ch == '+') {
ord.push_back('+');
}
}
cin >> n;
if (n < p + ne + n * ne || ((p + ne) * n) + ne < n) {
cout << "Impossible";
return;
}
vector<int> ans(ord.size());
for (int i = 0; i < ord.size(); i++) {
ans[i] = ('+' == ord[i] ? n : 1);
}
int rm = (p + ne) * n;
int f = n;
p += ne;
n -= ne;
for (int i = 0; i < ord.size(); i++) {
if (ord[i] == '-') {
continue;
}
int x = min(ans[i] - 1, rm - n);
ans[i] -= x;
p--;
rm -= x;
}
for (int i = 0; i < ord.size(); i++) {
if (ord[i] == '+') {
continue;
}
int x = min(f - 1, rm - n);
ans[i] += x;
p--;
rm -= x;
}
cout << "Possible\n";
for (int i = 0; i < ord.size(); i++) {
if (!i) {
cout << ans[i] << " ";
} else {
cout << ord[i] << " " << ans[i] << " ";
}
}
cout << "= " << f;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tq = 1;
for (; tq; tq--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
v.push_back(1);
int n;
while (1) {
char c;
scanf("%c", &c);
if (c == '?') continue;
if (c == '=') {
cin >> n;
break;
}
if (c == '-') v.push_back(-1);
if (c == '+') v.push_back(1);
}
int pl = 0, mi = 0, k = v.size();
for (int i = 0; i < k; i++) {
if (v[i] < 0)
mi++;
else
pl++;
}
if (n > (pl * n - mi * 1)) {
cout << "Impossible" << endl;
return 0;
}
if (n < (pl * 1 - mi * n)) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
int ans[1010];
for (int i = 1; i <= k; i++) {
if (v[i - 1] == -1)
ans[i] = n;
else
ans[i] = 1;
}
int dif = n - (pl * 1 - mi * n);
for (int i = 1; i <= k; i++) {
if (dif == 0) break;
if (v[i - 1] == -1) {
while (ans[i] > 1) {
ans[i]--;
dif--;
if (dif == 0) break;
}
if (dif == 0) break;
} else {
while (ans[i] < n) {
ans[i]++;
dif--;
if (dif == 0) break;
}
}
}
cout << ans[1] << " ";
for (int i = 2; i <= k; i++) {
if (v[i - 1] == -1)
cout << "- ";
else
cout << "+ ";
cout << ans[i] << " ";
}
cout << "= " << n << endl;
}
|
#include <bits/stdc++.h>
const int oo = INT_MAX;
const long long int OO = (1LL << 62);
using namespace std;
template <typename Iter>
std::ostream& _out(std::ostream& s, Iter b, Iter e) {
s << "[";
for (auto it = b; it != e; it++) s << (it == b ? "" : " ") << *it;
s << "]";
return s;
}
template <typename A, typename B>
std::ostream& operator<<(std::ostream& s, const std::pair<A, B>& p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
std::ostream& operator<<(std::ostream& s, const std::vector<T>& c) {
return _out(s, begin(c), end(c));
}
template <typename T>
std::ostream& operator<<(std::ostream& s, const std::set<T>& c) {
return _out(s, begin(c), end(c));
}
template <typename A, typename B>
std::ostream& operator<<(std::ostream& s, const std::map<A, B>& c) {
return _out(s, begin(c), end(c));
}
template <typename T>
void _dump(const char* s, T&& head) {
std::cerr << s << "=" << head << std::endl;
}
template <typename T, typename... Args>
void _dump(const char* s, T&& head, Args&&... tail) {
int c = 0;
while (*s != ',' || c != 0) {
if (*s == '(' || *s == '[' || *s == '{') c++;
if (*s == ')' || *s == ']' || *s == '}') c--;
std::cerr << *s++;
}
std::cerr << "=" << head << ", ";
_dump(s + 1, tail...);
}
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
int ceil(int x, int y) { return x / y + (x % y != 0); }
int main() {
string input;
getline(cin, input);
istringstream iss(input);
vector<string> tokens;
copy(istream_iterator<string>(iss), istream_iterator<string>(),
back_inserter(tokens));
int plus = 0, minus = 0;
int ans = 0;
int n = atoi(tokens.back().c_str());
for (int i = 0; i < tokens.size(); ++i) {
if (i == 0)
plus++;
else if (tokens[i - 1] == "+")
plus++;
else if (tokens[i - 1] == "-")
minus++;
}
vector<int> pluses, minuses;
do {
fprintf(stderr, "%s:%d - ", __PRETTY_FUNCTION__, 74);
_dump("plus", plus);
} while (0);
;
do {
fprintf(stderr, "%s:%d - ", __PRETTY_FUNCTION__, 75);
_dump("minus", minus);
} while (0);
;
if (ceil(minus + n, plus) > n or (minus > 0 and ceil(plus - n, minus) > n) or
(minus == 0 and plus > n)) {
cout << "Impossible\n";
return 0;
}
cout << "Possible\n";
if (plus - n >= minus) {
pluses.insert(pluses.end(), plus, 1);
if (minus) {
minuses.insert(minuses.end(), minus, (plus - n) / minus);
for (int i = 0; i < (plus - n) % minus; ++i) minuses[i]++;
}
} else {
minuses.insert(minuses.end(), minus, 1);
pluses.insert(pluses.end(), plus, (minus + n) / plus);
for (int i = 0; i < (minus + n) % plus; ++i) pluses[i]++;
}
string output;
for (int i = 0; i < tokens.size(); ++i) {
string output_token = tokens[i];
if (i == 0 or tokens[i - 1] == "+") {
output_token = to_string(pluses.front());
pluses.erase(pluses.begin());
} else if (tokens[i - 1] == "-") {
output_token = to_string(minuses.front());
minuses.erase(minuses.begin());
}
output += (output_token + " ");
}
cout << output << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int arr[111111], st[111111] = {0}, x = 0, y = 0, top = 0, i, a, b, c, d;
string str;
getline(cin, str);
for (i = 0; i < str.size(); i++) {
a = str[i] - 48;
if (a >= 0 && a <= 9) {
if (x == 0)
x = a;
else {
x *= 10;
x += a;
}
}
}
for (i = 0; i < str.size(); i++) {
if (str[i] == '?') {
arr[top] = 0;
top++;
} else if (str[i] == '+') {
arr[top] = -1;
top++;
} else if (str[i] == '-') {
arr[top] = -2;
top++;
} else if (str[i] == '=')
break;
}
a = 0;
for (i = 0; i < top; i++) {
if (arr[i] == 0 && i == 0) {
arr[i] = 1;
a += 1;
} else if (arr[i] == 0 && arr[i - 1] == -1) {
arr[i] = 1;
a += 1;
} else if (arr[i] == 0 && arr[i - 1] == -2) {
arr[i] = 1;
a -= 1;
}
}
if (a < x) {
for (i = 0; i < top; i++) {
if (a == x) break;
if (i == 0) {
b = x - arr[i];
c = x - a;
if (c > b) {
arr[i] = x;
a += b;
} else {
arr[i] = c + arr[i];
a = x;
}
} else if (arr[i - 1] == -1) {
b = x - arr[i];
c = x - a;
if (c > b) {
arr[i] = x;
a += b;
} else {
arr[i] = c + arr[i];
a = x;
}
}
}
} else if (a > x) {
for (i = 0; i < top; i++) {
if (a == x) break;
if (arr[i - 1] == -2) {
b = x - arr[i];
c = a - x;
if (c > b) {
arr[i] = x;
a -= b;
} else {
arr[i] = c + arr[i];
a = x;
}
}
}
}
if (a == x) {
cout << "Possible\n";
for (i = 0; i < top; i++) {
if (arr[i] == -1)
cout << '+' << ' ';
else if (arr[i] == -2)
cout << '-' << ' ';
else
cout << arr[i] << ' ';
}
cout << ' ' << '=' << ' ' << x << endl;
} else
cout << "Impossible\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l, i, a[10000], t, tot, p, ans, c[10000], cc, d[10000], dd, ccc, ddd, q;
bool bo;
string s;
int main() {
cin >> s;
l = s.length();
bo = true;
while (l == 1 && (s[0] < 48 || s[0] > 57)) {
if (s[0] == '?') {
a[++t] = bo ? 1 : -1;
if (bo)
c[++cc] = t;
else
d[++dd] = t;
}
if (s[0] == '-') bo = false;
if (s[0] == '+') bo = true;
cin >> s;
l = s.length();
}
p = 1;
for (i = l - 1; i >= 0; i--) {
tot = tot + p * (s[i] - 48);
p = p * 10;
}
for (i = 1; i <= t; i++) ans = ans + a[i];
if (cc * tot - dd < tot || cc - tot * dd > tot) {
printf("Impossible");
return 0;
}
ccc = 1;
ddd = 1;
while (ans != tot) {
if (ans < tot) {
q = tot - ans;
if (tot - a[c[ccc]] >= q) {
a[c[ccc]] += q;
ans += q;
} else {
ans = ans + (tot - a[c[ccc]]);
a[c[ccc]] = a[c[ccc]] + (tot - a[c[ccc]]);
ccc++;
}
}
if (ans > tot) {
q = ans - tot;
if (tot - abs(a[d[ddd]]) >= q) {
a[d[ddd]] -= q;
ans -= q;
} else {
ans = ans - (tot - abs(a[d[ddd]]));
a[d[ddd]] = a[d[ddd]] - (tot - abs(a[d[ddd]]));
ddd++;
}
}
if (ccc > cc && ans < tot) break;
if (ddd > dd && ans > tot) break;
}
if (ans != tot)
printf("Impossible");
else {
printf("Possible\n");
printf("%d ", a[1]);
for (i = 2; i <= t; i++) {
if (a[i] > 0)
printf("+ ");
else
printf("- ");
printf("%d ", abs(a[i]));
}
printf("= %d", tot);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15);
int N;
string str;
vector<bool> signs;
bool sign = true;
while (cin >> str) {
if (str == "=") break;
if (str == "?") {
signs.push_back(sign);
} else
sign = str == "+";
}
cin >> N;
int T = signs.size();
vector<int> lo(T + 1, N), hi(T + 1, N);
for (int i = T - 1; i >= 0; i--) {
if (signs[i]) {
lo[i] = lo[i + 1] - N;
hi[i] = hi[i + 1] - 1;
} else {
lo[i] = lo[i + 1] + 1;
hi[i] = hi[i + 1] + N;
}
}
if (hi[0] < 0 || lo[0] > 0) {
cout << "Impossible\n";
return 0;
}
cout << "Possible\n";
int cur = 0;
for (int i = 0; i < T; i++) {
if (i > 0) cout << (signs[i] ? " + " : " - ");
if (signs[i]) {
int val = max(1, lo[i + 1] - cur);
cout << val;
cur += val;
} else {
int val = max(1, cur - hi[i + 1]);
cout << val;
cur -= val;
}
}
cout << " = " << N << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
getline(cin, s);
long long ok = 0;
long long plus = 0, minus = 0;
vector<long long> digit;
for (char c : s) {
if (c == '?') {
if (!ok)
plus++;
else
minus++;
} else if (c == '+' || c == '-') {
if (c == '+')
ok = 0;
else
ok = 1;
} else if (c >= '0' && c <= '9') {
digit.push_back(c - '0');
}
}
long long num = 0, mul = 1;
for (long long i = digit.size() - 1; i >= 0; i--) {
num += (mul * digit[i]);
mul = mul * 10;
}
if (plus == minus) {
if (plus == 1 || num == 1) {
cout << "Impossible"
<< "\n";
return 0;
}
cout << "Possible"
<< "\n";
int first = 0;
ok = 0;
for (char c : s) {
if (c == '?') {
if (!ok) {
if (!first) {
cout << num;
first = 1;
} else if (first == 1) {
cout << 2;
first = 2;
} else {
cout << 1;
}
} else {
cout << 1;
}
} else {
if (c == '-') ok = 1;
if (c == '+') ok = 0;
cout << c;
}
}
cout << "\n";
return 0;
} else if (plus > minus) {
long long now = num + (minus * num), sum = 0;
vector<long long> tot;
if (now / plus == 0 || now / plus > num) {
cout << "Impossible"
<< "\n";
return 0;
}
cout << "Possible"
<< "\n";
for (int i = 0; i < plus; i++) tot.push_back(0);
int idx = 0;
while (now--) {
tot[idx]++;
idx++;
if (idx == plus) idx = 0;
}
for (int i = 0; i < plus; i++) {
if (tot[i] > num) {
cout << "Impossible"
<< "\n";
return 0;
}
}
ok = 0;
idx = 0;
for (char c : s) {
if (c == '?') {
if (!ok) {
cout << tot[idx];
idx++;
} else {
cout << num;
}
} else {
if (c == '+') ok = 0;
if (c == '-') ok = 1;
cout << c;
}
}
cout << "\n";
return 0;
} else {
long long now = (plus - 1) * num, sum = 0;
vector<long long> tot;
if (now / minus == 0) {
cout << "Impossible"
<< "\n";
return 0;
}
cout << "Possible"
<< "\n";
for (int i = 0; i < minus; i++) tot.push_back(0LL);
int idx = 0;
while (now--) {
tot[idx]++;
idx++;
if (idx == minus) idx = 0;
}
for (int i = 0; i < minus; i++) {
if (tot[i] > num) {
cout << "Impossible"
<< "\n";
return 0;
}
}
ok = 0;
idx = 0;
for (char c : s) {
if (c == '?') {
if (!ok) {
cout << num;
} else {
cout << tot[idx];
idx++;
}
} else {
if (c == '+') ok = 0;
if (c == '-') ok = 1;
cout << c;
}
}
cout << "\n";
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
getline(cin, str);
int arr[200], counter = 1, n, sum = 1;
arr[0] = 1;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '+') {
arr[counter] = 1;
counter++;
sum++;
} else if (str[i] == '-') {
arr[counter] = -1;
counter++;
sum--;
} else if (str[i] == '=') {
istringstream s(str.substr(i + 1, str.length() - (i + 1)));
s >> n;
}
}
for (int i = 0; i < counter; i++) {
if (sum < n) {
while (arr[i] > 0 && arr[i] < n && sum < n) {
sum++;
arr[i]++;
}
if (arr[i] < -1) {
while (arr[i] < -1 && sum < n) {
sum++;
arr[i]++;
}
}
} else if (sum > n) {
while (arr[i] < 0 && abs(arr[i]) < n && sum > n) {
sum--;
arr[i]--;
}
if (arr[i] > 1) {
while (arr[i] > 1 && sum > n) {
sum--;
arr[i]--;
}
}
} else if (sum == n)
break;
}
if (sum != n) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
cout << arr[0];
for (int i = 1; i < counter; i++) {
if (arr[i] > 0)
cout << " + ";
else if (arr[i] < 0)
cout << " - ";
cout << abs(arr[i]);
}
cout << " = " << n;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void printInt(int a) { printf("%d", a); }
inline void printDbl(double a) { printf("%.10lf", a); }
inline int getInt() {
int res;
scanf("%d", &res);
return res;
}
inline double getDbl() {
double res;
scanf("%lf", &res);
return res;
}
const int maxn = 100;
const int maxs = 210 * 100 * 2;
int sign[maxn];
int a[maxn][maxn];
bool can[maxn][maxn];
int ans[maxn];
int n = 0;
int inits;
int d;
void print() {
printf("Possible\n");
for (int i = (0); i < (n); i++) {
if (i != 0) printf("%c ", sign[i] == 1 ? '+' : '-');
printf("%d ", ans[i] + 1);
}
printf("= %d", inits);
}
int main() {
srand(time(0));
sign[0] = 1;
int plus = 1;
int minus = 0;
while (true) {
char c;
scanf("%c", &c);
assert(c == '?');
n++;
scanf("%c", &c);
assert(c == ' ');
scanf("%c", &c);
assert(c == '-' || c == '+' || c == '=');
if (c == '=') {
break;
}
sign[n] = c == '-' ? -1 : +1;
if (c == '-')
minus++;
else
plus++;
scanf("%c", &c);
assert(c == ' ');
}
d = plus - minus;
int s = getInt();
int lim = s - 1;
inits = s;
s -= d;
vector<int> ms;
vector<int> ps;
int mR = minus * lim;
int pR = plus * lim;
if (-mR <= s && s <= pR) {
if (s < 0) {
while (s < 0) {
int v = min(-s, lim);
ms.push_back(v);
s += v;
}
} else {
while (s > 0) {
int v = min(s, lim);
ps.push_back(v);
s -= v;
}
}
for (int i = (0); i < (n); i++) {
if (sign[i] == 1 && ((int)(ps).size()) > 0) {
ans[i] = ps[((int)(ps).size()) - 1];
ps.pop_back();
}
if (sign[i] == -1 && ((int)(ms).size()) > 0) {
ans[i] = ms[((int)(ms).size()) - 1];
ms.pop_back();
}
}
print();
} else {
printf("Impossible");
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int POS[101], NEG[101];
int main() {
int n = 0, i = 0, P = 1, N = 0;
string x;
getline(cin, x);
for (i = 0; x[i] != '='; i++)
if (x[i] == '+')
P++;
else if (x[i] == '-')
N++;
for (int j = x.size() - 1, T = 1; j > i + 1; j--, T *= 10)
n += T * (x[j] - '0');
if (n > n * P - N || n < P - n * N)
cout << "Impossible" << endl;
else {
cout << "Possible" << endl;
if (n > P - N)
for (int i = 0, a, m = n - (P - N); i < P; i++)
a = min(m, n - 1), m -= a, POS[i] = a;
else if (n < P - N)
for (int i = 0, a, m = (P - N) - n; i < N; i++)
a = min(m, n - 1), m -= a, NEG[i] = a;
char c = '+';
for (int i = 0, j = 0, k = 0; i < x.size(); i++) {
if (x[i] == '?')
if (c == '+')
cout << POS[j] + 1, j++;
else
cout << NEG[k] + 1, k++;
else if (x[i] == '+')
c = '+', cout << x[i];
else if (x[i] == '-')
c = '-', cout << x[i];
else
cout << x[i];
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.