text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long N = 1e9 + 7;
long long i, j, x, y, z, m, n, k, l, r, f, mi = 1e9, ans, x2, y2, nV, t, ma = 0,
sq, dp[1011010], a[1011010], x3, y3,
x4, y4;
string s;
vector<long long> v[101000];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> s;
x = 0;
if (s == "?")
x = 1e18;
else if (s[0] == '-') {
y = 1;
for (j = s.size() - 1; j > 0; j--) {
x += y * (s[j] - '0');
y *= 10;
}
x *= -1;
} else {
y = 1;
for (j = s.size() - 1; j >= 0; j--) {
x += y * (s[j] - '0');
y *= 10;
}
}
v[i % m].push_back(x);
}
for (i = 0; i < m; i++) {
x = -1;
y = -1e18;
v[i].push_back(1e17);
for (j = 0; j < v[i].size(); j++) {
if (v[i][j] == 1e18) continue;
if (j != 0 && v[i][j - 1] == 1e18) {
l = y;
r = v[i][j];
if (r - l < j - x) {
f = -1;
break;
}
if (l <= 0 && r <= 0) {
t = r - 1;
for (k = j - 1; k > x; k--) {
v[i][k] = t;
t--;
}
} else if (l >= 0 && r >= 0) {
t = l + 1;
for (k = x + 1; k <= j - 1; k++) {
v[i][k] = t;
t++;
}
} else {
int l2 = -(j - x - 1) / 2, r2 = (j - x - 2) / 2;
if (l2 < l + 1) {
t = l + 1 - l2;
l2 += t;
r2 += t;
}
if (r2 > r - 1) {
t = r2 - (r - 1);
l2 -= t;
r2 -= t;
}
for (k = x + 1; k < j; k++) {
v[i][k] = l2;
l2++;
}
}
} else if (j != 0) {
if (v[i][j] - v[i][j - 1] <= 0) {
f = -1;
break;
}
}
x = j;
y = v[i][j];
}
}
if (f == -1) {
cout << "Incorrect sequence";
} else {
for (i = 1; i <= n; i++) {
cout << v[i % m][(i - 1) / m] << ' ';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[1200000], i, j, kk, p[1200000], e, lst, s, pl[1200000];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
if (ch == '?') return 2e9 + 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int main() {
cin >> n >> k;
p[0] = -2e9 - 2;
for (i = 1; i <= n; ++i) {
a[i] = read();
}
for (i = 1; i <= k; ++i) {
s = i;
e = 0;
lst = 0;
while (s <= n) {
p[++e] = a[s];
if (p[e] != 2e9 + 1) pl[e] = lst, lst = e;
s += k;
}
p[e + 1] = 2e9 + 2;
pl[e + 1] = lst;
for (j = 1; j <= e + 1; ++j) {
if (p[j] != 2e9 + 1) {
if (p[j] - p[pl[j]] < j - pl[j]) {
cout << "Incorrect sequence";
return 0;
}
if (p[j] >= 0 && p[pl[j]] >= 0) {
for (kk = pl[j] + 1; kk < j; ++kk) p[kk] = p[pl[j]] + kk - pl[j];
} else if (p[j] < 0 && p[pl[j]] < 0) {
for (kk = j - 1; kk > pl[j]; --kk) p[kk] = p[j] - j + kk;
} else {
int mid = (pl[j] + j) >> 1;
if (mid - pl[j] >= -p[pl[j]]) mid = pl[j] - p[pl[j]];
if (j - mid > p[j]) mid = j - p[j];
for (kk = j - 1; kk > pl[j]; --kk) p[kk] = kk - mid;
}
}
}
for (j = 1; j <= e; ++j)
if (p[j] <= p[j - 1] || p[j] > 2e9 || p[j] < -2e9) {
cout << "Incorrect sequence";
return 0;
} else
a[(j - 1) * k + i] = p[j];
}
for (i = 1; i <= n; ++i) printf("%lld ", a[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int INF = 2000000000;
int n, a[MAXN], b[MAXN], sub[MAXN], tot, k;
int getint() {
char c = getchar();
int con = 0, f = 1;
while (c != '-' && c != '?' && (c < '0' || c > '9')) c = getchar();
if (c == '?') return INF;
if (c == '-') f = -f;
if (c == '-') c = getchar();
while (c >= '0' && c <= '9') con = con * 10 + c - '0', c = getchar();
return con * f;
}
int main() {
n = getint(), k = getint();
for (int i = 1; i <= n; i++) a[i] = getint();
for (int T = 1; T <= k; T++) {
tot = 0;
for (int i = T; i <= n; i += k) b[++tot] = a[i], sub[tot] = i;
int r = 0;
b[0] = -INF + 1;
b[++tot] = INF - 1;
while (r < tot) {
int L = b[r], l = r;
while (b[r + 1] == INF && r + 1 <= tot) r++;
r++;
int R = b[r];
if (R <= 0) {
for (int i = r - 1; i > l; i--) b[i] = b[i + 1] - 1, a[sub[i]] = b[i];
} else if (L >= 0) {
for (int i = l + 1; i < r; i++) b[i] = b[i - 1] + 1, a[sub[i]] = b[i];
} else {
int len = r - l - 1;
if (len != 0) b[l + 1] = -(len / 2), a[sub[l + 1]] = b[l + 1];
for (int i = l + 2; i < r; i++) b[i] = b[i - 1] + 1, a[sub[i]] = b[i];
if (b[r - 1] >= b[r])
for (int i = r - 1; i > l; i--) b[i] = b[i + 1] - 1, a[sub[i]] = b[i];
if (b[l + 1] <= b[l])
for (int i = l + 1; i < r; i++) b[i] = b[i - 1] + 1, a[sub[i]] = b[i];
}
}
}
for (int i = 1; i <= n - k; i++)
if (a[i] >= a[i + k]) {
puts("Incorrect sequence");
return 0;
}
for (int i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long q[2 * 100010];
int head, tail;
vector<int> b;
long long a[100010];
int n, k;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
char s[12];
scanf("%s", s);
if (s[0] == '?')
a[i] = 1e18;
else if (s[0] == '-') {
a[i] = 0;
for (int j = 1; j < strlen(s); j++) a[i] = a[i] * 10 - (s[j] - '0');
} else {
a[i] = 0;
for (int j = 0; j < strlen(s); j++) a[i] = a[i] * 10 + (s[j] - '0');
}
}
for (int i = 0; i < n; i++) {
if (a[i] == 1e18) {
long long down, up;
b.clear();
int j = i;
b.push_back(i);
while (j + k < n && a[j + k] == 1e18) {
b.push_back(j + k);
j += k;
}
if (i - k >= 0)
down = a[i - k];
else
down = -1e18;
if (j + k < n)
up = a[j + k];
else
up = 1e18;
head = tail = 0;
for (int p = -b.size() + 1; p <= 0; p++) q[tail++] = p;
while (abs(q[head]) > q[tail - 1] + 1) {
head++;
q[tail] = q[tail - 1] + 1;
tail++;
}
if (down >= q[head]) {
for (int p = 0; p < b.size(); p++) a[b[p]] = down + p + 1;
} else if (up <= q[tail - 1]) {
for (int p = 0; p < b.size(); p++)
a[b[p]] = (long long)(up - b.size() + p);
} else {
for (int p = 0; p < b.size(); p++) a[b[p]] = q[p + head];
}
}
}
int flag = 1;
for (int i = 0; i < n; i++) {
if (i + k < n && a[i + k] <= a[i]) {
flag = 0;
break;
}
}
if (flag) {
printf("%d", a[0]);
for (int i = 1; i < n; i++) printf(" %d", a[i]);
printf("\n");
} else
printf("Incorrect sequence\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 23, inf = 0x3f3f3f3f;
long long a[N];
inline long long inp() {
long long c = getchar(), x = 0;
bool neg = 0;
for (; ((c < 48 or c > 57) and c != '-' and c != '?'); c = getchar())
;
if (c == '?') return inf;
if (c == '-') neg = 1, c = getchar();
for (; c > 47 and c < 58; c = getchar()) x = (x << 1) + (x << 3) + c - 48;
return neg ? -x : x;
}
bool fix(long long st, long long en, long long n, long long k) {
long long lo = (st < 0 ? -inf : a[st]) + 1;
long long hi = (en >= n ? inf : a[en]) - 1;
long long num = (en - st) / k - 1;
if (hi - lo + 1 < num) return false;
if (lo >= 0) {
for (long long i = st + k; i < en; i += k) a[i] = lo++;
return true;
}
if (hi <= 0) {
for (long long i = en - k; i > st; i -= k) a[i] = hi--;
return true;
}
long long fst = (num - 1) / 2;
long long snd = num / 2;
if (fst > abs(lo)) {
snd += fst - abs(lo);
fst = abs(lo);
} else if (snd > hi) {
fst += snd - hi;
snd = hi;
}
long long cur = -fst;
for (long long i = st + k; i < en; i += k) a[i] = cur++;
return true;
}
bool go(long long r, long long n, long long k) {
long long prev = r - k;
for (long long i = r; i < n; i += k) {
if (a[i] < inf) {
if (prev >= 0 and a[prev] >= a[i]) return false;
prev = i;
continue;
}
while (i < n and a[i] == inf) i += k;
bool can = fix(prev, i, n, k);
if (!can) return false;
prev = i;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n = inp(), k = inp();
for (long long i = 0; i < n; i++) a[i] = inp();
for (long long i = 0; i < k; i++)
if (!go(i, n, k)) {
cout << "Incorrect sequence\n";
return 0;
}
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int N, K;
vector<pair<int, bool> > seq[MAXN];
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
cin >> N >> K;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
if (s[0] == '?') {
seq[i % K].push_back(make_pair(-1, false));
} else {
stringstream ss;
ss << s;
int x;
ss >> x;
seq[i % K].push_back(make_pair(x, true));
}
}
for (int i = 0; i < K; i++) {
seq[i].push_back(make_pair(2e9, true));
}
for (int i = 0; i < K; i++) {
int prvint = -2e9, ind = -1;
vector<pair<int, bool> > &v = seq[i];
for (int j = 0, sz = v.size(); j < sz; j++) {
pair<int, bool> p = v[j];
if (p.second) {
int cur = p.first, diff = j - ind;
if (cur < prvint + diff) {
cout << "Incorrect sequence\n";
return 0;
}
if (cur <= 1) {
int c = cur;
for (int k = j - 1; k >= 0 && !v[k].second; k--) {
v[k] = make_pair(--c, true);
}
} else if (prvint >= -1) {
int c = prvint;
for (int k = ind + 1; k < j; k++) {
v[k] = make_pair(++c, true);
}
} else {
int lt = prvint + 1, rt = cur - 1;
int numt = diff - 1;
if (numt % 2) {
int t = numt / 2;
if (lt <= -t && t <= rt) {
int c = -t;
for (int k = ind + 1; k < j; k++) {
v[k] = make_pair(c++, true);
}
} else if (-lt < rt) {
for (int k = ind + 1; k < j; k++) {
v[k] = make_pair(lt++, true);
}
} else {
for (int k = j - 1; k >= 0 && !v[k].second; k--) {
v[k] = make_pair(rt--, true);
}
}
} else if (numt) {
int t2 = numt / 2, t1 = t2 - 1;
if (lt <= -t1 && t2 <= rt) {
int c = -t1;
for (int k = ind + 1; k < j; k++) {
v[k] = make_pair(c++, true);
}
} else if (lt <= -t2 && t1 <= rt) {
int c = -t2;
for (int k = ind + 1; k < j; k++) {
v[k] = make_pair(c++, true);
}
} else if (-lt < rt) {
for (int k = ind + 1; k < j; k++) {
v[k] = make_pair(lt++, true);
}
} else {
for (int k = j - 1; k >= 0 && !v[k].second; k--) {
v[k] = make_pair(rt--, true);
}
}
}
}
ind = j;
prvint = cur;
}
}
}
for (int i = 0; i < N; i++) {
cout << seq[i % K][i / K].first << ' ';
assert(seq[i % K][i / K].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void set(int& n, int first) { n = n | (1 << first); }
void reset(int& n, int first) { n = n & ~(1 << first); }
bool check(int n, int first) { return (bool)(n & (1 << first)); }
const int mx = 100005;
int a[mx], k;
bool f[mx];
bool fun(int s, int e, int v1, int v2) {
if (v2 <= v1) return false;
int c = (e - s - k) / k;
if (c > v2 - v1 - 1) return false;
int m = -c / 2, st, i;
if (m <= v1) {
st = v1 + 1;
for (i = s + k; i < e; i += k) a[i] = st++;
} else if (m + c >= v2) {
st = v2 - 1;
for (i = e - k; i > s; i -= k) a[i] = st--;
} else {
for (i = s + k; i < e; i += k) a[i] = m++;
}
return true;
}
int main() {
int i, j, n;
while (scanf("%d%d", &n, &k) == 2) {
memset(f, false, sizeof f);
for (i = 1; i <= n; i++) {
char ch, sign = '+';
while (scanf("%c", &ch) && (ch == ' ' || ch == '\n'))
;
int t = 0;
while (true) {
if (ch == '?') {
f[i] = true;
break;
} else if (ch == '-')
sign = '-';
else if (ch == ' ' || ch == '\n')
break;
else
t = t * 10 + ch - '0';
scanf("%c", &ch);
}
if (sign == '-') t = -t;
a[i] = t;
}
int s = -k, e = 0;
a[0] = -2e9;
bool flag = false;
for (i = 1; i <= k; i++) {
int v1 = -1e9 - 1e6, t = 0;
s = i - k;
for (j = i; j <= n; j += k) {
if (f[j])
t++;
else if (s >= i && j > i && a[j] <= a[s])
flag = true;
else {
if (t > 0 && (!fun(s, j, v1, a[j]))) flag = true;
t = 0;
s = j;
v1 = a[j];
}
if (flag) break;
}
if (s < n) {
if (!fun(s, j, v1, 1e9 + 1e6))
;
}
if (flag) break;
}
if (flag)
printf("Incorrect sequence\n");
else {
for (i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%d", a[i]);
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int mod = 2000000007;
const int inf = 50000000;
const int maxn = 100010;
int n, k, A[maxn], notSet[maxn];
vector<int> v[maxn], temp;
string str;
int push(int l, int r, int sz) {
if (1LL * r - l - 1 < sz) {
return 0;
}
temp.clear();
if (l < 0 && r <= 0) {
for (int i = 0; i < sz; i++) {
temp.push_back(r - i - 1);
}
reverse(temp.begin(), temp.end());
} else if (l >= 0 && r > 0) {
for (int i = 0; i < sz; i++) {
temp.push_back(l + i + 1);
}
} else {
int c = 0;
long long sum = 1LL << 50;
for (int i = 0; i < sz; i++) {
if (-l - 1 < i) {
break;
}
if (r - 1 < sz - i - 1) {
continue;
}
long long second =
(1LL * (i - 1) * i) / 2 + (1LL * (sz - i - 1) * (sz - i)) / 2;
if (second < sum) {
sum = second;
c = -i;
}
}
for (int i = 0; i < sz; i++) {
temp.push_back(c);
c += 1;
}
}
return 1;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
cin >> str;
if (str[0] == '?') {
notSet[i] = 1;
A[i] = mod;
} else {
A[i] = stoi(str);
}
v[i % k].push_back(A[i]);
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < v[i].size();) {
if (v[i][j] == mod) {
int p = j;
while (p < v[i].size()) {
if (v[i][p] != mod) {
break;
}
p += 1;
}
int lft = (j == 0) ? -mod : v[i][j - 1];
int rgt = (p == v[i].size()) ? mod : v[i][p];
if (!push(lft, rgt, p - j)) {
printf("Incorrect sequence\n");
return 0;
} else {
int c = 0;
while (j < p) {
A[j * k + i] = v[i][j] = temp[c];
j += 1;
c += 1;
}
}
} else {
if (j > 0 && v[i][j] <= v[i][j - 1]) {
printf("Incorrect sequence\n");
return 0;
}
j += 1;
}
}
}
for (int i = 0; i < n; i++) {
printf("%d ", A[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 5e5 + 10;
long long indx[N], num[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == '?')
indx[i] = 1;
else
num[i] = stoi(s);
}
for (int i = 0; i < k; i++) {
long long pre = -2e9;
long long cnt = 0;
int last = i;
for (int j = i; j < n; j += k) {
if (indx[j])
cnt++;
else {
if (num[j] <= pre + cnt) {
puts("Incorrect sequence");
return 0;
}
long long st = max(pre + 1, min(-cnt / 2, num[j] - cnt));
for (int l = cnt; l > 0; l--) num[j - l * k] = st++;
cnt = 0;
pre = num[j];
}
last = j;
}
if (cnt) {
long long st = max(pre + 1, -cnt / 2);
while (last - k >= 0 && indx[last - k] == 1) {
last -= k;
}
for (int j = last; j < n; j += k) num[j] = st++;
}
}
for (int i = 0; i < n; i++) cout << num[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxm = 200005;
const int inf = 2e9 + 3;
const int finf = -2e9;
vector<pair<int, int> > bar[maxn];
vector<int> tmp;
int a[maxn], n, k;
char s[25];
int deal(char s[], int len) {
int st = 0, flag = 1;
if (s[0] == '-') st++, flag = -1;
int ret = 0;
for (int i = st; i < len; i++) {
ret = ret * 10 + s[i] - '0';
}
return ret * flag;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (int)1; i <= (int)n; i++) {
scanf("%s", s);
int l = strlen(s);
if (s[0] == '?')
a[i] = inf;
else
a[i] = deal(s, l);
int pos = i - (i - 1) / k * k;
bar[pos].push_back({a[i], i});
}
for (int i = 1; i <= k; i++) {
bar[i].push_back({inf + 2, 0});
}
int flag = 0;
for (int i = 1; i <= k; i++) {
int pre = -(int)2e9 - 1;
tmp.clear();
for (int j = 0; j < bar[i].size(); j++) {
int aim = bar[i][j].first;
if (aim == inf) {
tmp.push_back(bar[i][j].second);
} else {
if (aim <= pre) {
flag = 1;
break;
}
int can = aim - pre - 1;
if (can < tmp.size()) {
flag = 1;
break;
}
if (aim <= 0) {
for (int k = tmp.size() - 1, val = aim - 1; k >= 0; k--, val--) {
a[tmp[k]] = val;
}
tmp.clear();
} else {
if (pre < 0) {
int sz = tmp.size(), fir = aim - sz, gre = -(sz - 1) / 2;
if (fir > gre) {
fir = max(pre + 1, gre);
}
for (int k = 0, val = fir; k < sz; k++, val++) {
a[tmp[k]] = val;
}
tmp.clear();
} else {
for (int k = 0, val = pre + 1; k < tmp.size(); k++, val++) {
a[tmp[k]] = val;
}
tmp.clear();
}
}
pre = aim;
}
}
if (flag) break;
}
if (flag) return 0 * printf("Incorrect sequence\n");
for (int i = 1; i <= n; i++) {
printf("%d%c", a[i], i == n ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[100010];
int main() {
long long n, k;
cin >> n >> k;
string s;
getline(cin, s);
getline(cin, s);
char s2[s.size() + 1];
strcpy(s2, s.c_str());
char* pch;
pch = strtok(s2, " ");
long long i = -1;
while (pch != NULL) {
i++;
if (pch[0] == '?') {
pch = strtok(NULL, " ");
v[i] = 1101000000;
continue;
}
long long len = strlen(pch);
bool neg = false;
long long ini = 0;
if (pch[0] == '-') {
neg = true;
ini++;
}
long long num = 0;
for (; ini < len; ini++) {
num *= 10;
num += (pch[ini] - '0');
}
if (neg) num *= -1;
v[i] = num;
pch = strtok(NULL, " ");
}
bool resp = true;
for (int i = 0; i < min((n - k + 1), k); i++) {
vector<int> val;
vector<int> maior, menor;
for (int j = i; j < n; j += k) {
val.push_back(v[j]);
if (v[j] != 1101000000) {
maior.push_back(v[j]);
menor.push_back(v[j]);
} else {
maior.push_back(1101000000 - 1);
menor.push_back(-(1101000000 - 1));
}
}
int qtd = 0;
for (int j = 0; j < val.size(); j++) {
if (val[j] != 1101000000) {
qtd++;
for (int l = j + 1; l < val.size() && val[l] == 1101000000; l++) {
menor[l] = max(menor[l], val[j] + l - j);
}
for (int l = j - 1; l >= 0 && val[l] == 1101000000; l--)
maior[l] = min(maior[l], val[j] + (l - j));
}
}
if (qtd == 0) {
int f = val.size() / 2;
f *= -1;
for (int l = 0; l < val.size(); l++) val[l] = f++;
} else {
vector<int> posicao;
for (int l = 0; l < val.size(); l++) {
if (val[l] != 1101000000) posicao.push_back(l);
}
int f = min(max(menor[0], -(posicao[0] / 2)), maior[0]);
for (int l = 0; l < posicao[0]; l++) {
val[l] = f++;
}
if (posicao[posicao.size() - 1] != val.size() - 1) {
f = min(
maior[posicao[posicao.size() - 1] + 1],
max(menor[posicao[posicao.size() - 1] + 1],
(int)-((val.size() - posicao[posicao.size() - 1] - 1) / 2)));
for (int l = posicao[posicao.size() - 1] + 1; l < val.size(); l++) {
val[l] = f++;
}
}
for (int h = 0; h < posicao.size() - 1; h++) {
f = min(maior[posicao[h] + 1],
max(menor[posicao[h] + 1],
-((posicao[h + 1] - posicao[h] - 1) / 2)));
for (int l = posicao[h] + 1; l < posicao[h + 1]; l++) val[l] = f++;
}
}
for (int j = i; j < n; j += k) v[j] = val[j / k];
}
for (int i = 0; i < n; i++)
if (v[i] == 1101000000) v[i] = 0;
vector<long long> gera;
long long sum = 0;
for (int i = 0; i < k; i++) {
sum += v[i];
}
gera.push_back(sum);
for (int i = k; i < n; i++) {
sum += v[i];
sum -= v[i - k];
gera.push_back(sum);
}
for (int i = 0; i < gera.size() - 1 && resp; i++) {
if (gera[i] >= gera[i + 1]) resp = false;
}
if (resp) {
long long sum = 0;
for (int i = 0; i < n; i++) {
if (i) cout << " ";
cout << v[i];
sum += abs(v[i]);
}
cout << endl;
} else {
cout << "Incorrect sequence" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int inf = 1000000007;
char num[22];
int a[N];
bool can = true;
void solve(int prev, int current, int i, int j, const vector<int> &positions) {
if (j - i - 1 > (long long)current - prev - 1) {
can = false;
}
if (j - i - 1 <= 0) {
return;
}
int cant = j - i - 1;
int ri = cant / 2;
int le = ri - cant + 1;
if (prev < le && ri < current) {
for (int pos = i + 1; pos < j; pos++) {
a[positions[pos]] = le++;
}
} else {
long long left = 0, right = 0;
int v = prev + 1;
for (int rep = 0; rep < cant; rep++) {
left += abs(v);
v++;
}
v = current - 1;
for (int rep = 0; rep < cant; rep++) {
right += abs(v);
v--;
}
if (left < right) {
v = prev + 1;
for (int pos = i + 1; pos < j; pos++) {
a[positions[pos]] = v;
v++;
}
} else {
v = current - 1;
for (int pos = j - 1; pos > i; pos--) {
a[positions[pos]] = v;
v--;
}
}
}
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", num);
if (num[0] == '?') {
a[i] = inf;
} else {
int len = strlen(num);
int ini = 0;
if (num[0] == '-') {
ini = 1;
}
int val = 0;
for (int pos = ini; pos < len; ++pos) {
val = val * 10 + num[pos] - '0';
}
if (num[0] == '-') {
val = -val;
}
a[i] = val;
}
}
for (int ini = 0; ini < k; ini++) {
vector<int> positions;
for (int i = ini; i < n; i += k) {
positions.push_back(i);
}
int prev_val = -2 * inf;
int prev_pos = -1;
for (int i = 0; i < positions.size(); ++i) {
int where = positions[i];
if (a[where] != inf) {
solve(prev_val, a[where], prev_pos, i, positions);
prev_val = a[where];
prev_pos = i;
}
}
solve(prev_val, 2 * inf, prev_pos, positions.size(), positions);
}
if (!can) {
puts("Incorrect sequence");
return 0;
}
for (int i = 0; i < n; ++i) {
printf("%d ", a[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9;
const long long inf = -1e15;
bool mark[maxn];
long long arr[maxn];
char s[111];
long long sol() {
long long fu = 1;
long long d = 0;
if (s[0] == '-') {
fu = -1;
d++;
}
long long g = 0;
for (; s[d]; d++) {
g *= 10;
g += s[d] - '0';
}
g *= fu;
return g;
}
long long n, k;
queue<long long> pos;
long long ttt[maxn];
bool t;
void cal(long long chu, long long zhong, long long len) {
if (!len) return;
for (long long i = 0, e = -(len >> 1); i < len; i++, e++) {
ttt[i] = e;
}
if (chu == inf && zhong == inf) {
return;
}
if (chu == inf) {
if (zhong <= ttt[len - 1]) {
long long f = ttt[len - 1] - zhong + 1ll;
for (long long i = 0; i < len; i++) {
ttt[i] -= f;
}
}
return;
}
if (zhong == inf) {
if (chu >= ttt[0]) {
long long f = chu - ttt[0] + 1;
for (long long i = 0; i < len; i++) {
ttt[i] += f;
}
}
return;
}
if (zhong - chu - 1 < len) {
t = 0;
return;
}
if (chu >= 0) {
for (long long i = 0; i < len; i++) {
ttt[i] = chu + 1 + i;
}
} else if (zhong <= 0) {
for (long long i = len - 1, e = 1; i >= -1; i--, e++) {
ttt[i] = zhong - e;
}
} else {
if (chu >= ttt[0]) {
long long f = chu - ttt[0] + 1;
for (long long i = 0; i < len; i++) {
ttt[i] += f;
}
}
if (zhong <= ttt[len - 1]) {
long long f = ttt[len - 1] - zhong + 1ll;
for (long long i = 0; i < len; i++) {
ttt[i] -= f;
}
}
}
}
void chuli() {
int d = 0;
while (!pos.empty()) {
long long f = pos.front();
pos.pop();
arr[f] = ttt[d++];
}
}
int main() {
long long a, b, c, d, e, f, g, h;
ios::sync_with_stdio(0);
while (cin >> n >> k) {
memset(mark, 0, sizeof(mark));
for (d = 1; d <= n; d++) {
cin >> s;
if (s[0] == '?') {
mark[d] = 1;
} else {
arr[d] = sol();
}
}
t = 1;
for (d = 1; d <= k; d++) {
g = h = 0;
for (e = d; e <= n; e += k) {
if (!mark[e]) {
g = 1;
break;
}
pos.push(e);
}
if (!g) {
cal(inf, inf, pos.size());
chuli();
continue;
}
cal(inf, arr[e], pos.size());
chuli();
f = arr[e];
for (e += k; e <= n; e += k) {
if (mark[e]) {
pos.push(e);
} else {
cal(f, arr[e], pos.size());
chuli();
f = arr[e];
}
}
cal(f, inf, pos.size());
chuli();
}
for (d = 1; d <= k && t; d++) {
for (e = d + k; e <= n; e += k) {
if (arr[e] <= arr[e - k]) {
t = 0;
break;
}
}
}
if (t) {
cout << arr[1];
for (d = 2; d <= n; d++) {
cout << ' ' << arr[d];
}
cout << endl;
} else {
cout << "Incorrect sequence" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int64_t> seq;
vector<bool> unknown;
int nextKnown(int i) {
do {
i += k;
} while (i <= n + 1 && unknown[i]);
return i;
}
bool tryFill(int l, int r) {
int indexGap = (r - l) / k - 1;
int64_t lv = (l > 0) ? seq[l] : seq[0];
int64_t rv = (r <= n) ? seq[r] : seq[n + 1];
int64_t valueGap = rv - lv - 1;
if (indexGap > valueGap) return false;
auto cost = [&](int64_t alpha) -> int64_t {
int64_t res = 0;
int64_t curr = lv + 1 + alpha;
for (int i = l + k; i < r; i += k) {
res += abs(curr);
curr++;
}
return res;
};
auto isGood = [&](int64_t alpha) {
return alpha >= 0 && alpha <= valueGap - indexGap;
};
int64_t alpha = -1;
if (indexGap % 2 == 0) {
int64_t testAlpha = -lv - indexGap / 2 - 1;
if (isGood(testAlpha)) alpha = testAlpha;
testAlpha = -lv - indexGap / 2;
if (isGood(testAlpha)) alpha = testAlpha;
} else {
int64_t testAlpha = -lv - (indexGap + 1) / 2;
if (isGood(testAlpha)) alpha = testAlpha;
}
if (alpha < 0) {
auto c1 = cost(0);
auto c2 = cost(valueGap - indexGap);
alpha = (c1 < c2) ? 0 : valueGap - indexGap;
}
lv += alpha + 1;
for (int i = l + k; i < r; i += k) {
seq[i] = lv;
lv++;
}
return true;
}
int main() {
cin >> n >> k;
seq.resize(n + 2);
unknown.resize(n + 2);
seq[0] = -1e10 - 10;
unknown[0] = false;
seq[n + 1] = 1e10 + 10;
unknown[n + 1] = false;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
if (s == "?") {
unknown[i] = true;
seq[i] = 17;
} else {
unknown[i] = false;
seq[i] = stoll(s);
}
}
bool canFill = true;
for (int start = 1 - k; start <= 0; ++start) {
int l = start;
do {
int r = nextKnown(l);
canFill = canFill && tryFill(l, r);
l = r;
} while (l <= n);
}
if (canFill)
for (int i = 1; i <= n; ++i) cout << seq[i] << ' ';
else
cout << "Incorrect sequence";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (long long)1e5 + 228;
const long long MAXX = (long long)1.5e9;
long long n, k;
vector<long long> a(MAXN);
vector<bool> fucked(MAXN);
void no() {
cout << "Incorrect sequence";
exit(0);
}
vector<long long> kek(long long l, long long r, long long m) {
assert(m > 0);
if (m > (r - l - 1)) no();
vector<long long> ans;
if (l >= 0) {
for (long long i = 1; i <= m; ++i) {
ans.push_back(l + i);
}
} else if (r <= 0) {
for (long long i = 1; i <= m; ++i) {
ans.push_back(r - i);
}
reverse(ans.begin(), ans.end());
} else {
ans.push_back(0);
long long mm = m;
--mm;
for (long long i = 1; i <= m; ++i) {
for (long long sg = -1; sg <= 1; sg += 2) {
long long val = i * sg;
if (mm > 0 && val > l && val < r) {
--mm;
ans.push_back(val);
}
}
}
}
assert(((int)(ans).size()) == m);
sort(ans.begin(), ans.end());
return ans;
}
vector<long long> solve(vector<long long>& x, vector<bool>& f) {
long long l = -MAXX - 1;
vector<long long> ans;
for (long long i = 0; i < ((int)(x).size()); ++i) {
if (!f[i]) {
l = x[i];
continue;
}
long long j = i + 1;
long long r = +MAXX + 1;
while (j < ((int)(x).size()) && f[j]) {
++j;
}
if (j < ((int)(x).size())) r = x[j];
vector<long long> foo = kek(l, r, j - i);
for (int index = i; index < j; ++index) {
x[index] = foo[index - i];
}
i = j - 1;
}
return x;
}
int main() {
cout << setprecision(20);
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
if (s == "?") {
fucked[i] = true;
} else {
long long x = stoi(s);
a[i] = x;
}
}
for (int i = 0; i < k; ++i) {
vector<long long> x;
vector<bool> f;
for (int j = 0; i + k * j < n; ++j) {
long long idx = i + k * j;
x.push_back(a[idx]);
f.push_back(fucked[idx]);
}
auto res = solve(x, f);
for (int j = 0; i + k * j < n; ++j) {
long long idx = i + k * j;
if (fucked[idx]) {
a[idx] = res[j];
} else {
assert(a[idx] == res[j]);
}
}
}
for (int i = 0; i < n - k; ++i) {
if (a[i] >= a[i + k]) no();
}
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int a[maxn];
int l[maxn];
bool vis[maxn];
bool unknow[maxn];
void init() {
memset(a, 0, sizeof 0);
memset(vis, false, sizeof 0);
memset(unknow, false, sizeof 0);
}
int getNum(char *s) {
int len = strlen(s);
int d = 0;
for (int i = (s[0] == '-' ? 1 : 0); i < len; ++i) {
d = d * 10 + s[i] - '0';
}
return s[0] == '-' ? -d : d;
}
int main() {
init();
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
char s[17];
scanf("%s", s);
if (s[0] == '?') {
unknow[i] = true;
} else {
a[i] = getNum(s);
}
}
for (int i = 1; i <= n; ++i) {
if (unknow[i])
++l[i % k];
else if (l[i % k]) {
int lpos = i - (l[i % k] + 1) * k;
if (lpos < 1) {
if (a[i] < 0)
a[lpos + k] = a[i] - l[i % k];
else {
a[lpos + k] = 1 - max((l[i % k] + 1) >> 1, l[i % k] - a[i] + 1);
}
} else {
if (a[lpos] + l[i % k] >= a[i]) {
printf("Incorrect sequence");
return 0;
} else {
if (a[lpos] >= 0)
a[lpos + k] = a[lpos] + 1;
else if (a[i] < 0)
a[lpos + k] = a[i] - l[i % k];
else {
int z = (l[i % k] + 1) >> 1;
z = max(z, l[i % k] - a[i] + 1);
z = min(z, 1 - a[lpos] - 1);
a[lpos + k] = 1 - z;
}
}
}
l[i % k] = 0;
}
}
for (int i = n; i >= 1; --i) {
if (l[i % k]) {
int lpos = i - l[i % k] * k;
if (lpos < 1)
a[lpos + k] = 1 - ((l[i % k] + 1) >> 1);
else {
if (a[lpos] >= 0)
a[lpos + k] = a[lpos] + 1;
else {
int z = (l[i % k] + 1) >> 1;
z = min(z, -a[lpos]);
a[lpos + k] = 1 - z;
}
}
l[i % k] = 0;
}
}
memset(l, 0, sizeof l);
for (int i = 1; i <= n; ++i) {
if (unknow[i]) {
if (l[i % k]) {
a[i] = a[i - k] + 1;
} else {
l[i % k] = 1;
}
} else {
l[i % k] = 0;
}
if (i > k && a[i - k] >= a[i]) {
printf("Incorrect sequence");
return 0;
}
}
for (int i = 1; i <= n; ++i) {
printf("%d%c", a[i], i == n ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> arr(n);
vector<bool> fnd(n, 1);
for (long long i = 0; i < n; ++i) {
string x;
cin >> x;
if (x[0] == '?')
fnd[i] = 0;
else {
arr[i] = 0;
long long j = 0;
if (x[0] == '-') j++;
for (; j < (long long)x.length(); j++) {
arr[i] *= 10;
arr[i] += x[j] - '0';
}
if (x[0] == '-') arr[i] = -arr[i];
}
}
for (long long i = 0; i < k; ++i) {
long long m = -100000000002;
long long M = -m;
long long j = i;
long long cnt = 0;
while (j < n) {
long long prev = j;
cnt = 0;
M = 100000000002;
while (j < n && fnd[j] == 0) {
j += k;
cnt++;
}
if (j < n) {
M = arr[j];
}
if (M <= m + cnt) {
cout << "Incorrect sequence\n";
return 0;
}
if (cnt != 0) {
if (m >= -(cnt / 2 + 1)) {
for (long long q = prev; q < j; q += k) arr[q] = arr[q - k] + 1;
} else if (M <= cnt / 2 + 1) {
for (long long q = j - k; q >= prev; q -= k) arr[q] = arr[q + k] - 1;
} else {
arr[prev] = -(cnt / 2);
for (long long q = prev + k; q < j; q += k) arr[q] = arr[q - k] + 1;
}
}
m = M;
j += k;
}
}
for (long long i = 0; i < n; ++i) cout << arr[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
int a[100000];
int main(void) {
int i;
int n, k;
scanf("%d %d ", &n, &k);
for (i = 0; i < n; i++) {
int ch = getchar();
if (ch == '?') {
getchar();
a[i] = 1010000000;
} else {
ungetc(ch, stdin);
scanf("%d ", a + i);
}
}
for (i = 0; i < k; i++) {
int first, last;
first = i;
while (first <= n) {
int numQ, lFig, rFig;
for (last = first; last < n && a[last] == 1010000000; last += k)
;
numQ = (last - first) / k;
lFig = first - k >= 0 ? a[first - k] : -1010000000;
rFig = last < n ? a[last] : 1010000000;
if (rFig - lFig - 1 < numQ) {
puts("Incorrect sequence");
return 0;
} else {
int cnt;
int left = -(numQ / 2), right = left + numQ - 1;
if (!(lFig < left))
left = lFig + 1;
else if (!(right < rFig)) {
right = rFig - 1;
left = right - numQ + 1;
}
cnt = 0;
while (first < last) {
a[first] = left + cnt++;
first += k;
}
first += k;
}
}
}
for (i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t, i, k, j, flag;
int d[100010], q[100010], a[100010];
vector<int> v[100010];
char ch[100010];
void Puts(int x, int l, int r, int xl, int xr) {
int d = xr - xl + 1, i;
if (r - l + 1 < d) {
flag = 1;
return;
}
if (l >= 0 && r >= 0) {
for (i = xl; i <= xr; i++) v[x][i] = i - xl + l;
return;
}
if (l <= 0 && r <= 0) {
for (i = xr; i >= xl; i--) v[x][i] = r + i - xr;
return;
}
if (abs(l) < abs(r)) {
int z = d / 2;
if (z >= abs(l)) {
for (i = xl; i <= xr; i++) v[x][i] = l + i - xl;
return;
}
z = -d / 2;
for (i = xl; i <= xr; i++) v[x][i] = z + i - xl;
return;
}
int z = d / 2;
if (z >= abs(r)) {
for (i = xr; i >= xl; i--) v[x][i] = r - xr + i;
return;
}
z = -d / 2;
for (i = xl; i <= xr; i++) v[x][i] = z + i - xl;
}
void Solve(int x) {
int i, t = 0;
for (i = 1; i <= d[x]; i++)
if (v[x][i] != -1000000001) q[++t] = i;
if (!t) {
int z = -d[x] / 2;
for (i = 1; i <= d[x]; i++) v[x][i] = z + i - 1;
return;
}
if (t < 2)
return Puts(x, -1100000000, v[x][q[1]] - 1, 1, q[1] - 1),
Puts(x, v[x][q[t]] + 1, 1100000000, q[t] + 1, d[x]);
Puts(x, -1100000000, v[x][q[1]] - 1, 1, q[1] - 1),
Puts(x, v[x][q[t]] + 1, 1100000000, q[t] + 1, d[x]);
for (i = 1; i < t; i++)
Puts(x, v[x][q[i]] + 1, v[x][q[i + 1]] - 1, q[i] + 1, q[i + 1] - 1);
}
int Change() {
int n = strlen(ch), s = 0, st = 0, p = 1;
if (ch[0] == '-') p = -1, st++;
for (int i = st; i < n; i++) s = s * 10 + ch[i] - '0';
return s * p;
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%s", ch);
if (ch[0] == '?')
a[i] = -1000000001;
else
a[i] = Change();
}
for (i = 0; i < k; i++) v[i].push_back(-1);
for (i = 1; i <= n; i++) {
v[i % k].push_back(a[i]);
++d[i % k];
}
for (i = 0; i < k; i++) Solve(i);
if (flag) {
printf("Incorrect sequence");
return 0;
}
for (int j = 1; j <= d[0]; j++)
for (i = 1; i <= k; i++) printf("%d ", v[i % k][j]);
for (i = 1; d[i] > d[0]; i++) printf("%d ", v[i][d[i]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> grp[100002];
int main() {
int n, k, i, j, a[100002], flag = 0;
scanf("%d%d", &n, &k);
;
for (i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == '?')
a[i] = INT_MIN;
else {
int sign = 1, l = s.size();
a[i] = 0, j = 0;
if (s[0] == '-') {
sign = -1;
j = 1;
}
for (; j < s.size(); j++) a[i] = a[i] * 10 + (s[j] - '0');
a[i] *= sign;
}
grp[i % k].push_back(a[i]);
}
for (i = 0; i < k; i++) {
int l = grp[i].size(), val, cur = INT_MIN, pos = 0, prev = -1;
if (l == 0) {
if (grp[i][0] == INT_MIN) grp[i][0] = 0;
continue;
}
while (pos < l) {
if (grp[i][pos] != INT_MIN) {
int ele = pos - prev - 1, cnt;
if (cur >= 0)
cnt = cur + 1;
else if (grp[i][pos] < 0)
cnt = grp[i][pos] - ele;
else
cnt = min(max(0 - ele / 2, cur + 1), grp[i][pos] - ele);
for (j = prev + 1; j < pos; j++) grp[i][j] = cnt++;
cur = grp[i][pos];
prev = pos;
}
pos++;
}
int ele = l - 1 - prev, cnt = max(cur + 1, 0 - ele / 2);
for (j = prev + 1; j < l; j++) grp[i][j] = cnt++;
for (j = 0; j < l - 1; j++)
if (grp[i][j] >= grp[i][j + 1]) flag = 1;
}
if (flag)
cout << "Incorrect sequence\n";
else {
int cnt = 0, j = 0;
while (cnt < n) {
printf("%d ", grp[cnt % k][j]);
cnt++;
if (cnt % k == 0) j++;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, k;
string st;
vector<pair<long, long> > v[1 << 20];
long q;
vector<pair<long, long> > block;
long l1;
vector<long> tv;
long er;
long ans[1 << 20];
vector<long> solve(vector<pair<long, long> > v, long lwr, long upr) {
long sz = v.size();
if (lwr + sz >= upr) er = 1;
vector<long> res;
res.resize(v.size());
if (er) return res;
if (upr <= sz - 1 - sz / 2) {
for (int i = 0; i < v.size(); i++) res[i] = upr - sz + i;
return res;
}
if (lwr >= -(sz / 2)) {
for (int i = 0; i < v.size(); i++) {
res[i] = lwr + i + 1;
}
return res;
}
for (int i = 0; i < v.size(); i++) res[i] = i - sz / 2;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> st;
if (st == "?") {
v[i % k].push_back(make_pair(i, -2000000000));
} else {
stringstream s(st);
s >> q;
v[i % k].push_back(make_pair(i, q));
}
}
for (int i = 0; i < k; i++) {
block.clear();
l1 = -1100000001;
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j].second > -1.5e9) {
if (block.size()) {
tv = solve(block, l1, v[i][j].second);
for (int q = 0; q < tv.size(); q++)
v[i][j - tv.size() + q].second = tv[q];
}
block.clear();
if (j > 0 && v[i][j].second <= v[i][j - 1].second) er = 1;
l1 = v[i][j].second;
} else {
block.push_back(v[i][j]);
}
}
if (block.size()) {
tv = solve(block, l1, 1100000001);
for (int j = 0; j < tv.size(); j++)
v[i][v[i].size() - tv.size() + j].second = tv[j];
}
}
if (er)
cout << "Incorrect sequence" << endl;
else {
for (int i = 0; i < k; i++)
for (int j = 0; j < v[i].size(); j++) ans[v[i][j].first] = v[i][j].second;
for (int i = 1; i <= n; i++) {
if (i > 1) cout << " ";
cout << ans[i];
}
cout << endl;
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[102400];
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
char x[1024];
cin >> x;
if (x[0] == '?') {
arr[i] = 2000000000;
} else {
arr[i] = atoi(x);
}
}
for (int i = 0; i < k; i++) {
int lst = -2000000000;
int m = (n - i - 1) / k + 1;
for (int j = 0; j < m; j++) {
int x = j, tmp = 2000000000;
while (x < m && arr[x * k + i] == 2000000000) {
x++;
}
if (x < m) {
tmp = arr[i + x * k];
}
if (tmp <= x - j + lst) {
cout << "Incorrect sequence" << endl;
return 0;
}
int mx = (x - j + 1) / 2;
mx = min(mx, tmp);
mx = max(mx, lst + x - j + 1);
for (int y = j; y < x; y++) {
arr[i + y * k] = mx + y - x;
}
lst = tmp;
j = x;
}
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e5 + 7;
const int M = 12;
long long n, k, a[N], l[N], r[N], sum;
char s[20];
bool flag[N];
vector<long long> v[N];
void solve(int o) {
int len = strlen(s);
if (s[0] == '?')
a[o] = INF;
else if (s[0] == '-') {
long long ans = 0;
for (int i = 1; i < len; i++) ans *= 10, ans += s[i] - '0';
a[o] = -ans;
} else {
long long ans = 0;
for (int i = 0; i < len; i++) ans *= 10, ans += s[i] - '0';
a[o] = ans;
}
}
bool cal() {
for (int u = 0; u < k; u++) {
v[u].push_back(INF - 1);
int sz = v[u].size();
if (!sz) continue;
long long l = -INF, r = INF, cnt = 0;
for (int i = 0; i < sz; i++) {
if (v[u][i] != INF) {
r = v[u][i] - 1;
if (cnt > r - l + 1) return false;
if (l >= 0) {
int pos = i - cnt;
for (int j = l; j < l + cnt; j++) v[u][pos++] = j;
} else if (r <= 0) {
int pos = i - 1;
for (int j = r; j > r - cnt; j--) v[u][pos--] = j;
} else {
vector<long long> vec;
long long num = cnt;
if (num) vec.push_back(0 * 1ll), num--;
long long L = -1, R = 1;
while (num > 0) {
if (L >= l && num > 0) vec.push_back(L), L--, num--;
if (R <= r && num > 0) vec.push_back(R), R++, num--;
}
sort(vec.begin(), vec.end());
int pos = i - cnt;
for (int j = 0; j < vec.size(); j++) v[u][pos++] = vec[j];
}
cnt = 0;
l = v[u][i] + 1;
r = INF;
} else
cnt++;
}
}
return true;
}
int main() {
scanf("%lld", &n);
scanf("%lld", &k);
sum = 0;
for (int i = 0; i < n; i++) {
scanf("%s", s);
solve(i);
if (a[i] != INF) sum += abs(a[i]);
}
for (int i = 0; i < n; i++) v[i % k].push_back(a[i]);
if (!cal())
puts("Incorrect sequence");
else {
int ret = n;
for (int j = 0; ret; j++)
for (int i = 0; i < k && ret; i++) printf("%lld ", v[i][j]), ret--;
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int StoI(string s) {
int ANS = 0;
int Sign = 0;
if (s[0] == '-')
Sign = 1;
else
ANS = s[0] - 48;
for (int i = 1; i < s.length(); ++i) ANS *= 10, ANS += s[i] - 48;
if (Sign)
return -ANS;
else
return ANS;
}
int a[100007], n, k;
bool mark[100007];
int main(void) {
while (~scanf("%d%d", &n, &k)) {
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= n; ++i) {
string str;
cin >> str;
if (str[0] == '?')
mark[i] = 1;
else
a[i] = StoI(str);
}
int ERR = 0;
for (int start = 1; start <= k; ++start) {
int t = 1 + (n - start) / k;
int LowerBound = -1000100000, UpperBound;
for (int i = start; i <= n; i += k) {
if (!mark[i]) {
if (a[i] <= LowerBound) {
ERR = 1;
break;
} else {
LowerBound = a[i];
continue;
}
}
int L = i, R = i, cnt = 1;
while (R + k <= n && mark[R + k]) R += k, ++cnt;
if (R + k <= n)
UpperBound = a[R + k];
else
UpperBound = 1000100000;
if (UpperBound - LowerBound <= cnt) {
ERR = 1;
break;
} else {
if (UpperBound <= cnt / 2) {
for (int num = UpperBound - 1, j = R; j >= L; j -= k, num--) {
a[j] = num;
mark[j] = 0;
}
} else if (LowerBound >= -(cnt / 2)) {
for (int num = LowerBound + 1, j = L; j <= R; j += k, num++) {
a[j] = num;
mark[j] = 0;
}
} else if (UpperBound > cnt / 2 && cnt / 2 - LowerBound >= cnt) {
for (int num = cnt / 2, j = R; j >= L; j -= k, num--) {
a[j] = num;
mark[j] = 0;
}
} else if (LowerBound < -(cnt / 2) && UpperBound + cnt / 2 >= cnt) {
for (int num = -(cnt / 2), j = L; j <= R; j += k, num++) {
a[j] = num;
mark[j] = 0;
}
} else {
ERR = 2;
break;
}
}
}
if (ERR) break;
}
if (ERR) {
printf("Incorrect sequence\n");
} else {
for (int i = 1; i <= n; ++i) {
printf("%d", a[i]);
if (i == n)
printf("\n");
else
printf(" ");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = 2e5 + 10;
const int inf = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long llinf = (long long)1e18 + 5;
const long double pi = acos(-1.0);
int a[maxn];
int n, k;
vector<int> get(int l, int r, int k) {
if (r - l - 1 < k) {
cout << "Incorrect sequence\n";
exit(0);
}
if (k == 0) return vector<int>();
++l;
--r;
vector<int> ret;
if (r < 0) {
for (int j = (0); j < (k); j++) ret.push_back(r - j);
} else if (l > 0) {
for (int j = (0); j < (k); j++) ret.push_back(l + j);
} else {
ret.push_back(0);
k--;
int cur = 1;
while (k > 0) {
if (k > 0 && cur <= r) ret.push_back(cur), k--;
if (k > 0 && -cur >= l) ret.push_back(-cur), k--;
cur++;
}
}
sort((ret).begin(), (ret).end());
return ret;
}
vector<int> solve(vector<int> a) {
int last = a[0], cnt = 0;
vector<int> ret;
for (int i = (1); i < ((int)a.size()); i++) {
if (a[i] == -inf) {
cnt++;
} else {
vector<int> x = get(last, a[i], cnt);
cnt = 0;
last = a[i];
for (int z : x) ret.push_back(z);
ret.push_back(a[i]);
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = (0); i < (n); i++) {
string s;
cin >> s;
if (s == "?") {
a[i] = -inf;
} else {
a[i] = atoi(s.c_str());
}
}
for (int i = (0); i < (k); i++) {
vector<int> cur;
cur.push_back(-inf - n - 10);
for (int j = i; j < n; j += k) cur.push_back(a[j]);
cur.push_back(inf + n + 10);
vector<int> res = solve(cur);
for (int j = i; j < n; j += k) a[j] = res[(j - i) / k];
}
for (int i = (0); i < (n); i++) {
cout << a[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read_int() {
char c;
int res = 0, signal = 1;
do c = getchar();
while (c == ' ' or c == '\n');
if (c == '?') return 1000000001;
if (c == '-') {
signal = -1;
c = getchar();
}
do {
res = res * 10 + c - '0';
c = getchar();
} while (c != ' ' and c != '\n');
return res * signal;
}
int main() {
int n, k, array[100000];
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) array[i] = read_int();
bool impossible = false;
for (int j = 0; j < k; j++)
for (int i = j; i < n; i += k) {
if (array[i] != 1000000001) {
if (i > j and array[i] <= array[i - k]) impossible = true;
continue;
}
int last = i;
do last += k;
while (last <= n and array[last] == 1000000001);
if (i == j and last >= n) {
int mid = (last - i) / k / 2;
int val = last / k - mid;
for (int p = last - k; p >= i; p -= k) array[p] = --val;
} else if (i == j) {
int mid = (i + last) / 2;
if (n > 1000) mid = (last - i) / 2;
int val = min(last / k - mid / k, array[last]);
for (int p = last - k; p >= i; p -= k) array[p] = --val;
} else if (last >= n) {
int mid = (last - i - k) / k / 2;
int val = max(-mid, array[i - k] + 1);
for (int p = i; p < last; p += k) array[p] = val++;
} else {
if (array[last] - array[i - k] <= (last - i) / k)
impossible = true;
else if (abs(array[last]) < abs(array[i - k])) {
int mid = (i + last) / 2;
if (n > 1000) mid = (last - i) / 2;
int val = min(last / k - mid / k, array[last]);
for (int p = last - k; p >= i; p -= k) array[p] = --val;
} else {
int mid = (last - i - k) / k / 2;
int val = max(-mid, array[i - k] + 1);
for (int p = i; p < last; p += k) array[p] = val++;
}
}
i = last - k;
}
if (impossible)
printf("Incorrect sequence\n");
else {
printf("%d", array[0]);
for (int i = 1; i < n; i++) printf(" %d", array[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Bad = (int)2e9;
const int small = -(int)1e9 - (int)2e6;
const int big = -small;
int getint() {
char ch;
while (ch = getchar(), ch != '-' && ch != '?' && (ch < '0' || ch > '9'))
;
if (ch == '?') return Bad;
int sign = (ch == '-' ? -1 : 1);
int x = 0;
if (ch >= '0' && ch <= '9') x = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
x *= 10, x += ch - '0';
}
return x * sign;
}
vector<int> solve_part(vector<int> part) {
int n = (int)part.size();
vector<int> set_vals;
vector<int> where_set;
for (int i = 0; i < n; i++)
if (part[i] != Bad) set_vals.push_back(part[i]), where_set.push_back(i);
vector<int> other_vals;
int len = (int)set_vals.size();
for (int i = 0; i < len - 1; i++) {
int x = set_vals[i];
int y = set_vals[i + 1];
int dist = where_set[i + 1] - where_set[i] - 1;
if (y <= 0) {
for (int j = dist; j >= 1; j--) other_vals.push_back(y - j);
} else if (x >= 0) {
for (int j = 1; j <= dist; j++) other_vals.push_back(x + j);
} else {
assert(x < 0 && y > 0);
int righthalf = dist - dist / 2;
int lefthalf = dist / 2;
if (righthalf > y)
lefthalf += righthalf - y, righthalf = y;
else if (lefthalf >= abs(x))
righthalf += lefthalf - (abs(x) - 1), lefthalf = abs(x) - 1;
assert(lefthalf + righthalf == dist);
for (int i = lefthalf; i >= 1; i--) other_vals.push_back(-i);
for (int i = 0; i < righthalf; i++) other_vals.push_back(i);
}
}
int h = 0;
for (int i = 0; i < n; i++)
if (part[i] == Bad) {
assert(h < (int)other_vals.size());
part[i] = other_vals[h], h++;
}
return part;
}
void solve(int n) {
int k;
scanf(" %d", &k);
vector<int> a(n);
for (int i = 0; i < n; i++) a[i] = getint();
vector<vector<int> > parts(k);
for (int i = 0; i < k; i++) parts[i].push_back(small);
for (int i = 0; i < n; i++) parts[i % k].push_back(a[i]);
for (int i = 0; i < k; i++) parts[i].push_back(big);
for (int i = 0; i < k; i++) {
vector<int> v = solve_part(parts[i]);
parts[i] = v;
}
for (int i = 0; i < k; i++)
for (int j = 1; j < (int)parts[i].size() - 1; j++) {
assert(i + (j - 1) * k < n);
a[i + (j - 1) * k] = parts[i][j];
}
bool ok = true;
for (int i = 0; i < n; i++)
if (i >= k && a[i] <= a[i - k]) ok = false;
if (!ok) {
printf("Incorrect sequence\n");
return;
}
for (int i = 0; i < n; i++) {
assert(a[i] != Bad);
assert(a[i] >= small && a[i] <= big);
printf("%d ", a[i]);
}
printf("\n");
}
int main() {
int n;
while (cin >> n) solve(n);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9 + (int)2E5;
int N, K;
int x[100005];
void fillgap(stack<int> &stk, int r, int l) {
int n = stk.size();
int dr = 0 + n / 2;
int dl = dr - n + 1;
if (dr >= r) {
int shift = dr - (r - 1);
dr -= shift;
dl -= shift;
}
if (dl <= l) {
int shift = l + 1 - dl;
dl += shift;
dr += shift;
}
int v = dr;
while (stk.size()) {
int j = stk.top();
stk.pop();
x[j] = v--;
}
}
int main() {
cin >> N >> K;
for (int i = (0); i < (N); i++) {
char buf[20];
scanf("%s", buf);
if (buf[0] == '?') {
x[i] = INF;
} else {
sscanf(buf, "%d", &x[i]);
}
}
for (int s = 0; s < K; s++) {
int maxv = -INF;
int lasti = -1;
stack<int> stk;
for (int i = s; i < N; i += K) {
if (x[i] != INF) {
if (x[i] < maxv) return puts("Incorrect sequence"), 0;
maxv = max(maxv, x[i]);
if (lasti == -1) {
fillgap(stk, x[i], -INF);
} else {
int gap = x[i] - x[lasti] - 1;
if ((int)stk.size() > gap) return puts("Incorrect sequence"), 0;
fillgap(stk, x[i], x[lasti]);
}
lasti = i;
} else {
stk.push(i);
}
}
if (stk.size()) {
fillgap(stk, INF, lasti != -1 ? x[lasti] : -INF);
}
}
for (int i = (0); i < (N); i++) {
printf("%d ", x[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
bool isQuestion[N];
char t[N];
int get(char *s) {
if (s[0] == '-') {
return -get(s + 1);
}
int ret = 0;
for (int i = 0; s[i] != 0; ++i) {
ret = ret * 10 + s[i] - '0';
}
return ret;
}
pair<long long, int> getValue(int st, int k) {
long long ret = 0;
for (int i = st; i <= st + k - 1; ++i) ret += abs(i);
return {ret, st};
}
int getSt(int st, int ed, int k) {
pair<long long, int> ret = min(getValue(st, k), getValue(ed - k + 1, k));
if (st < 0 && ed > 0) {
ret = min(ret, getValue(max(st, min(-k / 2, ed - k + 1)), k));
}
return ret.second;
}
void solve2() {
int n, k;
scanf("%d %d ", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%s ", t);
if (t[0] == '?') {
isQuestion[i] = true;
} else {
isQuestion[i] = false;
a[i] = get(t);
}
}
a[0] = -2e9;
a[n + 1] = 2e9;
for (int i = 1; i <= k; ++i) {
vector<int> v;
v.push_back(0);
for (int j = i; j <= n; j += k) {
v.push_back(j);
}
v.push_back(n + 1);
int maxi = -2e9 - 19;
for (int ind : v) {
if (!isQuestion[ind]) {
if (maxi >= a[ind]) {
printf("Incorrect sequence\n");
return;
}
maxi = a[ind];
}
}
for (int j = 0; j + 1 < v.size();) {
int ind = v[j];
if (isQuestion[ind]) {
++j;
continue;
}
int t;
for (t = j + 1; t < v.size(); ++t) {
if (!isQuestion[v[t]]) {
break;
}
}
if (t < v.size() && (long long)a[v[t]] - a[v[j]] < t - j) {
printf("Incorrect sequence\n");
return;
}
if (t - j - 1 > 0) {
int st = getSt(a[v[j]] + 1, a[v[t]] - 1, t - j - 1);
for (int x = j + 1; x < t; ++x) {
a[v[x]] = st + x - j - 1;
}
}
j = t;
}
}
for (int i = 1; i <= n; ++i) {
printf("%d ", a[i]);
}
putchar('\n');
}
void solve() { solve2(); }
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long q[100100], l, r;
char s[20];
bool f[100100], w;
int i, j, n, k, a, b, p, t;
const long long mn = 2000000000;
const long long sn = -2000000000;
void Val(int p) {
long long x;
int i, l, c;
bool v;
l = strlen(s);
if (s[0] == '?')
f[p] = true;
else {
if (s[0] == '-') {
v = true;
c = 1;
} else {
v = false;
c = 0;
}
x = 0;
for (i = c; i < l; i++) x = x * 10 + s[i] - '0';
if (v) x *= -1;
q[p] = x;
}
}
void Work(int a, int b, long long l, long long r) {
long long d, t;
d = (b - a) / k + 1;
if (r - l - 1 < d) {
w = false;
return;
}
t = max(-d / 2, (long long)(l + 1));
t = min(t, (long long)(r - d));
for (; a <= b; a += k) {
q[a] = t;
t++;
f[a] = false;
}
}
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%s", s);
Val(i);
}
w = true;
for (i = 1; i <= k; i++) {
for (p = i; p <= n; p += k) {
if (!f[p]) {
if (p > k && q[p] <= q[p - k]) {
w = false;
break;
}
} else {
a = p;
b = p;
if (a > k)
l = q[p - k];
else
l = sn;
while (true) {
p += k;
if (p > n) {
b = p - k;
r = mn;
Work(a, b, l, r);
break;
}
if (!f[p]) {
b = p - k;
r = q[p];
Work(a, b, l, r);
break;
}
}
}
}
}
if (w) {
for (i = 1; i < n; i++) printf("%d ", q[i]);
printf("%d\n", q[n]);
} else
printf("Incorrect sequence");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void smain();
int main() {
ios_base::sync_with_stdio(false);
smain();
return 0;
}
bool b[200000];
long long a[200000];
void smain() {
long long n, k;
char str[200] = {0};
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> str;
if (str[0] == '?')
b[i] = false;
else {
b[i] = true;
a[i] = atoi(str);
}
}
long long pos, q, mx, pos2, pos3, mxl, mxr;
long long s1, s2;
for (long long st = 0; st < k; st++) {
pos = st;
q = 0;
while (pos < n && b[pos] == false) {
q++;
pos += k;
}
if (pos < n) {
mx = a[pos] - 1;
if (mx > q / 2) mx = q / 2;
} else {
mx = q / 2;
}
pos2 = pos - k;
while (pos2 >= st) {
a[pos2] = mx;
b[pos2] = true;
mx--;
pos2 -= k;
}
pos2 = pos + k;
while (pos2 < n) {
if (b[pos2] == true) {
if (a[pos] >= a[pos2]) {
cout << "Incorrect sequence";
return;
}
pos = pos2;
pos2 = pos + k;
continue;
}
pos3 = pos2;
q = 0;
while (pos3 < n && b[pos3] == false) {
pos3 += k;
q++;
}
if (pos3 >= n) {
mx = -q / 2;
if (mx <= a[pos]) {
mx = a[pos] + 1;
}
pos3 = pos2;
while (pos3 < n) {
a[pos3] = mx;
b[pos3] = true;
mx++;
pos3 += k;
}
pos = pos3;
pos2 = pos + k;
} else {
if (a[pos3] - a[pos] <= q) {
cout << "Incorrect sequence";
return;
}
mxl = -q / 2;
mxr = mxl + q - 1;
if (mxl <= a[pos]) {
mxl = a[pos] + 1;
mxr = mxl + q - 1;
}
if (mxr >= a[pos3]) {
mxr = a[pos3] - 1;
mxl = mxr - q + 1;
}
pos2 = pos + k;
for (long long i = 0; i < q; i++) {
a[pos2] = mxl;
b[pos2] = true;
mxl++;
pos2 += k;
}
pos = pos3;
pos2 = pos + k;
}
}
}
for (long long i = 0; i < n; i++) {
cout << a[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int a[maxn], n, k;
const int INF = (1 << 30) - 1;
void solve() {
int cnt = 0, pos = -INF;
for (int i = n + 1; i <= n + k; i++) a[i] = INF + 1;
for (int i = 1; i <= k; i++) {
cnt = 0;
pos = -INF;
for (int j = i; j <= n + k; j += k) {
if (a[j] == INF)
cnt++;
else {
if (a[j] - pos <= cnt) {
puts("Incorrect sequence");
return;
}
int st = max(pos + 1, min(a[j] - cnt, -cnt / 2));
for (int z = cnt; z >= 1; z--) {
a[j - z * k] = st;
st++;
}
pos = a[j];
cnt = 0;
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int main() {
while (scanf("%d %d", &n, &k) != EOF) {
char s[5];
for (int i = 1; i <= n; i++) {
scanf("%s", s);
if (s[0] == '?')
a[i] = INF;
else
sscanf(s, "%d", &a[i]);
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005];
char buf[12];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
if (buf[0] == '?')
a[i] = (1 << 30);
else
a[i] = atoi(buf);
}
for (int i = 0; i < m; i++) {
int prev = -(1 << 30), s = (n - i - 1) / m + 1;
for (int j = 0; j < s; j++) {
int k = j, next = (1 << 30);
while (k < s && a[i + k * m] == (1 << 30)) k++;
if (k < s) next = a[i + k * m];
if (next <= k - j + prev) {
puts("Incorrect sequence");
return 0;
}
int up = (k - j + 1) / 2;
up = min(up, next);
up = max(up, prev + k - j + 1);
for (int x = j; x < k; x++) {
a[i + x * m] = up - k + x;
}
prev = next;
j = k;
}
}
for (int i = 0; i < n; i++) printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 110000;
const int inf = 1e9;
int a[N];
int b[N];
int m;
int read() {
char p = getchar();
while (p != '?' && p != '-' && (!(p <= '9' && p >= '0'))) p = getchar();
if (p == '?') return inf + 1;
int sign = 1;
if (p == '-') {
sign = -1;
p = getchar();
}
int x = 0;
while (p <= '9' && p >= '0') {
x *= 10;
x += p - 48;
p = getchar();
}
return x * sign;
}
void fail() {
printf("Incorrect sequence");
exit(0);
}
void work() {
int lst = -inf - 1;
for (int i = (1); i <= (int)m; i++)
if (b[i] <= inf) {
if (b[i] <= lst) fail();
lst = b[i];
}
b[0] = -inf - 1;
b[m + 1] = inf + 1;
for (int i = 1; i <= m; i++)
if (b[i] > inf) {
int j = i;
while (j < m && b[j + 1] > inf) j++;
int mid = (i + j) / 2;
int r, l;
if (i == 1)
l = -inf - 1000086;
else
l = b[i - 1] + 1;
if (j == m)
r = inf + 1000086;
else
r = b[j + 1] - 1;
if (r - l < j - i) fail();
l += mid - i;
r -= j - mid;
if (r <= 0) {
int gt = r - (mid - i);
for (int k = (i); k <= (int)j; k++) {
b[k] = gt;
gt++;
}
} else if (l >= 0) {
int gt = l - (mid - i);
for (int k = (i); k <= (int)j; k++) {
b[k] = gt;
gt++;
}
} else {
int gt = 0 - (mid - i);
for (int k = (i); k <= (int)j; k++) {
b[k] = gt;
gt++;
}
}
i = j;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (1); i <= (int)n; i++) a[i] = read();
for (int i = (0); i <= (int)k - 1; i++) {
m = 0;
for (int j = i; j <= n; j += k)
if (j > 0) b[++m] = a[j];
work();
m = 0;
for (int j = i; j <= n; j += k)
if (j > 0) a[j] = b[++m];
}
for (int i = (1); i <= (int)n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200202;
const long long P = 1000000007;
long long a[N], b[N], s, x, n, k;
char C;
void ge(long long I) {
s = 1;
x = 0;
C = getchar();
while (C != '-' && C != '?' && (!('0' <= C && C <= '9'))) C = getchar();
if (C == '?') {
b[I] = 1;
return;
} else if (C == '-')
s = -1;
else
x = C - '0';
C = getchar();
while ('0' <= C && C <= '9') {
x = x * 10 + C - '0';
C = getchar();
}
a[I] = x * s;
}
long long go(long long y) {
if (y > n) return y;
if (b[y] == 0) return y;
return go(y + k);
}
vector<long long> ge(long long l, long long r, long long x) {
if (r - l + 1 < x) {
cout << "Incorrect sequence" << endl;
exit(0);
}
vector<long long> R;
if (l <= 0 && 0 <= r) {
R.push_back(0);
long long xx = 1;
while (R.size() < x) {
if (xx <= r) R.push_back(xx);
if (l <= -xx)
if (R.size() < x) R.push_back(-xx);
xx++;
}
sort(R.begin(), R.end());
return R;
}
if (l >= 0) {
for (int i = 0; i < x; i++) R.push_back(i + l);
return R;
}
for (int i = 0; i < x; i++) R.push_back(r - i);
sort(R.begin(), R.end());
return R;
}
bool ch() {
for (int i = 1; i <= k; i++) {
for (int j = i + k; j <= n; j += k)
if (a[j] <= a[j - k]) {
return 1;
}
}
return 0;
}
int main() {
scanf("%I64d%I64d", &n, &k);
for (int i = 1; i <= n; i++) ge(i);
long long fin = 0, li, las = -101000000001ll;
vector<long long> v;
for (int i = 1; i <= k; i++) {
fin = 0;
li = i;
las = -101000000001ll;
while (li <= n) {
if (b[li] == 1) {
fin = go(li + k);
if ((fin - li) / k > 0) {
if (fin <= n) {
v = ge(las + 1, a[fin] - 1, (fin - li) / k);
las = a[fin];
} else
v = ge(las + 1, 101000000001ll, (fin - li) / k);
for (int i = 0; i < (fin - li) / k; i++) a[li + i * k] = v[i];
}
li = fin + k;
} else
las = a[li], li += k;
}
}
if (ch()) {
cout << "Incorrect sequence" << endl;
return 0;
}
for (int i = 1; i <= n; i++) printf("%I64d ", a[i]);
bolo:
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
bool need[N];
long long a[N];
int n, k;
long long f(int i, long long x) {
long long ans = 0;
while (i < n && need[i]) {
ans += abs(x);
x++;
i += k;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
if (str == "?") {
need[i] = 1;
} else {
int t = 1, g = 0;
if (str[0] == '-') {
t = -1;
str.erase(0, 1);
}
for (int j = 0; j < str.size(); j++) {
g *= 10;
g += str[j] - '0';
}
a[i] = t * g;
}
}
for (int i = 0; i < n; i++) {
if (need[i]) {
long long l = (i - k >= 0 ? a[i - k] + 1 : -(long long)(1e9 + 1e7)), r,
d = 0;
int j = i;
while (j < n && need[j]) {
j += k;
d++;
}
if (j < n) {
r = a[j] - d;
} else {
r = (long long)(1e9 + 1e7);
}
while (r - l > 5) {
long long c1 = l + (r - l) / 3;
long long c2 = r + (l - r) / 3;
if (f(i, c1) < f(i, c2))
r = c2;
else
l = c1;
}
long long t = (long long)(1e18);
long long ti = -1;
while (l <= r) {
if (f(i, l) < t) {
t = f(i, l);
ti = l;
}
l++;
}
j = i;
while (j < n && need[j]) {
need[j] = 0;
a[j] = ti;
ti++;
j += k;
}
}
}
for (int i = 0; i < n; i++) {
if (i + k >= n) break;
if (a[i] >= a[i + k]) {
cout << "Incorrect sequence\n";
return 0;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[120000], i, j, kk, p[120000], e, lst, s, pl[120000];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
if (ch == '?') return 2e9 + 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int main() {
cin >> n >> k;
p[0] = -2e9 - 2;
for (i = 1; i <= n; ++i) a[i] = read();
for (i = 1; i <= k; ++i) {
s = i;
e = 0;
lst = 0;
while (s <= n) {
p[++e] = a[s];
if (p[e] != 2e9 + 1) pl[e] = lst, lst = e;
s += k;
}
p[e + 1] = 2e9 + 2;
pl[e + 1] = lst;
for (j = 1; j <= e + 1; ++j) {
if (p[j] != 2e9 + 1) {
if (p[j] - p[pl[j]] < j - pl[j]) {
cout << "Incorrect sequence";
return 0;
}
if (p[j] >= 0 && p[pl[j]] >= 0) {
for (kk = pl[j] + 1; kk < j; ++kk) p[kk] = p[pl[j]] + kk - pl[j];
} else if (p[j] < 0 && p[pl[j]] < 0) {
for (kk = j - 1; kk > pl[j]; --kk) p[kk] = p[j] - j + kk;
} else {
int mid = (pl[j] + j) >> 1;
if (mid - pl[j] >= -p[pl[j]]) mid = pl[j] - p[pl[j]];
if (j - mid > p[j]) mid = j - p[j];
for (kk = j - 1; kk > pl[j]; --kk) p[kk] = kk - mid;
}
}
}
for (j = 1; j <= e; ++j)
if (p[j] <= p[j - 1] || p[j] > 2e9 || p[j] < -2e9) {
cout << "Incorrect sequence";
return 0;
} else
a[(j - 1) * k + i] = p[j];
}
for (i = 1; i <= n; ++i) printf("%lld ", a[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int getNext() {
int ret = 0, sign = 1;
char ch = ' ';
while ((ch < '0' || ch > '9') && ch != '?' && ch != '-') {
ch = getchar();
}
if (ch == '?') {
return -1023456789;
}
if (ch == '-') {
sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ret *= 10;
ret += ch - '0';
ch = getchar();
}
return ret * sign;
}
int getFirstVal(int l, int r, int k) {
if (-(k / 2) > l && (k - 1) / 2 < r) {
return -k / 2;
}
if (abs(l) > abs(r)) {
return r - k;
} else {
return l + 1;
}
}
int a[212345];
vector<int> vec;
int main() {
int n, k, l, j, i, p, s;
cin >> n >> k;
for (i = 0; i < n; i++) {
a[i] = getNext();
}
for (i = 0; i < k; i++) {
vec.clear();
vec.push_back(-1023456789);
for (j = i; j < n; j += k) {
vec.push_back(a[j]);
}
l = 1;
s = vec.size();
vec.push_back(1023456789);
while (l < s) {
if (vec[l] != -1023456789) {
l++;
continue;
}
for (j = l + 1; j < s; j++) {
if (vec[j] != -1023456789) {
break;
}
}
if (vec[j] - vec[l - 1] - 1 < j - l) {
cout << "Incorrect sequence" << endl;
return 0;
}
if (vec[l - 1] >= 0) {
for (p = l; p < j; p++) {
vec[p] = vec[p - 1] + 1;
}
} else if (vec[j] <= 0) {
for (p = j - 1; p >= l; p--) {
vec[p] = vec[p + 1] - 1;
}
} else {
vec[l] = getFirstVal(vec[l - 1], vec[j], j - l);
for (p = l + 1; p < j; p++) {
vec[p] = vec[p - 1] + 1;
}
}
l = j + 1;
}
l = 1;
for (j = i; j < n; j += k) {
a[j] = vec[l];
l++;
}
}
for (j = k; j < n; j++) {
if (a[j] <= a[j - k]) {
cout << "Incorrect sequence" << endl;
return 0;
}
}
for (i = 0; i < n; i++) {
printf("%d", a[i]);
printf(i < n - 1 ? " " : "\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bs[10];
int n, k;
long long undef = -((long long)(1) << 55);
vector<long long> g[100000];
int parseInt(const string& s) {
int ans = 0;
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == '-') {
ans = -ans;
} else {
ans += bs[s.length() - 1 - i] * (s[i] - int('0'));
}
}
return ans;
}
void go(int pt) {
long long prev = undef;
for (int i = 0; i < g[pt].size(); i++) {
if (g[pt][i] != undef) {
if (g[pt][i] > prev) {
prev = g[pt][i];
} else {
printf("Incorrect sequence");
exit(0);
}
}
}
int lf = -1;
int rg = -1;
while (lf < (int)g[pt].size() || rg < (int)g[pt].size()) {
while (lf + 1 < g[pt].size() && g[pt][lf + 1] != undef) {
lf++;
}
if (lf == g[pt].size() - 1) break;
while (rg + 1 < g[pt].size() && (rg <= lf || g[pt][rg + 1] == undef)) {
rg++;
}
rg++;
long long lfbound, rgbound;
if (lf == -1) {
lfbound = undef;
} else {
lfbound = g[pt][lf] + 1;
}
if (rg == g[pt].size()) {
rgbound = -undef;
} else {
rgbound = g[pt][rg] - 1;
}
if (rgbound - lfbound + 1 < rg - lf - 1) {
printf("Incorrect sequence");
exit(0);
}
int pflf = -(rg - lf - 1) / 2;
int pfrg = (rg - lf - 1) / 2 + ((rg - lf - 1) % 2 == 0);
if (pflf < lfbound) {
for (int i = lf + 1; i < rg; i++) {
g[pt][i] = lfbound++;
}
continue;
} else if (pfrg > rgbound) {
for (int i = rg - 1; i > lf; i--) {
g[pt][i] = rgbound--;
}
continue;
} else {
for (int i = lf + 1; i < rg; i++) {
g[pt][i] = pflf++;
}
continue;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
bs[0] = 1;
for (int i = 1; i < 10; i++) bs[i] = bs[i - 1] * 10;
cin >> n >> k;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "?") {
g[i % k].push_back(undef);
} else {
g[i % k].push_back(parseInt(s));
}
}
for (int i = 0; i < k; i++) {
go(i);
}
for (int i = 0; i < n; i++) {
printf("%I64d ", g[i % k][i / k]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, k;
struct Number {
int value;
bool unknown;
friend istream& operator>>(istream& in, Number& num) {
string s;
in >> s;
if (s[0] == '?') {
num.unknown = true;
} else {
num.unknown = false;
stringstream ss(s);
ss >> num.value;
}
return in;
}
friend ostream& operator<<(ostream& out, Number& num) {
out << num.value;
return out;
}
} num[MAXN];
bool tryFill(int left, int right) {
long long lower = -INF, upper = INF;
if (left - k >= 0) {
lower = num[left - k].value;
}
if (right + k < n) {
upper = num[right + k].value;
}
int cnt = (right - left) / k + 1;
if (upper - lower - 1 < cnt) {
return false;
}
set<int> numSet;
if (lower <= 0 && upper >= 0) {
if (lower != 0 && upper != 0) {
numSet.insert(0);
}
int index = 1;
while ((int)numSet.size() < cnt) {
if (index < -lower) {
numSet.insert(-index);
}
if (index < upper) {
numSet.insert(index);
}
++index;
}
} else if (upper < 0) {
while ((int)numSet.size() < cnt) {
numSet.insert(--upper);
}
} else {
while ((int)numSet.size() < cnt) {
numSet.insert(++lower);
}
}
auto it = numSet.begin();
for (int i = left; i <= right; i += k) {
num[i].value = *(it++);
}
return true;
}
int main() {
while (cin >> n >> k) {
for (int i = 0; i < n; ++i) {
cin >> num[i];
}
bool valid = true;
for (int i = 0, j; i < k && valid; ++i) {
int left = -1, right;
for (j = i; j < n && valid; j += k) {
if (num[j].unknown && left == -1) {
left = j;
}
if (left != -1 && !num[j].unknown) {
right = j - k;
if (!tryFill(left, right)) {
valid = false;
}
left = -1;
}
}
if (left != -1) {
right = j - k;
if (!tryFill(left, right)) {
valid = false;
}
}
}
for (int i = 0; i < n - k; ++i) {
if (num[i].value >= num[i + k].value) {
valid = false;
break;
}
}
if (!valid) {
cout << "Incorrect sequence" << endl;
} else {
for (int i = 0; i < n; ++i) {
if (i) {
cout << ' ';
}
cout << num[i];
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005];
char buf[12];
vector<int> c[100005];
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); i++) {
scanf("%s", buf);
if (buf[0] == '?')
a[i] = (1 << 30);
else {
int j = 0;
bool neg = 0;
if (buf[j] == '-') j++, neg = 1;
for (; buf[j]; j++) a[i] = a[i] * 10 + buf[j] - '0';
if (neg) a[i] = -a[i];
}
c[i % m].push_back(a[i]);
}
for (int i = (0); i < (m); i++) {
int prev = (1 << 30);
for (int j = (0); j < (c[i].size()); j++) {
int k = j, next = (1 << 30);
while (k < c[i].size() && c[i][k] == (1 << 30)) k++;
if (k < c[i].size()) next = c[i][k];
if (prev == (1 << 30)) {
int up = min(next, (k - j + 1) / 2);
for (int l = (j); l < (k); l++) a[i + l * m] = up - k + l;
} else {
if (next == (1 << 30)) {
int lb = max(prev, -(k - j + 1) / 2);
for (int l = (j); l < (k); l++) a[i + l * m] = lb + 1 + l - j;
} else if (prev + (k - j) < next) {
if (next <= (k - j + 1) / 2)
for (int l = (j); l < (k); l++) a[i + l * m] = next - k + l;
else if (prev >= -(k - j + 1) / 2)
for (int l = (j); l < (k); l++) a[i + l * m] = prev + l - j + 1;
else {
int lb = -(k - j + 1) / 2;
for (int l = (j); l < (k); l++) a[i + l * m] = lb + 1 + l - j;
}
} else {
puts("Incorrect sequence");
scanf("\n");
return 0;
}
}
prev = next;
j = k;
}
}
for (int i = (0); i < (n); i++) printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
scanf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int convert(string second) {
int res = 0, sign = 1, beg = 0;
if (second[0] == '-') {
beg = 1;
sign = -1;
}
for (int i = beg; i < (int)((second).size()); ++i) {
res = res * 10 + second[i] - '0';
}
return res * sign;
}
vector<int> Set(int a, int b, int cnt) {
vector<int> res;
if (1ll * b - a - 1 < cnt) {
cout << "Incorrect sequence";
exit(0);
}
if (a >= 0 && b >= 0) {
for (int x = a + 1; (int)((res).size()) < cnt; ++x) {
res.push_back(x);
}
} else if (a <= 0 && b <= 0) {
for (int x = b - 1; (int)((res).size()) < cnt; --x) {
res.push_back(x);
}
} else {
for (int l = 0, r = 1; (int)((res).size()) < cnt;) {
if (l > a && (-l <= r || r == b)) {
res.push_back(l--);
} else {
res.push_back(r++);
}
}
}
sort((res).begin(), (res).end());
return res;
}
const int N = 1e5 + 5;
const int B = 1e9 + 1;
const int inf = 1 << 30;
int n, m, k, a[N], b[N];
string second;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> second;
if (second[0] == '?') {
a[i] = B;
} else {
a[i] = convert(second);
}
}
for (int i = 1; i <= k; ++i) {
b[m = 1] = -inf;
for (int j = i; j <= n; j += k) {
b[++m] = a[j];
}
b[++m] = inf;
int stupid_prev = 1;
for (int j = 2; j <= m; ++j) {
if (b[j] != B) {
vector<int> put = Set(b[stupid_prev], b[j], j - stupid_prev - 1);
for (int l = 0; l < (int)((put).size()); ++l) {
b[stupid_prev + 1 + l] = put[l];
}
stupid_prev = j;
}
}
for (int j = 2; j < m; ++j) {
a[i + (j - 2) * k] = b[j];
}
}
for (int i = 1; i <= n; ++i) {
cout << a[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E5 + 5;
int n, k, a[MAXN];
bool mark[MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
string buf;
cin >> buf;
if (buf == "?")
a[i] = 0, mark[i] = 1;
else
a[i] = atoi(buf.c_str()), mark[i] = 0;
}
for (int st = 1; st <= k; ++st) {
for (int i = st; i + k <= n; i += k)
if (!mark[i] && !mark[i + k] && a[i] >= a[i + k]) {
puts("Incorrect sequence");
return 0;
}
int x, y = st;
while (1) {
for (x = y; x <= n && !mark[x]; x += k)
;
if (x > n) break;
int cnt = 0;
for (y = x; y <= n && mark[y]; y += k) ++cnt;
int v1, v2;
if (x - k < 1)
v1 = -1000100000;
else
v1 = a[x - k];
if (y > n)
v2 = 1000100000;
else
v2 = a[y];
if (cnt > v2 - v1 - 1) {
puts("Incorrect sequence");
return 0;
}
if (v1 < 0 && v2 > 0) {
int v = -(cnt / 2);
while (v <= v1) ++v;
while (v + cnt - 1 >= v2) --v;
cnt = v;
} else if (v1 >= 0 && v2 >= 0) {
cnt = v1 + 1;
} else {
cnt = v2 - cnt;
}
for (int i = x; i < y; i += k) a[i] = cnt++;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, k;
int vis[N];
int pos[N];
long long a[N];
long long ABS(long long x) { return x < 0 ? -x : x; }
int get(int len, long long down, long long up, int t) {
if (t == 1) {
long long be = -len / 2 + len;
if (be < up)
return -len / 2;
else
return up - len;
} else if (t == -1) {
long long be = len / 2 - len + 1;
if (be > down)
return be;
else
return down + 1;
} else {
long long be = -len / 2;
long long tot1 = 0, tot2 = 0, tot3 = 0, now1 = down + 1, now2 = up - 1;
for (int i = 0; i < len; i++) tot1 += ABS(now1), now1++;
for (int i = 0; i < len; i++) tot2 += ABS(now2), now2--;
if (down < be && -be < up) {
for (int i = 0; i < len; i++) tot3 += be, be++;
} else
tot3 = 1LL << 50;
if (tot1 <= tot2 && tot1 <= tot3) return down + 1;
if (tot2 <= tot1 && tot2 <= tot3) return now2 + 1;
if (tot3 <= tot1 && tot3 <= tot2) return -len / 2;
}
}
bool work(int be) {
int cnt = 0, num = 0;
for (int i = be; i <= n; i += k) {
pos[++cnt] = i;
if (vis[i]) num++;
}
if (num == 0) {
for (int i = be + k; i <= n; i += k)
if (a[i] <= a[i - k]) return false;
return true;
}
if (cnt == num) {
int st = -cnt / 2;
for (int i = be; i <= n; i += k)
if (vis[i]) a[i] = st++;
} else {
if (vis[be]) {
int len = 0;
long long up;
for (int i = be; i <= n; i += k)
if (!vis[i]) {
up = a[i];
len = i - k;
break;
}
long long st = get((len - be) / k + 1, 0, up, 1);
for (int i = be; i <= len; i += k)
if (vis[i]) a[i] = st++;
}
if (vis[pos[cnt]]) {
int len = 0;
long long down;
for (int i = cnt; i >= 1; i--) {
int in = pos[i];
if (!vis[in]) {
down = a[in];
len = i;
break;
}
}
long long st = get(cnt - len, down, 0, -1);
for (int i = len + 1; i <= cnt; i++)
if (vis[pos[i]]) a[pos[i]] = st++;
}
int last = 1;
for (int i = 2; i <= cnt; i++) {
int in = pos[i], on = pos[last];
if (!vis[in]) {
if (a[in] - a[on] - 1 < i - last - 1) {
return false;
}
long long st = get(i - last - 1, a[on], a[in], 0);
for (int j = last + 1; j < i; j++)
if (vis[pos[j]]) a[pos[j]] = st++;
last = i;
}
}
}
return true;
}
int main() {
scanf("%d%d", &n, &k);
memset(a, 0, sizeof(a));
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
char s[15];
scanf("%s", s);
if (s[0] == '?')
vis[i]++;
else
sscanf(s, "%I64d", &a[i]);
}
int flag = 0;
for (int i = 1; i <= k && !flag; i++)
if (!work(i)) flag = 1;
if (flag)
puts("Incorrect sequence");
else {
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
cout << a[i];
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long nmax = 2 * 1e5 + 42, inf = 1e9 + 1e6;
long long n, k;
string inp[nmax];
pair<long long, long long> seen[nmax];
long long outp[nmax];
long long take(string s) {
long long mult = 1;
long long ret = 0;
for (auto k : s)
if (k == '-')
mult = -1;
else
ret = ret * 10 + (k - '0');
return ret * mult;
}
void make(long long i) {
if (seen[i % k].first >= 0 && outp[i] >= 0) {
long long now = seen[i % k].first;
for (long long j = seen[i % k].second + k; j < i; j = j + k) {
now++;
outp[j] = now;
}
for (long long j = seen[i % k].second + k; j < i && j < n; j = j + k)
if (j - k >= 0 && outp[j - k] >= outp[j]) assert(0 == 1);
return;
}
if (seen[i % k].first <= 0 && outp[i] <= 0) {
long long now = outp[i];
for (long long j = i - k; j > seen[i % k].second; j = j - k) {
now--;
outp[j] = now;
}
for (long long j = seen[i % k].second + k; j < i && j < n; j = j + k)
if (j - k >= 0 && outp[j - k] >= outp[j]) {
cout << ":(" << endl;
exit(0);
}
return;
}
long long d = (i - seen[i % k].second) / k - 1;
if (d == 0) return;
deque<long long> help = {0};
for (long long v = 1; help.size() < d; v++) {
if (seen[i % k].first < -v) help.push_front(-v);
if (help.size() == d) break;
if (outp[i] > v) help.push_back(v);
}
for (long long p = seen[i % k].second + k; p < i; p = p + k) {
if (help.size() == 0) {
cout << "y" << endl;
exit(0);
}
outp[p] = help.front();
help.pop_front();
}
if (help.size()) {
cout << "qqq" << endl;
exit(0);
}
for (long long j = seen[i % k].second + k; j < i && j < n; j = j + k)
if (j - k >= 0 && outp[j - k] >= outp[j]) {
cout << ":(" << endl;
exit(0);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> inp[i];
for (long long i = 0; i < k; i++) seen[i] = {-(inf), i - k};
for (long long i = 0; i < n; i++)
if (inp[i] != "?") {
outp[i] = take(inp[i]);
if (seen[i % k].first + (i - seen[i % k].second) / k <= outp[i]) {
make(i);
} else {
cout << "Incorrect sequence" << endl;
return 0;
}
seen[i % k] = {outp[i], i};
}
for (long long i = n; i - k + 1 <= n; i++)
if (seen[i % k].second + k != i) {
outp[i] = inf;
make(i);
}
for (long long i = 0; i < n; i++) cout << outp[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 6 * 1e5;
const int Q = 1e9 + 7 + 500000;
void fin() {
puts("Incorrect sequence");
exit(0);
}
int a[M];
int go(string s) {
int res = 0, l = 0, tq = 0;
if (s[0] == '-') l = 1, tq = 1;
for (int i = tq; i < (int)s.size(); i++) res = res * 10 + s[i] - '0';
if (l) return -res;
return res;
}
int main() {
srand(time(NULL));
int k, n;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "?")
a[i] = Q;
else
a[i] = go(s);
}
for (int kk = 0; kk < k; kk++) {
vector<int> g;
g.push_back(-Q);
for (int i = kk; i < n; i += k) g.push_back(a[i]);
g.push_back(Q);
int i = 0;
while (i < (int)g.size() - 1) {
int j = i + 1;
while (j < (int)g.size() - 1 && abs(g[j]) > 1e9) j++;
int aa = g[i], bb = g[j], h = j - i - 1;
int t = (bb - (h - 1) - (aa + 1));
if (aa >= bb || (h && t < 1)) fin();
int pos = aa + 1 + h / 2;
if (pos < 0) aa += (min(pos + t - 1, 0) - pos);
for (int kkk = i + 1; kkk < j; kkk++)
a[kk + (kkk - 1) * k] = aa + 1 + (kkk - (i + 1));
i = j;
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > DP;
long long N, k;
long long INF = 10000000000;
long long sstoi(string s) {
bool ok = 0;
if (s[0] == '-') {
ok = 1;
s.erase(0, 1);
}
long long ans = 0;
long long i, j, k;
j = 1;
for (i = s.size() - 1; i >= 0; i--) {
ans += (s[i] - '0') * j;
j *= 10;
}
if (ok == 1) ans = -ans;
return ans;
}
bool FL(long long n, long long x) {
long long i, j, n1, n2, n3;
n1 = (x - 1) / 2;
if (DP[n][x] > n1)
n1 = n1;
else
n1 = DP[n][x] - 1;
for (i = x - 1; i >= 0; i--) {
DP[n][i] = n1;
n1--;
}
return 1;
}
bool FF(long long n, long long x, long long y) {
if (x + 1 == y) {
if (DP[n][y] <= DP[n][x]) return 0;
return 1;
}
long long i, j, k, n1, n2, n3, m, L, R;
m = (y - x - 1);
if (DP[n][x] + m + 1 > DP[n][y]) return 0;
L = -m / 2;
R = m / 2;
if (DP[n][x] >= L) {
for (i = x + 1; i < y; i++) {
DP[n][i] = DP[n][x] + (i - x);
}
} else if (DP[n][y] <= R) {
for (i = y - 1; i > x; i--) {
DP[n][i] = DP[n][y] - (y - i);
}
} else {
n1 = L;
for (i = x + 1; i < y; i++) {
DP[n][i] = n1;
n1++;
}
}
return 1;
}
bool FR(long long n, long long y) {
long long i, j, k, n1, n2, n3, m, L, R, LL;
LL = DP[n].size();
m = (LL - y - 1);
L = -m / 2;
R = m / 2;
if (DP[n][y] >= L) L = DP[n][y] + 1;
for (i = y + 1; i < LL; i++) {
DP[n][i] = L;
L++;
}
return 1;
}
bool calculate(long long n) {
long long i, j, k, n1, n2, n3, L, R;
j = 0;
while (j < DP[n].size() && DP[n][j] == INF) j++;
if (j == DP[n].size()) {
n1 = DP[n].size();
n2 = n1 / 2;
n3 = -n1 / 2;
if (n2 > N) {
n3 = N - (n1 - 1);
}
for (i = 0; i < DP[n].size(); i++) {
DP[n][i] = n3;
n3++;
}
return 1;
}
L = j;
if (FL(n, L) == 0) return 0;
for (i = L + 1; i < DP[n].size(); i++) {
if (DP[n][i] == INF) continue;
R = i;
if (FF(n, L, R) == 0) return 0;
L = R;
}
if (DP[n][DP[n].size() - 1] == INF) {
if (FR(n, L) == 0) return 0;
}
return 1;
}
bool solve() {
long long i;
for (i = 0; i < k; i++) {
if (DP[i].size() == 0) continue;
if (calculate(i) == 0) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
long long i, j, n1, n2, n3;
cin >> N >> k;
string s;
DP.resize(k);
bool ok = 0;
for (i = 0; i < N; i++) {
cin >> s;
if (s == "?")
DP[(i % k)].push_back(INF);
else {
j = sstoi(s);
DP[(i % k)].push_back(j);
}
}
if (solve() == 0)
cout << "Incorrect sequence" << endl;
else {
for (i = 0; i < N; i++) {
if (i != 0) cout << ' ';
cout << DP[i % k][i / k];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
int n, k;
int a[maxn];
char s[100];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
if (s[0] == '?')
a[i] = INF;
else
a[i] = atoi(s);
}
bool ok = true;
for (int i = n + 1; i <= n + k; i++) a[i] = INF + 1;
for (int i = 1; i <= k; i++) {
int prev = -INF;
int sum = 0;
for (int j = i; j <= n + k; j += k) {
if (a[j] == INF)
sum++;
else {
if (a[j] - prev <= sum) {
ok = false;
break;
}
int num;
if (prev >= -1)
num = prev + 1;
else if (a[j] <= 1)
num = a[j] - sum;
else
num = max(prev + 1, min(-sum / 2, a[j] - sum));
for (int l = sum; l > 0; l--) a[j - l * k] = num++;
sum = 0;
prev = a[j];
}
}
}
if (!ok)
puts("Incorrect sequence");
else
for (int i = 1; i <= n; i++) printf("%d%c", a[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 23, inf = 0x3f3f3f3f;
long long a[N];
inline long long inp() {
long long c = getchar(), x = 0;
bool neg = 0;
for (; ((c < 48 or c > 57) and c != '-' and c != '?'); c = getchar())
;
if (c == '?') return inf;
if (c == '-') neg = 1, c = getchar();
for (; c > 47 and c < 58; c = getchar()) x = (x << 1) + (x << 3) + c - 48;
return neg ? -x : x;
}
bool fix(long long st, long long en, long long n, long long k) {
long long lo = (st < 0 ? -inf : a[st]) + 1;
long long hi = (en >= n ? inf : a[en]) - 1;
long long num = (en - st) / k - 1;
if (hi - lo + 1 < num) return false;
if (lo >= 0) {
for (long long i = st + k; i < en; i += k) a[i] = lo++;
return true;
}
if (hi <= 0) {
for (long long i = en - k; i > st; i -= k) a[i] = hi--;
return true;
}
long long fst = (num - 1) / 2;
long long snd = num / 2;
if (fst > abs(lo)) {
snd += fst - abs(lo);
fst = abs(lo);
} else if (snd > hi) {
fst += snd - hi;
snd = hi;
}
long long cur = -fst;
for (long long i = st + k; i < en; i += k) a[i] = cur++;
return true;
}
bool go(long long r, long long n, long long k) {
long long prev = r - k;
for (long long i = r; i < n; i += k) {
if (a[i] < inf) {
if (prev >= 0 and a[prev] >= a[i]) return false;
prev = i;
continue;
}
while (i < n and a[i] == inf) i += k;
bool can = fix(prev, i, n, k);
if (!can) return false;
prev = i;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n = inp(), k = inp();
for (long long i = 0; i < n; i++) a[i] = inp();
for (long long i = 0; i < k; i++)
if (!go(i, n, k)) {
cout << "Incorrect sequence\n";
return 0;
}
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long l = v.size();
for (long long i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
long long n, k;
vector<long long> v;
vector<bool> check;
void solve(long long beg, long long end, long long i) {
long long left = INT_MIN, right = INT_MAX;
long long cnt = (end - beg) / k + 1;
if (beg != i) left = v[beg - k];
if (end + k <= n) right = v[end + k];
if (left != INT_MIN and right != INT_MAX) {
if (v[end + k] - v[beg - k] - 1 < cnt) {
cout << "Incorrect sequence\n";
exit(0);
}
}
if (left >= 0) {
long long val = left + 1;
for (long long p = beg; p <= end; p += k) v[p] = val++;
return;
} else if (right <= 0) {
long long val = right - 1;
for (long long p = end; p >= beg; p -= k) v[p] = val--;
return;
}
set<long long> val;
val.insert(0);
long long x = 1, done = 1;
while (done < cnt) {
if (-1 * x > left) {
val.insert(-1 * x);
done++;
}
if (done == cnt) break;
if (x < right) {
val.insert(x);
done++;
}
x++;
}
for (long long p = beg; p <= end; p += k) {
v[p] = (*val.begin());
val.erase(*val.begin());
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
v.resize(n + 1, 0);
check.resize(n + 1, false);
for (long long i = 1; i <= n; i++) {
string x;
cin >> x;
if (x == "?")
check[i] = true;
else {
long long num = 0;
for (long long j = 0; x[j] != '\0'; j++) {
if (x[j] == '-') continue;
num = num * 10 + (x[j] - '0');
}
if (x[0] == '-') num = -num;
v[i] = num;
}
}
for (long long i = 1; i <= k; i++) {
long long f = -1, l = -1;
long long mn = INT_MIN;
long long j;
for (j = i; j <= n; j += k) {
if (check[j] == true and f == -1)
f = j;
else if (check[j] != true and f != -1) {
l = j - k;
solve(f, l, i);
f = -1;
l = -1;
} else if (check[j] != true and v[j] <= mn) {
cout << "Incorrect sequence\n";
return 0;
}
if (check[j] == false) mn = v[j];
}
if (f != -1) solve(f, j - k, i);
}
for (long long i = 1; i <= n; i++) cout << v[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 1;
void fail() {
printf("Incorrect sequence\n");
exit(0);
}
int main() {
int n, k, x;
char c;
scanf("%d %d", &n, &k);
vector<vector<int> > chain(k);
for (int i = 0; i < n; ++i) {
scanf(" %c", &c);
x = oo;
if (c != '?') {
ungetc(c, stdin);
scanf("%d", &x);
}
chain[i % k].push_back(x);
}
for (auto &ch : chain) {
int sz = (int)ch.size();
if (!sz) continue;
int lf = 0;
while (lf < sz && ch[lf] == oo) ++lf;
if (lf == sz) {
lf /= 2;
lf *= -1;
for (int &el : ch) el = lf++;
continue;
}
if (lf > 0) {
if (ch[lf] > (lf - 1) / 2) {
int val = -lf / 2;
for (int i = 0; i < lf; ++i) {
ch[i] = val++;
}
} else {
for (int i = lf - 1; i >= 0; --i) {
ch[i] = ch[i + 1] - 1;
}
}
}
int prev = ch[lf];
while (lf < sz - 1) {
int rg = lf + 1;
while (rg < sz && ch[rg] == oo) ++rg;
int tam = rg - lf - 1;
if (rg == sz) {
if (prev < -(tam - 1) / 2) {
int val = tam / 2;
for (int i = sz - 1; i > lf; --i) {
ch[i] = val--;
}
} else {
for (int i = lf + 1; i < sz; ++i) {
ch[i] = ch[i - 1] + 1;
}
}
break;
}
tam /= 2;
if (prev + rg - lf > ch[rg]) fail();
if (prev >= -tam) {
for (int i = lf + 1; i < rg; ++i) {
ch[i] = ch[i - 1] + 1;
}
} else if (ch[rg] <= tam) {
for (int i = rg - 1; i > lf; --i) {
ch[i] = ch[i + 1] - 1;
}
} else {
int val = -tam;
for (int i = lf + 1; i < rg; ++i) ch[i] = val++;
}
lf = rg;
prev = ch[rg];
}
}
for (int i = 0, x = 0, y = 0; i < n; ++i) {
printf("%d ", chain[x][y]);
++x;
if (x == k) x = 0, ++y;
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 110;
const int INF = 1e9 + 1e6;
bool vis[N];
int a[N], b[N];
void add(int *a, int n, int L, int R) {
if (R - L <= n) return;
if (L >= 0) {
for (int i = 0; i < n; i++) a[i] = ++L;
} else if (R <= 0) {
for (int i = n - 1; i >= 0; i--) a[i] = --R;
} else {
int t = n / 2, f = 0, l = -INF;
for (int i = t; i >= 0; i--)
if (L < -i && n - i - 1 < R) {
l = -i;
f = 1;
break;
}
for (int i = t; i < n && !f; i++)
if (L < -i && n - i - 1 < R) {
l = -i;
f = 1;
break;
}
for (int i = 0; i < n; i++) a[i] = l++;
}
}
void read(int i) {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && (ch != '-') && (ch != '?')) ch = getchar();
if (ch == '?') vis[i] = 1;
if (ch == '-') f = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
a[i] = f * x;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) read(i);
int F = 1;
for (int i = 0; i < k; i++) {
int p = 0, f = 0, tp = 0;
for (int j = i; j < n; j += k, tp++) {
if (vis[j]) {
if (!f) p = tp;
f = 1;
} else {
if (f) {
if (p == 0)
add(b + p, tp - p, -INF, a[j]);
else
add(b + p, tp - p, b[p - 1], a[j]);
}
f = 0;
}
b[tp] = a[j];
}
if (f) {
if (p == 0)
add(b + p, tp - p, -INF, INF);
else
add(b + p, tp - p, b[p - 1], INF);
}
for (int j = 1; j < tp; j++)
if (b[j] <= b[j - 1]) {
F = 0;
break;
}
tp = 0;
for (int j = i; j < n; j += k, tp++) a[j] = b[tp];
}
if (!F)
printf("Incorrect sequence\n");
else {
for (int i = 0; i < n; i++) printf("%d ", a[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * asin(1.0);
const int INF = 1000000000;
const double EPS = 1e-10;
inline int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
const int MAXN = 100005;
string vet[MAXN];
long long ans[MAXN];
int main() {
long long n, k;
while (cin >> n >> k) {
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
vet[i] = s;
if (s.compare("?") != 0) {
stringstream ss;
ss << s;
long long val;
ss >> val;
ans[i] = val;
}
}
bool ok = true;
for (int j = 0; j < n; ++j) {
long long it = j;
if (vet[it].compare("?") == 0) {
long long lo = -INF, hi = INF;
lo *= 100LL, hi *= 100LL;
if (it - k >= 0) lo = ans[it - k];
long long nit = it, cnt = 0;
while (nit < n && vet[nit].compare("?") == 0) nit += k, cnt++;
if (nit < n) hi = ans[nit];
long long inf = lo + 1, sup = hi - cnt;
if (sup < inf) {
ok = false;
break;
}
long long s = -cnt / 2;
if (s < inf) {
s = inf;
} else if (s > sup) {
s = sup;
}
while (it < nit) {
ans[it] = s++;
vet[it] = "x";
it += k;
}
}
}
for (int j = k; j < n; ++j)
if (ans[j - k] >= ans[j]) ok = false;
if (ok) {
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
cout << endl;
} else {
cout << "Incorrect sequence" << endl;
}
}
}
|
#include <bits/stdc++.h>
const double EPS = 1e-9;
const double PI = acos(-1.0);
const long long INF = 1070000000LL;
const long long MOD = 1000000007LL;
using namespace std;
int n, k;
vector<long long> v[100010];
vector<long long> val[100010];
int curs[100010];
void fail() {
cout << "Incorrect sequence" << endl;
exit(0);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (long long i = (long long)(0); i < (long long)(n); i++) {
string s;
cin >> s;
if (s[0] == '?')
v[i % k].push_back(INF);
else {
istringstream is(s);
int a;
is >> a;
v[i % k].push_back(a);
}
}
for (long long ind = (long long)(0); ind < (long long)(k); ind++) {
vector<long long> fixed;
vector<long long> q(1);
for (long long i = (long long)(0);
i < (long long)(((long long)(v[ind]).size())); i++) {
if (v[ind][i] != INF) {
fixed.push_back(v[ind][i]);
q.push_back(0);
} else {
q.back()++;
}
}
if (((long long)(fixed).size()) == 0) {
int from = -((q[0] - 1) / 2);
for (long long i = (long long)(from); i < (long long)(from + q[0]); i++) {
val[ind].push_back(i);
}
} else {
for (long long i = (long long)(0);
i < (long long)(((long long)(fixed).size()) - 1); i++) {
if (fixed[i] >= fixed[i + 1]) fail();
}
for (long long i = (long long)(0);
i < (long long)(((long long)(q).size())); i++) {
vector<long long> add;
if (q[i] == 0) continue;
if (i == 0) {
int from = min(fixed[0] - 1, 0LL);
add.push_back(from);
int dif = 1;
int dir = +1;
while (((long long)(add).size()) < q[i]) {
int cur = from + dif * dir;
if (cur < fixed[0]) {
add.push_back(cur);
}
if (dir == +1)
dir = -1;
else
dir = +1, dif++;
}
} else if (i == ((long long)(q).size()) - 1) {
int from = max(fixed.back() + 1, 0LL);
add.push_back(from);
int dif = 1;
int dir = +1;
while (((long long)(add).size()) < q[i]) {
int cur = from + dif * dir;
if (cur > fixed.back()) {
add.push_back(cur);
}
if (dir == +1)
dir = -1;
else
dir = +1, dif++;
}
} else {
int L = fixed[i - 1] + 1, R = fixed[i] - 1;
if (!(L <= R)) fail();
int from = min(R, max(L, 0));
add.push_back(from);
int dif = 1;
int dir = +1;
int failcombo = 0;
while (((long long)(add).size()) < q[i]) {
int cur = from + dif * dir;
if (L <= cur && cur <= R) {
add.push_back(cur);
failcombo = 0;
} else {
failcombo++;
if (failcombo == 2) fail();
}
if (dir == +1)
dir = -1;
else
dir = +1, dif++;
}
}
sort((add).begin(), (add).end());
for (long long j = (long long)(0);
j < (long long)(((long long)(add).size())); j++)
val[ind].push_back(add[j]);
}
}
}
for (long long i = (long long)(0); i < (long long)(n); i++) {
if (v[i % k][i / k] != INF)
cout << v[i % k][i / k] << " ";
else {
cout << val[i % k][curs[i % k]++] << " ";
}
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const int INF = -(int)2e9;
int a[N], mark[N];
char buf[20];
vector<int> dep[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, kk;
cin >> n >> kk;
memset(mark, 0, sizeof(mark));
memset(a, 0, sizeof(a));
for (int i = 0; i < (n); ++i) {
cin >> buf;
if (buf[0] == '?')
mark[i] = true;
else
sscanf(buf, "%d", a + i);
}
for (int i = 0; i < (n); ++i) {
dep[i % kk].push_back(i);
}
for (int i = 0; i < (kk); ++i)
if (((int)dep[i].size()) > 1) {
int lastFixed = INF;
for (int j = 0; j < ((int)dep[i].size()); ++j) {
if (!mark[dep[i][j]]) {
if (a[dep[i][j]] <= lastFixed) {
cout << "Incorrect sequence\n";
return 0;
}
lastFixed = a[dep[i][j]];
continue;
}
int k = j;
while (k < ((int)dep[i].size()) and mark[dep[i][k]] > 0) ++k;
assert(j < k);
int len = (k - j);
if (k == ((int)dep[i].size())) {
if (lastFixed == INF) {
for (int l = j; l < k; ++l) a[dep[i][l]] = -(len / 2) + (l - j);
} else if (lastFixed >= 0) {
for (int l = j; l < k; ++l) a[dep[i][l]] = lastFixed + l - j + 1;
} else {
int minv = max(-(len / 2), lastFixed + 1);
for (int l = j; l < k; ++l) a[dep[i][l]] = minv + (l - j);
}
} else {
if (lastFixed == INF) {
if (a[dep[i][k]] <= 0) {
for (int l = k - 1; l >= j; --l)
a[dep[i][l]] = a[dep[i][k]] - (k - l);
} else {
int maxv = min((len / 2), a[dep[i][k]] - 1);
for (int l = k - 1; l >= j; --l)
a[dep[i][l]] = maxv - (k - l - 1);
}
} else {
if ((long long)a[dep[i][k]] - (long long)lastFixed <= len) {
cout << "Incorrect sequence\n";
return 0;
}
if (a[dep[i][k]] < 0 and lastFixed < 0) {
for (int l = k - 1; l >= j; --l)
a[dep[i][l]] = a[dep[i][k]] - (k - l);
} else if (a[dep[i][k]] >= 0 and lastFixed >= 0) {
for (int l = j; l < k; ++l) a[dep[i][l]] = lastFixed + l - j + 1;
} else {
if (abs(a[dep[i][k]]) <= abs(lastFixed)) {
int maxv = min((len / 2), a[dep[i][k]] - 1);
for (int l = k - 1; l >= j; --l)
a[dep[i][l]] = maxv - (k - l - 1);
} else {
int minv = max(-(len / 2), lastFixed + 1);
for (int l = j; l < k; ++l) a[dep[i][l]] = minv + (l - j);
}
}
}
}
j = k - 1;
}
}
for (int i = 0; i < (n); ++i) cout << a[i] << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 2e9;
const int lim = 1e9;
int ans[N];
vector<int> num[N];
vector<int> at[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
k = min(k, n);
for (int i = 0; i < n; i++) {
char s[100];
scanf("%s", s);
ans[i] = (s[0] == '?' ? inf : atoi(s));
num[i % k].push_back(ans[i]);
at[i % k].push_back(i);
}
for (int i = 0; i < k; i++) {
int bef = -inf;
for (auto it : num[i]) {
if (it == inf)
bef++;
else if (bef <= it)
bef = it + 1;
else {
puts("Incorrect sequence");
return 0;
}
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < num[i].size(); j++) {
int pt = j;
while (num[i][pt] == inf && pt < num[i].size()) pt++;
int pol = (pt == num[i].size() ? inf : num[i][pt]);
int pil = (j == 0 ? -inf : num[i][j - 1] + 1);
int cnt = pt - j;
int start = (-cnt / 2);
start = max(start, pil);
start = min(start, pol - cnt);
for (; j < pt; j++, start++) {
num[i][j] = start;
ans[at[i][j]] = start;
}
}
}
for (int i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int DEBUG = 1;
const int maxn = 2e5;
int a[maxn];
int b[maxn];
int us[maxn];
long long l[maxn];
long long r[maxn];
int n, k;
void tlen() {
cout << "Incorrect sequence" << endl;
exit(0);
}
void koko(vector<int>& a) {
vector<int> b(a.size());
int l = 0, r = a.size() - 1;
for (int i = a.size() - 1; i >= 0; i--) {
if (a[i] <= 0)
b[l] = a[i], l++;
else
b[r] = a[i], r--;
}
swap(a, b);
}
inline void solve(vector<int>& y, long long r) {
if (y.empty()) return;
long long l = ::l[y[0]];
vector<int> ans1, ans2, ans3;
long long a1, a2, a3 = a2 = a1 = 3e15;
if (l <= 0 && 0 < r) {
vector<int> pl, mn;
pl.push_back(0);
a1 = 0;
int d = 0;
bool f = ans1.size() < y.size();
for (d = 1; f; d++) {
if (pl.size() + mn.size() == y.size()) break;
if (l <= -d) a1 += d, f = 1, mn.push_back(-d);
if (pl.size() + mn.size() == y.size()) break;
if (d < r) a1 += d, f = 1, pl.push_back(d);
if (pl.size() + mn.size() == y.size()) break;
}
ans1.insert(ans1.end(), mn.rbegin(), mn.rend());
ans1.insert(ans1.end(), pl.begin(), pl.end());
if (ans1.size() != y.size()) a1 = 3e15;
}
a2 = 0;
for (int i = 0; i < (int)y.size(); i++) {
if (l + i >= r) break;
ans2.push_back(i + l);
a2 += abs(i + l);
}
if (ans2.size() < y.size()) a2 = 3e15;
a3 = 0;
for (int i = 0; i < (int)y.size(); i++) {
if (r - i - 1 < l) break;
ans3.push_back(r - i - 1);
a3 += abs(r - i - 1);
}
reverse(ans3.begin(), ans3.end());
if (ans3.size() < y.size()) a3 = 3e15;
vector<int> ans;
long long dlt;
bool f = 1;
if (a1 <= a2 && a1 <= a3) {
f = 0, swap(ans, ans1);
}
if (a2 <= a1 && a2 <= a3) {
swap(ans, ans2);
}
if (a3 <= a2 && a3 <= a1) {
swap(ans, ans3);
}
if (ans.size() != y.size()) tlen();
for (int i = 0; i < (int)y.size(); i++) a[y[i]] = ans[i];
y.clear();
}
char s[100];
int matoi(string& s) {
int x = 0;
int f = 0;
if (s[0] == '-') f = 1;
for (int i = 0; i < (int)s.size() - f; i++) x = 10 * x + s[i + f] - '0';
if (f) return -x;
return x;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < (int)n; i++) {
string s;
cin >> s;
if (s[0] != '?')
a[i] = matoi(s);
else
b[i] = 1;
}
vector<int> y;
for (int i = 0; i < min(n, k); i++) {
if (b[i]) {
l[i] = -2e9;
y.push_back(i);
} else
l[i] = a[i];
int j = i + k;
for (; j < n; j += k) {
if (b[j]) {
l[j] = l[j - k] + 1;
y.push_back(j);
} else {
if (a[j] <= l[j - k]) tlen();
solve(y, a[j]);
l[j] = a[j];
}
}
solve(y, 2e9);
}
for (int i = 0; i < (int)n; i++) cout << a[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long p[100010], e[100010];
void fill(int x, int m, long long l, long long r) {
if (r - l - 1 < m) {
cout << "Incorrect sequence" << endl;
exit(0);
}
if (m == 0) return;
if (r <= 0) {
for (int i = 0; i < m; i++) p[x + i * k] = r - (m - i), e[x + i * k] = 0;
} else if (l >= 0) {
for (int i = 0; i < m; i++) p[x + i * k] = l + 1 + i, e[x + i * k] = 0;
} else {
int cnt = 1;
long long ll = -1, rr = 1;
while (cnt < m) {
if ((rr >= r || abs(ll) < abs(rr)) && ll > l)
ll--;
else
rr++;
cnt++;
}
for (int i = 0; i < m; i++) p[x + i * k] = ll + 1 + i, e[x + i * k] = 0;
}
}
int main() {
scanf("%d %d", &n, &k);
char s[200];
for (int i = 0; i < n; i++) {
scanf("%s ", s);
if (s[0] == '?')
e[i] = 1;
else
p[i] = atoi(s);
}
for (int i = 0; i < n; i++) {
int cnt = 0;
while (i + cnt * k < n && e[i + cnt * k]) cnt++;
long long l = -10000000000LL, r = 10000000000LL;
if (i + cnt * k < n) r = p[i + cnt * k];
if (i >= k) l = p[i - k];
fill(i, cnt, l, r);
}
for (int i = 0; i < n; i++) cout << p[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qst = (1000LL * 1000LL * 1000LL + 11LL);
long long mn = -(qst * qst / 10), mx = (qst * qst / 10);
bool putNums(vector<pair<long long, long long> > &rng1,
vector<pair<long long, long long> > &rng2, vector<long long> &a,
long long first, long long k) {
long long n = (a.size() - 2);
for (long long j = 0; j < rng1.size(); j++) {
long long lf = rng1[j].first, rt = rng1[j].second;
long long xx = rng2[j].first, yy = rng2[j].second;
long long diff = rng2[j].second - rng2[j].first - 1;
if ((diff) > (a[rt] - a[lf] - 1)) return false;
if (a[rt] >= 0 && a[lf] >= 0) {
assert(lf > 0);
long long z = a[lf];
for (long long i = lf + k; i < rt; i += k) a[i] = ++z;
} else if (a[rt] <= 0 && a[lf] <= 0) {
assert(rt < (n + 1));
long long val = a[rt];
for (long long i = rt - k; i > lf; i -= k) a[i] = --val;
} else {
long long x;
if (abs(a[lf]) >= abs(a[rt])) {
x = diff >> 1;
x = min(x, abs(a[rt]));
if (x == abs(a[rt])) x--;
long long lst =
(rt == (n + 1)) ? (first + ((n - first) / k) * k) : (rt - k);
for (long long i = lst; i > lf; i -= k) a[i] = (x--);
} else {
x = diff >> 1;
x = min(x, abs(a[lf]));
long long val = -x;
if (x == abs(a[lf])) val++;
for (long long i = lf + (lf == 0 ? first : k); i < rt; i += k)
a[i] = val++;
}
}
}
return true;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(n + 2, 0);
a[0] = mn;
a[n + 1] = mx;
for (long long i = 0; i < (n); i++) {
string s;
cin >> s;
long long p;
if (s == "?")
p = qst;
else
p = stoll(s);
a[i + 1] = p;
}
for (long long i = 1; i <= k; i++) {
vector<long long> v;
vector<pair<long long, long long> > rng1, rng2;
v.push_back(0);
for (long long j = i; j <= n; j += k) {
long long z = a[*(v.end() - 1)];
if (z != qst && a[j] != qst && a[j] <= z) {
cout << "Incorrect sequence";
return 0;
}
v.push_back(j);
}
v.push_back(n + 1);
for (long long l = 1, r = 0; l < (v.size()); l++) {
while (a[v[++r]] == qst)
;
if (l != r) {
rng1.push_back(pair<long long, long long>(v[l - 1], v[r]));
rng2.push_back(pair<long long, long long>(l - 1, r));
}
l = r;
}
if (!putNums(rng1, rng2, a, i, k)) {
cout << "Incorrect sequence";
return 0;
}
}
for (long long i = 1; i < n; i++) cout << a[i] << ' ';
cout << a[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ad, a[444444], u[444444];
char str[11];
int getnum(char str[]) {
int ret = 0, neg = -1, i = 1;
if (str[0] != '-') {
neg = 1;
i = 0;
}
for (; str[i]; i++) {
ret = ret * 10 + str[i] - '0';
}
ret *= neg;
return ret;
}
int main() {
int i, j, fg = 0, nd, pd, ll, lt, rt, ds, mid, ld;
scanf("%d%d", &n, &k);
ad = k;
for (i = 1; i <= n; i++) {
scanf("%s", str);
if (str[0] == '?')
a[i + ad] = 1;
else
u[i + ad] = getnum(str);
}
for (i = 1; i <= ad; i++) {
u[i] = -1010000000 + i;
u[ad + n + i] = 1010000000 + i;
}
for (i = 1; i <= k; i++) {
if (fg) break;
nd = pd = -1;
ll = u[i];
for (j = i + k; j <= n + 2 * ad; j += k) {
if (a[j]) continue;
if (u[j] <= ll) {
fg = 1;
break;
}
ll = u[j];
}
if (fg) break;
for (j = i; j <= n + 2 * ad; j += k) {
if (pd == -1 && !a[j] && u[j] >= 0) {
pd = j;
break;
}
}
for (j = pd; j >= 1; j -= k) {
if (nd == -1 && !a[j] && u[j] < 0) {
nd = j;
break;
}
}
for (j = pd + k; j <= n + 2 * ad; j += k) {
ld = j - k;
if (!a[j]) {
if (u[ld] >= u[j]) fg = 1;
continue;
}
if (fg) break;
a[j] = 0;
u[j] = u[ld] + 1;
}
if (fg) break;
for (j = nd - k; j >= 1; j -= k) {
ld = j + k;
if (!a[j]) {
if (u[j] >= u[ld]) fg = 1;
continue;
}
if (fg) break;
a[j] = 0;
u[j] = u[ld] - 1;
}
mid = (pd - nd) / k - 1;
if (mid > u[pd] - u[nd]) {
fg = 1;
break;
}
lt = -((mid - 1) / 2);
rt = mid / 2;
if (u[pd] <= rt) {
ds = rt - u[pd] + 1;
rt -= ds;
lt -= ds;
}
if (u[nd] >= lt) {
ds = u[nd] - lt + 1;
rt += ds;
lt += ds;
}
for (j = nd + k; j < pd; j += k) {
u[j] = lt;
lt++;
}
}
if (fg)
puts("Incorrect sequence");
else {
for (i = k + 1; i <= k + n; i++) printf("%d ", u[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int a[N], n, k;
int in(string s) {
if (s[0] == '?')
return INF;
else {
int ans = 0, flag = 0;
for (int i = 0; i < (int)(s.size()); i++) {
if (s[i] == '-')
flag = 1;
else
ans = 10 * ans + s[i] - '0';
}
return flag ? -ans : ans;
}
}
long long getsum(int start, int n) {
long long ans = 0;
for (int i = 0; i < (int)(n); i++) {
ans += abs(start++);
}
return ans;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n >> k;
string s;
for (int i = (int)(1); i <= (int)(n); i++) {
cin >> s;
a[i] = in(s);
}
bool bad = 0;
for (int i = (int)(1); i <= (int)(k); i++) {
int j = i;
vector<int> tmp;
while (j <= n) {
tmp.push_back(a[j]);
j += k;
}
for (int t = 0; t < (int)(tmp.size()); t++) {
if (tmp[t] == INF) {
int now = t;
while (now < (int)tmp.size() && tmp[now] == INF) {
now++;
}
if (now == (int)tmp.size()) {
int st = -(now - t - 1) / 2;
if (t) {
st = max(tmp[t - 1] + 1, st);
}
for (int r = (int)(t); r <= (int)(tmp.size() - 1); r++) {
a[i + k * r] = st++;
}
} else {
if (t == 0) {
int st = -(now - t) / 2;
int ed = st + now - t - 1;
ed = min(ed, tmp[now] - 1);
for (int r = now - 1; r >= t; r--) {
a[i + k * r] = ed--;
}
} else {
int left = tmp[t - 1], right = tmp[now];
if (right - left <= now - t) {
bad = 1;
break;
}
int lo = left + 1, hi = right - (now - t);
while (lo + 5 < hi) {
int mid1 = (2LL * lo + hi) / 3;
int mid2 = (lo + 2LL * hi) / 3;
long long sum1 = getsum(mid1, now - t),
sum2 = getsum(mid2, now - t);
if (sum1 >= sum2) {
lo = mid1;
} else {
hi = mid2;
}
}
long long ans = 1LL << 60;
int id = INF;
for (int i = (int)(lo); i <= (int)(hi); i++) {
long long tmp = 0;
int tt = i;
for (int j = (int)(t); j <= (int)(now - 1); j++) {
tmp += abs(tt++);
}
if (tmp < ans) {
ans = tmp;
id = i;
}
}
lo = id;
for (int r = (int)(t); r <= (int)(now - 1); r++) {
a[i + k * r] = lo++;
}
}
}
t = now - 1;
}
}
if (bad) break;
}
if (!bad) {
for (int i = (int)(1); i <= (int)(n); i++) {
if (i + k <= n && a[i] >= a[i + k]) {
bad = 1;
break;
}
}
}
if (bad) {
cout << "Incorrect sequence" << endl;
} else {
for (int i = (int)(1); i <= (int)(n); i++) {
cout << a[i] << " \n"[i == n];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100010];
const long long inf = 1e15;
int main() {
int n, k;
char s[20];
scanf("%d", &n);
scanf("%d", &k);
vector<long long> seriesN, seriesL, seriesR, seriesStart;
for (int i = 0; i < n; i++) {
scanf("%s", s);
if (s[0] == '?')
arr[i] = inf;
else
arr[i] = atoi(s);
}
for (int i = 0; i < k; i++) {
long long prev = -inf, next;
long long curN = 0, curL = -inf, curR = 2 * inf, start;
for (int j = i; j < n; j += k) {
if (arr[j] != inf && prev != inf && arr[j] <= prev) {
printf("Incorrect sequence\n");
return 0;
}
if (arr[j] == inf) {
if (curN == 0) curL = prev, start = j;
curN++;
} else if (curN) {
seriesN.push_back(curN);
seriesL.push_back(curL);
seriesR.push_back(arr[j]);
seriesStart.push_back(start);
curN = 0;
}
prev = arr[j];
}
if (curN) {
seriesN.push_back(curN);
seriesL.push_back(curL);
seriesR.push_back(2 * inf);
seriesStart.push_back(start);
}
}
long long N = n;
for (int i = 0; i < seriesN.size(); i++) {
long long n = seriesN[i], l = seriesL[i], r = seriesR[i],
idx = seriesStart[i];
if (r - l - 1 < n) {
printf("Incorrect sequence\n");
return 0;
}
if (r <= 0) {
for (int i = idx, j = n; j > 0; i += k, j--) arr[i] = r - j;
} else if (l >= 0) {
for (int i = idx, j = 0; j < n; i += k, j++) arr[i] = l + j + 1;
} else {
long long cur = max(-n / 2, l + 1);
if (cur + n - 1 >= r) cur = r - n;
for (int i = idx, j = 0; j < n; i += k, j++) arr[i] = cur + j;
}
}
for (int i = 0; i < n; i++) printf("%lld ", arr[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 1e9 + 1e5 + 10;
int n, k, a[N];
char buffer[256];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%s", buffer);
if (buffer[0] == '?')
a[i] = M;
else
a[i] = atoi(buffer);
}
for (int i = 0; i < k; i++) {
int last_id, low, hi, now;
now = i;
low = -M;
while (now < n) {
if (a[now] == M) {
last_id = now;
for (; now < n && a[now] == M; now += k)
;
if (now >= n)
hi = M;
else
hi = a[now];
int r = (now - last_id) / k;
if ((hi - low) <= r) {
puts("Incorrect sequence");
return 0;
}
low = max(low, min(-(r + 2) / 2, hi - r - 1));
for (; last_id < now; last_id += k) {
low++;
a[last_id] = low;
}
}
if (now < n) {
if (a[now] <= low) {
puts("Incorrect sequence");
return 0;
}
low = a[now];
}
now += k;
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 10;
const double eps = 1e-5;
const int maxN = 1e5 + 100;
const int maxM = 1;
const int inf = 1e10;
int n, k;
vector<int> O[maxN];
string s;
int A[maxN];
inline void init() {
int t;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "?")
O[i % k].push_back(-inf);
else {
t = 0;
if (s[0] == '-') {
for (int i = 1; i < s.size(); i++) t = t * 10 + (s[i] - '0');
t = -t;
} else {
for (int i = 0; i < s.size(); i++) t = t * 10 + (s[i] - '0');
}
O[i % k].push_back(t);
}
}
for (int i = 0; i < k; i++) {
int s = -1;
for (int j = 0; j < O[i].size(); j++) {
if (O[i][j] == -inf) continue;
if (j - s > 1) {
int lo = (s == -1) ? -inf : O[i][s];
int up = O[i][j];
for (int x = s + 1; x < j; x++) O[i][x] = x - ((j + s) / 2);
int KL = O[i][s + 1];
if (O[i][s + 1] <= lo)
for (int x = s + 1; x < j; x++) O[i][x] += lo - KL + 1;
KL = O[i][j - 1];
if (O[i][j - 1] >= up)
for (int x = s + 1; x < j; x++) O[i][x] -= KL + 1 - up;
}
s = j;
}
if (s + 1 != O[i].size()) {
int lo = (s == -1) ? -inf : O[i][s];
for (int x = s + 1; x < O[i].size(); x++)
O[i][x] = x - ((O[i].size() + s) / 2);
int KL = O[i][s + 1];
if (O[i][s + 1] <= lo)
for (int x = s + 1; x < O[i].size(); x++) O[i][x] += lo - KL + 1;
}
}
for (int i = 0; i < k; i++) {
for (int j = 1; j < O[i].size(); j++) {
if (O[i][j] <= O[i][j - 1]) {
cout << "Incorrect sequence" << endl;
return;
}
}
}
for (int i = 0; i < n; i++) {
A[i] = O[i % k][i / k];
cout << A[i] << " ";
}
}
inline void solve() {}
int main() {
ios_base::sync_with_stdio(0);
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100005;
const int X = ~0U >> 1;
const int INF = (int)X - 5;
int n, k;
int b[maxn];
int a[maxn];
inline int read() {
char ch;
bool flag = false;
int a = 0;
while (!((((ch = getchar()) >= '0') && (ch <= '9')) || (ch == '-') ||
(ch == '?')))
;
if (ch == '?') return X;
if (ch != '-') {
a *= 10;
a += ch - '0';
} else
flag = true;
while (((ch = getchar()) >= '0') && (ch <= '9')) {
a *= 10;
a += ch - '0';
}
if (flag) {
a = -a;
}
return a;
}
inline bool jabs(int x) { return x < 0 ? 0 : 1; }
void solve() {
bool flag = false;
for (int T = 1; T <= k; T++) {
int t = 0;
for (int i = T; i <= n; i += k) b[++t] = i;
b[0] = 0;
b[++t] = n + 1;
int hloc, tloc;
int head, tail;
hloc = tloc = 0;
head = tail = -INF;
for (int i = 1; i <= t; i++) {
bool f = false;
if (a[b[i]] != X) {
f = true;
head = tail;
tail = a[b[i]];
hloc = tloc;
tloc = i;
}
if (f && (head >= tail || ((long long)tail - head) < (tloc - hloc))) {
flag = true;
break;
}
if (tloc - hloc > 1 && f) {
if (jabs(head) == jabs(tail)) {
if (jabs(tail)) {
for (int z = hloc + 1; z < tloc; z++) a[b[z]] = a[b[z - 1]] + 1;
} else {
for (int z = tloc - 1; z > hloc; z--) a[b[z]] = a[b[z + 1]] - 1;
}
} else {
int mi = ((((head) < 0 ? -(head) : (head))) <
(((tail) < 0 ? -(tail) : (tail)))
? (((head) < 0 ? -(head) : (head)))
: (((tail) < 0 ? -(tail) : (tail))));
int need = ((tloc - hloc - 1) / 2);
if (mi > need) {
a[b[tloc - 1]] = need;
for (int z = tloc - 2; z > hloc; z--) a[b[z]] = a[b[z + 1]] - 1;
} else {
if (((head) < 0 ? -(head) : (head)) == mi)
for (int z = hloc + 1; z < tloc; z++) a[b[z]] = a[b[z - 1]] + 1;
else
for (int z = tloc - 1; z > hloc; z--) a[b[z]] = a[b[z + 1]] - 1;
}
}
}
}
if (flag == true) break;
}
if (flag)
puts("Incorrect sequence");
else
for (int i = 1; i <= n; i++) printf("%d%c", a[i], i == n ? '\n' : ' ');
}
int main() {
while (~scanf("%d %d\n", &n, &k) && n) {
for (int i = 1; i <= n; i++) a[i] = read();
a[0] = -INF;
a[n + 1] = +INF;
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long l = v.size();
for (long long i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
long long n, k;
vector<long long> v;
vector<bool> check;
void solve(long long beg, long long end, long long i) {
if (beg == i or end + k > n) {
long long left = INT_MIN, right = INT_MAX;
long long cnt = (end - beg) / k + 1;
if (beg != i) left = v[beg - k];
if (end + k <= n) right = v[end + k];
if (left >= 0) {
long long val = left + 1;
for (long long p = beg; p <= end; p += k) v[p] = val++;
return;
} else if (right <= 0) {
long long val = right - 1;
for (long long p = end; p >= beg; p -= k) v[p] = val--;
return;
}
set<long long> val;
val.insert(0);
long long x = 1, done = 1;
while (done < cnt) {
if (-1 * x > left) {
val.insert(-1 * x);
done++;
}
if (done == cnt) break;
if (x < right) {
val.insert(x);
done++;
}
x++;
}
for (long long p = beg; p <= end; p += k) {
v[p] = (*val.begin());
val.erase(*val.begin());
}
} else {
long long cnt = (end - beg) / k + 1;
if (v[end + k] - v[beg - k] - 1 < cnt) {
cout << "Incorrect sequence\n";
exit(0);
}
if (v[beg - k] >= 0) {
long long val = v[beg - k] + 1;
for (long long p = beg; p <= end; p += k) v[p] = val++;
} else if (v[beg - k] <= 0 and v[end + k] <= 0) {
long long val = v[end + k] - 1;
for (long long p = end; p >= beg; p -= k) v[p] = val--;
} else {
long long left = v[beg - k], right = v[end + k];
set<long long> val;
val.insert(0);
long long x = 1, done = 1;
while (done < cnt) {
if (-1 * x > left) {
val.insert(-1 * x);
done++;
}
if (done == cnt) break;
if (x < right) {
val.insert(x);
done++;
}
x++;
}
for (long long p = beg; p <= end; p += k) {
v[p] = (*val.begin());
val.erase(*val.begin());
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
v.resize(n + 1, 0);
check.resize(n + 1, false);
for (long long i = 1; i <= n; i++) {
string x;
cin >> x;
if (x == "?")
check[i] = true;
else {
long long num = 0;
for (long long j = 0; x[j] != '\0'; j++) {
if (x[j] == '-') continue;
num = num * 10 + (x[j] - '0');
}
if (x[0] == '-') num = -num;
v[i] = num;
}
}
for (long long i = 1; i <= k; i++) {
long long f = -1, l = -1;
long long mn = INT_MIN;
long long j;
for (j = i; j <= n; j += k) {
if (check[j] == true and f == -1)
f = j;
else if (check[j] != true and f != -1) {
l = j - k;
solve(f, l, i);
f = -1;
l = -1;
} else if (check[j] != true and v[j] <= mn) {
cout << "Incorrect sequence\n";
return 0;
}
if (check[j] == false) mn = v[j];
}
if (f != -1) solve(f, j - k, i);
}
for (long long i = 1; i <= n; i++) cout << v[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
const int INF = 1001000001;
int a[maxn];
bool board[maxn];
int N, K;
void make(int cnt, int id, int l) {
int r = a[id];
long long x, y, z;
x = y = z = 0;
for (int i = 1; i <= cnt; i++) x += abs(l + i);
for (int i = 1; i <= cnt; i++) y += abs(r - i);
z = (long long)INF * INF;
if (r > 0 && l < 0 && cnt / 2 < r && cnt / 2 - cnt + 1 > l) {
z = 0;
for (int i = 0; i < cnt; i++) z += abs(cnt / 2 - i);
}
if (z <= x && z <= y) {
for (int i = 1; i <= cnt; i++) a[id - K * i] = cnt / 2 - i + 1;
} else if (x <= z && x <= y) {
for (int i = 1; i <= cnt; i++) a[id - K * (cnt - i + 1)] = l + i;
} else {
for (int i = 1; i <= cnt; i++) a[id - K * i] = r - i;
}
}
int main() {
cin >> N >> K;
for (int i = 1 + K; i <= N + K; i++) {
char s[100];
scanf("%s", s);
if (!strcmp("?", s))
board[i] = 1;
else
sscanf(s, "%d", a + i);
}
for (int i = 1; i <= K; i++) {
a[i] = -INF;
a[i + K + N] = INF;
}
bool wa = 0;
int cnt = 0;
for (int i = 1; i <= K; i++) {
int l = -INF;
for (int j = K + i; j <= N + K * 2; j += K) {
if (board[j]) {
cnt++;
} else {
if (a[j] - l <= cnt) {
wa = 1;
}
if (cnt > 0) make(cnt, j, l);
cnt = 0;
l = a[j];
}
}
}
if (wa)
printf("Incorrect sequence\n");
else
for (int i = 1 + K; i <= N + K; i++)
printf("%d%c", a[i], i == N + K ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e6 + 100;
const long long maxM = 1e3 + 100;
const long long mod = 1e9 + 7;
const long long hmod = 1e16 + 7;
const long double PI = 3.141592653;
const long double eps = 1e-8;
const long long D = 1379;
const long long INF = 1e18 + 20;
const long long Inf = 1e9 + 140;
void NO() {
cout << "Incorrect sequence" << endl;
exit(0);
}
void YES() {
cout << "YES" << endl;
exit(0);
}
long long n, k, a[maxN];
long long done(string s, long long p = 0) {
if (!p)
if (s[0] == '-') return -1 * done(s, 1);
long long x = 0;
for (long long i = p; i <= ((int)(s).size()) - 1; i++) {
x *= 10;
x += s[i] - '0';
}
return x;
}
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i <= n - 1; i++) {
cin >> s;
if (s[0] == '?')
a[i] = INF;
else
a[i] = done(s);
}
for (long long i = n; i <= n + k - 1; i++) a[i] = INF - 1;
for (long long i = 0; i <= k - 1; i++) {
long long m = -INF;
long long cnt = 0;
for (long long j = i; j < n + k; j += k) {
if (a[j] == INF)
cnt++;
else {
if (a[j] - m <= cnt) {
NO();
}
long long bagh = max(m + 1, min(-cnt / 2, a[j] - cnt));
for (long long x = cnt; x >= 1; x--) {
long long ind = j - x * k;
a[ind] = bagh++;
}
m = a[j];
cnt = 0;
}
}
}
for (long long i = 0; i <= n - 1; i++) cout << a[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int MAX_INT = 0x3f3f3f3f;
int seq[100010];
int convert(char a[]) {
int len = strlen(a), f, s;
if (a[0] == '-')
f = -1, s = 1;
else
f = 1, s = 0;
int ans = 0;
for (int i = s; i < len; ++i) ans = ans * 10 + a[i] - '0';
return f * ans;
}
void setnum(int to, int need, int da, int xiao) {
if ((-need / 2) <= xiao) {
int cn = 1;
for (int i = to - need * k; i < to; i += k) {
seq[i] = xiao + cn;
cn++;
}
} else if (need / 2 >= da) {
int cn = 1;
for (int i = to - k; i >= to - need * k; i -= k) {
seq[i] = da - cn;
cn++;
}
} else {
int cn = need / 2;
for (int i = to - k; i >= to - need * k; i -= k) {
seq[i] = cn;
cn--;
}
}
}
int main() {
scanf("%d%d", &n, &k);
char a[15];
for (int i = 0; i < n; ++i) {
scanf("%s", a);
if (strcmp(a, "?") == 0)
seq[i] = MAX_INT;
else
seq[i] = convert(a);
}
int flag = 0;
for (int i = 0; i < k; ++i) {
int j = i;
int need = 0;
while (j < n) {
if (seq[j] == MAX_INT) {
need++;
} else {
if (need == 0) {
if (j >= k && seq[j] <= seq[j - k]) {
flag = 1;
break;
}
} else {
if (j - (need + 1) * k >= 0) {
if (seq[j] - seq[j - (need + 1) * k] > need) {
setnum(j, need, seq[j], seq[j - (need + 1) * (k)]);
} else {
flag = 1;
break;
}
} else {
setnum(j, need, seq[j], -1e10);
}
need = 0;
}
}
j = j + k;
}
if (need > 0) {
if (j - (need + 1) * k >= 0) {
setnum(j, need, 1e10, seq[j - (need + 1) * k]);
} else {
setnum(j, need, 1e10, -1e10);
}
}
if (flag == 1) break;
}
if (flag == 1)
printf("Incorrect sequence\n");
else {
for (int i = 0; i < n; ++i) {
printf("%d ", seq[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, INF = 2000000000;
bool ques;
template <typename T>
void read(T &x) {
bool neg = false;
unsigned char c = getchar();
for (; ((c ^ 48) > 9) && c != '?'; c = getchar())
if (c == '-') neg = true;
if (c == '?') ques = true;
for (x = 0; (c ^ 48) < 10; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
if (neg) x = -x;
}
int n, k, a[N];
bool u[2 * N];
int first(int l, int r, int k) {
int ans = -k / 2;
if (ans <= l) ans = l + 1;
if (ans + k > r) ans = r - k;
return ans;
}
int main() {
read(n);
read(k);
for (int i = 0, i_end = n; i < i_end; ++i) {
ques = false;
read(a[i]);
if (ques) u[i] = true;
}
for (int i = 0, i_end = k; i < i_end; ++i) {
int last = i - k;
for (int j = i;; j += k)
if (!u[j]) {
int len = (j - last - k) / k, l, r;
if (len == 0) {
last = j;
if (j >= n) break;
continue;
}
if (last < 0)
l = -INF;
else
l = a[last];
if (j >= n)
r = INF;
else
r = a[j];
a[last + k] = first(l, r, len);
for (int ii = last + 2 * k; ii < j; ii += k) a[ii] = a[ii - k] + 1;
last = j;
if (j >= n) break;
}
}
for (int i = k, i_end = n; i < i_end; ++i)
if (a[i] <= a[i - k]) return puts("Incorrect sequence"), 0;
;
for (int i = 0, i_end = n; i < i_end; ++i) printf("%d ", a[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MIN = (int)(-1e9 - 2e5);
const int MAX = (int)(+1e9 + 2e5);
vector<int> get(int lower, int upper, int n) {
vector<int> res(n);
if (lower >= 0) {
for (int i = 0; i < n; ++i) {
res[i] = lower + 1 + i;
}
} else if (upper <= 0) {
for (int i = 0; i < n; ++i) {
res[n - 1 - i] = upper - 1 - i;
}
} else {
int left = max(0, n - upper), right = min(n - 1, -lower - 1);
int middle = (n - 1) / 2, pos;
if (left <= middle && middle <= right) {
pos = middle;
} else if (right < middle) {
pos = right;
} else {
pos = left;
}
for (int i = 0; i < n; ++i) {
res[i] = i - pos;
}
}
return res;
}
bool solve(int n, int k, vector<int>& array, vector<bool>& flag) {
for (int i = 0; i < k; ++i) {
for (int st = i, ed; st < n; st = ed) {
for (ed = st + k; ed < n; ed += k) {
if (flag[ed]) {
break;
}
}
if (ed >= n) {
continue;
}
int cnt = (ed - st) / k - 1;
if (array[ed] - array[st] - 1 < cnt) {
return false;
}
vector<int> buf = get(array[st], array[ed], cnt);
for (int j = 0; j < cnt; ++j) {
array[st + k + j * k] = buf[j];
}
}
}
return true;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> array(n + 2 * k);
vector<bool> flag(n + 2 * k);
for (int i = 0; i < k; ++i) {
flag[i] = true;
array[i] = MIN;
}
for (int i = k; i < n + k; ++i) {
string buf;
cin >> buf;
if (buf == "?") {
flag[i] = false;
} else {
flag[i] = true;
sscanf(buf.c_str(), "%d", &array[i]);
}
}
for (int i = n + k; i < n + 2 * k; ++i) {
flag[i] = true;
array[i] = MAX;
}
if (solve(n + 2 * k, k, array, flag)) {
for (int i = k; i < n + k; ++i) {
cout << array[i] << (i == n + k - 1 ? "\n" : " ");
}
} else {
cout << "Incorrect sequence" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[101010];
void virhe() {
cout << "Incorrect sequence\n";
exit(0);
}
void tee(int x1, int x2, int i1, int i2, vector<int> v) {
if (x2 - x1 - 1 < (i2 - i1) / k - 1) virhe();
if (x1 >= 0) {
int x = x1;
for (int i = i1 + k; i <= i2 - k; i += k) {
x++;
a[i] = x;
}
return;
} else if (x2 <= 0) {
int x = x2;
for (int i = i2 - k; i >= i1 + k; i -= k) {
x--;
a[i] = x;
}
return;
}
vector<int> u;
u.push_back(0);
for (int i = 1;; i++) {
if (u.size() >= v.size()) break;
if (i < x2) u.push_back(i);
if (-i > x1) u.push_back(-i);
}
sort(u.begin(), u.end());
int c = 0;
for (int i = i1 + k; i <= i2 - k; i += k) {
a[i] = u[c];
c++;
}
}
void laske(int s) {
vector<int> v;
int x1 = -1060000001;
int i1 = s - k, i3;
for (int i = s; i < n; i += k) {
if (a[i] == 1060000001) {
v.push_back(i);
i3 = i;
} else {
int x2 = a[i];
if (x2 <= x1) virhe();
if (v.size() > 0) tee(x1, x2, i1, i, v);
x1 = a[i];
i1 = i;
v.clear();
}
}
if (v.size() > 0) tee(x1, 1060000001, i1, i3 + k, v);
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
string x;
cin >> x;
if (x == "?")
a[i] = 1060000001;
else
a[i] = atoi(x.c_str());
}
for (int i = 0; i < k; i++) laske(i);
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Pt {
T x, y;
void scan() { cin >> x >> y; }
};
template <typename T>
inline T sqr(const T& a) {
return a * a;
}
template <typename T>
inline int sign(const T& a) {
return a < 0 ? -1 : a > 0;
}
void task();
int main() {
task();
return 0;
}
const int INF = 1e9 + 5e5 + 100;
struct S {
int real_pos;
int value;
};
int n, k;
int a[int(1e5) + 10];
bool can_trans(vector<S>& v) {
int is_free = 1;
for (int i = 0; i < (int)v.size(); ++i)
if (v[i].value != INF) {
is_free = 0;
break;
}
if (is_free) {
int mn = -((int)v.size() / 2);
for (int i = 0; i < (int)v.size(); ++i) v[i].value = mn, mn++;
return true;
}
int id = 0;
while (v[id].value == INF) ++id;
if (id) {
int mn = -id / 2;
if (mn + id - 1 > v[id].value - 1) mn = v[id].value - id;
for (int i = 0, val = mn; i < id; ++i, ++val) v[i].value = val;
}
int left_ = id;
id = v.size() - 1;
while (v[id].value == INF) --id;
if (id != (int)v.size() - 1) {
int len = (int)v.size() - id - 1;
int mn = -(len / 2);
if (mn < v[id].value + 1) mn = v[id].value + 1;
for (int i = id + 1, val = mn; i < (int)v.size(); ++i, ++val)
v[i].value = val;
}
int right_ = id;
while (left_ != right_) {
int id = left_ + 1;
while (v[id].value == INF) ++id;
if (v[id].value - v[left_].value < id - left_) return false;
int len = id - left_ - 1;
int mn = -(len / 2);
if (mn < v[left_].value + 1) mn = v[left_].value + 1;
if (mn + len - 1 > v[id].value - 1) mn = v[id].value - len;
for (int i = left_ + 1, val = mn; i < id; ++i, ++val) v[i].value = val;
left_ = id;
}
return true;
}
void task() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
if (s == "?")
a[i] = INF;
else
a[i] = atoi(s.c_str());
}
for (int j = 0; j < k; ++j) {
vector<S> v;
for (int i = j; i < n; i += k) v.push_back({i, a[i]});
if (!can_trans(v)) {
cout << "Incorrect sequence";
return;
}
for (auto& x : v) a[x.real_pos] = x.value;
}
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
int a[100100];
int findOptimal(int l, int h, int len) {
if (l >= 0) return l;
if (h + len <= 0) return h;
if (l + l + len - 1 >= 0) return l;
int delta = abs(l + l + len - 1) / 2;
delta = min(delta, h - l);
return l + delta;
}
bool solve(vector<int>& inp) {
inp.push_back(MOD + 200000);
reverse(inp.begin(), inp.end());
inp.push_back(-1000200001);
reverse(inp.begin(), inp.end());
for (int i = 0; i < inp.size(); i += 1) {
if (inp[i] == MOD) {
int s = i, e = i;
while (e < inp.size() and inp[e] == MOD) e += 1;
int low = inp[s - 1] + 1;
int high = inp[e] - 1;
if (high - low + 1 < e - s) return false;
high = inp[e] - (e - s);
int optimal = findOptimal(low, high, e - s);
for (int j = s; j < e; ++j) inp[j] = optimal++;
}
}
inp.pop_back();
reverse(inp.begin(), inp.end());
inp.pop_back();
reverse(inp.begin(), inp.end());
for (int i = 1; i < inp.size(); ++i)
if (inp[i] <= inp[i - 1]) return false;
return true;
}
int main() {
int n, k;
string x;
cin >> n >> k;
for (int i = 0; i < (n); ++i) {
cin >> x;
if (x == "?")
a[i] = MOD;
else
a[i] = atoi(x.c_str());
}
vector<int> v;
for (int i = 0; i < k; ++i) {
for (int j = i; j < n; j += k) {
v.push_back(a[j]);
}
bool f = solve(v);
if (!f) {
cout << "Incorrect sequence\n";
return 0;
}
for (int j = i, jj = 0; j < n; j += k, jj += 1) {
a[j] = v[jj];
}
v.clear();
}
for (int i = 0; i < (n); ++i) cout << a[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T>
inline void scand(T &x) {
char c;
x = 0;
while ((c = getchar()) < '0')
;
while (c >= '0' && c <= '9') x = x * 10 + (c - 48), c = getchar();
}
template <class T>
inline void gmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void gmin(T &a, T b) {
if (b < a) a = b;
}
using namespace std;
const int N = 1e5 + 10, M = 0, L = 0, Z = 1e9 + 7, t30 = 1 << 30,
maxint = 2147483647, ms31 = 522133279, ms63 = 1061109567,
ms127 = 2139062143;
const double eps = 1e-8, PI = acos(-1.0);
struct A {};
map<int, int> mop;
int casenum, casei, inf;
int spe = 1e9 + N;
int n, k, i, j;
int a[N];
char s[15];
bool test() {
for (i = 0; i < k; i++) {
int p = i;
int maxx = spe;
int minn = -spe;
int num = 0;
int x;
int stp = i;
while (p < n) {
if (a[p] != spe) {
gmin(maxx, a[p]);
if (num > maxx - minn - 1) return 0;
if (num) {
x = max(minn + 1, -num / 2);
x = min(x, maxx - num);
for (int pp = stp; pp < p; pp += k) {
a[pp] = x;
x++;
}
}
maxx = spe;
minn = a[p];
num = 0;
stp = p + k;
} else
num++;
p += k;
}
if (p >= n && num) {
x = max(minn + 1, -num / 2);
for (int pp = stp; pp < n; pp += k) {
a[pp] = x;
x++;
}
}
}
return 1;
}
int main() {
while (~scanf("%d%d", &n, &k)) {
for (i = 0; i < n; i++) {
scanf("%s", s);
if (s[0] == '?')
a[i] = spe;
else {
if (s[0] != '-') {
int l = strlen(s);
a[i] = 0;
for (j = 0; j < l; j++) a[i] = a[i] * 10 + s[j] - 48;
} else {
int l = strlen(s);
a[i] = 0;
for (j = 1; j < l; j++) a[i] = a[i] * 10 + s[j] - 48;
a[i] = -a[i];
}
}
}
if (!test())
printf("Incorrect sequence\n");
else {
for (i = 0; i < n; i++) printf("%d ", a[i]);
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101010;
const int INF = 1000110001;
int n, k, l, a[MAXN], b[MAXN];
bool fix[MAXN], visited[MAXN];
int getInt(char str[]) {
int len = strlen(str), num = 0, j = 0;
if (str[0] == '-') j = 1;
for (int i = j; i < len; i++) num = num * 10 + str[i] - '0';
if (j == 1) num = -num;
return num;
}
void read() {
scanf("%d%d", &n, &k);
memset(fix, false, sizeof(fix));
char str[12];
for (int i = 0; i < n; i++) {
scanf("%s", str);
if (str[0] != '?') {
a[i] = getInt(str);
fix[i] = true;
}
}
}
bool getOptimal(int lower, int upper) {
if (upper - lower - 1 < l) return false;
if (lower >= 0) {
a[b[0]] = lower + 1;
for (int i = 1; i < l; i++) a[b[i]] = a[b[i - 1]] + 1;
} else if (upper <= 0) {
a[b[l - 1]] = upper - 1;
for (int i = l - 2; i >= 0; i--) a[b[i]] = a[b[i + 1]] - 1;
} else {
int len = l / 2;
if (-lower > len && upper > len) {
a[b[len]] = 0;
for (int i = len - 1; i >= 0; i--) a[b[i]] = a[b[i + 1]] - 1;
for (int i = len + 1; i < l; i++) a[b[i]] = a[b[i - 1]] + 1;
} else if (-lower > len) {
a[b[l - 1]] = upper - 1;
for (int i = l - 2; i >= 0; i--) a[b[i]] = a[b[i + 1]] - 1;
} else {
a[b[0]] = lower + 1;
for (int i = 1; i < l; i++) a[b[i]] = a[b[i - 1]] + 1;
}
}
return true;
}
bool solve() {
int lower = -INF, upper = INF;
memset(visited, false, sizeof(visited));
for (int i = 0; i < n; i++)
if (!visited[i]) {
lower = -INF;
upper = INF;
l = 0;
for (int j = i; j < n; j += k) {
visited[j] = true;
if (fix[j]) {
if (a[j] <= lower) return false;
if (l == 0) {
lower = a[j];
} else {
upper = a[j];
if (!getOptimal(lower, upper)) return false;
l = 0;
lower = a[j];
upper = INF;
}
} else {
b[l++] = j;
}
}
if (l > 0)
if (!getOptimal(lower, upper)) return false;
}
return true;
}
int main() {
read();
if (!solve())
puts("Incorrect sequence");
else {
for (int i = 0; i < n - 1; i++) printf("%d ", a[i]);
printf("%d\n", a[n - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 1;
void fail() {
printf("Incorrect sequence\n");
exit(0);
}
int main() {
int n, k, x;
char c;
scanf("%d %d", &n, &k);
vector<vector<int> > chain(k);
for (int i = 0; i < n; ++i) {
scanf(" %c", &c);
x = oo;
if (c != '?') {
ungetc(c, stdin);
scanf("%d", &x);
}
chain[i % k].push_back(x);
}
for (auto &ch : chain) {
int sz = (int)ch.size();
if (!sz) continue;
int lf = 0;
while (lf < sz && ch[lf] == oo) ++lf;
if (lf == sz) {
lf /= 2;
lf *= -1;
for (int &el : ch) el = lf++;
continue;
}
if (lf > 0) {
if (ch[lf] > (lf - 1) / 2) {
int val = -lf / 2;
for (int i = 0; i < lf; ++i) {
ch[i] = val++;
}
} else {
for (int i = lf - 1; i >= 0; --i) {
ch[i] = ch[i + 1] - 1;
}
}
}
int prev = ch[lf];
while (lf < sz - 1) {
int rg = lf + 1;
while (rg < sz && ch[rg] == oo) ++rg;
int tam = rg - lf - 1;
if (rg == sz) {
if (prev < -(tam - 1) / 2) {
int val = tam / 2;
for (int i = sz - 1; i > lf; --i) {
ch[i] = val--;
}
} else {
for (int i = lf + 1; i < sz; ++i) {
ch[i] = ch[i - 1] + 1;
}
}
break;
}
tam /= 2;
if (prev + rg - lf > ch[rg]) fail();
if (prev >= -tam) {
for (int i = lf + 1; i < rg; ++i) {
ch[i] = ch[i - 1] + 1;
}
} else if (ch[rg] <= tam) {
for (int i = rg - 1; i > lf; --i) {
ch[i] = ch[i + 1] - 1;
}
} else {
int val = -tam;
for (int i = lf + 1; i < rg; ++i) ch[i] = val++;
}
lf = rg;
prev = ch[rg];
}
}
for (int i = 0, x = 0, y = 0; i < n; ++i) {
printf("%d ", chain[x][y]);
++x;
if (x == k) x = 0, ++y;
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 2e5 + 5;
void exit() {
cout << "Incorrect sequence" << '\n';
exit(0);
}
int n, m, x, a[N], ans[N], b[N], t, s, k;
char str[12];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", str);
if (str[0] == '?')
a[i] = mod;
else
a[i] = atoi(str);
}
a[0] = -inf * 2;
a[n + 1] = inf * 2;
for (int i = 1; i <= k; i++) {
s = 0, t = i;
b[++s] = 0;
while (t <= n) {
b[++s] = t;
t += k;
}
b[++s] = n + 1;
int last = -2 * inf, lll = 2;
for (int j = 2; j <= s; j++)
if (a[b[j]] != mod) {
int t = max(min(a[b[j]] - (j - lll + 1) + 1, -(j - lll) / 2), last);
for (int k = lll; k <= j - 1; k++) ans[b[k]] = t++;
if (t > a[b[j]]) exit();
ans[b[j]] = a[b[j]];
last = a[b[j]] + 1;
lll = j + 1;
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct elem {
long long int val;
bool h;
};
long long int N, L, K, sol[200010];
vector<elem> b[200010];
char s[5000000];
int main() {
cin >> N >> K;
cin.ignore();
fgets(s, 5000000, stdin);
L = strlen(s);
L--;
s[L] = ' ';
long long int i, j, nr = 0, t = 0;
bool n = 0;
elem aux;
for (i = 0; i <= L; i++) {
if (s[i] == '-') {
n = 1;
continue;
} else if (s[i] == '?')
continue;
else if (s[i] == ' ') {
t++;
if (s[i - 1] == '?')
aux.val = 0, aux.h = 1;
else
aux.val = nr, aux.h = 0;
if (n) aux.val *= -1;
b[t % K].push_back(aux);
nr = 0;
n = 0;
} else
nr = nr * 10 + s[i] - '0';
}
long long int r = 0, k, l;
for (i = 0; i < K; i++) {
r = 0;
for (r = 0; r < b[i].size(); r++)
if (!b[i][r].h) break;
if (b[i][0].h) {
if (r == b[i].size()) {
k = b[i].size() / 2;
k = -k;
for (j = 0; j < b[i].size(); j++) b[i][j].val = k, k++;
continue;
} else {
k = r / 2;
k = -k;
if (k + r - 1 >= b[i][r].val) k = b[i][r].val - r;
for (j = 0; j < r; j++) b[i][j].val = k, k++;
}
}
while (r != b[i].size()) {
l = r;
for (r = r + 1; r < b[i].size(); r++)
if (!b[i][r].h) break;
if (r - l < 2) continue;
if (r == b[i].size()) {
k = (r - l - 1) / 2;
k = -k;
if (k <= b[i][l].val) k = b[i][l].val + 1;
for (j = l + 1; j < r; j++) b[i][j].val = k, k++;
} else {
if (r - l - 1 > b[i][r].val - b[i][l].val - 1 ||
b[i][r].val <= b[i][l].val) {
cout << "Incorrect sequence\n";
return 0;
}
if (b[i][r].val <= 0)
for (j = r - 1; j > l; j--) b[i][j].val = b[i][j + 1].val - 1;
else if (b[i][l].val >= 0)
for (j = l + 1; j < r; j++) b[i][j].val = b[i][j - 1].val + 1;
else {
k = (r - l - 1) / 2;
k = -k;
if (k <= b[i][l].val) k = b[i][l].val + 1;
if (k + r - l - 2 >= b[i][r].val) k = b[i][r].val - r + l + 1;
for (j = l + 1; j < r; j++) b[i][j].val = k, k++;
}
}
}
}
for (i = 0; i < K; i++)
for (j = 0; j < b[i].size(); j++)
sol[j * K + (i == 0 ? K : i)] = b[i][j].val;
for (i = 1; i <= N - K; i++)
if (sol[i] >= sol[i + K]) {
cout << "Incorrect sequence\n";
return 0;
}
for (i = 1; i <= N; i++) cout << sol[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const float eps = 1e-8;
const long long lloo = 1e18;
const int oo = (2e9);
int dau[200010], a[200010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n + k; i++) a[i] = oo;
for (int i = 0; i < n; i++) {
a[i] = 0;
string s;
cin >> s;
if (s == "?")
dau[i] = 1;
else {
int l = 0;
if (s[0] == '-') l = 1;
for (int j = l, _b = s.size() - 1; j <= _b; j++) {
a[i] = a[i] * 10 + s[j] - '0';
}
if (l == 1) a[i] = -a[i];
}
}
for (int i = 0, _b = k - 1; i <= _b; i++) {
int y = i - k;
int val = -oo;
for (int x = i; x < n + k; x += k) {
if (dau[x] == 0) {
int len = (x - y) / k - 2;
int l = -len / 2, r = len + l;
if (a[x] <= len) {
l -= r - (a[x] - 1);
r -= r - (a[x] - 1);
}
int vec = 0;
if (val >= l) {
vec = val + 1 - l;
l += vec;
r += vec;
}
if (r >= a[x]) {
cout << "Incorrect sequence";
return 0;
}
for (y += k; y < x; y += k) {
a[y] = l++;
}
val = a[x];
}
}
}
for (int i = 0; i < n; i++) cout << a[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 322228;
long long a[N];
int n, k;
int cou[N];
bool solve(int l, int r) {
long long need = cou[l % k];
long long tl = l - k >= 0 ? a[l - k] + 1 : -1000000000000ll;
long long tr = r + k < n ? a[r + k] - 1 : 1000000000000ll;
if (tr - tl + 1 < need) return 0;
if (tl >= 0) {
for (long long i = tl; i < tl + need; i++) a[l + (i - tl) * k] = i;
} else if (tr <= 0) {
for (long long i = tr; i > tr - need; i--) a[r - (tr - i) * k] = i;
} else {
long long ttl = 0, ttr = need - 1;
while (ttl - 1 >= tl && (abs(ttl - 1) <= abs(ttr) || ttr > tr))
ttl--, ttr--;
for (int i = 0; i < need; i++) a[l + i * k] = ttl + i;
}
return 1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
int tn = ((n - 1) / k + 2) * k;
for (int i = 0; i < tn; i++) {
string s;
if (i < n)
cin >> s;
else if (i < tn - k)
s = "1000000000000";
else
s = "1000000000001";
if (s == "?") {
cou[i % k]++;
} else {
a[i] = atoll(s.c_str());
if (cou[i % k]) {
if (!solve(i - k * cou[i % k], i - k))
return cout << "Incorrect sequence", 0;
cou[i % k] = 0;
} else if (i - k >= 0 && a[i] <= a[i - k])
return cout << "Incorrect sequence", 0;
}
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005];
char buf[12];
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); i++) {
scanf("%s", buf);
if (buf[0] == '?')
a[i] = (1 << 30);
else
a[i] = atoi(buf);
}
for (int i = (0); i < (m); i++) {
int prev = -(1 << 30), s = (n - i - 1) / m + 1;
for (int j = (0); j < (s); j++) {
int k = j, next = (1 << 30);
while (k < s && a[i + k * m] == (1 << 30)) k++;
if (k < s) next = a[i + k * m];
if (next <= k - j + prev) {
puts("Incorrect sequence");
return 0;
}
int up = (k - j + 1) / 2;
up = min(up, next);
up = max(up, prev + k - j + 1);
for (int x = (j); x < (k); x++) a[i + x * m] = up - k + x;
prev = next;
j = k;
}
}
for (int i = (0); i < (n); i++) printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int maxn = 100000 + 100;
const int qsign = -1000000000 - 2 - maxn;
const int smin = -1000000000 - 1 - maxn;
const int smax = 1000000000 + 1 + maxn;
int a[maxn];
bool was[maxn] = {0};
int n, k;
void do_fill(int s, int c, int v) {
for (int i = 0; i < c; i++) {
a[s + i * k] = v;
v++;
was[s + i * k] = true;
}
}
void do_fill_r(int s, int c, int v) {
for (int i = 0; i < c; i++) {
a[s - i * k] = v;
v--;
was[s - i * k] = true;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "?") {
a[i] = qsign;
} else {
bool minus = (s[0] == '-');
int j = 0;
a[i] = 0;
if (minus) j++;
for (; j < s.length(); j++) {
a[i] = a[i] * 10 + s[j] - '0';
}
if (minus) a[i] = -a[i];
}
}
for (int i = 0; i <= n - k; i++) {
if (!was[i]) {
int mmin = smin;
int mmax = smax;
vector<int> seq;
for (int j = i; j < n; j += k) {
seq.push_back(a[j]);
was[j] = true;
}
int last = -1;
for (int j = 0; j < seq.size(); j++) {
if (seq[j] != qsign) {
if (last != -1 && seq[last] >= seq[j]) {
cout << "Incorrect sequence" << '\n';
return 0;
}
last = j;
}
}
int j = 0;
while (j < seq.size()) {
while (j < seq.size() && seq[j] != qsign) j++;
if (j == seq.size()) continue;
int start = j;
int end = j;
while (end < seq.size() && seq[end] == qsign) end++;
j = end;
end = end - 1;
mmin = (start == 0) ? smin : seq[start - 1];
mmax = (end == seq.size() - 1) ? smax : seq[end + 1];
if (mmax - mmin - 1 < end - start + 1 || mmin >= mmax) {
cout << "Incorrect sequence" << '\n';
return 0;
}
if (mmin == smin && mmax == smax) {
do_fill(i + start * k, end - start + 1, -(end - start + 1) / 2);
} else {
int initial = -(end - start + 1) / 2;
if (initial <= mmin) initial += (mmin - initial) + 1;
if (initial + end - start >= mmax)
initial -= (initial + end - start - mmax) + 1;
do_fill(i + start * k, end - start + 1, initial);
}
}
}
}
for (int i = n - k + 1; i < n; i++) {
if (a[i] == qsign) a[i] = 0;
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1 << 30;
const int N = 100010;
std::vector<int> sequence;
char buf[15];
int num[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
int sign = 1;
for (int j = 0; buf[j]; j++) {
if (buf[j] == '?') {
num[i] = inf;
break;
} else if (buf[j] == '-') {
sign = -1;
} else {
num[i] = num[i] * 10 + (buf[j] - '0');
}
}
num[i] *= sign;
}
int ok = 1;
for (int i = 0; i < k; i++) {
sequence.clear();
for (int j = i; j < n; j += k) {
sequence.push_back(num[j]);
}
int s = -1, t = -1, sz = sequence.size();
for (int j = 0; j < sz; j++) {
if (sequence[j] != inf) {
s = t;
t = j;
int l = s != -1 ? sequence[s] : -inf, r = sequence[t];
int d = t - s - 1;
if (r - l - 1 < t - s - 1) ok = -1;
if ((long long)l * r >= 0) {
if (r <= 0) {
for (int o = t - 1, c = 1; o > s; o--, c++) sequence[o] = r - c;
} else {
for (int o = s + 1, c = 1; o < t; o++, c++) sequence[o] = l + c;
}
} else {
if (abs(l) <= abs(r)) {
for (int o = s + 1, c = 0; o < t; o++, c++)
sequence[o] = std::max(l + 1, -(d - 1) / 2) + c;
} else {
for (int o = t - 1, c = 0; o > s; o--, c++)
sequence[o] = std::min(r - 1, (d - 1) / 2) - c;
}
}
}
}
int d = sz - t - 1;
if (t != sz - 1 && ~t) {
for (int o = t + 1, c = 0; o < sequence.size(); o++, c++)
sequence[o] = std::max(sequence[t] + 1, -(d - 1) / 2) + c;
}
if (s == -1 && t == -1) {
for (int o = 0, c = 0; o < sz; o++, c++) sequence[o] = -(sz - 1) / 2 + c;
}
if (ok == -1) return puts("Incorrect sequence"), 0;
for (int j = i; j < n; j += k) num[j] = sequence[j / k];
}
for (int i = 0; i < n; i++) printf("%d%c", num[i], " \n"[i == n - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 123456;
const int MAX = 1e9 + N;
const int HIHIHI = 2e9;
int a[N];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
if (s == "?") {
a[i] = HIHIHI;
} else {
stringstream ss(s);
ss >> a[i];
}
}
for (int i = 1; i <= k; ++i) {
vector<int> v;
v.push_back(-MAX - 1);
for (int j = i; j <= n; j += k) {
v.push_back(a[j]);
}
v.push_back(MAX + 1);
for (int j = 0, p; j < v.size(); j = p) {
p = j + 1;
while (p < v.size() && v[p] == HIHIHI) {
++p;
}
if (p < v.size()) {
int cnt = p - j - 1;
int diff = v[p] - v[j] - 1;
if (cnt > diff) {
cout << "Incorrect sequence";
return 0;
}
if (v[j] >= 0) {
for (int z = 0; z < cnt; ++z) {
v[j + z + 1] = v[j] + z + 1;
}
} else if (v[p] <= 0) {
for (int z = 0; z < cnt; ++z) {
v[p - z - 1] = v[p] - z - 1;
}
} else {
int h = -(cnt / 2);
if (h < v[j] + 1) h = v[j] + 1;
if (h + cnt - 1 > v[p] - 1) h = v[p] - 1 - cnt + 1;
for (int z = 0; z < cnt; ++z) {
v[j + z + 1] = h++;
}
}
}
}
int w = 1;
for (int j = i; j <= n; j += k) {
a[j] = v[w++];
}
}
for (int i = 1; i <= n; ++i) {
cout << a[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 110000;
const int inf = 1e9;
int a[N];
int b[N];
int m;
int read() {
char p = getchar();
while (p != '?' && p != '-' && (!(p <= '9' && p >= '0'))) p = getchar();
if (p == '?') return inf + 1;
int sign = 1;
if (p == '-') {
sign = -1;
p = getchar();
}
int x = 0;
while (p <= '9' && p >= '0') {
x *= 10;
x += p - 48;
p = getchar();
}
return x * sign;
}
void fail() {
printf("Incorrect sequence");
exit(0);
}
void work() {
int lst = -inf - 1;
for (int i = (1); i <= (int)m; i++)
if (b[i] <= inf) {
if (b[i] <= lst) fail();
lst = b[i];
}
b[0] = -inf - 1;
b[m + 1] = inf + 1;
for (int i = 1; i <= m; i++)
if (b[i] > inf) {
int j = i;
while (j < m && b[j + 1] > inf) j++;
int mid = (i + j) / 2;
int r, l;
if (i == 1)
l = -inf - 1000086;
else
l = b[i - 1] + 1;
if (j == m)
r = inf + 1000086;
else
r = b[j + 1] - 1;
if (r - l < j - i) fail();
l += mid - i;
r -= j - mid;
if (r <= 0) {
int gt = r - (mid - i);
for (int k = (i); k <= (int)j; k++) {
b[k] = gt;
gt++;
}
} else if (l >= 0) {
int gt = l - (mid - i);
for (int k = (i); k <= (int)j; k++) {
b[k] = gt;
gt++;
}
} else {
int gt = 0 - (mid - i);
for (int k = (i); k <= (int)j; k++) {
b[k] = gt;
gt++;
}
}
i = j;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (1); i <= (int)n; i++) a[i] = read();
for (int i = (0); i <= (int)k - 1; i++) {
m = 0;
for (int j = i; j <= n; j += k)
if (j > 0 && j <= n) b[++m] = a[j];
work();
m = 0;
for (int j = i; j <= n; j += k)
if (j > 0 && j <= n) a[j] = b[++m];
}
for (int i = (1); i <= (int)n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
int a[200000];
char tmp[200000];
int b[200000];
int bi;
int c[200000];
int ci;
int d[200000];
vector<int> dab;
void calc() {
int i, j;
int cnt = 0;
d[0] = -((1 << 30) - 1);
ci = 0;
for (i = 0; i < bi; i++) {
if (b[i] == ((1 << 30) - 1))
cnt++;
else {
c[++ci] = cnt;
d[ci] = b[i];
cnt = 0;
}
}
c[++ci] = cnt;
d[ci++] = ((1 << 30) - 1);
for (i = 0; i < ci - 1; i++) {
if (d[i + 1] - d[i] - 1 < c[i + 1]) {
printf("Incorrect sequence");
exit(0);
}
}
dab.clear();
for (i = 0; i < ci - 1; i++) {
if (c[i + 1] == 0) continue;
if (d[i] <= 0 && d[i + 1] <= 0) {
for (j = d[i + 1] - c[i + 1]; j <= d[i + 1] - 1; j++) dab.push_back(j);
} else if (d[i] >= 0 && d[i + 1] >= 0) {
for (j = d[i] + 1; j <= d[i] + c[i + 1]; j++) dab.push_back(j);
} else {
if (min(abs(d[i + 1] - 1), abs(d[i] + 1)) * 2 + 1 >= c[i + 1]) {
for (j = -(c[i + 1] - 1) / 2; j <= (c[i + 1] / 2); j++)
dab.push_back(j);
} else {
int u = min(abs(d[i + 1] - 1), abs(d[i] + 1));
if (abs(d[i + 1] - 1) > abs(d[i] + 1)) {
for (j = -u; j <= u; j++) dab.push_back(j);
for (j = u + 1;
j <=
u + c[i + 1] - min(abs(d[i + 1] - 1), abs(d[i] + 1)) * 2 - 1;
j++)
dab.push_back(j);
} else {
for (j = -u -
(c[i + 1] - min(abs(d[i + 1] - 1), abs(d[i] + 1)) * 2 - 1);
j <= -u - 1; j++)
dab.push_back(j);
for (j = -u; j <= u; j++) dab.push_back(j);
}
}
}
}
}
int main() {
int i, j, k;
cin >> n >> m;
for (i = 0; i < n; i++) {
scanf("%s", tmp);
if (tmp[0] == '?')
a[i] = ((1 << 30) - 1);
else
a[i] = atoi(tmp);
}
for (i = 0; i < m; i++) {
bi = 0;
for (j = i; j < n; j += m) {
b[bi++] = a[j];
}
calc();
int u = 0;
for (j = i; j < n; j += m) {
if (a[j] == ((1 << 30) - 1)) a[j] = dab[u++];
}
}
for (i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000 * 100 + 5, inf = 1000000000000000LL;
long long a[N];
vector<long long> r[N];
set<long long>::iterator it;
int main() {
long long n, k, i, x;
cin >> n >> k;
scanf("\n");
char ch;
for (i = 1; i <= n; i++) {
scanf("%c", &ch);
if (ch == ' ') {
scanf("%c", &ch);
}
if (ch == '?') {
x = -inf;
} else {
long long fl = 1;
if (ch == '-') {
fl = -1;
ch = getchar();
}
x = ch - '0';
while (1) {
ch = getchar();
if (!isdigit(ch)) {
break;
}
x = x * 10 + ch - '0';
}
x = x * fl;
}
a[i] = x;
r[i % k].push_back(x);
}
long long left, right;
for (i = 0; i < k; i++) {
left = -1;
long long lb, rb;
if ((int(r[i].size())) == 0) {
continue;
}
while (left < (int(r[i].size()))) {
right = left + 1;
while ((right < (int(r[i].size()))) && (r[i][right] == -inf)) {
right++;
}
set<long long> s;
if (left == -1) {
lb = -inf * 2;
} else {
lb = r[i][left];
}
if (right == (int(r[i].size()))) {
rb = inf * 2;
} else {
rb = r[i][right];
}
if (rb - 0LL - lb - 1 < right - left - 1) {
puts("Incorrect sequence");
return 0;
}
long long cnt = right - left - 1, curr = 0;
if (cnt == 0) {
left = right;
continue;
}
lb++;
rb--;
if ((lb <= 0) && (rb >= 0)) {
s.insert(0);
cnt--;
long long fl = 1;
curr = 1;
if (rb == 0) {
curr = -1;
fl = 0;
}
while (cnt > 0) {
s.insert(curr);
if (fl) {
if (-curr < lb) {
curr++;
} else {
curr = -curr;
fl = 0;
}
} else {
if (-(curr - 1) > rb) {
curr--;
} else {
curr = -(curr - 1);
fl = 1;
}
}
cnt--;
}
} else if (lb > 0) {
while (cnt > 0) {
s.insert(lb);
lb++;
cnt--;
}
} else {
while (cnt > 0) {
s.insert(rb);
rb--;
cnt--;
}
}
it = s.begin();
for (left = left + 1; left < right; left++) {
r[i][left] = (*it);
it++;
}
}
}
for (i = n; i >= 1; i--) {
a[i] = r[i % k].back();
r[i % k].pop_back();
}
for (i = 1; i <= n; i++) {
printf("%I64d ", a[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int UNKNOWN = 0x7FFFFFFF;
int N, K;
int A[100000];
bool seen[100000];
int nbad, last;
void fail() {
printf("Incorrect sequence\n");
exit(0);
}
void fix_bad(int pos, int cur) {
if (cur - last - 1 < nbad) fail();
if (nbad == 0) return;
if (last <= 0 && cur <= 0) {
for (int i = 0; i <= nbad; i++)
if (0 <= pos - i * K && pos - i * K < N) A[pos - i * K] = cur - i;
} else if (last >= 0 && cur >= 0) {
for (int i = 1; i <= nbad + 1; i++)
if (0 <= pos - i * K && pos - i * K < N)
A[pos - i * K] = last - i + nbad + 1;
} else {
vector<int> toadd;
toadd.push_back(0);
int n = 1;
while ((int)toadd.size() < nbad) {
if (last < n && n < cur) toadd.push_back(n);
if ((int)toadd.size() >= nbad) break;
if (last < -n && -n < cur) toadd.push_back(-n);
n++;
}
sort(toadd.rbegin(), toadd.rend());
for (int i = 1; i <= nbad; i++)
if (0 <= pos - i * K && pos - i * K < N) A[pos - i * K] = toadd[i - 1];
}
}
void dfs(int u) {
if (u >= N) {
if (nbad) fix_bad(u, 1050000000);
return;
}
seen[u] = true;
if (A[u] == UNKNOWN)
nbad++;
else {
fix_bad(u, A[u]);
nbad = 0;
last = A[u];
}
dfs(u + K);
}
int main() {
scanf("%d%d", &N, &K);
char c;
for (int i = 0; i < N; i++) {
scanf(" %c", &c);
if (c == '?')
A[i] = UNKNOWN;
else {
ungetc(c, stdin);
scanf("%d", A + i);
}
}
for (int i = 0; i < N; i++)
if (!seen[i]) {
last = -1050000000;
nbad = 0;
dfs(i);
}
for (int i = 0; i < N; i++) printf("%d%c", A[i], " \n"[i == N - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 2;
int convert(string s) {
stringstream ss(s);
int x;
ss >> x;
return x;
}
int main() {
int n, k;
cin >> n >> k;
string s;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> s;
if (s[0] == '?') {
v[i] = INF;
} else {
v[i] = convert(s);
}
}
for (int i = 0; i < k; ++i) {
int start = i - k;
int l = 0;
int j;
for (j = i; j < n; j += k) {
if (v[j] != INF) {
int mn = (start == i - k) ? -INF : v[start];
int mx = v[j];
if (l >= mx - mn) {
cout << "Incorrect sequence" << endl;
return 0;
}
int beg = -(l - 1) / 2;
int end = beg + l - 1;
if (beg <= mn) {
beg = mn + 1;
end = beg + l - 1;
}
if (end >= mx) {
end = mx - 1;
beg = end - l + 1;
}
for (int u = start + k; u < j; u += k) v[u] = beg + (u - start - k) / k;
start = j;
l = 0;
} else
++l;
}
int mn = (start == i - k) ? -INF : v[start];
int mx = INF;
if (l >= mx - mn) {
cout << "Incorrect sequence" << endl;
return 0;
}
int beg = -(l - 1) / 2;
int end = beg + l - 1;
if (beg <= mn) {
beg = mn + 1;
end = beg + l - 1;
}
if (end >= mx) {
end = mx - 1;
beg = end - l + 1;
}
for (int u = start + k; u < j; u += k) v[u] = beg + (u - start - k) / k;
start = j;
l = 0;
}
for (int i = 0; i < n; ++i) cout << (i ? " " : "") << v[i];
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, k;
string st;
vector<pair<long, long> > v[1 << 20];
long q;
vector<pair<long, long> > block;
long l1;
vector<long> tv;
long er;
long ans[1 << 20];
vector<long> solve(vector<pair<long, long> > v, long lwr, long upr) {
long sz = v.size();
if (lwr + sz >= upr) er = 1;
vector<long> res;
res.resize(v.size());
if (er) return res;
if (upr <= sz - 1 - sz / 2) {
for (int i = 0; i < v.size(); i++) res[i] = upr - sz + i;
return res;
}
if (lwr >= -(sz / 2)) {
for (int i = 0; i < v.size(); i++) {
res[i] = lwr + i + 1;
}
return res;
}
for (int i = 0; i < v.size(); i++) res[i] = i - sz / 2;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> st;
if (st == "?") {
v[i % k].push_back(make_pair(i, -2000000000));
} else {
stringstream s(st);
s >> q;
v[i % k].push_back(make_pair(i, q));
}
}
for (int i = 0; i < k; i++) {
block.clear();
l1 = -1100000001;
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j].second > -1.5e9) {
if (block.size()) {
tv = solve(block, l1, v[i][j].second);
for (int q = 0; q < tv.size(); q++)
v[i][j - tv.size() + q].second = tv[q];
}
block.clear();
if (j > 0 && v[i][j].second <= v[i][j - 1].second) er = 1;
l1 = v[i][j].second;
} else {
block.push_back(v[i][j]);
}
}
if (block.size()) {
tv = solve(block, l1, 1100000001);
for (int j = 0; j < tv.size(); j++)
v[i][v[i].size() - tv.size() + j].second = tv[j];
}
}
if (er)
cout << "Incorrect sequence" << endl;
else {
for (int i = 0; i < k; i++)
for (int j = 0; j < v[i].size(); j++) ans[v[i][j].first] = v[i][j].second;
for (int i = 1; i <= n; i++) {
if (i > 1) cout << " ";
cout << ans[i];
}
cout << endl;
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INF = ((int)1e9) + 7;
int toint(string tmp) {
bool t = (tmp[0] == '-');
int l = 0;
if (t) {
l = 1;
}
int ans = 0;
for (int i = l; i < tmp.size(); i++) {
ans *= 10;
ans += (tmp[i] - '0');
}
if (t) {
ans *= -1;
}
return ans;
}
int main() {
int n, k;
string tmp;
getline(cin, tmp);
int lll = 0;
for (int i = 0; i < tmp.size(); i++) {
if (tmp[i] != ' ') {
lll++;
} else {
break;
}
}
n = toint(tmp.substr(0, lll));
k = toint(tmp.substr(lll + 1, tmp.size() - lll - 1));
vector<int> a;
tmp.clear();
getline(cin, tmp);
for (int i = 0; i < tmp.size(); i++) {
if (tmp[i] == '?') {
a.push_back(INF);
} else if (tmp[i] != ' ') {
int len = 0;
for (int j = i; j < tmp.size(); j++) {
if (tmp[j] != ' ') {
len++;
} else {
break;
}
}
a.push_back(toint(tmp.substr(i, len)));
i += len;
}
}
for (int i = 0; i < k; i++) {
int l = -1, j;
for (j = 0; k * j + i < n; j++) {
int y = k * j + i;
if (l > -1 && a[y] != INF) {
if (a[y] >= 0 && a[k * l + i] >= 0) {
for (int q = l + 1; q < j; q++) {
a[k * q + i] = a[k * (q - 1) + i] + 1;
}
} else if (a[y] < 0 && a[k * l + i] < 0) {
for (int q = j - 1; q > l; q--) {
a[k * q + i] = a[k * (q + 1) + i] - 1;
}
} else if (a[y] >= 0 && a[k * l + i] < 0) {
int tmp = max(0, (j - l - 2) / 2);
if (max(0, (j - l - 2)) % 2 != 0) {
tmp++;
}
if (a[y] <= tmp) {
for (int q = j - 1; q > l; q--) {
a[k * q + i] = a[k * (q + 1) + i] - 1;
}
} else if (a[k * l + i] >= -tmp) {
for (int q = l + 1; q < j; q++) {
a[k * q + i] = a[k * (q - 1) + i] + 1;
}
} else {
tmp *= -1;
for (int q = l + 1; q < j; q++) {
a[k * q + i] = tmp;
tmp++;
}
}
}
l = j;
}
if (l == -1 && a[y] != INF) {
l = j;
}
if (l == -2 && a[y] != INF) {
l = -1;
if (a[y] < 0) {
for (int q = j - 1; q > l; q--) {
a[k * q + i] = a[k * (q + 1) + i] - 1;
}
} else {
int tmp = (j - 1) / 2;
if (a[y] <= tmp) {
for (int q = j - 1; q > l; q--) {
a[k * q + i] = a[k * (q + 1) + i] - 1;
}
} else {
if ((j - 1) % 2 != 0) {
tmp++;
}
tmp *= -1;
for (int q = l + 1; q < j; q++) {
a[k * q + i] = tmp;
tmp++;
}
}
}
l = j;
}
if (l == -1 && a[y] == INF) {
l = -2;
}
}
if (l == -2) {
l = -1;
int tmp = (j - 1) / 2;
tmp *= -1;
for (int q = l + 1; q < j; q++) {
a[k * q + i] = tmp;
tmp++;
}
l = j;
}
if (j != l) {
int y = k * j + i;
if (a[k * l + i] >= 0) {
for (int q = l + 1; q < j; q++) {
a[k * q + i] = a[k * (q - 1) + i] + 1;
}
} else {
int tmp = max(0, (j - l - 2) / 2);
if (a[k * l + i] >= -tmp) {
for (int q = l + 1; q < j; q++) {
a[k * q + i] = a[k * (q - 1) + i] + 1;
}
} else {
tmp *= -1;
for (int q = l + 1; q < j; q++) {
a[k * q + i] = tmp;
tmp++;
}
}
}
}
vector<int> tmp, ch;
for (int j = 0; k * j + i < n; j++) {
int y = k * j + i;
tmp.push_back(a[y]);
}
ch = tmp;
sort(ch.begin(), ch.end());
bool t = false;
for (int i = 1; i < ch.size(); i++) {
if (ch[i] <= ch[i - 1]) {
t = true;
break;
}
}
if (ch != tmp || t) {
cout << "Incorrect sequence";
return 0;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[(1 << 17)];
int n, k, a[(1 << 17)];
vector<int> v[(1 << 17)];
int trans(char* s) {
int l = strlen(s), res = 0;
int st = s[0] == '-';
for (int i = st; i < l; i++) res = res * 10 + s[i] - 48;
return st ? -res : res;
}
int solve(int l, int r, int st, int ed) {
vector<int> vt;
if (l > r) return ed - st >= -1;
if (st > ed) return 0;
if (ed - st < (r - l) / k) return 0;
int cnt = (r - l) / k + 1;
if (st >= 0) {
for (int i = 0; i < cnt; i++) vt.push_back(st + i);
} else if (ed < 0) {
for (int i = cnt - 1; i >= 0; i--) vt.push_back(ed - i);
} else {
vt.push_back(0);
for (int x = -1, y = 1, i = 1; i < cnt; i++) {
if (x < st)
vt.push_back(y++);
else if (y > ed)
vt.push_back(x--);
else {
if (abs(x) < abs(y))
vt.push_back(x--);
else
vt.push_back(y++);
}
}
sort(vt.begin(), vt.end());
}
for (int i = l, j = 0; i <= r; i += k, j++) a[i] = vt[j];
return 1;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%s", s);
if (s[0] == '?')
a[i] = 1010000000;
else
a[i] = trans(s);
}
for (int i = 0; i < k; i++) {
int last = -1, j;
for (j = i; j < n; j += k)
if (a[j] != 1010000000) {
if (last == -1)
solve(i, j - k, -1010000000, a[j] - 1);
else {
if (!solve(last + k, j - k, a[last] + 1, a[j] - 1)) {
puts("Incorrect sequence");
return 0;
}
}
last = j;
}
if (last == -1)
solve(i, j - k, -1010000000, 1010000000);
else
solve(last + k, j - k, a[last] + 1, 1010000000);
}
for (int i = 0; i < n - 1; i++) printf("%d ", a[i]);
printf("%d\n", a[n - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 500;
const long long inf = -1e15;
long long kk;
long long a[maxn];
vector<long long> khon[maxn];
long long sss(string s) {
if (s[0] != '-') {
long long ans = 0;
for (long long i = 0; i < s.size(); i++) {
ans *= 10;
ans += s[i] - '0';
}
return ans;
}
long long ans = 0;
for (long long i = 1; i < s.size(); i++) {
ans *= 10;
ans += s[i] - '0';
}
return -ans;
}
long long g(long long i, long long j) { return kk * j + i; }
long long f(long long v, long long j, long long i) {
long long m = (j + v) / 2;
a[g(i, m)] = 0;
for (long long k = m + 1; k <= j; k++) {
a[g(i, k)] = 1 + a[g(i, k - 1)];
}
for (long long k = m - 1; k >= v; k--) {
a[g(i, k)] = a[g(i, k + 1)] - 1;
}
}
void ggg(long long v, long long i, long long j) {
f(v + 1, j - 1, i);
if (v >= 0)
if (a[g(i, v)] >= a[g(i, v + 1)]) {
long long p = a[g(i, v)] - a[g(i, v + 1)] + 1;
for (long long k = v + 1; k < j; k++) {
a[g(i, k)] += p;
}
}
if (j < khon[i].size()) {
if (a[g(i, j - 1)] >= a[g(i, j)]) {
long long p = a[g(i, j - 1)] - a[g(i, j)] + 1;
for (long long k = v + 1; k < j; k++) {
a[g(i, k)] -= p;
}
}
}
}
int main() {
long long n;
string c;
cin >> n >> kk;
for (long long i = 0; i < n; i++) {
cin >> c;
if (c == "?") {
a[i] = inf;
} else {
a[i] = sss(c);
}
khon[i % kk].push_back(a[i]);
}
for (long long i = 0; i < n - kk; i++) {
if (a[i] >= a[i + kk] && a[i] != inf && a[i + kk] != inf) {
cout << "Incorrect sequence";
return 0;
}
}
long long v = -1;
for (long long i = 0; i < kk; i++) {
long long v = -1;
for (long long j = 0; j < khon[i].size(); j++) {
if (khon[i][j] != inf) {
if (v + 1 != j) {
ggg(v, i, j);
}
v = j;
}
}
if (v + 1 != khon[i].size()) {
ggg(v, i, khon[i].size());
}
}
for (long long i = 0; i < n - kk; i++) {
if (a[i] >= a[i + kk]) {
cout << "Incorrect sequence";
return 0;
}
}
for (long long i = 0; i < n; i++) {
cout << a[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 10000000000000000LL;
int n, k;
long long num[100005];
long long rem[100005];
char s[1000];
inline bool chuli(int a, int b, long long x, long long y) {
if (y - x < b - a) return 0;
if (x >= 0)
for (int i = a; i <= b; ++i) rem[i] = x++;
else if (y <= 0)
for (int i = b; i >= a; --i) rem[i] = y--;
else {
long long xia, shang;
xia = max(x, -(b - a + 1) / 2LL);
xia = min(xia, y - (b - a));
shang = b - a + 1 + xia - 1;
while (xia < 1) rem[a++] = xia++;
while (shang) rem[b--] = shang--;
}
return 1;
}
inline bool chuli(int N) {
long long last = -INF;
rem[++N] = INF - 1;
for (int i = 1; i <= N; ++i) {
if (rem[i] != INF) {
if (rem[i] <= last) return 0;
last = rem[i];
} else {
int t = i;
while (rem[t] == INF) ++t;
if (!chuli(i, t - 1, last + 1, rem[t] - 1)) return 0;
i = t - 1;
last = rem[i];
}
}
return 1;
}
bool getans() {
int cou;
for (int i = 1; i <= k; ++i) {
cou = 0;
for (int j = i; j <= n; j += k) rem[++cou] = num[j];
if (!chuli(cou)) return 0;
for (int j = i, x = 1; x <= cou; ++x, j += k) num[j] = rem[x];
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> s;
if (s[0] == '?')
num[i] = INF;
else {
sscanf(s, "%d", &t);
num[i] = t;
}
}
if (getans()) {
for (int i = 1; i <= n; ++i) cout << num[i] << ' ';
cout << endl;
} else
cout << "Incorrect sequence" << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int INT_INF = 0x3f3f3f3f;
const int INT_M_INF = 0x7f7f7f7f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const long long LL_M_INF = 0x7f7f7f7f7f7f7f7f;
const double pi = acos(-1.0);
const double EPS = 1e-6;
const int dr[] = {0, 0, -1, 1, -1, -1, 1, 1};
const int dc[] = {-1, 1, 0, 0, -1, 1, -1, 1};
const long long MOD = 1e9 + 7;
const int MAXN = 100 + 10;
const int MAXT = 100000 + 10;
using namespace std;
int n, k, a[MAXT];
int main() {
while (scanf("%d%d", &n, &k) == 2) {
memset(a, INT_INF, sizeof a);
char s[20];
for (int i = 0; i < n; ++i) {
scanf("%s", s);
if (s[0] == '?') continue;
sscanf(s, "%d", &a[i]);
}
bool flag = true;
for (int i = 0; i < k; ++i) {
int l = i, alllen = 0;
for (int j = i; j < n; j += k) {
++alllen;
if (a[j] == INT_INF) continue;
if (j == l) {
if (j != i && a[j] <= a[j - k]) {
flag = false;
goto op;
}
l = j + k;
continue;
}
if (l - k < 0) {
int tmp, len = (j - i) / k;
if (len % 2)
tmp = len / 2 < a[j] - 1 ? len / 2 : a[j] - 1;
else
tmp = len / 2 - 1 < a[j] - 1 ? len / 2 - 1 : a[j] - 1;
for (int u = j - k; u >= i; u -= k) a[u] = tmp--;
l = j + k;
} else {
int tmp, len = (j - l) / k;
if (len > a[j] - a[l - k] - 1) {
flag = false;
goto op;
}
if (len % 2) {
tmp = len / 2 < a[j] - 1 ? len / 2 : a[j] - 1;
if (tmp - len + 1 <= a[l - k]) tmp = a[l - k] + len;
} else {
tmp = len / 2 - 1 < a[j] - 1 ? len / 2 - 1 : a[j] - 1;
if (tmp - len + 1 <= a[l - k]) tmp = a[l - k] + len;
}
for (int u = j - k; u >= l; u -= k) a[u] = tmp--;
l = j + k;
}
}
if (l < n) {
if (l - k < 0) {
int tmp = -alllen / 2;
for (int u = i; u < n; u += k) a[u] = tmp++;
} else {
int len = (n - l) / k;
int tmp = -len / 2 < a[l - k] + 1 ? a[l - k] + 1 : -len / 2;
for (int u = l; u < n; u += k) a[u] = tmp++;
}
}
}
op:
if (!flag)
printf("Incorrect sequence\n");
else {
for (int i = 0; i < n; ++i) {
if (i) printf(" ");
printf("%d", a[i]);
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[110001];
char str[21];
int Parse() {
if (str[1] == '?') return 1999999999;
int i;
int L = strlen(str + 1);
bool ngt = false;
int num = 0;
for (i = 1; i <= L; i++) {
if (str[i] == '-') {
ngt = true;
continue;
}
num *= 10;
num += (int)(str[i] - '0');
}
if (ngt) num = -num;
return num;
}
int Line[110001];
int L;
bool Fill(int L, int R, int lowbound, int upbound) {
if (L > R) return true;
int i;
if ((long long)upbound - (long long)lowbound - 1LL <
(long long)R - (long long)L + 1LL) {
return false;
}
if (upbound <= 0) {
for (i = R; i >= L; i--) {
Line[i] = upbound - (R - i + 1);
}
} else if (lowbound >= 0) {
for (i = L; i <= R; i++) {
Line[i] = lowbound + (i - L + 1);
}
} else {
int wantednegative = (R - L + 1) / 2;
int wantedpositive = (R - L) / 2;
int b;
if (lowbound < -wantednegative && upbound > wantedpositive) {
b = -wantednegative;
for (i = L; i <= R; i++) {
Line[i] = b;
b++;
}
} else if (lowbound >= -wantednegative) {
b = lowbound + 1;
for (i = L; i <= R; i++) {
Line[i] = b;
b++;
}
} else {
b = upbound - 1;
for (i = R; i >= L; i--) {
Line[i] = b;
b--;
}
}
}
return true;
}
bool SolveLine() {
int lowbound = -1999999999;
int beg = 1;
int i;
int curnum = -1999999999;
for (i = 1; i <= L; i++) {
if (Line[i] != 1999999999) {
if (Line[i] <= curnum) return false;
curnum = Line[i];
}
}
for (i = 1; i <= L; i++) {
if (Line[i] != 1999999999) {
if (!Fill(beg, i - 1, lowbound, Line[i])) return false;
lowbound = Line[i];
beg = i + 1;
}
}
if (!Fill(beg, L, lowbound, 1999999999)) return false;
return true;
}
int main() {
int i, j;
scanf("%d %d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%s", str + 1);
arr[i] = Parse();
}
for (i = 1; i <= k; i++) {
L = 0;
for (j = i; j <= n; j += k) {
L++;
Line[L] = arr[j];
}
if (!SolveLine()) {
printf("Incorrect sequence\n");
return 0;
}
L = 0;
for (j = i; j <= n; j += k) {
L++;
arr[j] = Line[L];
}
}
for (i = 1; i <= n; i++) {
printf("%d", arr[i]);
if (i != n) printf(" ");
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = acos(-1);
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int MAXN = 320 * 1000;
int a[MAXN];
bool q[MAXN];
char s[100];
string::size_type sz;
void bad() {
printf("Incorrect sequence\n");
exit(0);
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", s);
if (s[0] == '?') {
q[k + i] = true;
} else {
a[k + i] = atoi(s);
}
}
for (int i = 0; i < k; ++i) {
a[i] = -inf;
a[n + k + i] = inf;
}
n = n + 2 * k;
for (int r = 0; r < k; ++r) {
for (int i = r; i < n;) {
int j = i;
if (q[i]) {
int num = 1;
while (q[j + k]) {
j += k;
num++;
}
if (a[j + k] - a[i - k] <= num) {
bad();
}
if (a[i - k] >= -(num / 2)) {
for (int t = i; t <= j; t += k) {
a[t] = a[t - k] + 1;
}
} else if (a[j + k] <= (num / 2)) {
for (int t = j; t >= i; t -= k) {
a[t] = a[t + k] - 1;
}
} else {
a[i] = -(num / 2);
for (int t = i + k; t <= j; t += k) {
a[t] = a[t - k] + 1;
}
}
}
i = j + k;
}
}
for (int i = 0; i + k < n; ++i) {
if (a[i] >= a[i + k]) {
bad();
}
}
for (int i = k; i < n - k; ++i) {
printf("%d%c", a[i], (i == n - k - 1 ? '\n' : ' '));
}
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline bool scan(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
using namespace std;
long long n, k;
long long a[100005];
vector<long long> b[100005];
long long get(string s) {
long long ans = 0;
long long sn = 1;
long long l = 0;
if (s[0] == '-') sn = -1, l++;
for (; l < s.length(); l++) {
ans = ans * 10 + s[l] - '0';
}
return ans * sn;
}
bool solve(vector<long long> &b, long long L, long long R, long long l,
long long r) {
if (R <= L) return 0;
if (r < l) return 1;
if (R - L - 1 < r - l + 1) return 0;
long long len = r - l + 1;
if (len / 2 < R && -((len - 1) / 2) > L) {
for (long long i = r, j = len / 2; i >= l; i--, j--) {
b[i] = j;
}
} else if ((len - 1) / 2 < R && -(len / 2) > L) {
for (long long i = r, j = (len - 1) / 2; i >= l; i--, j--) {
b[i] = j;
}
} else if (abs(L) < abs(R)) {
for (long long i = l, j = L + 1; i <= r; i++, j++) {
b[i] = j;
}
} else {
for (long long i = r, j = R - 1; i >= l; i--, j--) {
b[i] = j;
}
}
return 1;
}
bool ok(vector<long long> &b) {
long long sz = b.size();
long long l = -2e9, r;
long long pre = 0, now;
for (long long i = 0; i < sz; i++) {
if (b[i] != 1e9 + 5) {
r = b[i];
now = i;
if (!solve(b, l, r, pre, now - 1)) return 0;
pre = i + 1;
l = b[i];
}
}
if (!solve(b, l, 2e9, pre, sz - 1)) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
string s;
cin >> s;
if (s[0] == '?')
a[i] = 1e9 + 5;
else
a[i] = get(s);
}
for (long long i = 1; i <= k; i++) {
b[i].clear();
for (long long j = i; j <= n; j += k) b[i].push_back(a[j]);
}
for (long long i = 1; i <= k; i++) {
if (!ok(b[i])) {
cout << "Incorrect sequence" << endl;
return 0;
}
}
for (long long i = 1; i <= k; i++) {
for (long long j = i, l = 0; j <= n; j += k, l++) {
a[j] = b[i][l];
}
}
for (long long i = 1; i <= n; i++) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
typedef struct {
int first, last;
int prev, next;
} Rec;
Rec rec[50000];
int size;
int a[100000];
int main(void) {
int i, j;
int n, k;
scanf("%d %d ", &n, &k);
for (i = 0; i < n; i++) {
int ch = getchar();
if (ch == '?') {
getchar();
a[i] = 1010000000;
} else {
ungetc(ch, stdin);
scanf("%d ", a + i);
}
}
for (i = 0; i < k; i++) {
int mode;
size = mode = 0;
for (j = i; j < n; j += k)
if (a[j] == 1010000000) {
if (!mode) {
mode = 1;
rec[size].first = j;
rec[size].prev = j - k >= 0 ? a[j - k] : -1010000000;
}
} else if (mode) {
mode = 0;
rec[size].last = j - k;
rec[size].next = a[j];
if (rec[size].prev >= rec[size].next) {
puts("Incorrect sequence");
return 0;
}
size++;
} else if (j - k >= 0)
if (a[j - k] >= a[j]) {
puts("Incorrect sequence");
return 0;
}
if (mode) {
rec[size].last = j - k;
rec[size].next = 1010000000;
if (rec[size].prev >= rec[size].next) {
puts("Incorrect sequence");
return 0;
}
size++;
}
while (size) {
Rec r = rec[--size];
int num = (r.last - r.first) / k + 1;
if (r.next - r.prev - 1 < num) {
puts("Incorrect sequence");
return 0;
}
if (r.next <= 0) {
int tmp = 1;
for (j = r.last; j >= r.first; j -= k) a[j] = r.next - tmp++;
} else if (r.prev < 0 && r.next > 0) {
int tmp;
int left = -(num / 2), right = left + num - 1;
if (!(r.prev < left))
left = r.prev + 1;
else if (!(right < r.next)) {
right = r.next - 1;
left = right - num + 1;
}
tmp = 0;
for (j = r.first; j <= r.last; j += k) a[j] = left + tmp++;
} else {
int tmp = 1;
for (j = r.first; j <= r.last; j += k) a[j] = r.prev + tmp++;
}
}
}
for (i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.