text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <typename Int>
inline Int read() {
Int flag = 1;
char c = getchar();
while ((!isdigit(c)) && c != '-') c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline void write(Int x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x > 9) write(x / 10);
putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
write(x);
putchar(nextch);
}
struct LR {
long long l, r, idx;
long long length;
LR(long long L = 0, long long R = 0, long long IDX = 0)
: l(L), r(R), idx(IDX), length(r - l + 1) {}
bool operator<(const LR &other) const { return l > other.l; }
};
struct Memory_Manager {
long long from[107], size;
long long l[107], r[107], top;
Memory_Manager() : top(0) { memset(from, 0, sizeof(from)); }
void alloc(long long n) {
bool isSuccess = 0;
for (long long i = 1; i <= size - n + 1; i++) {
bool couldUse = 1;
for (long long j = 0; j < n; j++) {
if (from[i + j]) {
couldUse = 0;
i = i + j;
break;
}
}
if (couldUse) {
top++;
l[top] = i;
r[top] = i + n - 1;
for (long long j = l[top]; j <= r[top]; j++) {
from[j] = top;
}
isSuccess = 1;
break;
}
}
if (isSuccess) {
write(top, '\n');
} else {
puts("NULL");
}
}
void erase(long long x) {
if (x <= 0 || x > top || l[x] == -1) {
puts("ILLEGAL_ERASE_ARGUMENT");
return;
}
for (long long j = l[x]; j <= r[x]; j++) {
from[j] = 0;
}
l[x] = -1;
}
void defragment() {
priority_queue<LR> pq;
for (long long i = 1; i <= top; i++) {
if (l[i] != -1) {
pq.push(LR(l[i], r[i], i));
}
}
memset(from, 0, sizeof(from));
long long Rwall = 0;
while (!pq.empty()) {
LR f = pq.top();
pq.pop();
l[f.idx] = Rwall + 1;
r[f.idx] = Rwall + f.length;
Rwall += f.length;
for (long long i = l[f.idx]; i <= r[f.idx]; i++) {
from[i] = f.idx;
}
}
}
} BerlOS;
long long t, m;
char buf[20], n;
signed main() {
t = read<long long>();
m = read<long long>();
BerlOS.size = m;
while (t--) {
scanf("%s", buf);
switch (buf[0]) {
case 'a':
BerlOS.alloc(read<long long>());
break;
case 'e':
BerlOS.erase(read<long long>());
break;
case 'd':
BerlOS.defragment();
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
vector<int> A;
A.resize(m);
int c = 0;
for (int i = 0; i < m; ++i) A[i] = 0;
for (int i = 0; i < t; ++i) {
string z;
int tmp;
cin >> z;
if (z[0] == 'd') {
for (int j = 0; j < m - 1; ++j) {
for (int k = m - 1; k > j; k--) {
if (A[k] != 0 && 0 == A[k - 1]) {
int tmp2 = A[k];
A[k] = A[k - 1];
A[k - 1] = tmp2;
}
}
}
} else if (z[0] == 'e') {
cin >> tmp;
int j = 0;
while (j < m && A[j] != tmp) j++;
if (j == m || tmp == 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
while (j < m && A[j] == tmp) {
A[j] = 0;
j++;
}
} else {
cin >> tmp;
int empty = 0;
int j = 0;
while (j < m && empty < tmp) {
if (A[j] == 0)
empty++;
else
empty = 0;
j++;
}
if (j == m && empty < tmp)
cout << "NULL" << endl;
else {
c++;
for (int k = j - 1; k > j - 1 - empty; --k) {
A[k] = c;
}
cout << c << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
list<pair<int, int> > f;
list<pair<pair<int, int>, int> > nf;
f.push_back(pair<int, int>(1, m));
int a = 1;
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s == "alloc") {
int n;
cin >> n;
bool found = false;
for (list<pair<int, int> >::iterator it = f.begin(); it != f.end();
++it) {
if (it->second - it->first + 1 >= n) {
cout << a << endl;
found = true;
nf.push_back(pair<pair<int, int>, int>(
pair<int, int>(it->first, it->first + n - 1), a));
nf.sort();
it->first = it->first + n;
if (it->first > it->second) f.erase(it);
a++;
break;
}
}
if (!found) {
cout << "NULL" << endl;
}
} else if (s == "erase") {
int n;
cin >> n;
list<pair<pair<int, int>, int> >::iterator ff;
bool found = false;
for (ff = nf.begin(); ff != nf.end(); ++ff) {
if (ff->second == n) {
found = true;
f.push_back(pair<int, int>(ff->first.first, ff->first.second));
nf.erase(ff);
f.sort();
list<pair<int, int> >::iterator prev = f.end();
for (list<pair<int, int> >::iterator it = f.begin(); it != f.end();) {
if (prev != f.end() && it->first - prev->second == 1) {
prev->second = it->second;
prev = it;
it = f.erase(it);
} else {
prev = it;
++it;
}
}
break;
}
}
if (!found) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
int s = 1;
for (list<pair<pair<int, int>, int> >::iterator it = nf.begin();
it != nf.end(); ++it) {
int sz = it->first.second - it->first.first;
it->first.first = s;
it->first.second = s + sz;
s = it->first.second + 1;
}
f.clear();
if (s <= m) f.push_back(pair<int, int>(s, m));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
int a[101];
int xx = 0;
int x;
string s;
int main() {
cin >> t >> m;
for (int i = 0; i < t; i++) {
cin >> s;
if (s == "defragment") {
for (int j = 0; j < m; j++) {
if (a[j] == 0) {
int find = -1;
for (int k = m - 1; k > j; k--) {
if (a[k] != 0) find = k;
}
if (find != -1) {
a[j] = a[find];
a[find] = 0;
}
}
}
} else {
if (s.find("alloc") != -1) {
cin >> x;
bool ok1 = false;
for (int j = 0; j < m; j++) {
if (!ok1) {
bool ok = true;
for (int k = 0; k < x; k++)
if ((j + k >= m) || (a[j + k] != 0)) ok = false;
if (ok) {
ok1 = true;
xx++;
for (int k = j; k < j + x; k++) a[k] = xx;
}
}
}
if (!ok1)
cout << "NULL" << endl;
else
cout << xx << endl;
} else {
cin >> x;
bool ok = false;
for (int j = 0; j < m; j++)
if (a[j] == x) {
ok = true;
a[j] = 0;
}
if (x == 0) ok = false;
if (!ok) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int a[100 + 10], b[100 + 10], id, n, m;
char s[1000 + 10];
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); i++) {
int k;
scanf("%s", s);
if (s[0] == 'a') {
cin >> k;
bool g = false;
if (k > 0) {
for (int i = (0); i < (m - k + 1); i++) {
bool f = true;
for (int j = (i); j < (i + k); j++)
if (a[j] != 0) f = false;
if (f) {
g = true;
id++;
for (int j = (i); j < (i + k); j++) a[j] = id;
break;
}
}
}
if (!g)
printf("NULL\n");
else
printf("%d\n", id);
} else if (s[0] == 'e') {
cin >> k;
bool f = false;
for (int i = (0); i < (m); i++)
if (a[i] == k) {
f = true;
a[i] = 0;
}
if (!f || k == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else if (s[0] == 'd') {
int p = 0;
for (int i = (0); i < (m); i++) {
if (a[i] != 0) {
a[p++] = a[i];
}
}
for (int i = (p); i < (m); i++) a[i] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace red {
inline int read() {
int x = 0;
char ch, f = 1;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return f ? x : -x;
}
const int N = 1e5 + 10;
int n, m, id;
int a[N], b[N];
int l[N], r[N];
char s[N];
inline void alloc(int x) {
int pre = 1;
for (int i = 1; i <= m; ++i) {
if (b[i])
pre = i + 1;
else {
if (i - pre + 1 >= x) {
++id;
for (int j = pre; j <= i; ++j) b[j] = id;
l[id] = pre, r[id] = i;
printf("%d\n", id);
return;
}
}
}
puts("NULL");
}
inline void erase(int x) {
if (x <= 0 || x > id) {
puts("ILLEGAL_ERASE_ARGUMENT");
return;
}
bool flag = 0;
for (int i = 1; i <= m; ++i) {
if (b[i] == x) {
flag = 1;
b[i] = 0;
}
}
if (!flag) puts("ILLEGAL_ERASE_ARGUMENT");
}
inline void get_col(int x, int y, int col) {
for (int i = x; i <= y; ++i) b[i] = col;
if (col) l[col] = x, r[col] = y;
}
inline void defragment() {
int pre = 1;
for (int i = 1; i <= m; ++i) {
if (b[i]) {
if (pre == l[b[i]]) {
pre = r[b[i]] + 1;
i = r[b[i]];
} else {
int col = b[i], len = r[col] - l[col];
get_col(l[col], r[col], 0);
get_col(pre, pre + len, col);
i = r[col];
pre = r[col] + 1;
}
}
}
}
inline void main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
if (s[0] == 'a') alloc(read());
if (s[0] == 'e') erase(read());
if (s[0] == 'd') defragment();
}
}
} // namespace red
signed main() {
red::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n;
long long mem[100];
string s;
int main() {
cin >> t >> n;
long long su = 0;
for (int op = 0; op < t; op++) {
cin >> s;
if (s == "alloc") {
long long N;
cin >> N;
bool ok = false;
for (int i = 0; i < n - N + 1; i++) {
bool ok1 = true;
for (int j = i; j < i + N; j++)
if (mem[j] != 0) ok1 = false;
if (ok1) {
su++;
for (int j = i; j < i + N; j++) mem[j] = su;
ok = true;
break;
}
}
if (ok)
cout << su << endl;
else
cout << "NULL" << endl;
}
if (s == "erase") {
long long N;
cin >> N;
bool ok = false;
for (int i = 0; i < n; i++)
if (mem[i] == N) {
mem[i] = 0;
ok = true;
}
if (!ok || N == 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
if (s == "defragment") {
for (int i = 0; i < n; i++) {
if (mem[i] == 0)
for (int j = i + 1; j < n; j++)
if (mem[j] != 0) {
mem[i] = mem[j];
mem[j] = 0;
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1e5) + 9;
int mem[110];
string s;
int t, m;
bool add(int len, int name) {
int i, j, d = m - len + 1;
bool flag = false;
for (i = 1; i <= d; i++) {
flag = false;
for (j = i; j < i + len; j++) {
if (mem[j]) flag = true;
}
if (flag == false) {
for (j = i; j < i + len; j++) {
mem[j] = name;
}
return true;
}
}
return false;
}
int main() {
int i, j, k;
int len, na, name = 1;
bool flag;
scanf("%d%d\n", &t, &m);
memset(mem, 0, sizeof(int) * 110);
for (k = 0; k < t; k++) {
cin >> s;
if (s[0] == 'a') {
scanf("%d", &len);
if (add(len, name)) {
printf("%d\n", name);
name++;
} else {
printf("NULL\n");
}
} else if (s[0] == 'e') {
scanf("%d", &na);
if (na == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
for (i = 1; i <= m; i++) {
if (mem[i] == na) break;
}
if (i > m) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
while (mem[i] == na) {
mem[i] = 0;
i++;
}
}
}
} else if (s[0] == 'd') {
i = j = 1;
while (j <= m) {
mem[i] = mem[j];
if (mem[i]) {
i++;
if (j >= i) mem[j] = 0;
}
j++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M;
vector<pair<pair<int, int>, int> > v;
bool alloc(int x, int id) {
int i, j;
for ((i) = 0; (i) < (int)(M - x + 1); (i)++) {
bool bad = false;
for ((j) = 0; (j) < (int)(v.size()); (j)++) {
int a = v[j].first.first, b = v[j].first.second;
if (a < i + x && b > i) bad = true;
}
if (!bad) {
v.push_back(make_pair(make_pair(i, i + x), id));
cout << id << endl;
return true;
}
}
cout << "NULL" << endl;
return false;
}
bool erase2(int id) {
int i;
for ((i) = 0; (i) < (int)(v.size()); (i)++)
if (v[i].second == id) {
v.erase(v.begin() + i);
return true;
}
return false;
}
void defragment(void) {
int i, sum = 0;
sort(v.begin(), v.end());
for ((i) = 0; (i) < (int)(v.size()); (i)++) {
int x = v[i].first.second - v[i].first.first;
v[i].first.first = sum;
v[i].first.second = sum + x;
sum += x;
}
}
int main(void) {
int Q, x, i, id = 1;
cin >> Q >> M;
for ((i) = 0; (i) < (int)(Q); (i)++) {
string s;
cin >> s;
if (s == "alloc") {
cin >> x;
if (alloc(x, id)) id++;
} else if (s == "erase") {
cin >> x;
if (!erase2(x)) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
int x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, now, idt[105];
char ope[15];
int main() {
n = IN(), m = IN(), now = 1;
for (int i = 1; i <= n; i++) {
scanf("%s", ope);
if (ope[0] == 'a') {
int x = IN(), find = 0;
for (int i = 1; i <= m - x + 1; i++) {
if (idt[i]) continue;
int j = i;
while (j - i + 1 < x && !idt[j + 1]) j++;
if (j - i + 1 == x) {
for (int k = i; k <= j; k++) idt[k] = now;
find = 1;
break;
}
i = j;
}
if (find)
printf("%d\n", now++);
else
puts("NULL");
}
if (ope[0] == 'e') {
int x = IN(), find = 0;
for (int i = 1; i <= m; i++) {
if (idt[i] == x) idt[i] = 0, find = 1;
}
if (x <= 0 || x >= now || !find) puts("ILLEGAL_ERASE_ARGUMENT");
}
if (ope[0] == 'd') {
for (int i = 1; i <= m; i++)
if (!idt[i]) {
int j = i + 1;
while (j <= m && !idt[j]) j++;
if (j > m)
break;
else
idt[i] = idt[j], idt[j] = 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long storage[102];
void solve() {
long long t, m;
cin >> t >> m;
long long id = 0;
for (long long i = 0; i < t; i++) {
string s;
cin >> s;
if (s[0] == 'a') {
long long t;
cin >> t;
long long i, j;
for (i = 0, j = -1; i < m; i++) {
if (!storage[i] && i - j >= t)
break;
else if (storage[i])
j = i;
}
if (i < m) {
cout << ++id << "\n";
for (++j; j <= i; j++) storage[j] = id;
} else
cout << "NULL"
<< "\n";
} else if (s[0] == 'e') {
long long t;
cin >> t;
long long i = 0, j = 0;
for (i = j = 0; i < m; i++)
if (storage[i] == t) storage[i] = 0, j = 1;
if (!j or t == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT"
<< "\n";
}
} else {
for (long long i = 0, j = 0; i < m; i++) {
if (storage[i]) {
long long t = storage[i];
storage[i] = 0, storage[j++] = t;
}
}
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int d[101], t, m, c, a, b = 0;
int i, j, k, l;
string s;
int main() {
cin >> t >> m;
for (i = 0; i < t; i++) {
cin >> s;
if (s[0] == 'a') {
cin >> c;
for (k = 0, j = -1; k < m; k++)
if (k - j == c && !d[k])
break;
else if (d[k])
j = k;
if (k - j == c && k < m) {
cout << ++b << endl;
for (l = j + 1; l <= k; l++) d[l] = b;
} else
cout << "NULL" << endl;
} else if (s[0] == 'e') {
cin >> c;
for (k = 0, j = 0; k < m; k++)
if (d[k] == c && c != 0) {
d[k] = 0;
j = 1;
}
if (!j) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else if (s[0] == 'd') {
for (k = 0, j = 0; k < m; k++)
if (d[k]) {
a = d[j];
d[j] = d[k];
d[k] = a;
j++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 20;
const int mod = 1000000007;
int T;
int n, m;
char str[20];
int a[110], tot(1);
long long t;
int main() {
T = 1;
for (int T1 = 1; T1 <= T; T1++) {
scanf("%d %d", &n, &m);
for (int k = 1; k <= n; k++) {
scanf("%s", str);
if (str[0] == 'a') {
scanf("%lld", &t);
int cnt(0);
for (int i = 1; i <= m; i++) {
if (!a[i])
cnt++;
else
cnt = 0;
if (cnt == t) {
while (t) {
a[i - t + 1] = tot;
t--;
}
break;
}
}
if (t)
puts("NULL");
else
printf("%d\n", tot++);
} else if (str[0] == 'e') {
scanf("%lld", &t);
if (t <= 0 || t > n) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
int ff(0);
for (int i = 1; i <= m; i++) {
if (a[i] == t) ff = 1, a[i] = 0;
}
if (!ff) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (int i = 2; i <= m; i++) {
if (a[i]) {
int j = i - 1;
while (j && !a[j]) {
a[j] = a[j + 1];
a[j + 1] = 0;
j--;
}
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[115];
int t, m;
int main() {
cin >> t >> m;
int cnt = 1;
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
int n;
cin >> n;
int id = -1;
for (int i = 0; i <= m - n; i++) {
bool ok = true;
for (int j = 0; j < n; j++)
if (a[i + j] != 0) {
ok = false;
break;
}
if (ok) {
id = i;
break;
}
}
if (id == -1)
puts("NULL");
else {
cout << cnt << endl;
for (int i = 0; i < n; i++) a[id + i] = cnt;
cnt++;
}
}
if (s == "erase") {
int x;
cin >> x;
if (x == 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
bool ok = false;
for (int i = 0; i < m; i++)
if (a[i] == x) {
ok = true;
a[i] = 0;
}
if (!ok) puts("ILLEGAL_ERASE_ARGUMENT");
}
if (s == "defragment") {
int w = 0;
for (int i = 0; i < m; i++)
if (a[i] != 0) a[w++] = a[i];
for (int i = w; i < m; i++) a[i] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[102];
char inp[100];
char inp2[100];
long long p;
int main() {
gets(inp);
int n, m;
sscanf(inp, "%d%d", &n, &m);
int cnt = 1;
for (int i = 0; i < n; i++) {
gets(inp);
if (inp[0] == 'd') {
vector<int> ch;
for (int t = 0; t < m; t++) {
if (ar[t] != 0) ch.push_back(ar[t]);
}
memset(ar, 0, sizeof(ar));
int k = 0;
for (int t = 0; t < m && k < ch.size(); t++, k++) {
ar[t] = ch[k];
}
} else if (inp[0] == 'e') {
sscanf(inp, "%s%lld", inp2, &p);
bool got = false;
if (p > 0)
for (int t = 0; t < m; t++) {
if (ar[t] == p) {
ar[t] = 0;
got = true;
}
}
if (!got) {
puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
sscanf(inp, "%s%lld", inp2, &p);
bool perf = false;
for (int t = 0; t + p <= m; t++) {
int j = t;
for (; j < t + p; j++)
if (ar[j] != 0) break;
if (j == t + p) {
j = t;
for (; j < t + p; j++) ar[j] = cnt;
perf = true;
printf("%d\n", cnt);
cnt++;
break;
}
}
if (!perf) puts("NULL");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, ord;
string s;
int n;
int mm[110];
int alloc(int mem) {
int i, j;
for (i = 0; i <= m - mem; i++) {
for (j = i; j < i + mem; j++)
if (mm[j] != 0) break;
if (j == i + mem) {
ord++;
for (j = i + mem - 1; j >= i; j--) mm[j] = ord;
return ord;
}
}
return -1;
}
int erase(int num) {
bool f = 0;
for (int i = 0; i < m; i++) {
if (mm[i] == num) {
f = 1;
mm[i] = 0;
}
}
if (f) return 1;
return -1;
}
void defragment() {
int nw[110];
int np = 0;
memset(nw, 0, sizeof(nw));
for (int i = 0; i < m; i++) {
if (mm[i] != 0) nw[np++] = mm[i];
mm[i] = 0;
}
for (int i = 0; i < np; i++) mm[i] = nw[i];
}
int main() {
cin >> t >> m;
for (int i = 0; i < t; i++) {
cin >> s;
if (s == "alloc") {
cin >> n;
int y = alloc(n);
if (y == -1)
cout << "NULL" << endl;
else
cout << y << endl;
}
if (s == "erase") {
cin >> n;
int y = erase(n);
if (y == -1 || n <= 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
if (s == "defragment") {
defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Arr[105];
int main() {
int t, m;
cin >> t >> m;
int id = 1, i;
string s;
while (t--) {
cin >> s;
if (s[0] == 'a') {
int p;
cin >> p;
int cnt = 0, idx = 0;
bool ok = false;
for (i = 0; i < m; i++) {
if (!Arr[i])
cnt++;
else {
cnt = 0;
idx = i + 1;
}
if (cnt == p) {
ok = true;
break;
}
}
if (ok) {
for (i = idx; i < idx + p; i++) Arr[i] = id;
cout << id++ << endl;
} else
puts("NULL");
} else if (s[0] == 'e') {
int p;
cin >> p;
if (p > id || p <= 0)
puts("ILLEGAL_ERASE_ARGUMENT");
else {
int f = false;
for (i = 0; i < m; i++) {
if (Arr[i] == p) break;
}
while (Arr[i] == p) {
Arr[i] = 0;
i++;
f = true;
}
if (!f) puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
int idx = 0;
for (i = 0; i < m; i++) {
if (Arr[i]) Arr[idx++] = Arr[i];
}
for (i = idx; i < m; i++) Arr[i] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct T1 {
int fr, len;
int nu;
int vis;
T1(){};
T1(int fr, int len, int nu) : fr(fr), len(len), nu(nu){};
};
bool operator<(const T1& a, const T1& b) { return a.fr < b.fr; }
vector<T1> a;
int used[2000];
int m, nu;
int find(int x) {
for (int i = 0; i < a.size(); i++) {
if (a[i].nu == x) return i;
}
return -1;
}
int call(int x) {
int i, j, k;
for (i = 1; i <= m;)
if (used[i] == 0) {
k = 0;
for (j = i + 1; j <= m; j++)
if (used[j]) break;
k = j - i;
if (k >= x) {
a.push_back(T1(i, x, nu));
for (int z = i; z < i + x; z++) used[z] = 1;
nu++;
return 1;
}
i = j;
} else
i++;
return 0;
}
int clear(int x) {
int cp = find(x);
if (cp == -1) return 0;
for (int i = 0; i < a[cp].len; i++) used[a[cp].fr + i] = 0;
a.erase(a.begin() + cp);
return 1;
}
void resize() {
sort(a.begin(), a.end());
int sum = 0;
for (int i = 0; i < a.size(); i++) sum += a[i].len;
for (int i = 1; i <= sum; i++) {
used[i] = 1;
}
for (int i = sum + 1; i <= m; i++) used[i] = 0;
sum = 1;
for (int i = 0; i < a.size(); i++) {
a[i].fr = sum;
sum += a[i].len;
}
}
int main() {
int T, x;
string s;
cin >> T >> m;
a.clear();
memset(used, 0, sizeof(used));
nu = 1;
for (int i = 0; i < T; i++) {
cin >> s;
if (s == "alloc") {
cin >> x;
if (call(x) == 1)
cout << nu - 1 << endl;
else
cout << "NULL" << endl;
} else if (s == "erase") {
cin >> x;
if (clear(x) == 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else
resize();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int n, m;
set<int> all;
int use[101];
void miracle() {
int n, m;
cin >> n >> m;
memset(use, 0, sizeof(use));
int r = 0;
for (int t = 0; t < n; t++) {
string s;
cin >> s;
if (s == "alloc") {
int l, OK = 0;
cin >> l;
for (int i = 0; i + l <= m; i++) {
int ok = 1;
for (int j = 0; j < l; j++)
if (use[i + j]) ok = 0;
if (ok) {
OK = 1;
r++;
for (int j = 0; j < l; j++) use[i + j] = r;
all.insert(r);
cout << r << endl;
break;
}
}
if (!OK) cout << "NULL" << endl;
} else if (s == "erase") {
int x;
cin >> x;
if (all.find(x) == all.end())
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
all.erase(x);
for (int j = 0; j < m; j++)
if (use[j] == x) use[j] = 0;
}
} else {
int mm = 0;
for (int j = 0; j < m; j++) {
if (use[j] != 0) {
use[mm] = use[j];
mm++;
}
}
for (int j = mm; j < m; j++) use[j] = 0;
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
miracle();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
vector<int> v(m, 1000000000);
int c = 1;
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s == "alloc") {
int x;
cin >> x;
int r = 0;
bool found = false;
for (int i = 0; i < m; i++) {
if (v[i] == 1000000000) {
r++;
} else {
r = 0;
}
if (r == x) {
found = true;
for (int j = i - r + 1; j <= i; j++) {
v[j] = c;
}
break;
}
}
if (found) {
cout << c << endl;
c++;
} else {
cout << "NULL" << endl;
}
} else if (s == "erase") {
int x;
cin >> x;
bool b = false;
for (int i = 0; i < m; i++) {
if (v[i] == x) {
b = true;
v[i] = 1000000000;
}
}
if (!b) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
vector<int> v1;
for (int i = 0; i < m; i++) {
if (v[i] != 1000000000) {
v1.push_back(v[i]);
}
}
while (v1.size() < m) {
v1.push_back(1000000000);
}
v = v1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mem[101] = {0};
long long int numbering = 0;
long long int t;
long long int n;
long long int length(long long int value, long long int index) {
long long int l;
for (l = 0; l + index < n && mem[index + l] == value; l++)
;
return l;
}
long long int Alloc(long long int size) {
for (long long int i = 0; i < n; i++)
if (mem[i] == 0) {
long long int cnt = length(0, i);
if (cnt >= size) {
numbering++;
for (long long int j = i; j < i + size && j < n; j++)
mem[j] = numbering;
return numbering;
} else
i += cnt;
}
return -1;
}
long long int erase(long long int name) {
if (name <= 0) return -1;
long long int ILL = true;
for (long long int i = 0; i < n; i++)
if (mem[i] == name) {
mem[i] = 0;
ILL = false;
}
if (ILL) return -1;
return 1;
}
int main() {
cin >> t >> n;
for (long long int c = 0; c < t; c++) {
char cmd[10];
cin >> cmd;
if (!strcmp(cmd, "defragment")) {
int temp[101] = {0};
int s = 0;
for (int i = 0; i < n; i++) {
if (mem[i] != 0) temp[s++] = mem[i];
}
for (int i = 0; i < n; i++) mem[i] = temp[i];
} else {
long long int temp;
cin >> temp;
if (!strcmp(cmd, "alloc")) {
long long int res = Alloc(temp);
if (res < 0)
cout << "NULL" << endl;
else
cout << res << endl;
} else if (!strcmp(cmd, "erase")) {
long long int res = erase(temp);
if (res < 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1E-10;
inline long long intpow(long long a, long long n) {
long long r = 1;
while (n) {
if (n & 1) {
r *= a;
} else {
a *= a;
n = n >> 1;
}
}
return r;
}
inline long long hash(string s) {
long long r = 0;
long long p = 1;
long long m = 1777;
for (int i = 0; i < s.size(); i++) {
r += s[i] * p;
p *= m;
}
return r;
}
inline short bit(long long a, int p) { return (a >> p) & 1; }
inline long long gcd(long long a, long long b) {
if (a == b) return a;
if (a == 0) return b;
if (b == 0) return a;
if (a > b)
return gcd(a % b, b);
else
return gcd(a, b % a);
}
vector<string> splitstring(string s, char* tokens) {
bool b[256];
memset(b, 0, sizeof(b));
for (int i = 0; i < strlen(tokens); i++) {
b[int(tokens[i])] = true;
}
vector<string> r;
string t = "";
for (int i = 0; i < s.size(); i++) {
if (b[s[i]]) {
if (!t.empty()) {
r.push_back(t);
t.clear();
}
} else {
t += s[i];
}
}
if (!t.empty()) {
r.push_back(t);
t.clear();
}
return r;
}
vector<int> kmp(string s, string t) {
string r = s + "\r" + t;
int sz = r.size();
int ssz = s.size();
int tsz = t.size();
vector<int> p(sz);
p[0] = 0;
int j;
for (int i = 1; i < sz; ++i) {
j = p[i - 1];
while (j > 0 && r[i] != r[j]) j = p[j - 1];
if (r[i] == r[j]) ++j;
p[i] = j;
}
vector<int> ans;
for (int i = s.size() + 1; i < sz; i++) {
if (p[i] == ssz) {
ans.push_back(i - ssz - ssz);
}
}
return ans;
}
void dbgVint(vector<int> a) {
for (int i = 0; i < a.size(); i++) {
printf("%d ", a[i]);
}
printf("\n");
}
void dbgVvint(vector<vector<int> > a) {
for (int i = 0; i < a.size(); i++) {
dbgVint(a[i]);
}
}
void dbgVstr(vector<string> a) {
for (int i = 0; i < a.size(); i++) {
printf("%s\n", a[i].data());
}
}
int main() {
int t, m;
cin >> t >> m;
vector<int> b(m);
int id = 1;
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s[0] == 'a') {
int sz;
cin >> sz;
bool p = false;
int k = 0;
for (int j = 0; j < m; j++) {
if (b[j] == 0)
k++;
else {
k = 0;
}
if (k == sz) {
for (int u = j - k + 1; u <= j; u++) {
b[u] = id;
}
p = true;
break;
}
}
if (p) {
cout << id << endl;
id++;
} else {
cout << "NULL" << endl;
}
} else {
if (s[0] == 'e') {
int w;
cin >> w;
if (w >= id || w <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
bool p = false;
for (int i = 0; i < m; i++) {
if (b[i] == w) {
p = true;
for (int j = i; j < m && b[j] == w; j++) {
b[j] = 0;
}
break;
}
}
if (!p) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
vector<int> nb;
for (int i = 0; i < m; i++) {
if (b[i] != 0) nb.push_back(b[i]);
}
nb.resize(m);
b = nb;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool f[1000];
int t, m;
char s[100];
int cnt;
int start[1000], len[1000];
bool used[1000];
void solve() {
scanf("%d%d", &t, &m);
for (int i = 0; i < t; i++) {
scanf("%s", s);
if (s[0] == 'a') {
int n;
scanf("%d", &n);
int q = 0;
for (int i = 0; i + n <= m; i++) {
bool ok = true;
for (int j = i; j < i + n; j++)
if (used[j]) {
ok = false;
break;
}
if (ok) {
printf("%d\n", ++cnt);
f[cnt] = true;
for (int j = i; j < i + n; j++) used[j] = true;
start[cnt] = i;
len[cnt] = n;
q = 1;
break;
}
}
if (q == 0) {
printf("NULL\n");
}
} else if (s[0] == 'e') {
int x;
scanf("%d", &x);
if (x >= 0 && x < 1000 && f[x]) {
f[x] = false;
for (int j = start[x]; j < start[x] + len[x]; j++) used[j] = false;
} else {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else {
int min_st = -1;
int have = 0;
memset(used, 0, sizeof(used));
while (true) {
int q = -1;
int mi = 1000;
for (int i = 1; i <= cnt; i++)
if (f[i] && start[i] > min_st && start[i] < mi) {
q = i;
mi = start[i];
}
if (q == -1) break;
min_st = start[q];
start[q] = have;
have += len[q];
}
for (int i = 0; i < have; i++) used[i] = true;
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int mark[maxn];
int idn = 1;
int m, t;
string q;
vector<pair<int, pair<int, int> > > vec;
int ja[maxn];
int main() {
ios::sync_with_stdio(false);
cin >> t >> m;
for (int i = 0; i < t + 1; ++i) ja[i] = -1;
for (int it = 0; it < t; ++it) {
cin >> q;
if (q == "erase") {
int x;
cin >> x;
if (x >= idn || x < 1 || ja[x] == -1)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
pair<int, pair<int, int> > v = vec[ja[x]];
if (v.second.second != x) cerr << "ERROR" << endl;
vec.erase(vec.begin() + ja[x]);
for (int i = 0; i < (int)(vec).size(); ++i)
ja[vec[i].second.second] = i;
for (int i = v.first; i < v.second.first + v.first; ++i)
mark[i] = false;
ja[x] = -1;
}
}
if (q == "alloc") {
int n;
bool bo = false;
int now = 0;
cin >> n;
for (int i = 0; i < m - n + 1; ++i) {
for (int j = 0; j < n; ++j) {
if (mark[j + i]) break;
if (j == n - 1) {
bo = true;
now = i;
}
}
if (bo) break;
}
if (bo) {
for (int i = now; i < now + n; ++i) mark[i] = true;
vec.push_back(pair<int, pair<int, int> >(now, pair<int, int>(n, idn)));
sort((vec).begin(), (vec).end());
for (int i = 0; i < (int)(vec).size(); ++i)
ja[vec[i].second.second] = i;
cout << idn++ << endl;
} else
cout << "NULL" << endl;
}
if (q == "defragment") {
for (int i = 0; i < m; ++i) mark[i] = false;
int sum = 0;
for (int i = 0; i < (int)(vec).size(); ++i) {
vec[i].first = sum;
sum += vec[i].second.first;
}
for (int i = 0; i < sum; ++i) mark[i] = true;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Int>
inline Int read() {
Int flag = 1;
char c = getchar();
while ((!isdigit(c)) && c != '-') c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline void write(Int x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x > 9) write(x / 10);
putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
write(x);
putchar(nextch);
}
struct LR {
long long l, r, idx;
long long length;
LR(long long L = 0, long long R = 0, long long IDX = 0)
: l(L), r(R), idx(IDX), length(r - l + 1) {}
bool operator<(const LR &other) const { return l > other.l; }
};
struct Memory_Manager {
long long from[107], size;
long long l[107], r[107], top;
Memory_Manager() : top(0) { memset(from, 0, sizeof(from)); }
void alloc(long long n) {
bool isSuccess = 0;
for (long long i = 1; i <= size - n + 1; i++) {
bool couldUse = 1;
for (long long j = 0; j < n; j++) {
if (from[i + j]) {
couldUse = 0;
i = i + j;
break;
}
}
if (couldUse) {
top++;
l[top] = i;
r[top] = i + n - 1;
for (long long j = l[top]; j <= r[top]; j++) {
from[j] = top;
}
isSuccess = 1;
break;
}
}
if (isSuccess) {
write(top, '\n');
} else {
puts("NULL");
}
}
void erase(long long x) {
if (x <= 0 || x > top || l[x] == -1) {
puts("ILLEGAL_ERASE_ARGUMENT");
return;
}
for (long long j = l[x]; j <= r[x]; j++) {
from[j] = 0;
}
l[x] = -1;
}
void defragment() {
priority_queue<LR> pq;
for (long long i = 1; i <= top; i++) {
if (l[i] != -1) {
pq.push(LR(l[i], r[i], i));
}
}
memset(from, 0, sizeof(from));
long long Rwall = 0;
while (!pq.empty()) {
LR f = pq.top();
pq.pop();
l[f.idx] = Rwall + 1;
r[f.idx] = Rwall + f.length;
Rwall += f.length;
for (long long i = l[f.idx]; i <= r[f.idx]; i++) {
from[i] = f.idx;
}
}
}
} BerlOS;
long long t, m;
char buf[20], n;
signed main() {
t = read<long long>();
m = read<long long>();
BerlOS.size = m;
while (t--) {
scanf("%s", buf);
switch (buf[0]) {
case 'a':
BerlOS.alloc(read<long long>());
break;
case 'd':
BerlOS.defragment();
break;
case 'e':
BerlOS.erase(read<long long>());
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[128];
int main() {
int n, m, cnt = 0;
cin >> n >> m;
fill(mem, mem + m, 0);
string s;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "alloc") {
int len;
cin >> len;
int ok = -1;
for (int j = 0; j < m; j++) {
if (mem[j] != 0) continue;
for (int k = 0; k < len; k++)
if (j + k >= m || mem[j + k] != 0) goto end;
ok = j;
break;
end:;
}
if (ok == -1)
cout << "NULL" << endl;
else {
cnt++;
cout << cnt << endl;
mem[ok] = cnt;
for (int j = 1; j < len; j++) mem[ok + j] = -1;
}
} else if (s == "erase") {
int num, ok = -1;
cin >> num;
for (int j = 0; j < m; j++)
if (num == mem[j]) {
ok = j;
break;
}
if (ok == -1 || num <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
do {
mem[ok] = 0;
ok += 1;
} while (ok < m && mem[ok] == -1);
}
} else {
int k = 0;
for (int j = 0; j < m; j++)
if (mem[j] != 0) mem[k++] = mem[j];
for (int j = k; j < m; j++) mem[j] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int n, m;
string s;
int a[maxn];
int main() {
cin >> n >> m;
int cnt = 0;
while (n--) {
cin >> s;
if (s[0] == 'a') {
int x;
cin >> x;
int num = 0;
bool flag = false;
for (int i = 1; i + x - 1 <= m; i++) {
num = 0;
for (int j = i; j <= i + x - 1; j++) {
if (a[j] == 0) num++;
}
if (num == x) {
cnt++;
flag = true;
for (int j = i; j <= i + x - 1; j++) a[j] = cnt;
cout << cnt << endl;
break;
}
}
if (!flag) cout << "NULL" << endl;
} else if (s[0] == 'e') {
int x;
cin >> x;
if (x <= 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
bool flag = false;
for (int i = 1; i <= m; i++) {
if (a[i] == x) {
a[i] = 0;
flag = true;
}
}
if (!flag) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
int k = 1;
for (int i = 1; i <= m; i++) {
if (a[i]) {
a[k++] = a[i];
}
}
for (; k <= m; k++) a[k] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool byte[105];
int sum, ans, clear[105], start[105];
vector<int> use;
int main() {
int t, n;
cin >> t >> n;
sum = n;
for (int i = 1; i <= n; i++) byte[i] = true;
while (t--) {
string in;
int a;
cin >> in;
if (in == "defragment") {
for (int i = 1; i <= n; i++)
if (i > n - sum)
byte[i] = true;
else
byte[i] = false;
pair<int, int> order[105];
int cnt = 1;
for (int i = 0; i < use.size(); i++)
if (start[use[i]]) order[cnt++] = make_pair(start[use[i]], use[i]);
sort(order + 1, order + cnt);
int k = 1;
for (int i = 1; i < cnt; i++) {
if (!clear[order[i].second]) continue;
start[order[i].second] = k;
k += clear[order[i].second];
}
} else if (in == "alloc") {
cin >> a;
bool find = false;
for (int i = 1; i <= n - a + 1 && !find; i++) {
bool ok = true;
for (int j = i; j <= i + a - 1 && !find; j++)
if (!byte[j]) ok = false;
if (ok) {
find = true;
start[++ans] = i;
clear[ans] = a;
use.push_back(ans);
sum -= a;
cout << ans << endl;
}
}
if (find)
for (int i = start[ans]; i <= start[ans] + clear[ans] - 1; i++)
byte[i] = false;
else
cout << "NULL" << endl;
} else {
cin >> a;
if (a <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
if (!clear[a])
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
sum += clear[a];
for (int i = start[a]; i <= start[a] + clear[a] - 1; i++)
byte[i] = true;
clear[a] = start[a] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') f = ch == '-' ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
const int MAXN = 110;
char opt[MAXN];
long long memory[MAXN];
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = read(), m = read();
int tot = 0;
for (int _ = (1); _ <= (t); _ += (1)) {
scanf("%s", opt + 1);
if (opt[1] == 'a') {
long long len = read();
bool find = false;
for (int i = (1); i <= (m - len + 1); i += (1)) {
bool ok = true;
for (int j = (i); j <= (i + len - 1); j += (1))
if (memory[j]) ok = false;
if (ok) {
tot++;
for (int j = (i); j <= (i + len - 1); j += (1)) memory[j] = tot;
find = true;
break;
}
}
if (find)
printf("%d\n", tot);
else
puts("NULL");
} else if (opt[1] == 'e') {
long long id = read();
if (id < 1 || id > tot) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
bool find = false;
for (int i = (1); i <= (m); i += (1))
if (memory[i] == id) memory[i] = 0, find = true;
if (!find) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (int i = 1, j = 1; j <= m; j++) {
while (memory[i]) i++;
j = max(j, i + 1);
if (memory[j]) memory[i] = memory[j], memory[j] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < vec.size(); i++) {
os << vec[i];
if (i + 1 != vec.size()) os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end()) os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end()) os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end()) os << " ";
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &st) {
for (auto itr = st.begin(); itr != st.end(); ++itr) {
os << *itr;
auto titr = itr;
if (++titr != st.end()) os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &mp) {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
os << itr->first << ":" << itr->second;
auto titr = itr;
if (++titr != mp.end()) os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp) {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
os << itr->first << ":" << itr->second;
auto titr = itr;
if (++titr != mp.end()) os << " ";
}
return os;
}
using ll = long long int;
using P = pair<int, int>;
const int inf = 1e9;
const ll linf = 1LL << 50;
const double EPS = 1e-10;
const int mod = 1000000007;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
struct fast_io {
fast_io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
}
} fast_io_;
int main(int argc, char const *argv[]) {
int t, m;
cin >> t >> m;
vector<ll> a(m, 0);
int curr = 1;
for (int i = (0); i < (t); ++i) {
string s;
cin >> s;
if (s == "alloc") {
ll x;
cin >> x;
bool flg = false;
for (int i = 0; i + x <= m; i++) {
bool ok = true;
for (int j = 0; j < x; j++) {
if (a[i + j] != 0) ok = false;
}
if (ok) {
for (int j = (0); j < (x); ++j) a[i + j] = curr;
cout << curr << endl;
curr++;
flg = true;
break;
}
}
if (!flg) cout << "NULL" << endl;
} else if (s == "erase") {
ll x;
cin >> x;
bool flg = false;
for (int i = (0); i < (m); ++i)
if (a[i] == x && a[i] != 0) a[i] = 0, flg = true;
if (!flg) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
vector<ll> b;
b.reserve(m);
for (int i = (0); i < (m); ++i)
if (a[i] != 0) b.emplace_back(a[i]);
b.resize(m, 0);
swap(a, b);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const int mod = 1000000007;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
template <class T>
inline void read(T& x, T& y, T& z, T& q) {
read(x);
read(y);
read(z);
read(q);
}
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
map<int, pair<int, int> > m;
string s;
int t, mi, n, x = 0;
read(t, mi);
int a[mi + 1], noz[mi + 1];
memset(a, 0, sizeof(a));
memset(noz, 0, sizeof(noz));
while (t--) {
cin >> s;
if (s == "alloc") {
read(n);
int in, flag = 0, cnt = 0;
for (int i = 0; i < mi; i++) {
if (a[i] == 0) {
cnt++;
} else {
cnt = 0;
}
if (cnt == n) {
flag = 1;
in = i - cnt + 1;
break;
}
}
if (flag == 1) {
for (int i = 0; i < n; i++) {
a[in + i] = 1;
}
x++;
m[x] = make_pair(in, n);
cout << x << endl;
} else {
cout << "NULL\n";
}
} else if (s == "erase") {
read(n);
if (m.find(n) != m.end()) {
int z = m[n].first, y = m[n].second;
for (int i = z; i < z + y; i++) {
a[i] = 0;
}
m.erase(n);
} else {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
} else {
if (a[0] == 0) {
noz[0] = 1;
} else {
noz[0] = 0;
}
for (int i = 1; i < mi; i++) {
if (a[i] == 0) {
noz[i] = 1 + noz[i - 1];
} else {
noz[i] = noz[i - 1];
}
}
memset(a, 0, sizeof(a));
map<int, pair<int, int> >::iterator it;
for (it = m.begin(); it != m.end(); it++) {
it->second.first -= noz[it->second.first];
}
for (int i = 0; i < mi - noz[mi - 1]; i++) {
a[i] = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int mem[1001] = {0}, temp[1001] = {0}, t, m, i, j, k, a = 0, si, n, tr;
char s[30];
scanf("%d%d", &t, &m);
while (t--) {
scanf(" %[^\n]", s);
n = 0;
if (s[0] == 'a' || s[0] == 'e') {
i = 0;
while (s[i] != ' ') i++;
i++;
while (s[i]) {
n = n * 10 + s[i] - '0';
i++;
}
}
if (s[0] == 'a') {
a++;
tr = 0;
for (i = 1; i <= m; i++) {
k = i;
while (mem[i] == 0 && i <= m) {
i++;
}
if (i - k >= n) {
for (j = k; j <= k + n - 1; j++) {
mem[j] = a;
}
tr = 1;
break;
}
}
if (tr) {
printf("%d\n", a);
} else {
a--;
printf("NULL\n");
}
} else if (s[0] == 'e') {
tr = 0;
for (i = 1; i <= m; i++) {
if (mem[i] == n) {
mem[i] = 0;
tr = 1;
}
}
if (!tr || n == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else {
k = 1;
for (i = 1; i <= m; i++) {
if (mem[i]) {
temp[k++] = mem[i];
}
}
for (; k <= m; k++) temp[k] = 0;
for (i = 1; i <= m; i++) {
mem[i] = temp[i];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
long long mem[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t, m;
cin >> t >> m;
long long id = 1;
while (t--) {
string tp;
cin >> tp;
if (tp == "alloc") {
long long sz;
cin >> sz;
bool f = 0;
for (long long i = 0; i < m && i + sz - 1 < m; i++) {
bool good = 1;
for (long long j = i; j < i + sz; j++) good &= mem[j] == 0;
if (good) {
for (long long j = i; j < i + sz; j++) mem[j] = id;
cout << id++ << '\n';
f = 1;
break;
}
}
if (!f) cout << "NULL\n";
} else if (tp == "erase") {
long long v;
cin >> v;
bool f = 0;
for (long long i = 0; i < m; i++)
if (mem[i] == v) mem[i] = 0, f = 1;
if (!f || v == 0) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else if (tp == "defragment") {
vector<long long> v;
for (long long i = 0; i < m; i++)
if (mem[i] != 0) v.push_back(mem[i]);
memset(mem, 0, sizeof mem);
for (long long i = 0; i < v.size(); i++) mem[i] = v[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Elem {
int ind, f, l;
Elem(int ind, int f, int l) {
this->ind = ind;
this->f = f;
this->l = l;
}
};
ifstream fin("/home/home/cf7/input.txt");
int n, nn, ss;
string com;
list<Elem> m;
list<Elem>::iterator it1, it2, pos;
int comx;
int q, i, j, d;
int main() {
ios_base::sync_with_stdio(0);
cin >> nn >> ss;
m.push_back(Elem(0, 0, 0));
for (q = 0; q < nn; q++) {
cin >> com;
if (com[0] == 'a') {
cin >> comx;
pos = m.end();
for (it2 = m.begin(), it2++; it2 != m.end(); it2++) {
it1 = it2;
it1--;
d = it2->f - it1->l - 1;
if (d >= comx) {
pos = it1;
break;
}
}
if (pos == m.end()) {
it1 = m.end();
it1--;
d = ss - it1->l;
if (d >= comx) {
pos = it1;
}
}
if (pos != m.end()) {
it1 = pos;
it1++;
n++;
m.insert(it1, Elem(n, pos->l + 1, pos->l + comx));
cout << n << endl;
} else
cout << "NULL\n";
} else if (com[0] == 'd') {
for (it2 = m.begin(), it2++; it2 != m.end(); it2++) {
it1 = it2;
it1--;
d = it2->l - it2->f;
it2->f = it1->l + 1;
it2->l = it2->f + d;
}
} else if (com[0] == 'e') {
cin >> comx;
for (it2 = m.begin(), it2++; it2 != m.end(); it2++) {
if (it2->ind == comx) break;
}
if (it2 != m.end())
m.erase(it2);
else
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
int a[111];
char in[1000];
int main() {
int t, m, i, j;
scanf("%d%d", &t, &m);
int aid = 1;
while (t--) {
scanf("%s", in);
int k;
if (in[0] == 'a') {
scanf("%d", &k);
for (i = 0; i <= m - k; i++) {
for (j = i; j < i + k; j++)
if (a[j] != 0) break;
if (j == i + k) break;
}
if (i <= m - k) {
printf("%d\n", aid);
for (j = i; j < i + k; j++) a[j] = aid;
aid++;
} else {
puts("NULL");
}
} else if (in[0] == 'e') {
bool f = 0;
scanf("%d", &k);
for (i = 0; i < m; i++)
if (a[i] && a[i] == k) {
a[i] = 0;
f = 1;
}
if (!f) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (i = 0, j = 0; i < m; i++)
if (a[i]) {
a[j++] = a[i];
}
for (; j < m; j++) a[j] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int M;
vector<pair<pair<int, int>, int> > v;
bool alloc(int x, int id) {
int i, j;
for ((i) = 0; (i) < (int)M - x + 1; (i)++) {
bool bad = false;
for ((j) = 0; (j) < (int)v.size(); (j)++) {
int a = v[j].first.first, b = v[j].first.second;
if (a < i + x && b > i) bad = true;
}
if (!bad) {
v.push_back(make_pair(make_pair(i, i + x), id));
cout << id << endl;
return true;
}
}
cout << "NULL" << endl;
return false;
}
bool erase2(int id) {
int i;
for ((i) = 0; (i) < (int)v.size(); (i)++)
if (v[i].second == id) {
v.erase(v.begin() + i);
return true;
}
return false;
}
void defragment(void) {
int i, sum = 0;
sort(v.begin(), v.end());
for ((i) = 0; (i) < (int)v.size(); (i)++) {
int x = v[i].first.second - v[i].first.first;
v[i].first.first = sum;
v[i].first.second = sum + x;
sum += x;
}
}
int main() {
int Q, x, i, id = 1;
cin >> Q >> M;
for ((i) = 0; (i) < (int)Q; (i)++) {
string s;
cin >> s;
if (s == "alloc") {
cin >> x;
if (alloc(x, id)) id++;
} else if (s == "erase") {
cin >> x;
if (!erase2(x)) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-9;
const int nn = 1000;
struct item {
int u, cnt;
int id;
item() {}
item(const int a, const int b, const int c) : u(a), cnt(b), id(c) {}
};
int n, m, u = 0;
vector<item> mem;
int alloc(const int b) {
int sz = (int((mem).size()));
int last = 0;
for (int i = 0; i < sz; ++i) {
if (mem[i].u - last >= b) {
mem.insert(mem.begin() + i, item(last, b, ++u));
return u;
}
last = mem[i].u + mem[i].cnt;
}
if (m - last >= b) {
mem.push_back(item(last, b, ++u));
return u;
}
return -1;
}
int erase(const int id) {
int sz = (int((mem).size()));
for (int i = 0; i < sz; ++i)
if (mem[i].id == id) {
mem.erase(mem.begin() + i);
return 0;
}
return 1;
}
void defragment() {
int last = 0;
int sz = (int((mem).size()));
for (int i = 0; i < sz; ++i) {
mem[i].u = last;
last = mem[i].u + mem[i].cnt;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
char com[256];
int b;
scanf("%s", com);
if (!strcmp(com, "defragment"))
defragment();
else {
scanf("%d\n", &b);
if (!strcmp(com, "alloc")) {
int t = alloc(b);
if (t == -1)
printf("NULL\n");
else
printf("%d\n", t);
} else {
if (erase(b)) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, q, k, x, cnt = 0;
int i, j;
int ex;
bool e_mark;
int mem[100] = {0};
string op;
cin >> t >> m;
for (i = 0; i < t; i++) {
cin >> op;
if (op[0] == 'a') {
cin >> q;
k = 0;
for (j = 0; j < m && k < q; j++) {
if (!mem[j])
k++;
else if (mem[j])
k = 0;
}
if (k == q) {
cnt++;
for (int l = j - k; l < j; l++) mem[l] = cnt;
cout << cnt << endl;
} else
cout << "NULL" << endl;
}
if (op[0] == 'e') {
cin >> q;
e_mark = 0;
for (j = 0; j < m; j++)
if (mem[j] == q && q != 0) mem[j] = 0, e_mark = 1;
if (!e_mark) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
if (op[0] == 'd') {
k = 0;
for (j = 0; j < m; j++) {
if (!mem[j])
k++;
else
ex = mem[j - k], mem[j - k] = mem[j], mem[j] = ex;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, x;
int a[1005], cnt, v[1005], tot;
string oper;
bool found(int x) {
for (int i = 1; i <= n; i++)
if (a[i] == x) return true;
return false;
}
int main() {
cin >> q >> n;
while (q--) {
cin >> oper;
if (oper == "erase") {
cin >> x;
if (!found(x) || x == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
continue;
}
for (int i = 1; i <= n; i++)
if (a[i] == x) a[i] = 0;
} else if (oper == "alloc") {
cin >> x;
int len = 0, l = 0, i;
for (i = 1; i <= n; i++) {
if (a[i] == 0) {
len++;
if (l == 0) l = i;
if (len == x) {
v[++tot] = ++cnt;
cout << cnt << endl;
for (int j = l; j <= i; j++) a[j] = cnt;
break;
}
} else
l = len = 0;
}
if (i > n) cout << "NULL\n";
} else if (oper == "defragment") {
int s = 0, w[105];
for (int i = 1; i <= n; i++)
if (a[i] > 0) w[++s] = a[i];
memset(a, 0, sizeof(a));
for (int i = 1; i <= s; i++) a[i] = w[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100 + 7;
char op[1729];
int cc[maxn];
int main() {
int n, m, cnt = 1, t, i, j;
scanf("%d%d", &n, &m);
while (n--) {
scanf("%s", op);
if (op[0] == 'a') {
scanf("%d", &t);
for (i = 0; i <= m - t; ++i) {
for (j = i; j < i + t; ++j)
if (cc[j]) break;
if (j == i + t) break;
}
if (i <= m - t) {
printf("%d\n", cnt);
for (j = i; j < i + t; ++j) cc[j] = cnt;
cnt++;
} else {
puts("NULL");
}
} else if (op[0] == 'e') {
scanf("%d", &t);
bool ok = false;
for (i = 0; i < m; ++i)
if (cc[i] && cc[i] == t) {
ok = true;
cc[i] = 0;
}
if (!ok) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (i = 0, j = 0; i < m; ++i)
if (cc[i]) {
cc[j++] = cc[i];
}
for (; j < m; ++j) cc[j] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int xot[101];
int main() {
int n, m, t, d, i, j, tart = 0, bor, joy;
string s;
cin >> n >> m;
for (t = 1; t <= n; t++) {
cin >> s;
if (s == "alloc") {
cin >> d;
bor = 0;
for (i = 1; i <= m - d + 1 && bor == 0; i++) {
joy = 0;
for (j = i; j <= i + d - 1; j++)
if (xot[j] == 0) joy++;
if (joy == d) {
bor = 1;
tart++;
for (j = i; j <= i + d - 1; j++) xot[j] = tart;
}
}
if (bor == 0)
cout << "NULL" << endl;
else
cout << tart << endl;
}
if (s == "erase") {
cin >> d;
if (d <= 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
bor = 0;
for (i = 1; i <= m && bor == 0; i++)
if (xot[i] == d) bor = i;
if (bor == 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
j = bor;
while (xot[j] == d) {
xot[j] = 0;
j++;
}
}
}
}
if (s == "defragment") {
for (i = 1; i <= m; i++)
if (xot[i] == 0) {
bor = 0;
for (j = i; j <= m && bor == 0; j++)
if (xot[j] > 0) {
bor = 1;
xot[i] = xot[j];
xot[j] = 0;
}
if (bor == 0) i = m;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 112;
int mem[Maxn];
int main() {
string str;
int n, m, t, idx = 1;
cin >> n >> m;
while (n--) {
cin >> str;
if (str[0] == 'a') {
cin >> t;
bool done = false;
for (int i = 1; i <= m; i++)
if (!mem[i] && i + t - 1 <= m) {
bool flags = true;
for (int j = i; j <= i + t - 1; j++)
if (mem[j]) {
flags = false;
break;
}
if (flags) {
for (int j = i; j <= i + t - 1; j++) mem[j] = idx;
done = true;
cout << idx++ << endl;
break;
}
}
if (!done) cout << "NULL\n";
} else if (str[0] == 'e') {
cin >> t;
bool flags = false;
for (int i = 1; i <= m; i++)
if (mem[i] == t) {
mem[i] = 0;
flags = true;
}
if (t == 0 || !flags) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else if (str[0] == 'd') {
int tmp[Maxn];
memcpy(tmp, mem, sizeof(mem));
memset(mem, 0, sizeof(mem));
for (int i = 1, j = 1; i <= m && j <= m; i++)
if (tmp[i]) {
mem[j] = tmp[i];
j++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[102];
char inp[100];
char inp2[100];
int p;
int main() {
memset(ar, -1, sizeof(ar));
gets(inp);
int n, m;
sscanf(inp, "%d%d", &n, &m);
int cnt = 1;
for (int i = 0; i < n; i++) {
gets(inp);
if (inp[0] == 'd') {
vector<int> ch;
for (int t = 0; t < m; t++) {
if (ar[t] != -1) ch.push_back(ar[t]);
}
memset(ar, -1, sizeof(ar));
int k = 0;
for (int t = 0; t < m && k < ch.size(); t++, k++) {
ar[t] = ch[k];
}
} else if (inp[0] == 'e') {
sscanf(inp, "%s%d", inp2, &p);
bool got = false;
if (p > 0)
for (int t = 0; t < m; t++) {
if (ar[t] == p) {
ar[t] = -1;
got = true;
}
}
if (!got) {
puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
sscanf(inp, "%s%d", inp2, &p);
bool perf = false;
for (int t = 0; t + p <= m; t++) {
int j = t;
for (; j < t + p; j++)
if (ar[j] != -1) break;
if (j == t + p) {
j = t;
for (; j < t + p; j++) ar[j] = cnt;
perf = true;
printf("%d\n", cnt);
cnt++;
break;
}
}
if (!perf) puts("NULL");
}
}
return 0;
}
|
#include <bits/stdc++.h>
int mm[128];
int n, m;
int main() {
char str[16];
int cnt = 0, t, i, j;
for (scanf("%d %d", &n, &m); n--;) {
scanf("%s", str);
if (str[0] == 'a') {
scanf("%d", &t);
for (i = 0, j = -1; i < m; i++) {
if (!mm[i] && i - j >= t)
break;
else if (mm[i])
j = i;
}
if (i < m) {
printf("%d\n", ++cnt);
for (++j; j <= i; j++) mm[j] = cnt;
} else
puts("NULL");
} else if (str[0] == 'e') {
scanf("%d", &t);
for (i = j = 0; i < m; i++)
if (mm[i] == t) mm[i] = 0, j = 1;
if (!j || t == 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else
for (i = j = 0; i < m; i++)
if (mm[i]) t = mm[i], mm[i] = 0, mm[j++] = t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, n, k, ka;
int q[109], f;
char a[20];
int main() {
scanf("%d%d", &t, &m);
for (int i = 0; i < t; i++) {
scanf("%s", a);
if (a[0] == 'a') {
scanf("%d", &n);
k = f = 0;
for (int i = 0; i < m; i++) {
if (q[i] == 0) {
k++;
if (k == n) {
printf("%d\n", ++ka);
for (int j = i; k; k--, j--) {
q[j] = ka;
}
f = 1;
break;
}
} else
k = 0;
}
if (f == 0) printf("NULL\n");
} else if (a[0] == 'e') {
f = 0;
scanf("%d", &n);
if (n <= 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
for (int i = 0; i < m; i++) {
if (q[i] == n) {
f = 1;
q[i] = 0;
}
}
if (f == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
k = 0;
for (int i = 0; i < m; i++)
if (q[i]) q[k++] = q[i];
while (k < m) q[k++] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100];
int x;
int t;
int n, m;
int a[10000];
bool free(int x, int n) {
while (n) {
if (a[x] != 0) return false;
x++;
n--;
}
return true;
}
int main() {
scanf("%d%d\n", &t, &m);
for (int i = m; i < 1000; i++) a[i] = -1;
int k = 0;
bool find;
for (int i = 0; i < t; i++) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d\n", &n);
find = false;
for (int i = 0; i < m; i++)
if (free(i, n)) {
find = true;
k++;
while (n) {
a[i] = k;
n--;
i++;
}
break;
}
if (find)
printf("%d\n", k);
else
printf("NULL\n");
}
if (s[0] == 'e') {
scanf("%d\n", &x);
find = false;
if (x > 0) {
find = false;
for (int i = 0; i < m; i++)
if (a[i] == x) {
a[i] = 0;
find = true;
}
}
if (!find) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
}
if (s[0] == 'd') {
scanf("\n");
for (int i = 0; i < 3 * m; i++)
for (int j = 0; j < m - 1; j++)
if (a[j] == 0) {
int c = a[j];
a[j] = a[j + 1];
a[j + 1] = c;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7;
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q, m;
cin >> q >> m;
int c = 1;
while (q--) {
string s;
cin >> s;
if (s[0] == 'a') {
int n;
cin >> n;
int kam = 0;
bool found = 0;
for (int i = 1; i <= m; i++) {
if (a[i] == 0)
kam++;
else
kam = 0;
if (kam == n) {
found = 1;
for (int j = i; j >= i - n + 1; j--) a[j] = c;
break;
}
}
if (!found)
cout << "NULL";
else
cout << c++;
cout << '\n';
} else if (s[0] == 'e') {
int n;
cin >> n;
bool found = 0;
for (int i = 1; i <= m; i++) {
if (a[i] == n) {
found = 1;
a[i] = 0;
}
}
if (!found || !n) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
vector<int> v;
for (int i = 1; i <= m; i++) {
if (a[i]) {
v.push_back(a[i]);
}
}
for (int i = 1; i <= m; i++) {
a[i] = 0;
}
for (int i = 1; i <= v.size(); i++) {
a[i] = v[i - 1];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[201];
struct infor {
int kind;
int num;
};
infor cao[201];
void init_infor() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string p;
cin >> p;
if (p == "alloc") {
cao[i].kind = 1;
cin >> cao[i].num;
} else if (p == "erase") {
cao[i].kind = 2;
cin >> cao[i].num;
} else {
cao[i].kind = 3;
}
}
a[m + 1] = -1;
}
void solve_infor() {
init_infor();
int hao = 0;
bool ok;
for (int i = 1; i <= n; i++) {
if (cao[i].kind == 1) {
ok = false;
for (int j = 1; j <= m; j++) {
if (a[j] == 0) {
int k = j;
while (a[k] == 0 && k - j + 1 <= cao[i].num && k <= m) k++;
k--;
if (k - j + 1 >= cao[i].num) {
hao++;
for (int z = j; z <= j + cao[i].num - 1; z++) {
a[z] = hao;
}
ok = true;
break;
}
j = k;
}
}
if (ok == false) {
cout << "NULL" << endl;
} else {
cout << hao << endl;
}
} else if (cao[i].kind == 2) {
ok = false;
for (int j = 1; j <= m; j++) {
if (a[j] == cao[i].num) {
a[j] = 0;
ok = true;
}
}
if (ok == false || cao[i].num == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
int k = 0;
int w = 0;
while (w < m) {
w++;
if (a[w] != 0) {
k++;
a[k] = a[w];
if (k != w) a[w] = 0;
}
}
}
}
}
int main() {
solve_infor();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, n, idx = 0, mem[110] = {};
char op[20];
scanf("%d%d", &t, &m);
while (t--) {
scanf("%s", op);
if (op[0] == 'a') {
scanf("%d", &n);
int flg = 0;
for (int i = 1, j; i <= m; i = j) {
if (mem[i] != 0) {
j = i + 1;
continue;
}
for (j = i; j <= m && mem[j] == 0; j++)
;
if (j - i >= n) {
idx++;
flg = 1;
for (int k = 0; k < n; k++) mem[i + k] = idx;
break;
}
}
if (flg)
printf("%d\n", idx);
else
puts("NULL");
} else if (op[0] == 'e') {
scanf("%d", &n);
int flg = 0;
if (n < 1 || n > idx) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
for (int i = 1; i <= m; i++)
if (mem[i] == n) mem[i] = 0, flg = 1;
if (flg == 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else if (op[0] == 'd') {
for (int i = 1, j = 1; i <= m; i++)
if (mem[i] != 0) {
mem[j++] = mem[i];
if (i >= j) mem[i] = 0;
}
} else
puts("QQ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
int pos[maxn];
int num;
string s;
int d;
int n, m;
void add() {
cin >> d;
int flag = -1;
for (int j = 1; j <= m; j++) {
int p = 0;
for (int k = j; k <= j + d - 1 && k <= m; k++)
if (pos[k] == 0) p++;
if (p == d) {
flag = j;
break;
}
}
if (flag == -1) {
printf("NULL\n");
return;
} else {
num++;
for (int i = flag; i <= flag + d - 1; i++) pos[i] = num;
printf("%d\n", num);
}
}
void del() {
int d;
cin >> d;
if (d <= 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
int flag = -1;
for (int i = 1; i <= m; i++)
if (pos[i] == d) flag = 1, pos[i] = 0;
if (flag == -1) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
void getsort() {
int i = 1, j = 1;
for (i = 1; i <= m; i++)
if (pos[i]) pos[j++] = pos[i];
for (; j <= m; j++) pos[j] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
cin >> s;
if (s == "alloc") add();
if (s == "erase") del();
if (s == "defragment") getsort();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int get(int size, const bool* f, int fsize) {
int streak = 0;
for (int i = 0; i < fsize; i++) {
if (!f[i]) {
if (++streak == size) {
return i - size + 1;
}
} else
streak = 0;
}
return -1;
}
int main() {
int t, m;
cin >> t >> m;
map<int, pair<int, int> > allocated;
bool* f = new bool[m];
for (int i = 0; i < m; i++) f[i] = false;
int nextId = 1;
while (t--) {
string cmd;
cin >> cmd;
if (cmd[0] == 'a') {
int size;
cin >> size;
int start = get(size, f, m);
if (start < 0)
cout << "NULL" << endl;
else {
cout << nextId << endl;
allocated[nextId] = make_pair(start, start + size);
for (int i = 0; i < size; i++) f[start + i] = true;
nextId++;
}
} else if (cmd[0] == 'e') {
int id;
cin >> id;
map<int, pair<int, int> >::iterator it = allocated.find(id);
if (it == allocated.end())
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
for (int i = it->second.first; i < it->second.second; i++) f[i] = false;
allocated.erase(it);
}
} else {
map<pair<int, int>, int> s;
map<int, pair<int, int> >::iterator it = allocated.begin();
while (it != allocated.end()) {
s[it->second] = it->first;
it++;
}
int loc = 0;
allocated.clear();
map<pair<int, int>, int>::iterator it1 = s.begin();
while (it1 != s.end()) {
int size = it1->first.second - it1->first.first;
allocated[it1->second] = make_pair(loc, loc + size);
for (int i = 0; i < size; i++) f[loc + i] = true;
loc += size;
it1++;
}
while (loc < m) f[loc++] = false;
}
}
delete[] f;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
const int N = 105;
int st[N];
int l[N], r[N];
int main() {
cin >> t >> m;
int cnt = 0;
while (t--) {
string str;
int state;
cin >> str;
if (str[0] != 'd') cin >> state;
if (str[0] == 'a') {
int alloc_ok = 0;
for (int i = 1; i <= m - state + 1; i++) {
int ok = 1;
for (int j = i; j <= i + state - 1; j++) {
if (st[j]) {
ok = 0;
i = j + 1 - 1;
break;
}
}
if (ok) {
alloc_ok = 1;
l[++cnt] = i;
r[cnt] = i + state - 1;
for (int k = l[cnt]; k <= r[cnt]; k++) st[k] = 1;
break;
}
}
if (alloc_ok)
cout << cnt << endl;
else
cout << "NULL" << endl;
} else if (str[0] == 'e') {
if (state > 0 && l[state] != -1 && r[state] != -1 && state <= cnt) {
for (int i = l[state]; i <= r[state]; i++) st[i] = 0;
l[state] = -1;
r[state] = -1;
} else
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else if (str[0] == 'd') {
for (int i = 1; i <= cnt; i++) {
if (l[i] == -1) continue;
int pos = 0;
for (int j = 1; j <= l[i]; j++)
if (!st[j]) pos++;
l[i] -= pos;
r[i] -= pos;
}
memset(st, 0, sizeof(st));
for (int i = 1; i <= cnt; i++) {
if (l[i] == -1) continue;
for (int j = l[i]; j <= r[i]; j++) st[j] = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
static bool constexpr dbg = 0;
ll constexpr NM = 110;
ll n;
ll id;
bool used[NM];
bool tmp[NM];
map<ll, pll> id2info;
struct idcmp {
bool operator()(ll id1, ll id2) {
return id2info[id1].first < id2info[id2].first;
}
};
set<ll, idcmp> ids;
ll alloc(ll arg) {
ll ret = 0;
for (ll i = 1; i <= n - arg + 1; ++i) {
if (none_of(&used[i], &used[i + arg], [](bool b) { return b; })) {
ret = ++id;
for (ll j = i; j < i + arg; ++j) used[j] = true;
id2info[ret] = {i, arg};
ids.insert(ret);
break;
}
}
return ret;
}
bool erase(ll i) {
if (!id2info.count(i)) return false;
for (ll j = id2info[i].first; j < id2info[i].first + id2info[i].second; ++j)
used[j] = false;
ids.erase(i);
id2info.erase(i);
return true;
}
void defra() {
ll head = 1;
for (auto curi : ids) {
ll pstart = id2info[curi].first;
ll curSize = id2info[curi].second;
if (pstart > head) {
for (ll i = pstart; i < pstart + curSize; ++i) used[i] = false;
for (ll i = head; i < head + curSize; ++i) used[i] = true;
}
id2info[curi].first = head;
head += curSize;
}
}
int main() {
if (!dbg) {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
}
ll t;
cin >> t >> n;
string cmd;
for (ll _ = 1; _ <= (ll)(t); ++_) {
cin >> cmd;
if (cmd == "defragment") {
defra();
continue;
}
ll arg;
cin >> arg;
if (cmd == "alloc") {
auto ret = alloc(arg);
if (ret)
cout << ret << '\n';
else
cout << "NULL\n";
} else {
if (!erase(arg)) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
int t, m;
std::vector<int> memory;
int number = 1;
void alloc(int size) {
for (int i = 0; i < m; i++) {
if (memory[i] == 0) {
int start = i, space = 1;
while (++i < m && memory[i] == 0) {
space++;
}
if (space >= size) {
for (int j = start; j < start + size; j++) memory[j] = number;
std::cout << number++ << std::endl;
return;
}
}
}
std::cout << "NULL" << std::endl;
}
void erase(int n) {
if (n <= 0) {
std::cout << "ILLEGAL_ERASE_ARGUMENT" << std::endl;
return;
}
for (int i = 0; i < m; i++) {
if (memory[i] == n) {
int start = i, space = 1;
while (++i < m && memory[i] == n) {
space++;
}
for (int j = start; j < start + space; j++) memory[j] = 0;
return;
}
}
std::cout << "ILLEGAL_ERASE_ARGUMENT" << std::endl;
}
void defragment() {
std::vector<int> new_memory;
for (int i = 0; i < m; i++) {
if (memory[i] != 0) new_memory.push_back(memory[i]);
}
new_memory.resize(m, 0);
memory = new_memory;
}
int main() {
std::cin >> t >> m;
std::vector<std::string> commands(t);
std::vector<int> arguments(t, 0);
for (int i = 0; i < t; i++) {
std::cin >> commands[i];
if (commands[i] == "alloc" || commands[i] == "erase")
std::cin >> arguments[i];
}
memory.resize(m, 0);
for (int i = 0; i < t; i++) {
if (commands[i] == "alloc") {
alloc(arguments[i]);
} else if (commands[i] == "erase") {
erase(arguments[i]);
} else if (commands[i] == "defragment") {
defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pos[205];
int num;
string s;
int d;
int n, m;
void add() {
cin >> d;
int flag = -1;
for (int j = 1; j <= m; j++) {
int p = 0;
for (int k = j; k <= j + d - 1 && k <= m; k++) {
if (pos[k] == 0) p++;
}
if (p == d) {
flag = j;
break;
}
}
if (flag == -1) {
printf("NULL\n");
return;
} else {
num++;
for (int i = flag; i <= flag + d - 1; i++) pos[i] = num;
printf("%d\n", num);
}
}
void del() {
int d;
cin >> d;
if (d <= 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
int flag = -1;
for (int i = 1; i <= m; i++) {
if (pos[i] == d) {
flag = 1;
pos[i] = 0;
}
}
if (flag == -1) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
void getsort() {
int i = 1, j = 1;
for (i = 1; i <= m; i++)
if (pos[i]) pos[j++] = pos[i];
for (; j <= m; j++) pos[j] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
cin >> s;
if (s == "alloc") add();
if (s == "erase") del();
if (s == "defragment") getsort();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25];
int a[1005];
int b[1005];
int main() {
int t, m, n, num;
while (scanf("%d%d", &t, &m) != EOF) {
num = 1;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
while (t--) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &n);
int flag = 0;
for (int i = 1; i <= m; i++) {
if (flag == 1) break;
if (a[i] == 0) {
int cnt = 1;
if (cnt == n) {
a[i] = num;
b[num] = 1;
printf("%d\n", num);
num++;
flag = 1;
}
for (int j = i + 1; j <= m; j++) {
if (a[j] == 0) {
cnt++;
if (cnt == n) {
for (int k = i; k <= j; k++) a[k] = num;
b[num] = 1;
printf("%d\n", num);
num++;
flag = 1;
break;
}
} else
break;
}
}
}
if (flag == 0) printf("NULL\n");
} else if (s[0] == 'e') {
scanf("%d", &n);
if (n <= 0 || n >= num || b[n] == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
for (int i = 1; i <= m; i++) {
if (a[i] == n) a[i] = 0;
}
b[n] = 0;
}
} else if (s[0] == 'd') {
int c[1005];
memset(c, 0, sizeof(c));
int k = 1;
for (int i = 1; i <= m; i++) {
if (a[i] != 0) {
c[k++] = a[i];
a[i] = 0;
}
}
for (int i = 1; i <= k; i++) {
a[i] = c[i];
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[110];
int t, m, sum;
int main() {
cin >> t >> m;
for (int i = 1; i <= m; i++) c[i] = -1;
bool flag;
while (t--) {
string x;
cin >> x;
int y;
if (x == "alloc") {
bool f = false;
cin >> y;
flag = false;
for (int i = 1; i <= m - y + 1; i++) {
if (c[i] == -1) {
flag = true;
for (int j = i; j <= i + y - 1; j++)
if (c[j] != -1) flag = false;
if (flag) {
sum++;
for (int j = i; j <= i + y - 1; j++) c[j] = sum;
cout << sum << endl;
f = true;
}
}
if (flag) break;
}
if (!f) cout << "NULL" << endl;
} else if (x == "erase") {
cin >> y;
bool f = false;
if (y > 0) {
for (int i = 1; i <= m; i++)
if (c[i] == y) {
c[i] = -1;
f = true;
}
if (!f) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
int l = 1;
for (int i = 1; i <= m; i++) {
if (c[i] != -1) {
c[l++] = c[i];
if (i != l - 1) c[i] = -1;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const double PI = 3.141592653589793;
int tab[105], used[105], a, i, u, m, n, k;
char t[15];
bool good(int p, int a) {
int i;
for (i = p; i < p + a; i++)
if (used[i]) return false;
return true;
}
int pr(int a) {
int i, j;
for (i = 1; i <= m - a + 1; i++)
if (good(i, a)) {
for (j = i; j < i + a; j++) used[j] = u + 1;
return i;
}
return 0;
}
void kas(int a) {
int i = tab[a];
while (i <= m && used[i] == a) {
used[i] = 0;
i++;
}
tab[a] = 0;
}
void defr() {
int i, j;
for (i = 2; i <= m; i++)
if (used[i] != 0 && used[i - 1] == 0) {
j = i;
while (j - 1 >= 1 && used[j - 1] == 0) {
swap(used[j - 1], used[j]);
j--;
}
if (j == 1 || used[j - 1] != used[j]) tab[used[j]] = j;
}
}
int main() {
scanf("%d %d", &n, &m);
u = 0;
for (i = 0; i < n; i++) {
scanf("%s", &t);
if (t[0] == 'a') {
scanf("%d", &a);
k = pr(a);
if (k) {
u++;
tab[u] = k;
printf("%d\n", u);
} else
printf("NULL\n");
} else if (t[0] == 'e') {
scanf("%d", &a);
if (a < 0 || a > 100 || tab[a] == 0)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else
kas(a);
} else {
defr();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, m, used;
};
int main() {
int n, m;
cin >> n >> m;
int alloc_num = 0;
vector<node> a;
a.push_back(node{0, m, 0});
while (n--) {
string s;
cin >> s;
if (s == "alloc") {
int t;
cin >> t;
int flag = 1;
for (int i = 0; i < a.size(); i++) {
if (a[i].used == 0 && a[i].m >= t) {
cout << (++alloc_num) << endl;
a[i].num = 0, a[i].used = 1;
if (a[i].m > t) a.insert(a.begin() + i, node{0, a[i].m - t, 0});
a.insert(a.begin() + i, node{alloc_num, t, 1});
flag = 0;
break;
}
}
if (flag) cout << "NULL\n";
} else if (s == "erase") {
int t;
cin >> t;
int flag = 1;
for (int i = 0; i < a.size(); i++) {
if (a[i].num == t && a[i].used == 1) {
a[i].used = 0, flag = 0;
if (i >= 1 && a[i - 1].used == 0) {
a[i].m += a[i - 1].m;
a[i - 1].num = 0, a[i - 1].used = 1;
}
if (i + 1 < s.size() && a[i + 1].used == 0) {
a[i].m += a[i + 1].m;
a[i + 1].num = 0, a[i + 1].used = 1;
}
}
}
if (flag) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
int sum = 0, flag = 0;
for (int i = 0; i < a.size(); i++)
if (a[i].used == 0) flag++;
while (flag) {
for (int i = 0; i < a.size(); i++) {
if (a[i].used == 0) {
sum += a[i].m;
a.erase(a.begin() + i);
flag--;
}
}
}
a.push_back(node{0, sum, 0});
}
int flag = 0;
for (int i = 0; i < a.size(); i++)
if (a[i].num == 0 && a[i].used == 1) flag++;
while (flag) {
for (int i = 0; i < a.size(); i++) {
if (a[i].num == 0 && a[i].used == 1) {
a.erase(a.begin() + i);
flag--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long m, t, M[110];
long long id = 1;
void alc(long long n) {
for (long long i = 1; i <= m - n + 1; i++) {
long long j;
for (j = i; j < i + n; j++)
if (M[j]) break;
if (j < i + n) continue;
for (j = i; j < i + n; j++) M[j] = id;
cout << id++ << '\n';
return;
}
cout << "NULL\n";
}
void ers(long long n) {
long long cnt = 0;
for (long long i = 1; i <= 100; i++)
if (M[i] == n && M[i] >= 1 && M[i] <= 100) M[i] = 0, cnt++;
if (!cnt) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
void frg() {
vector<long long> v;
for (long long i = 1; i <= 100; i++)
if (M[i]) v.push_back(M[i]);
memset(M, 0, sizeof(M));
long long L = v.size();
for (long long i = 1; i <= L; i++) M[i] = v[i - 1];
}
int main() {
cin >> t >> m;
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
long long x;
cin >> x;
alc(x);
}
if (s == "erase") {
long long x;
cin >> x;
ers(x);
}
if (s == "defragment") {
frg();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int memory[100 + 5];
int main() {
int t, m;
int index = 1;
cin >> t >> m;
for (int i = 1; i <= m; i++) {
memory[i] = 0;
}
for (int cnt = 1; cnt <= t; cnt++) {
string s;
int n;
cin >> s;
if (s[0] != 'd') {
cin >> n;
}
if (s[0] == 'a') {
bool allocatedok = false;
for (int i = 1; i <= m; i++) {
int tmp = 0;
int final = m > i + n - 1 ? i + n - 1 : m;
for (int j = i; j <= final; j++) {
if (memory[j] == 0) {
tmp++;
}
}
if (tmp == n) {
for (int j = i; j <= final; j++) {
memory[j] = index;
}
index++;
cout << index - 1 << endl;
allocatedok = true;
break;
}
}
if (allocatedok == false) {
cout << "NULL" << endl;
}
}
if (s[0] == 'e') {
bool eraseok = false;
for (int i = 1; i <= m; i++) {
if (memory[i] == n) {
eraseok = true;
break;
}
}
if (n == 0) {
eraseok = false;
}
if (eraseok == false) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
for (int i = 1; i <= m; i++) {
if (memory[i] == n) {
memory[i] = 0;
}
}
}
}
if (s[0] == 'd') {
int tmpmemory[100 + 5];
for (int i = 1; i <= m; i++) {
tmpmemory[i] = 0;
}
int start = 1;
for (int i = 1; i <= m; i++) {
if (memory[i] != 0) {
tmpmemory[start++] = memory[i];
}
}
for (int i = start; i <= m; i++) {
tmpmemory[i] = 0;
}
for (int i = 1; i <= m; i++) {
memory[i] = tmpmemory[i];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
int id = 1;
vector<int> v(m);
for (int c = 0; c < m; c++) v[c] = 0;
for (int c = 0; c < t; c++) {
string s;
cin >> s;
if (s == "defragment") {
int c3 = 0;
for (int c2 = 0; c2 < v.size(); c2++) {
if (v[c2] != 0) {
v[c3++] = v[c2];
if (c2 != c3 - 1) v[c2] = 0;
}
}
} else {
long long int n;
cin >> n;
if (s == "alloc") {
int act = 0;
bool flag = false;
for (int c2 = 0; c2 < v.size() && !flag; c2++) {
if (v[c2] != 0)
act = 0;
else
act++;
if (act == n) {
for (int c3 = c2; c3 > c2 - n; c3--) v[c3] = id;
flag = true;
id++;
}
}
if (flag)
cout << id - 1 << endl;
else
cout << "NULL" << endl;
} else {
bool flag = false;
for (int c2 = 0; c2 < v.size(); c2++) {
if (v[c2] == n) {
flag = true;
v[c2] = 0;
}
}
if (!flag || n <= 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30;
const int N = 210;
char op[maxn];
int memory[N], t, n, is[N];
int m, s[N], id = 1, siz[N];
set<int> stor;
int f[N];
bool is_null(int s, int e) {
for (int i = s; i < e; i++)
if (memory[i] != 0) return false;
return true;
}
int main() {
scanf("%d%d", &t, &m);
memset(is, -1, sizeof(is));
for (int i = 0; i < t; i++) {
scanf("%s", &op);
if (strcmp(op, "alloc") == 0) {
int x, i;
scanf("%d", &x);
for (i = 1; i <= m; i++) {
if (i + x - 1 <= m && memory[i] == 0 && is_null(i, i + x)) {
for (int j = i; j < i + x; j++) memory[j] = id;
break;
}
}
if (i <= m) {
is[id] = i;
siz[id] = x;
stor.insert(id);
printf("%d\n", id++);
} else {
printf("NULL\n");
}
} else if (strcmp(op, "erase") == 0) {
int x;
scanf("%d", &x);
if (stor.count(x) == 0)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
stor.erase(x);
for (int i = is[x]; i < is[x] + siz[x]; i++) memory[i] = 0;
is[x] = -1;
}
} else if (strcmp(op, "defragment") == 0) {
int num = 0;
for (int i = 1; i <= m; i++)
if (memory[i] && (!num || memory[i] != f[num - 1]))
f[num++] = memory[i];
memset(memory, 0, sizeof(memory));
int pre = 1;
for (int i = 0; i < num; i++)
if (is[f[i]] != -1) {
int h = f[i];
for (int j = pre; j < pre + siz[h]; j++) memory[j] = h;
is[h] = pre;
pre += siz[h];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int id = 0;
int m[104];
string cmd;
bool alloc(int n, int p) {
int s = -1, e;
for (e = 0; e <= n; ++e) {
if (0 == m[e] && -1 == s) s = e;
if (-1 != s && 0 != m[e]) {
if (e - s < p) s = -1;
}
}
if (-1 != s) {
++id;
while (p--) m[s++] = id;
return true;
} else
return false;
}
bool erase(int n, string r) {
int i, e = 0, p = 0;
for (i = 0; i < r.length(); ++i) p *= 10, p += r[i] - '0';
for (i = 0; i < n; ++i)
if (p == m[i]) m[i] = 0, ++e;
if (0 == e || 0 == p)
return false;
else
return true;
}
void defragment(int n) {
int z, i, nz;
for (z = 0; z < n; ++z)
if (0 == m[z]) break;
for (nz = z; nz < n; ++nz) {
if (0 != m[nz]) {
m[z++] = m[nz];
m[nz] = 0;
}
}
}
int main() {
int t, n, p;
cin >> t >> n;
m[n] = -1;
for (int i = 0; i < t; ++i) {
cin >> cmd;
if ("alloc" == cmd) {
cin >> p;
if (alloc(n, p))
cout << id << endl;
else
cout << "NULL" << endl;
} else if ("erase" == cmd) {
string e;
cin >> e;
if (e.length() > 4 || !erase(n, e))
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
defragment(n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > blocks;
char used[128];
int n;
int Malloc(int v) {
for (int i = 0; i < n; i++) {
bool ok = 1;
for (int j = 0; j < v; j++) {
if (i + j >= n || used[i + j]) {
ok = 0;
break;
}
}
if (ok) {
for (int j = 0; j < v; j++) {
used[i + j] = 1;
}
blocks.push_back(pair<int, int>(i, v));
return blocks.size();
}
}
return -1;
}
int Erase(int id) {
id--;
if (id < 0 || id >= blocks.size()) return -1;
pair<int, int>& b = blocks[id];
if (b.first == -1) return -1;
for (int i = 0; i < b.second; i++) {
used[b.first + i] = 0;
}
b.first = -1;
return 0;
}
void Defragment() {
map<int, char> was;
int cn = blocks.size();
int last = 0;
while (cn > 0) {
int bi = -1;
for (int i = 0; i < blocks.size(); i++) {
if (was[i]) continue;
if (bi == -1 || blocks[i].first < blocks[bi].first) {
bi = i;
}
}
cn--;
was[bi] = 1;
if (blocks[bi].first == -1) continue;
blocks[bi].first = last;
last += blocks[bi].second;
}
memset(used, 0, sizeof(used));
for (int i = 0; i < last; i++) {
used[i] = 1;
}
}
int main() {
int t;
scanf("%d%d", &t, &n);
for (int i = 0; i < t; i++) {
string cmd;
int p;
cin >> cmd;
if (cmd == "alloc") {
cin >> p;
int r = Malloc(p);
if (r == -1)
cout << "NULL";
else
cout << r;
cout << endl;
} else if (cmd == "erase") {
cin >> p;
int r = Erase(p);
if (r == -1) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
Defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[102];
char inp[100];
char inp2[100];
int p;
int main() {
gets(inp);
int n, m;
sscanf(inp, "%d%d", &n, &m);
int cnt = 1;
for (int i = 0; i < n; i++) {
gets(inp);
if (inp[0] == 'd') {
vector<int> ch;
for (int t = 0; t < m; t++) {
if (ar[t] != 0) ch.push_back(ar[t]);
}
memset(ar, 0, sizeof(ar));
int k = 0;
for (int t = 0; t < m && k < ch.size(); t++, k++) {
ar[t] = ch[k];
}
} else if (inp[0] == 'e') {
sscanf(inp, "%s%d", inp2, &p);
bool got = false;
if (p > 0)
for (int t = 0; t < m; t++) {
if (ar[t] == p) {
ar[t] = 0;
got = true;
}
}
if (!got) {
puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
sscanf(inp, "%s%d", inp2, &p);
bool perf = false;
for (int t = 0; t + p <= m; t++) {
int j = t;
for (; j < t + p; j++)
if (ar[j] != 0) break;
if (j == t + p) {
j = t;
for (; j < t + p; j++) ar[j] = cnt;
perf = true;
printf("%d\n", cnt);
cnt++;
break;
}
}
if (!perf) puts("NULL");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[128];
int main() {
memset(mem, -1, sizeof(mem));
int T, M;
cin >> T >> M;
int id = 0;
for (int ct = 0; ct < (int)(T); ++ct) {
string command;
cin >> command;
if (command[0] == 'd') {
vector<int> v;
for (int i = 0; i < (int)(M); ++i)
if (mem[i] != -1) v.push_back(mem[i]);
memset(mem, -1, sizeof(mem));
for (int i = 0; i < (int)(v.size()); ++i) mem[i] = v[i];
} else {
int x;
cin >> x;
bool ok;
if (command[0] == 'a') {
for (int start = 0; start < (int)(M); ++start) {
int size = 0;
ok = false;
for (int i = start; i < M; ++i) {
if (mem[i] == -1) {
size++;
if (size == x) {
ok = true;
break;
}
} else
break;
}
if (ok) {
cout << ++id << endl;
for (int i = start; i < start + size; ++i) mem[i] = id;
break;
}
}
if (!ok) cout << "NULL" << endl;
} else if (command[0] == 'e') {
int op = 0;
for (int i = 0; i < (int)(M); ++i)
if (x > 0 && mem[i] == x) {
mem[i] = -1;
++op;
}
if (op == 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, p, num;
int pl[1010];
int used[1010];
int ord[1010];
int size[1010];
int alloc(int p) {
if (p > m) return -1;
for (int i = 1; i <= m; i++) {
bool flag = 1;
if (i + p > m + 1) return -1;
for (int j = i; j < i + p; j++)
if (used[j]) flag = 0;
if (flag) return i;
}
return -1;
}
bool cmp(int a, int b) { return pl[a] < pl[b]; }
void def() {
int temp = 0;
for (int i = 1; i <= m; i++) temp += used[i];
memset(used, 0, sizeof used);
for (int i = 1; i <= temp; i++) used[i] = 1;
int tot = 0;
for (int i = 1; i <= num; i++)
if (pl[i] != -1) ord[tot++] = i;
sort(ord, ord + tot, cmp);
int now = 1;
for (int i = 0; i < tot; i++) pl[ord[i]] = now, now += size[ord[i]];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
char ctrl[20];
scanf("%s", ctrl);
if (ctrl[0] == 'a') {
scanf("%d", &p);
int a = alloc(p);
if (a == -1) {
puts("NULL");
continue;
}
pl[++num] = a;
size[num] = p;
printf("%d\n", num);
for (int i = pl[num]; i < pl[num] + size[num]; i++) used[i] = 1;
} else if (ctrl[0] == 'e') {
scanf("%d", &p);
if (p > num || p <= 0 || pl[p] == -1) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
for (int i = pl[p]; i < pl[p] + size[p]; i++) used[i] = 0;
pl[p] = -1;
} else
def();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 110;
int inx, t, n, tot;
char c[20];
struct In {
int l;
int r;
int len;
int id;
} s[MAXM];
int find_pos(int x) {
if (tot == 0) {
if (x <= n) {
s[tot].l = 1;
s[tot].r = x;
s[tot].len = x;
s[tot].id = inx;
tot++;
return inx;
} else
return -1;
} else {
int i, j;
for (i = 0; i < tot; i++) {
if (i == 0) {
if (s[i].l - 1 >= x) {
for (j = tot; j > i; j--) {
s[j].l = s[j - 1].l;
s[j].r = s[j - 1].r;
s[j].len = s[j - 1].len;
s[j].id = s[j - 1].id;
}
s[i].l = 1;
s[i].r = x;
s[i].len = x;
s[i].id = inx;
tot++;
return inx;
}
} else {
if (s[i].l - s[i - 1].r - 1 >= x) {
for (j = tot; j > i; j--) {
s[j].l = s[j - 1].l;
s[j].r = s[j - 1].r;
s[j].len = s[j - 1].len;
s[j].id = s[j - 1].id;
}
s[i].l = s[i - 1].r + 1;
s[i].r = s[i - 1].r + x;
s[i].len = x;
s[i].id = inx;
tot++;
return inx;
}
}
}
if (n - s[tot - 1].r >= x) {
s[tot].l = s[tot - 1].r + 1;
s[tot].r = s[tot - 1].r + x;
s[tot].len = x;
s[tot].id = inx;
tot++;
return inx;
} else
return -1;
}
}
int find_erase(int x) {
int i, j;
for (i = 0; i < tot; i++)
if (s[i].id == x) break;
if (i == tot) return -1;
for (j = i; j < tot - 1; j++) {
s[j].l = s[j + 1].l;
s[j].r = s[j + 1].r;
s[j].len = s[j + 1].len;
s[j].id = s[j + 1].id;
}
tot--;
return i;
}
void update() {
int i;
for (i = 0; i < tot; i++) {
if (i == 0) {
s[i].l = 1;
s[i].r = s[i].len;
} else {
s[i].l = s[i - 1].r + 1;
s[i].r = s[i - 1].r + s[i].len;
}
}
}
int main() {
inx = 1;
scanf("%d%d", &t, &n);
tot = 0;
int i, j;
while (t--) {
scanf("%s", c);
if (c[0] == 'a') {
scanf("%d", &i);
j = find_pos(i);
if (j == -1)
printf("NULL\n");
else {
inx++;
printf("%d\n", j);
}
} else if (c[0] == 'e') {
scanf("%d", &i);
j = find_erase(i);
if (j == -1) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
update();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[101], r[101], n, x, t, cnt;
bool a[101], al[101];
bool canput(int l, int r) {
for (int i = l; i <= r; i++) {
if (a[i]) return 0;
}
return 1;
}
void alloc() {
cin >> x;
for (int i = 1; i <= n - x + 1; i++) {
if (canput(i, i + x - 1)) {
cout << ++cnt << endl;
l[cnt] = i, r[cnt] = i + x - 1;
for (int j = l[cnt]; j <= r[cnt]; j++) a[j] = 1;
al[cnt] = 1;
return;
}
}
printf("NULL\n");
return;
}
void erase() {
cin >> x;
if (x > cnt || x < 1 || !al[x]) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
for (int j = l[x]; j <= r[x]; j++) a[j] = 0;
l[x] = r[x] = 0;
al[x] = 0;
return;
}
void deflagment() {
for (int i = 1; i <= cnt; i++) {
if (al[i]) {
for (int j = l[i]; j <= r[i]; j++) a[j] = 0;
while (a[l[i] - 1] == 0 && l[i] > 1) {
l[i]--;
r[i]--;
}
for (int j = l[i]; j <= r[i]; j++) a[j] = 1;
}
}
return;
}
int main() {
cin >> t >> n;
for (int i = 1; i <= t; i++) {
string s;
cin >> s;
if (s[0] == 'a') alloc();
if (s[0] == 'e') erase();
if (s[0] == 'd') deflagment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100];
struct Range {
Range(int _start, int _len, int _id) : start(_start), len(_len), id(_id) {}
int start, len;
int id;
};
list<Range> ranges;
int main() {
int nQ, size;
while (scanf("%d%d", &nQ, &size) == 2) {
ranges.clear();
int nextId = 1;
for (int q = 0; q < nQ; ++q) {
scanf("%s", str);
if (strcmp(str, "alloc") == 0) {
int want;
scanf("%d", &want);
list<Range>::iterator itr = ranges.begin();
int start = 0;
bool success = false;
while (itr != ranges.end()) {
int free = itr->start - start;
if (free >= want) {
ranges.insert(itr, Range(start, want, nextId));
success = true;
break;
}
start = itr->start + itr->len;
++itr;
}
if (!success && size - start >= want) {
success = true;
ranges.push_back(Range(start, want, nextId));
}
if (success)
printf("%d\n", nextId++);
else
puts("NULL");
} else if (strcmp(str, "erase") == 0) {
int target;
scanf("%d", &target);
bool found = false;
for (list<Range>::iterator itr = ranges.begin(); itr != ranges.end();
++itr) {
if (itr->id == target) {
ranges.erase(itr);
found = true;
break;
}
}
if (!found) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int start = 0;
for (list<Range>::iterator itr = ranges.begin(); itr != ranges.end();
++itr) {
itr->start = start;
start = itr->start + itr->len;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int memory[100];
int m, n;
void defrag() {
for (int i = 0, j = 0; i < m; i++) {
while (j < i && memory[j] != 0) j++;
if (memory[j] != 0) continue;
if (memory[i] == 0) continue;
memory[j++] = memory[i];
memory[i] = 0;
}
}
int alloc(int x) {
int count = 0;
int i;
for (i = 0; i < m && count < x; i++) {
if (memory[i] == 0)
count++;
else
count = 0;
}
if (count < x) return -1;
n++;
for (int j = 0; j < x; j++) memory[i - j - 1] = n;
return n;
}
bool erase(int x) {
if (x <= 0) return false;
for (int i = 0; i < m; i++)
if (memory[i] == x) {
while (i < m && memory[i] == x) memory[i++] = 0;
return true;
}
return false;
}
int main() {
int t, x;
string s;
cin >> t >> m;
while (t--) {
cin >> s;
if (s == "alloc") {
cin >> x;
x = alloc(x);
if (x == -1)
cout << "NULL" << endl;
else
cout << x << endl;
} else if (s == "erase") {
cin >> x;
if (!erase(x)) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else
defrag();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, m, n, x;
cin >> t >> m;
string op;
vector<int> mem(m + 1, 0);
vector<pair<int, int> > a(120, {0, 0});
int id = 1;
for (int i = 0; i < t; ++i) {
cin >> op;
if (op == "alloc") {
cin >> n;
int s = 1;
int cnt = 0;
bool found = false;
while (s <= m) {
if (mem[s] == 0) {
cnt++;
s++;
} else {
cnt = 0;
s += a[mem[s]].second;
}
if (cnt == n) {
found = true;
break;
}
}
if (found) {
int start = s - n;
a[id].second = n;
a[id].first = start;
mem[start] = id;
cout << id << endl;
id++;
} else {
cout << "NULL\n";
}
} else if (op == "erase") {
cin >> x;
if (x < 0 || x > id || a[x].first == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
mem[a[x].first] = 0;
a[x].first = 0;
a[x].second = 0;
}
} else {
int offset = 1;
for (int i = 1; i <= m;) {
if (mem[i] != 0) {
int id1 = mem[i];
mem[i] = 0;
mem[offset] = id1;
a[id1].first = offset;
offset += a[id1].second;
i += a[id1].second;
} else {
i++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
int memory[100];
fill(memory, memory + 100, 0);
int index = 1;
for (int ti = 0; ti < t; ti++) {
string command;
cin >> command;
if (command == "alloc") {
int size;
cin >> size;
int count = 0;
int start = -1;
for (int mi = 0; mi < m; mi++) {
if (memory[mi] != 0) {
count = 0;
continue;
}
count++;
if (count == size) {
start = mi - size + 1;
break;
}
}
if (start != -1) {
for (int si = 0; si < size; si++) memory[si + start] = index;
cout << index++ << endl;
} else {
cout << "NULL" << endl;
}
} else if (command == "erase") {
int x;
cin >> x;
bool found = false;
for (int mi = 0; mi < m; mi++)
if (memory[mi] == x) {
memory[mi] = 0;
found = true;
}
if (x == 0 || !found) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
int len = 0;
for (int mi = 0; mi < m; mi++) {
if (memory[mi] == 0)
len++;
else {
for (int mj = mi; mj < m; mj++) memory[mj - len] = memory[mj];
for (int mj = 0; mj < len; mj++) memory[m - mj - 1] = 0;
mi -= len;
len = 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100;
int col[MAX_N], cnt;
int t, n;
char cmd[16];
int main() {
scanf("%d%d", &t, &n);
for (int x; t-- && scanf("%s", cmd) != EOF;) {
if (cmd[0] == 'a') {
scanf("%d", &x);
int pos = n;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < x && i + j < n; j++) cnt += (col[i + j] == 0);
if (cnt == x) {
pos = i;
break;
}
}
if (pos == n)
printf("NULL\n");
else {
printf("%d\n", ++cnt);
for (int i = 0; i < x; i++) col[pos + i] = cnt;
}
} else if (cmd[0] == 'e') {
scanf("%d", &x);
if (x <= 0 || x > cnt)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
int pos = n;
for (int i = 0; i < n; i++)
if (col[i] == x) {
pos = i;
break;
}
if (pos == n)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else
while (pos < n && col[pos] == x) col[pos++] = 0;
}
} else {
int m = 0;
for (int i = 0; i < n; i++)
if (col[i]) col[m++] = col[i];
for (int i = m; i < n; i++) col[i] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m, id;
int memory[105];
while (scanf("%d%d", &n, &m) == 2) {
memset(memory, 0, sizeof(memory)), id = 1;
while (n--) {
char cmd[20];
scanf("%s", cmd);
if (cmd[0] == 'a') {
int size, start, ok;
scanf("%d", &size);
start = ok = 0;
for (int i = 1; i <= m; i++)
if (memory[i])
start = i;
else if (i - start == size) {
ok = 1;
break;
}
if (ok == 0)
puts("NULL");
else {
for (int i = start + 1; i <= start + size; i++) memory[i] = id;
printf("%d\n", id);
id++;
}
} else if (cmd[0] == 'e') {
int temp, ok = 0;
scanf("%d", &temp);
for (int i = 1; i <= m; i++)
if (memory[i] == temp) ok = 1, memory[i] = 0;
if (ok == 0 || temp <= 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int now = 1;
for (int i = 1; i <= m; i++)
if (memory[i] > 0) memory[now++] = memory[i];
for (int i = now; i <= m; i++) memory[i] = 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char ch;
int n, m, x, y;
list<pair<int, int> > l;
vector<list<pair<int, int> >::iterator> v;
scanf("%d%d", &n, &m);
l.push_back(pair<int, int>(m, 0));
v.push_back(l.end());
for (int i = 0; i < n; ++i) {
scanf(" %c%*s%d", &ch, &x);
if (ch == 'a') {
y = 0;
for (list<pair<int, int> >::iterator i = l.begin(); i != l.end(); ++i) {
if (y + x <= i->first) {
printf("%d\n", v.size());
v.push_back(l.insert(i, make_pair(y, x)));
break;
}
y = i->first + i->second;
}
if (y == m) {
puts("NULL");
}
} else if (ch == 'e') {
if (0 < x && x < (int)v.size() && v[x] != l.end()) {
l.erase(v[x]);
v[x] = l.end();
} else {
puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
y = 0;
for (list<pair<int, int> >::iterator i = l.begin(); i->first < m; ++i) {
i->first = y;
y += i->second;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[120];
int m;
int kol;
void alloc(int n) {
int l = 0;
for (int i = 0; i < m; i++) {
if (mem[i])
l = 0;
else {
l++;
if (l == n) {
kol++;
for (int j = i - n + 1; j <= i; j++) mem[j] = kol;
printf("%d\n", kol);
return;
}
}
}
printf("NULL\n");
}
void erase(int id) {
if (!id) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
bool q = false;
for (int i = 0; i < m; i++) {
if (mem[i] == id) {
q = true;
mem[i] = 0;
}
}
if (!q) printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
void defragment() {
int sdv = 0;
for (int i = 0; i < m; i++) {
if (mem[i] == 0) {
sdv++;
continue;
}
mem[i - sdv] = mem[i];
if (sdv != 0) mem[i] = 0;
}
return;
}
int main() {
int t;
scanf("%d %d\n", &t, &m);
kol = 0;
for (int i = 0; i < t; i++) {
string s;
getline(cin, s);
int par;
if (sscanf(s.data(), "alloc %d", &par) == 1)
alloc(par);
else if (sscanf(s.data(), "erase %d", &par) == 1)
erase(par);
else
defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void hora() {
time_t t;
time(&t);
struct tm* petm = localtime(&t);
FILE* pfile;
pfile = fopen("compilaciones.txt", "a");
fprintf(pfile, " \n");
fprintf(pfile, "compil�: %s\n", asctime(petm));
fclose(pfile);
}
int mm[128];
int T, m;
int main() {
string cad;
int cnt = 0, t, i, j;
cin >> T >> m;
for (int z = 0; z < T; z++) {
cin >> cad;
if (cad[0] == 'a') {
cin >> t;
for (i = 0, j = -1; i < m; i++) {
if (!mm[i] && i - j >= t)
break;
else if (mm[i])
j = i;
}
if (i < m) {
cout << (++cnt) << endl;
for (++j; j <= i; j++) mm[j] = cnt;
} else
puts("NULL");
} else if (cad[0] == 'e') {
cin >> t;
for (i = j = 0; i < m; i++)
if (mm[i] == t) mm[i] = 0, j = 1;
if (!j || t == 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else
for (i = j = 0; i < m; i++)
if (mm[i]) t = mm[i], mm[i] = 0, mm[j++] = t;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int mem[N];
void def(const int& m) {
int j, k, id;
int cnt1;
for (int i = (int)(0); i < (int)(m); ++i) {
if (mem[i] == -1) {
cnt1 = 0;
for (j = i; mem[j] == -1 and j < m; j++)
;
id = mem[j];
if (mem[j] == -1 or j == m) break;
for (k = j; mem[k] == id; k++) {
cnt1 += 1;
mem[k] = -1;
}
for (j = i; j < i + cnt1; j++) {
mem[j] = id;
}
i = j - 1;
}
}
}
string itoa(int a) {
string ret = "";
while (a) {
int v = a % 10;
ret += char(v + '0');
a /= 10;
}
reverse((ret).begin(), (ret).end());
return ret;
}
string all(const int& m, int& id, const int& val) {
if (val > m) return "NULL";
for (int i = (int)(0); i < (int)(m); ++i) {
if (mem[i] == -1) {
int cnt = 0;
for (int j = i; mem[j] == -1 and j < m; j++) {
cnt += 1;
}
if (cnt >= val) {
for (int j = i; j < i + val; j++) {
mem[j] = id;
}
id += 1;
return itoa(id - 1);
}
}
}
return "NULL";
}
string era(const int& m, const int& id, int val) {
if (val >= id or val <= 0) return "ILLEGAL_ERASE_ARGUMENT";
bool flag = true;
for (int i = (int)(0); i < (int)(m); ++i) {
if (mem[i] == val) {
flag = false;
mem[i] = -1;
}
}
if (flag) return "ILLEGAL_ERASE_ARGUMENT";
return "-1";
}
int main() {
int t, m, val;
int id = 1;
string cmd;
cin >> t >> m;
for (int i = (int)(0); i < (int)(m); ++i) mem[i] = -1;
for (int i = (int)(0); i < (int)(t); ++i) {
cin >> cmd;
if (cmd == "defragment") {
def(m);
} else {
cin >> val;
if (cmd == "alloc") {
cout << all(m, id, val) << endl;
} else {
string tmp = era(m, id, val);
if (tmp != "-1") cout << tmp << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fp(long long int n, long long int p) {
if (p == 0) return 1;
if (p == 1) return n;
long long int res = fp(n, p / 2);
res = ((res) * (res));
if (p % 2) res = (res * n);
return res;
}
int n, m, x, mem[105], block = 1;
map<int, int> mp;
int main() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
;
string s;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s;
if (s == "alloc") {
cin >> x;
bool f = 0;
int idx = 0, tmp = 0;
for (int i = 0; i < m; i++) {
if (mem[i] == 0)
tmp++;
else
tmp = 0;
if (tmp == x) {
f = 1;
idx = i - x + 1;
break;
}
}
if (f) {
mp[block] = x;
for (int i = 0; i < x; i++, idx++) {
mem[idx] = block;
}
cout << block << '\n';
block++;
} else
cout << "NULL" << '\n';
} else if (s == "erase") {
cin >> x;
if (mp.count(x)) {
int idx = 0, aa = mp[x];
for (int i = 0; i < m; i++) {
if (mem[i] == x) {
idx = i;
break;
}
}
for (int i = 0; i < aa; i++) {
mem[idx] = 0;
idx++;
}
mp.erase(x);
} else {
cout << "ILLEGAL_ERASE_ARGUMENT" << '\n';
}
} else {
vector<int> t;
for (int i = 0; i < m; i++) {
if (mem[i] != 0) {
t.push_back(mem[i]);
mem[i] = 0;
}
}
for (int i = 0; i < int(t.size()); i++) {
mem[i] = t[i];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int vis[110];
int ps[110];
int main() {
int t, m;
memset(vis, -1, sizeof(vis));
scanf("%d%d", &t, &m);
int id = 1, x;
for (int i = 0; i < t; i++) {
cin >> s;
if (s == "defragment") {
int len = 0;
memset(ps, -1, sizeof(ps));
for (int j = 1; j <= m; j++) {
if (vis[j] != -1) ps[++len] = vis[j];
}
for (int j = 1; j <= m; j++) vis[j] = ps[j];
} else if (s == "alloc") {
scanf("%d", &x);
int minx = 0, ff = 0;
for (int j = 1; j <= m; j++) {
if (vis[j] == -1)
minx++;
else {
minx = 0;
}
if (minx == x) {
for (int k = j - x + 1; k <= j; k++) vis[k] = id;
printf("%d\n", id);
ff = 1;
id++;
}
if (ff) break;
}
if (ff == 0) printf("NULL\n");
} else {
scanf("%d", &x);
int flag = 0;
if (x < 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
for (int j = 1; j <= m; j++) {
if (vis[j] == x) vis[j] = -1, flag = 1;
}
if (flag == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, n, cnt = 0, mem[105], def[105];
string s;
bool flag, found;
int main() {
cin >> t >> m;
memset(mem, 0, sizeof(mem));
for (int i = 0; i < t; i++) {
cin >> s;
if (s != "defragment") cin >> n;
if (s == "alloc") {
found = false;
for (int j = 0; j <= m - n; j++) {
flag = true;
for (int k = 0; k < n; k++) {
if (mem[j + k] != 0) {
flag = false;
break;
}
}
if (flag) {
found = true;
++cnt;
for (int k = 0; k < n; k++) {
mem[j + k] = cnt;
}
cout << cnt << endl;
break;
}
}
if (!found) cout << "NULL" << endl;
}
if (s == "erase") {
if (n == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
flag = true;
for (int j = 0; j < m; j++) {
if (mem[j] == n) flag = false, mem[j] = 0;
}
if (flag) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
if (s == "defragment") {
int ccnt = 0;
for (int j = 0; j < m; j++)
if (mem[j] != 0) def[ccnt++] = mem[j];
memset(mem, 0, sizeof(mem));
for (int j = 0; j < ccnt; j++) mem[j] = def[j];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void gi(int& x) {
static char r[(1 << 17) + 16], *s = r, *l = r + (1 << 17);
x = 0;
if (!*s) memset(r, 0, (1 << 17)), cin.read(r, (1 << 17)), s = r;
while (*s && (*s < 48 || *s > 57)) ++s;
while (*s >= 48 && *s <= 57) {
x = x * 10 + *s - 48, ++s;
if (s == l) memset(r, 0, (1 << 17)), cin.read(r, (1 << 17)), s = r;
}
++s;
}
char QQ[(1 << 17) + 16], *OP = QQ, *LP = QQ + (1 << 17);
void pn(int x) {
char *B = OP, c, *E;
int t;
if (!x) t = x / 10, c = x - 10 * t + 48, *OP++ = c, x = t;
while (x) t = x / 10, c = x - 10 * t + 48, *OP++ = c, x = t;
E = OP - 1;
while (B < E) swap(*B, *E), ++B, --E;
if (OP > LP) cout.write(QQ, OP - QQ), OP = QQ;
}
void pc(char c) { *OP++ = c; }
int N, A[(1000006)], g, l, G[(1000006)], L[(1000006)], P[(1000006)], a, W;
long long S, X;
int main(void) {
ios_base::sync_with_stdio(0);
gi(N);
for (int i(0); i < N; i++) gi(A[i + 1]);
for (int k(1); k < N + 1; k++)
if (A[k] > k)
++g, S += a = A[k] - k, --G[a], ++L[a], P[N - k] += 2 * A[k] - 1 - N,
++G[N - k], --L[N - k];
else
++l, S += k - A[k], a = N - k + A[k], --G[a], ++L[a],
P[N - k] += 2 * A[k] - 1 - N, ++G[N - k], --L[N - k];
X = S;
for (int k(0); k < N; k++) {
l += L[k], g += G[k], S += P[k] + l - g + 1;
if (S < X) X = S, W = k + 1;
}
printf("%lld %d\n", X, W);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int cf[maxn];
int p[maxn];
int main() {
int n;
cin >> n;
long long sum = 0;
int L = 0, R = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
if (p[i] <= i)
R++;
else
L++;
cf[(p[i] + n - i) % n]++;
sum += abs(p[i] - i);
}
long long ans = sum;
int op = 0;
for (int i = 1; i < n; i++) {
sum = sum - L;
sum = sum + R - 1;
sum = sum - abs(p[n - i + 1] - n) + abs(p[n - i + 1] - 1);
L = L - (cf[i] - 1);
R = R + (cf[i] - 1);
if (ans > sum) {
ans = sum;
op = i;
}
}
printf("%lld %d\n", ans, op);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, a[2000010], chafen[2000010], fangan;
long long xz, zeng, ans;
void read(int &k) {
int f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
int abs(int x) { return x >= 0 ? x : -x; }
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] >= i) {
chafen[a[i] - i]++;
xz += a[i] - i;
zeng--;
} else {
chafen[a[i] + n - i]++;
xz += i - a[i];
zeng++;
}
}
ans = xz;
int ps = 0;
for (int i = 1; i < n; i++) {
zeng += chafen[i - 1] * 2 - 2;
xz += abs(a[n - i + 1] - 1) - abs(a[n - i + 1] - n) + 1 + zeng;
if (xz < ans) ans = xz, fangan = i;
}
printf("%I64d %d\n", ans, fangan);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15;
const int MAXN = 2e6;
long long p[MAXN], d[MAXN];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
long long k, ans2 = INF;
long long ans = 0;
long long s = 0;
for (int i = 1; i <= n; i++) {
if (p[i] > i) {
d[p[i] - i]++;
ans += p[i] - i;
s++;
}
}
if (ans < ans2) {
ans2 = ans;
k = 0;
}
for (int i = 1; i < n; i++) {
long long ans3 = 0;
ans3 += p[n - i + 1] - 1;
if (i + p[n - i + 1] - 1 < n) {
d[i + p[n - i + 1] - 1]++;
}
ans3 += ans - s;
s = s + 1 - d[i];
ans = ans3;
if (ans < ans2) {
ans2 = ans;
k = i;
}
}
cout << 2 * ans2 << ' ' << k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
void read(T &res) {
bool flag = false;
char ch;
while (!isdigit(ch = getchar())) (ch == '-') && (flag = true);
for (res = ch - 48; isdigit(ch = getchar());
res = (res << 1) + (res << 3) + ch - 48)
;
flag && (res = -res);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long qp(long long a, long long b, long long mod) {
long long ans = 1;
if (b == 0) {
return ans % mod;
}
while (b) {
if (b % 2 == 1) {
b--;
ans = ans * a % mod;
}
a = a * a % mod;
b = b / 2;
}
return ans % mod;
}
long long qpn(long long a, long long b, long long p) {
long long ans = 1;
a %= p;
while (b) {
if (b & 1) {
ans = (ans * a) % p;
--b;
}
a = (a * a) % p;
b >>= 1;
}
return ans % p;
}
long long fact_pow(long long n, long long p) {
long long res = 0;
while (n) {
n /= p;
res += n;
}
return res;
}
long long mult(long long a, long long b, long long p) {
a %= p;
b %= p;
long long r = 0, v = a;
while (b) {
if (b & 1) {
r = (r + v) % p;
r = (r + p) % p;
}
v <<= 1;
v = (v + p) % p;
b >>= 1;
}
return r % p;
}
long long pow_mod(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = mult(res, x, mod);
x = mult(x, x, mod);
n >>= 1;
}
return res;
}
long long quick_pow(long long a, long long b, long long p) {
long long r = 1, v = a % p;
while (b) {
if (b & 1) r = mult(r, v, p);
v = mult(v, v, p);
b >>= 1;
}
return r;
}
bool CH(long long a, long long n, long long x, long long t) {
long long r = quick_pow(a, x, n);
long long z = r;
for (long long i = 1; i <= t; i++) {
r = mult(r, r, n);
if (r == 1 && z != 1 && z != n - 1) return true;
z = r;
}
return r != 1;
}
bool Miller_Rabin(long long n) {
if (n < 2) return false;
if (n == 2) return true;
if (!(n & 1)) return false;
long long x = n - 1, t = 0;
while (!(x & 1)) {
x >>= 1;
t++;
}
srand(time(NULL));
long long o = 8;
for (long long i = 0; i < o; i++) {
long long a = rand() % (n - 1) + 1;
if (CH(a, n, x, t)) return false;
}
return true;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long ans = exgcd(b, a % b, y, x);
y -= (a / b) * x;
return ans;
}
long long INV(long long a, long long b) {
long long x, y;
return exgcd(a, b, x, y), (x % b + b) % b;
}
long long crt(long long x, long long p, long long mod) {
return INV(p / mod, mod) * (p / mod) * x;
}
long long FAC(long long x, long long a, long long b) {
if (!x) return 1;
long long ans = 1;
for (long long i = 1; i <= b; i++)
if (i % a) ans *= i, ans %= b;
ans = pow_mod(ans, x / b, b);
for (long long i = 1; i <= x % b; i++)
if (i % a) ans *= i, ans %= b;
return ans * FAC(x / a, a, b) % b;
}
long long C(long long n, long long m, long long a, long long b) {
long long N = FAC(n, a, b), M = FAC(m, a, b), Z = FAC(n - m, a, b), sum = 0,
i;
for (i = n; i; i = i / a) sum += i / a;
for (i = m; i; i = i / a) sum -= i / a;
for (i = n - m; i; i = i / a) sum -= i / a;
return N * pow_mod(a, sum, b) % b * INV(M, b) % b * INV(Z, b) % b;
}
long long exlucas(long long n, long long m, long long p) {
long long t = p, ans = 0, i;
for (i = 2; i * i <= p; i++) {
long long k = 1;
while (t % i == 0) {
k *= i, t /= i;
}
ans += crt(C(n, m, i, k), p, k), ans %= p;
}
if (t > 1) ans += crt(C(n, m, t, t), p, t), ans %= p;
return ans % p;
}
long long H(long long x, long long p) {
long long ans = 0;
if (x == 0) return 1;
x = x % (2 * p);
if (x == 0) x = 2 * p;
for (int i = 2; i <= x; ++i) ans = (ans * i + (i % 2 == 0 ? 1 : -1)) % p;
return (ans + p) % p;
}
const int maxn = 2e6 + 7;
long long a[maxn], vis[maxn], l = 0, r = 0;
int main() {
long long n, ans = 0, flag;
read(n);
long long add = 0;
long long ls = n;
for (int i = 1; i <= n; i++) {
read(a[i]);
add = add + abs(a[i] - i);
if (i == n) {
continue;
}
if (a[i] - i > 0) {
vis[a[i] - i]++;
l++;
} else {
r++;
}
}
ans = add;
flag = 0;
for (int i = 1; i < n; i++) {
add = add - l + r + a[ls] - 1 - n + a[ls];
if (add < ans) {
ans = add;
flag = i;
}
r = r + vis[i];
l = l - vis[i];
if (a[ls] != 1) {
r--;
l++;
}
vis[a[ls] - 1 + i]++;
ls--;
}
printf("%lld %lld", ans, flag);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int z[N], f[N], p[N], n;
int sum[N * 4];
void update(int i, int v) {
for (; i < n * 4; i += (i & -i)) sum[i] += v;
}
int getsum(int i) {
int ans = 0;
for (; i; i -= (i & -i)) ans += sum[i];
return ans;
}
int main() {
memset(sum, 0, sizeof(sum));
scanf("%d", &n);
long long int tmp = 0, tem = 0;
int ans = 0, dd = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
tmp += ((p[i] - i) > 0 ? (p[i] - i) : -(p[i] - i));
update(p[i] - i + n, 1);
}
tem = tmp;
for (int i = 2; i <= n; i++) {
tem -= ((p[n - i + 2] - n) > 0 ? (p[n - i + 2] - n) : -(p[n - i + 2] - n));
tem += ((p[n - i + 2] - 1) > 0 ? (p[n - i + 2] - 1) : -(p[n - i + 2] - 1));
update(p[n - i + 2] - (n - i + 2) + n, -1);
int t = getsum(dd);
tem += t;
tem -= n - 1 - t;
dd++;
update(p[n - i + 2] - 1 + dd, 1);
if (tem < tmp) {
tmp = tem;
ans = i - 1;
}
}
printf("%lld %d\n", tmp, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 5;
const long long INF = 1e18;
int a[MAXN];
int num[MAXN];
int main() {
int n;
cin >> n;
int L = 0, R = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] >= i) {
L++;
num[a[i] - i]++;
} else
R++;
sum += abs(a[i] - i);
}
long long ans = sum, k = 0;
for (int i = 0; i < n - 1; i++) {
L -= num[i];
R += num[i];
sum = sum - L + R - 1 - (n - a[n - i]) + (a[n - i] - 1);
num[a[n - i] + i]++;
L++;
R--;
if (sum < ans) {
ans = sum;
k = i + 1;
}
}
cout << ans << " " << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000], ans, status[1000000];
long long sum, dev, tot;
vector<int> ins[1000005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
sum += abs(a[i] - i);
if (i == n - 1)
status[i] = 2 * a[i] - n + 1;
else
status[i] = a[i] > i ? -1 : 1;
tot += status[i];
ins[a[i] > i ? a[i] - i : a[i] - i + n].push_back(i);
ins[n - i - 1].push_back(i);
ins[n - i].push_back(i);
}
dev = sum;
ans = 0;
for (int i = 1; i < n; i++) {
sum += tot;
if (sum < dev) {
dev = sum;
ans = i;
}
int sz = ins[i].size();
for (int j = 0; j < sz; j++) {
int k = ins[i][j];
tot -= status[k];
status[k] = abs(a[k] - (i + k + 1) % n) - abs(a[k] - (i + k) % n);
tot += status[k];
}
}
cout << dev << ' ' << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int tab[1000001];
vector<int> V[3000001];
long long m = 0, p = 0, res = 0, tim = 0;
long long m_amount = 0, p_amount = 0;
bool ifmin[1000001];
void read_and_prepare() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tab[i];
if (tab[i] - i > 0) {
p_amount++;
p += tab[i] - i;
V[tab[i] - i].push_back(i);
} else {
ifmin[i] = 1;
m_amount++;
m += i - tab[i];
}
}
res = m + p;
}
void shifts() {
for (int i = 1; i < n; i++) {
int id = n - i + 1;
m -= n - tab[id];
p += tab[id] - 1;
m_amount--;
ifmin[id] = 0;
p -= p_amount;
m += m_amount;
p_amount++;
V[i + tab[id] - 1].push_back(id);
for (unsigned int j = 0; j < V[i].size(); j++) {
id = V[i][j];
if (!ifmin[id]) {
ifmin[id] = 1;
p_amount--;
m_amount++;
}
}
if (m + p < res) {
res = m + p;
tim = i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
read_and_prepare();
shifts();
cout << res << " " << tim << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void addmod(int &a, long long b) {
a = (a + b);
if (a >= 1000000007) a -= 1000000007;
}
void mulmod(int &a, long long b) { a = (a * b) % 1000000007; }
template <class T>
bool domin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool domax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gll() {
long long a;
scanf("%lld", &a);
return a;
}
int main() {
int n = gi(), ix = 0;
vector<int> a(n + 1);
long long ans = 0, nr = 0, ni = 0, mans = LLONG_MAX;
vector<int> sr(n + 5, 0);
for (auto i = 1; i <= n; i++) {
a[i] = gi();
ans += abs(i - a[i]);
if (a[i] <= i) {
ni++;
} else {
nr++;
sr[a[i] - i]++;
}
}
mans = ans;
for (int i = n, j = 1; i > 1; i--, j++) {
ni--;
long long tans = ans - abs(a[i] - n);
tans += a[i] - 1;
tans += (ni - nr);
if (mans > tans) {
mans = tans;
ix = j;
}
ans = tans;
nr++;
int k = j + a[i] - 1;
if (k <= n) sr[k]++;
nr -= sr[j];
ni += sr[j];
}
cout << mans << " " << ix << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[1000001];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
map<int, int> change_v;
int above = 0, below = 0;
long long sum = 0;
long long best_i = 0;
for (int i = 0; i < n; i++) {
int xs = A[i] - i - 1;
int x = (xs > 0) ? xs : -1 * xs;
if (xs < 0) {
change_v[x]++;
}
if (xs < 0) {
below++;
} else {
above++;
}
sum += x;
}
long long best_sum = sum;
for (int i = 0; i < n - 1; i++) {
long long xs = A[i] - n;
long long x = (xs > 0) ? xs : -1 * xs;
long long cnt = change_v[i + 1];
if (xs < 0) {
change_v[x + i + 1]++;
}
int cur_below_d = (A[i] - 1 < 0) ? 1 : 0;
int cur_above_d = (A[i] - 1 >= 0) ? 1 : 0;
sum -= below - cur_below_d;
sum += above - cur_above_d;
sum -= (A[i] - 1 > 0) ? A[i] - 1 : 1 - A[i];
sum += x;
above += cnt;
below -= cnt;
if (xs < 0 && A[i] - 1 >= 0) {
below++;
above--;
}
if (sum < best_sum) {
best_i = i + 1;
best_sum = sum;
}
}
if (best_i != 0) {
best_i = n - best_i;
}
cout << best_sum << " " << best_i;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2000005];
int n;
int tp[1000005];
long long ans = 0;
int x = 0;
int neg = 0, pos = 0;
vector<int> modify[2000005];
void solve() {
for (int i = 1; i <= n; i++) {
neg += a[i] - i < 0;
pos += a[i] - i >= 0;
ans += abs(a[i] - i);
if (a[i] < i) modify[i - a[i]].push_back(i);
}
long long cnt = ans;
for (int i = 1; i < n; i++) {
int l = i + 1, r = i + n;
cnt -= a[i] - 1, cnt += abs(a[r] - n);
pos--;
cnt += pos - neg;
neg += a[r] - n < 0, pos += a[r] - n >= 0;
for (vector<int>::iterator j = modify[i].begin(); j != modify[i].end();
++j) {
if (*j <= i) continue;
pos++, neg--;
}
if (a[r] < n) modify[n - a[r] + i].push_back(r);
if (cnt < ans) ans = cnt, x = n - i;
}
cout << ans << " " << x << endl;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) a[i + n] = a[i];
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int mp[10000005];
int main() {
int i, j, k, l, m, n, t, q, r;
t = 1;
while (t--) {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long pos = 0;
int np = 0;
for (i = 1; i <= n; i++) {
mp[a[i] - i + 3000000]++;
if (a[i] - i > 0) {
pos += (a[i] - i);
np++;
}
}
long long mi = pos;
int id = 0;
int sh = 1;
for (i = n; i > 1; i--) {
pos -= np;
pos += (a[i] - 1);
if (a[i] - 1 > 0) {
np++;
}
np -= mp[(sh - 1) + 1 + 3000000];
if (pos < mi) {
mi = pos;
id = sh;
}
mp[(a[i] - 1) + sh + 3000000]++;
mp[(a[i] - n) + sh + 3000000]--;
sh++;
}
cout << mi * 2 << " " << id << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(rand());
long long inf = 1e9;
long long mod = 1e9 + 7;
long long big_inf = 1e18;
signed main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(n);
set<pair<long long, long long> > s1;
long long s2_size = 0;
vector<long long> set_val(n);
long long my_sum = 0;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
long long r = i + 1 - a[i];
set_val[i] = r;
if (r < 0)
s1.insert({r, i});
else
s2_size++;
my_sum += abs(i + 1 - a[i]);
}
long long j = n - 1;
long long ans = my_sum;
long long ans_num = 0;
for (long long i = 0; i < n - 1; ++i) {
my_sum -= abs(n - a[j]);
my_sum += abs(1 - a[j]);
my_sum -= s1.size();
my_sum += s2_size - 1;
if (my_sum < ans) {
ans = my_sum;
ans_num = i + 1;
}
while (s1.size() && s1.rbegin()->first + i + 1 >= 0) {
s2_size++;
s1.erase(*s1.rbegin());
}
if (a[j] > 1) {
s2_size--;
s1.insert({1 - a[j] - i - 1, j});
}
--j;
}
cout << ans << " " << ans_num;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3fll;
const int LGN = 25;
const int MOD = 1e9 + 7;
const int N = 1e6 + 5;
int n;
long long delta[N];
void add(int l, int r, int v) {
if (r < l || n <= l) return;
delta[l] += v;
delta[r + 1] -= v;
}
int main() {
std::ios::sync_with_stdio(false);
scanf("%d", &(n));
static int p[N];
long long d = 0;
for (long long i = 1, __R = n; i <= __R; i++) {
scanf("%d", &(p[i]));
d += abs(i - p[i]);
if (p[i] > i) {
add(1, p[i] - i, -1);
add(p[i] - i + 1, n - i, +1);
add(n - i + 1, n - i + 1, -(n - p[i]) + (p[i] - 1));
add(n - i + 2, n - 1, -1);
} else if (p[i] == i) {
add(1, n - i, +1);
add(n - i + 1, n - i + 1, -(n - p[i]) + (p[i] - 1));
add(n - i + 2, n - 1, -1);
} else {
add(1, n - i, +1);
add(n - i + 1, n - i + 1, -(n - p[i]) + (p[i] - 1));
add(n - i + 2, n - i + p[i], -1);
add(n - i + p[i] + 1, n - 1, +1);
}
}
long long mind = d;
int mink = 0;
for (long long k = 1, __R = n - 1; k <= __R; k++) {
delta[k] += delta[k - 1];
}
for (long long k = 1, __R = n - 1; k <= __R; k++) {
d += delta[k];
if (d < mind) {
mind = d;
mink = k;
}
}
printf("%lld %d\n", mind, mink);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e6 + 10;
int p[maxn];
int cnt[maxn];
int main() {
int n;
scanf("%d", &n);
int a = 0, b = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
if (p[i] > i)
a++;
else
b++;
ans += abs(p[i] - i);
cnt[(p[i] - i + n) % n]++;
}
long long ANS = ans, x = 0;
for (int i = 1; i <= n; i++) {
int j = n - i + 1;
ans -= abs(p[j] - (j + i - 1));
ans += abs(p[j] - 1);
b--;
ans += b - a;
if (ANS > ans) ANS = ans, x = i;
++a;
a -= cnt[i % n];
b += cnt[i % n];
}
cout << ANS << ' ' << x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int main(void) {
cin >> n;
vector<int> p(n);
for (int i = (0); i < (n); i++) scanf("%d", &p[i]), p[i]--;
vector<long long> t(n + 1);
long long ch = 0;
long long d = 0;
for (int i = (0); i < (n); i++) {
t[(p[i] - i + n) % n]++;
if (p[i] > i)
ch--;
else
ch++;
d += abs(p[i] - i);
}
long long mk = 0;
long long m = 1e18;
t[n] = t[0];
t[0] = 1;
long long j = ch, l = d;
for (int k = (0); k < (n + 1); k++) {
if (k) d += ch - abs(n - 1 - p[n - k]) + abs(p[n - k]) - 1;
if (d < m) m = d, mk = k;
ch += 2 * t[k] - 2;
if (k == n) assert(j == ch && l == d);
}
printf("%lld %lld\n", m, mk);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.