text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int casenum, lnth, cnt, ind, cur;
string s;
bool ok[101];
int arr[101];
string getss() {
string k = "";
char a;
a = getchar();
while (a == -1 || a == 32 || a == 10) a = getchar();
while (a != -1 && a != 32 && a != 10) {
k += a;
a = getchar();
}
return k;
}
void calc1() {
scanf("%d", &cnt);
if (cnt < 1) {
puts("NULL");
return;
}
cur = 0;
for (int i = 0; i < lnth; i++) {
if (arr[i] > 0) {
cur = 0;
continue;
}
cur++;
if (cur == cnt) {
for (int j = 0; j < cnt; j++) {
arr[i - j] = ind;
}
ok[ind] = true;
break;
}
}
if (cur < cnt)
puts("NULL");
else
printf("%d\n", ind++);
}
void calc2() {
scanf("%d", &cnt);
if (cnt < 1 || cnt > 100) {
puts("ILLEGAL_ERASE_ARGUMENT");
return;
}
for (int i = 0; i < lnth; i++)
if (arr[i] == cnt) arr[i] = 0;
if (!ok[cnt])
puts("ILLEGAL_ERASE_ARGUMENT");
else
ok[cnt] = false;
}
void calc3() {
cnt = 0;
for (int i = 0; i < lnth; i++)
if (arr[i] > 0) arr[cnt++] = arr[i];
for (int i = cnt; i < lnth; i++) arr[i] = 0;
}
int main() {
scanf("%d%d", &casenum, &lnth);
memset(arr, 0, sizeof arr);
memset(ok, false, sizeof ok);
ind = 1;
for (int i = 0; i < casenum; i++) {
s = getss();
if (s == "alloc") calc1();
if (s == "erase") calc2();
if (s == "defragment") calc3();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Tag {
Tag(int id_, int size_) : id(id_), size(size_) {}
int id;
int size;
};
class MemoryManager {
public:
MemoryManager(int size) : m_slots(1, Tag(0, size)), m_id(1) {}
void alloc(int size);
void erase(int id);
void defragment();
void print() const;
private:
list<Tag> m_slots;
int m_id;
};
void MemoryManager::alloc(int request) {
list<Tag>::iterator it;
for (it = m_slots.begin(); it != m_slots.end(); ++it) {
if (it->id == 0 && it->size >= request) {
if (it->size == request) {
it->id = m_id;
} else {
it->size -= request;
m_slots.insert(it, Tag(m_id, request));
}
break;
}
}
if (it != m_slots.end()) {
cout << m_id << endl;
m_id++;
} else {
cout << "NULL" << endl;
}
}
void MemoryManager::erase(int id) {
if (id == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
list<Tag>::iterator it;
for (it = m_slots.begin(); it != m_slots.end(); ++it) {
if (it->id == id) {
it->id = 0;
list<Tag>::iterator itNext = it;
itNext++;
if (itNext != m_slots.end() && itNext->id == 0) {
it->size += itNext->size;
m_slots.erase(itNext);
}
if (it != m_slots.begin()) {
list<Tag>::iterator itPrev = it;
itPrev--;
if (itPrev->id == 0) {
it->size += itPrev->size;
m_slots.erase(itPrev);
}
}
break;
}
}
if (it == m_slots.end()) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
void MemoryManager::defragment() {
for (list<Tag>::iterator it = m_slots.begin(); it != m_slots.end(); ++it) {
if (it->id == 0) {
list<Tag>::iterator itNext = it;
itNext++;
while (itNext != m_slots.end() && itNext->id == 0) {
it->size += itNext->size;
m_slots.erase(itNext);
itNext = it;
itNext++;
}
if (itNext != m_slots.end() && itNext->id > 0) {
swap(it->id, itNext->id);
swap(it->size, itNext->size);
}
}
}
}
void MemoryManager::print() const {
cout << "==============" << endl;
for (list<Tag>::const_iterator it = m_slots.begin(); it != m_slots.end();
++it) {
cout << "(" << it->id << " " << it->size << ")" << endl;
}
cout << "==============" << endl;
}
int main() {
int t, m;
cin >> t >> m;
MemoryManager mm(m);
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s == "alloc") {
int size;
cin >> size;
mm.alloc(size);
} else if (s == "erase") {
int id;
cin >> id;
mm.erase(id);
} else {
mm.defragment();
}
}
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;
char s[100];
int n, m, ans;
int blocks = 0;
int a[1010];
int alloc(int x) {
for (int i = 1; i <= m; i++) {
int j = i;
int num = 0;
while (a[j] == 0 && num != x && j <= m) {
num++;
j++;
}
if (num != x) {
i = j;
} else {
blocks++;
for (int k = i; k < j; k++) {
a[k] = blocks;
}
return blocks;
}
}
return 0;
}
int earse(int x) {
if (x <= 0) {
return -1;
}
int flag = 0;
for (int i = 1; i <= m; i++) {
while (a[i] == x) {
a[i++] = 0;
flag = 1;
}
}
if (flag == 1) {
return -2;
}
return -1;
}
int defragment() {
for (int i = 1; i <= m; i++) {
if (a[i] == 0) {
for (int j = i + 1; j <= m; j++) {
if (a[j]) {
swap(a[i], a[j]);
break;
}
}
}
}
return -5;
}
int main() {
int x;
cin >> n >> m;
memset(a, 0, sizeof(a));
while (n--) {
scanf("%s", &s);
if (s[0] == 'a') {
cin >> x;
ans = alloc(x);
} else if (s[0] == 'e') {
cin >> x;
ans = earse(x);
} else {
ans = defragment();
}
if (ans == 0) {
cout << "NULL" << endl;
} else if (ans == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else if (ans >= 1) {
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, L, cnt;
int occ[1111];
pair<int, int> q[1111];
bool chk(int st, int len) {
for (int i = st; i < st + len; i++)
if (occ[i]) return false;
return true;
}
void mset(int l, int r, int val) {
for (int i = l; i <= r; i++) occ[i] = val;
}
int main() {
scanf("%d%d", &n, &L);
cnt = 0;
for (int i = 0; i < n; i++) {
char s[22];
scanf("%s", s);
if (s[0] == 'a') {
int sz;
scanf("%d", &sz);
int found = 0;
for (int i = 1; i <= L - sz + 1 && !found; i++)
if (!occ[i] && chk(i, sz)) found = i;
if (!found)
puts("NULL");
else {
q[++cnt] = make_pair(found, found + sz - 1);
mset(found, found + sz - 1, cnt);
printf("%d\n", cnt);
}
} else if (s[0] == 'e') {
int id;
scanf("%d", &id);
if (id < 1 || id > cnt || q[id].first == -1)
puts("ILLEGAL_ERASE_ARGUMENT");
else {
mset(q[id].first, q[id].second, 0);
q[id] = make_pair(-1, -1);
}
} else {
int st = 1;
for (int i = 1; i <= L; i++)
if (occ[i]) {
int id = occ[i];
if (i > st) {
int len = q[id].second - q[id].first + 1;
mset(q[id].first, q[id].second, 0);
q[id].first = st;
q[id].second = st + len - 1;
mset(q[id].first, q[id].second, id);
}
st = q[id].second + 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[110];
int main() {
memset(v, 0, sizeof(v));
int n, m;
scanf("%d%d", &n, &m);
long long id = 1;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
if (str[0] == 'a') {
long long vi;
cin >> vi;
int ok = 0;
for (int j = 0; j < m; j++) {
if (v[j]) continue;
long long c = 0;
for (int k = j; k < m; k++) {
if (v[k]) break;
c++;
}
if (c >= vi) {
for (int k = j; k < m; k++) {
v[k] = id;
vi--;
if (!vi) break;
}
ok = 1;
break;
}
}
if (ok)
cout << (id++) << endl;
else
printf("NULL\n");
} else if (str[0] == 'e') {
long long f;
cin >> f;
if (f == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
int ok = 0;
for (int j = 0; j < m; j++) {
if (v[j] == f) {
ok = 1;
for (int k = j; k < m; k++) {
if (v[k] == f)
v[k] = 0;
else
break;
}
break;
}
}
if (!ok) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
for (int i = 0; i < m; i++) {
if (!v[i]) {
for (int j = i + 1; j < m; j++) {
if (v[j]) {
swap(v[i], v[j]);
break;
}
}
}
}
}
}
}
|
#include <bits/stdc++.h>
int main() {
std::array<int, 100> Arr{0};
int t, m;
std::cin >> t >> m;
int id = 1;
std::string Command;
while (t--) {
std::cin >> Command;
if (Command[0] == 'a') {
int p;
std::cin >> p;
int cnt = 0, idx = 0;
bool OK = false;
for (int i = 0; i < m; ++i) {
if (!Arr[i]) {
++cnt;
} else {
cnt = 0;
idx = i + 1;
}
if (cnt == p) {
OK = true;
break;
}
}
if (OK) {
for (int i = idx; i < idx + p; ++i) {
Arr[i] = id;
}
std::cout << id++ << std::endl;
} else {
std::puts("NULL");
}
} else if (Command[0] == 'e') {
int p;
std::cin >> p;
if (p > id || p <= 0) {
std::puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int f = false;
int i;
for (i = 0; i < m; ++i) {
if (Arr[i] == p) {
break;
}
}
while (Arr[i] == p) {
Arr[i] = 0;
++i;
f = true;
}
if (!f) {
std::puts("ILLEGAL_ERASE_ARGUMENT");
}
}
} else {
int idx = 0;
for (int i = 0; i < m; ++i) {
if (Arr[i]) {
Arr[idx++] = Arr[i];
}
}
for (int i = idx; i < m; ++i) {
Arr[i] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Block {
int tag;
int sta;
int size;
bool operator<(const Block &r) const { return sta < r.sta; }
};
void alloc(vector<Block> &mems, int &tag, int size, int m) {
Block bt;
bt.size = size;
int sta = 1;
int pos = 0;
bool flag = false;
for (int i = 0; i < mems.size(); ++i) {
if (sta + size - 1 < mems[i].sta) {
bt.sta = sta;
bt.tag = tag++;
pos = i;
flag = true;
break;
} else {
sta = mems[i].sta + mems[i].size;
}
}
if (flag) {
mems.insert(mems.begin() + pos, bt);
cout << tag - 1 << endl;
return;
}
if (sta + size - 1 <= m) {
cout << tag << endl;
bt.sta = sta;
bt.tag = tag++;
mems.insert(mems.end(), bt);
} else {
cout << "NULL" << endl;
}
}
void erase(vector<Block> &mems, int tag) {
int pos = -1;
for (int i = 0; i < mems.size(); ++i) {
if (mems[i].tag == tag) {
pos = i;
break;
}
}
if (pos != -1) {
mems.erase(mems.begin() + pos);
} else {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
void defragment(vector<Block> &mems) {
int sta = 1;
for (int i = 0; i < mems.size(); ++i) {
mems[i].sta = sta;
sta += mems[i].size;
}
}
int main() {
int t, m;
cin >> t >> m;
vector<Block> mems;
string ins;
int tag = 1;
while (t--) {
cin >> ins;
if (ins == "alloc") {
int size;
cin >> size;
alloc(mems, tag, size, m);
} else if (ins == "erase") {
int pos;
cin >> pos;
erase(mems, pos);
} else {
defragment(mems);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[102];
int main() {
int t, m;
cin >> t >> m;
int j = 1;
a[m + 1] = 1000;
while (t--) {
string s;
int n;
cin >> s;
if (s == "alloc" || s == "erase") {
cin >> n;
}
if (s == "alloc") {
int dem = 0;
int i = 1;
bool k = true;
for (i = 1; i <= m + 1; i++) {
if (a[i] == 0 && dem < n) {
dem++;
} else if (dem == n) {
cout << j << endl;
k = false;
break;
} else if (a[i] != 0 && dem < n) {
dem = 0;
}
}
if (k == true) {
cout << "NULL" << endl;
continue;
} else if (k == false) {
while (dem--) {
a[i - 1] = j;
i--;
}
j++;
}
continue;
}
if (s == "erase") {
bool k = true;
for (int i = 1; i <= m; i++) {
if (a[i] == n) {
k = false;
a[i] = 0;
}
}
if (k == true || n == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
continue;
}
if (s == "defragment") {
queue<int> q;
for (int i = 1; i <= m; i++) {
if (a[i] != 0) q.push(a[i]);
}
for (int i = 1; i <= m; i++) {
if (q.size() != 0) {
a[i] = q.front();
q.pop();
} else
a[i] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M[110], M2[110];
int main() {
int t, m, n, cur = 1;
memset(M, 0, sizeof(M));
cin >> t >> m;
while (t-- > 0) {
string op;
cin >> op;
if (op == "alloc") {
cin >> n;
bool f = false;
for (int i = 0; i < m; ++i) {
int cnt = 0;
for (int j = i; j < m; ++j) {
if (M[j] == 0)
++cnt;
else
break;
if (cnt == n) break;
}
if (cnt == n) {
for (int j = i; j < i + n; ++j) M[j] = cur;
cout << cur << endl;
++cur;
f = true;
break;
}
}
if (!f) cout << "NULL" << endl;
} else if (op == "erase") {
cin >> n;
bool f = false;
for (int i = 0; i < m; ++i)
if (M[i] == n) {
M[i] = 0;
f = true;
}
if (!f || n == 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else if (op == "defragment") {
int j = 0;
for (int i = 0; i < m; ++i)
if (M[i] != 0) M[j++] = M[i];
while (j < m) M[j++] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct block {
long long start, size, id;
bool free;
block(long long s, long long sz, bool f, long long i = -1) {
start = s;
size = sz;
free = f;
id = i;
}
};
long long alloc = 0, id = 1;
bool allocate(vector<block>& blocks, long long size) {
for (long long i = 0; i < blocks.size(); ++i) {
if (blocks[i].free && blocks[i].size >= size) {
long long sz = blocks[i].size;
block b(0, size, false, id++);
if (i > 0) {
b.start = blocks[i - 1].start + blocks[i - 1].size;
}
blocks.erase(blocks.begin() + i);
blocks.insert(blocks.begin() + i, b);
blocks.insert(blocks.begin() + i + 1,
block(b.start + b.size, sz - size, true));
alloc += size;
return true;
}
}
return false;
}
bool erase(vector<block>& blocks, long long id) {
for (long long i = 0; i < blocks.size(); ++i) {
if (!blocks[i].free && blocks[i].id == id) {
alloc -= blocks[i].size;
long long l = i - 1, r = i + 1, size = blocks[i].size;
while (l >= 0 && blocks[l].free) {
size += blocks[l].size;
l--;
}
while (r < blocks.size() && blocks[r].free) {
size += blocks[r].size;
r++;
}
blocks.erase(blocks.begin() + l + 1, blocks.begin() + r);
block b(0, size, true);
if (l > 0) {
b.start = blocks[l - 1].start + blocks[l - 1].size;
}
blocks.insert(blocks.begin() + l + 1, b);
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, m;
cin >> t >> m;
block b(0, m, true);
vector<block> blocks;
blocks.push_back(b);
while (t--) {
string s;
long long x;
cin >> s;
if (s == "alloc") {
cin >> x;
if (allocate(blocks, x)) {
cout << id - 1 << "\n";
} else {
cout << "NULL\n";
}
} else if (s == "erase") {
cin >> x;
if (!erase(blocks, x)) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
} else {
long long j = 0;
for (long long i = 0; i < blocks.size(); ++i) {
if (!blocks[i].free) {
blocks[j] = blocks[i];
if (j == 0) {
blocks[j].start = 0;
} else {
blocks[j].start = blocks[j - 1].start + blocks[j - 1].size;
}
j++;
}
}
blocks.erase(blocks.begin() + j, blocks.end());
blocks.push_back(block(alloc, m - alloc, true));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
int v[105];
int main() {
cin >> t >> m;
string op;
int i, j, n, k = 1;
for (long long i = 0; i <= m; i++) v[i] = 0;
while (t--) {
cin >> op;
if (op[0] == 'd') {
for (i = 0, j = 0; i < m; i++)
if (v[i]) v[j++] = v[i];
for (; j < m; j++) v[j] = 0;
} else {
cin >> n;
if (op[0] == 'a') {
for (i = 0; i <= m - n; i++) {
for (j = i; j < i + n; j++)
if (v[j] != 0) break;
if (j == i + n) break;
}
if (i <= m - n) {
cout << k << endl;
for (j = i; j < i + n; j++) v[j] = k;
;
k++;
} else
cout << "NULL" << endl;
} else {
int f = 0;
for (i = 0; i < m; i++)
if (v[i] && v[i] == n) {
v[i] = 0;
f = 1;
}
if (!f) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int used[128];
int m;
int cc = 0;
bool ok(int i, int k) {
if (i + k > m) return false;
for (int j = (i), __j = (i + k); j < __j; j++)
if (used[j]) return false;
return true;
}
int main() {
int n;
cin >> n >> m;
map<int, pair<int, int> > a;
for (int it = (0), __it = (n); it < __it; it++) {
string op;
int x;
cin >> op;
if (op == "alloc") {
cin >> x;
bool bad = true;
for (int i = (0), __i = (m); i < __i; i++)
if (ok(i, x)) {
for (int j = (i), __j = (i + x); j < __j; j++) used[j] = 1;
++cc;
a[cc] = make_pair(i, x);
cout << cc << endl;
bad = false;
break;
}
if (bad) {
cout << "NULL" << endl;
}
} else if (op == "erase") {
cin >> x;
if (a[x] == make_pair(0, 0)) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
for (int j = ((a[x]).first), __j = ((a[x]).first + (a[x]).second);
j < __j; j++)
used[j] = 0;
a[x] = make_pair(0, 0);
}
} else if (op == "defragment") {
vector<pair<pair<int, int>, int> > b;
map<int, pair<int, int> >::iterator it;
for (it = a.begin(); it != a.end(); ++it) {
if (it->second != make_pair(0, 0)) {
b.push_back(make_pair(it->second, it->first));
it->second = make_pair(0, 0);
}
}
sort((b).begin(), (b).end());
memset(used, 0, sizeof(used));
int p = 0;
for (int i = (0), __i = (int((b).size())); i < __i; i++) {
a[b[i].second] = make_pair(p, b[i].first.second);
for (int j = (p), __j = (p + b[i].first.second); j < __j; j++)
used[j] = 1;
p += b[i].first.second;
}
} else {
cerr << "BAD" << endl;
while (1)
;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int num[101];
int vis[101];
char op[101];
int main() {
int a, b;
int i, ii, j;
int step;
int data, flag;
while (scanf("%d%d", &a, &b) != EOF) {
step = 0;
memset(num, 0, sizeof(num));
memset(vis, 0, sizeof(vis));
for (ii = 0; ii < a; ii++) {
scanf("%s", op);
switch (op[0]) {
case 'a':
flag = 0;
int fir;
scanf("%d", &data);
for (j = 0, i = 1; i <= b; i++) {
if (num[i] == 0) {
++j;
if (j == data) {
flag = 1;
fir = i;
break;
}
} else {
j = 0;
flag = 0;
}
}
if (flag) {
++step;
vis[step] = 1;
for (i = fir; i > fir - data; i--) num[i] = step;
printf("%d\n", step);
} else
printf("NULL\n");
;
break;
case 'e':
scanf("%d", &data);
if (data <= 0 || !vis[data])
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
for (i = 1; i <= b; i++)
if (num[i] == data) {
num[i] = 0;
}
vis[data] = 0;
}
break;
case 'd':
int s;
for (s = 0, i = 1; i <= b; i++) {
if (num[i]) num[++s] = num[i];
if (i > s) num[i] = 0;
}
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int memory[300];
int main() {
int t, m;
cin >> t >> m;
for (int i = 0; i < m; i++) memory[i] = -2;
int last_id = 1;
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s[0] == 'a') {
int n;
cin >> n;
int start = -1;
for (int j = 0; j < m; j++) {
int counts = 0;
if (memory[j] == -2)
for (int k = j; k < m; k++) {
if (memory[k] != -2)
break;
else
counts++;
}
if (counts >= n) {
start = j;
break;
}
}
if (start == -1)
cout << "NULL" << endl;
else {
for (int j = 0; j < n; j++) {
memory[start] = last_id;
start++;
}
cout << last_id << endl;
last_id++;
}
} else if (s[0] == 'e') {
int n;
cin >> n;
bool found = false;
for (int i = 0; i < m; i++) {
if (memory[i] == n) {
found = true;
memory[i] = -2;
}
}
if (!found) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
for (int i = 0; i < m; i++) {
if (i != m - 1 && memory[i] == -2 && memory[i + 1] != -2) {
memory[i] = memory[i + 1];
memory[i + 1] = -2;
i = -1;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, n;
int mem[105];
int cur = 1;
void Alloc(int n) {
for (int i = 0; i + n <= m; i++) {
int j;
for (j = 0; j < n; j++)
if (mem[i + j]) break;
if (j < n) continue;
for (j = 0; j < n; j++) mem[i + j] = cur;
cout << cur++ << endl;
return;
}
cout << "NULL" << endl;
}
void Erase(int n) {
if (n <= 0 || n >= cur)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
bool was = false;
for (int i = 0; i < m; i++)
if (mem[i] == n) {
was = true;
mem[i] = 0;
}
if (!was) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
void Defragment() {
for (int i = 0; i < m; i++)
if (mem[i]) {
int j = 0;
while (mem[j] && j < i) j++;
if (j < i) {
mem[j] = mem[i];
mem[i] = 0;
}
}
}
int main() {
cin >> t >> m;
string s;
while (t--) {
cin >> s;
if (s[0] == 'a') {
cin >> n;
Alloc(n);
} else if (s[0] == 'e') {
cin >> n;
Erase(n);
} else
Defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt, M;
bool arr[1000];
int pos[1000], num[1000], loc[1000];
void doAlloc() {
int n;
cin >> n;
bool found = false;
for (int i = 0; i + n <= M; i++) {
bool flag = true;
for (int j = 0; j < n; j++)
if (!arr[i + j]) flag = false;
if (flag) {
++cnt;
pos[cnt] = i;
cout << cnt << "\n";
found = true;
num[cnt] = n;
loc[i] = cnt;
for (int j = 0; j < n; j++) arr[i + j] = false;
break;
}
}
if (!found) cout << "NULL\n";
return;
}
void doErase() {
long long x;
cin >> x;
if (x > cnt || x <= 0 || x > 100) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
return;
}
int t = pos[x];
if (t == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
return;
}
bool found = false;
for (int i = 0; i < num[x]; i++)
if (arr[i + t])
found = true;
else
arr[i + t] = true;
if (found)
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else
pos[x] = num[x] = -1;
return;
}
void doFrament() {
int last = 0;
bool found = true;
while (found) {
found = false;
for (int i = 1; i < M; i++)
if (arr[i - 1] && !arr[i]) {
found = true;
arr[i - 1] = false;
arr[i] = true;
if (loc[i] > 0) {
loc[i - 1] = loc[i];
pos[loc[i]] = i - 1;
loc[i] = 0;
}
}
}
return;
}
int main() {
int T;
cin >> T >> M;
cnt = 0;
memset(arr, true, sizeof(arr));
memset(pos, -1, sizeof(pos));
memset(num, 0, sizeof(num));
memset(loc, 0, sizeof(loc));
for (int i = 0; i < T; i++) {
string command;
cin >> command;
if (command == "alloc")
doAlloc();
else if (command == "erase")
doErase();
else
doFrament();
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
int m;
char op[20];
int mem[1000];
int r;
int i;
int j;
int k;
int num;
int flag;
int count;
while (scanf("%d%d", &n, &m) != EOF) {
num = 1;
memset(mem, 0, sizeof(mem));
while (n--) {
scanf("%s", op);
if (op[0] != 'd') {
scanf("%d", &r);
}
if (op[0] == 'a') {
k = 0;
while (mem[k] != 0) {
k++;
}
count = 0;
flag = 0;
for (i = k; i < m; i++) {
if (mem[i] != 0) {
if (count >= r) {
k = i - count + 1;
flag = 1;
break;
}
count = 0;
} else {
count++;
}
if (count >= r) {
k = i - count + 1;
flag = 1;
break;
}
}
if (flag == 1) {
for (i = k; i < k + r; i++) {
mem[i] = num;
}
printf("%d\n", num);
num++;
} else {
printf("NULL\n");
}
} else if (op[0] == 'e') {
flag = 0;
for (i = 0; i < m; i++) {
if (mem[i] == r) {
mem[i] = 0;
flag = 1;
}
}
if (flag != 1 || r == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else if (op[0] == 'd') {
k = 0;
while (mem[k]) {
k++;
}
j = k;
for (i = k; i < m; i++) {
if (mem[i] != 0) {
mem[j] = mem[i];
mem[i] = 0;
j++;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[102];
int cur = 0;
void Alloc(int x) {
for (int i = 1; i <= m; i++) {
if (a[i] == 0) {
bool was = true;
for (int j = 0; j < x; j++) {
if (a[i + j] != 0 || i + j > m) {
was = false;
break;
}
}
if (was) {
cur++;
for (int j = i; j < i + x; j++) {
a[j] = cur;
}
cout << cur << endl;
return;
}
}
}
cout << "NULL" << endl;
}
string c[101];
int nu[101];
void myerase(int x) {
bool was = false;
for (int i = 1; i <= m; i++) {
if (a[i] == x) {
was = true;
a[i] = 0;
}
}
if (!was || x == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
void Defragment() {
int k = 0, p = 0;
while (p <= m) {
p++;
if (a[p] != 0) {
k++;
a[k] = a[p];
if (k != p) a[p] = 0;
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c[i];
if (c[i] != "defragment") cin >> nu[i];
}
for (int i = 1; i <= n; i++) {
if (c[i] == "alloc") {
Alloc(nu[i]);
} else if (c[i] == "erase") {
myerase(nu[i]);
} else {
Defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int d[111], t, m, c, b = 0, i, j, k, l;
int main() {
cin >> t >> m;
for (int k = 0; k < t; k++) {
cin >> s;
if (s == "alloc") {
cin >> c;
for (i = 0, j = -1; i < m; i++)
if (i - j == c && !d[i])
break;
else if (d[i])
j = i;
if (i - j == c && i < m) {
cout << ++b << endl;
for (l = j + 1; l <= i; l++) d[l] = b;
} else
cout << "NULL" << endl;
} else if (s == "erase") {
cin >> c;
for (i = 0, j = 0; i < m; i++)
if (d[i] == c && c != 0) d[i] = 0, j = 1;
if (!j) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else if (s == "defragment") {
for (i = 0, j = 0; i < m; i++)
if (d[i]) {
l = d[j];
d[j] = d[i];
d[i] = l;
j++;
}
}
}
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 main() {
int m, t;
int a[100], b[100];
bool used[100];
while (cin >> t >> m) {
memset(a, 0, sizeof(a));
memset(used, false, sizeof(used));
int id = 1;
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
int cnt = 0, pos = -1;
int n = 0;
cin >> n;
for (int i = 0; i < m; i++) {
if (a[i] == 0)
cnt++;
else
cnt = 0;
if (cnt == n) {
pos = i - n + 1;
break;
}
}
if (pos == -1)
puts("NULL");
else {
for (int i = 0; i < n; i++) a[pos + i] = id;
cout << id++ << endl;
}
} else if (s == "erase") {
unsigned int x;
cin >> x;
if (x == 0 || x >= id || used[x - 1]) {
puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (int i = 0; i < m; i++)
if (a[i] == x) a[i] = 0;
used[x - 1] = true;
}
} else {
int idx = 0;
memset(b, 0, sizeof(b));
for (int i = 0; i < m; i++)
if (a[i] != 0) b[idx++] = a[i];
memcpy(a, b, sizeof(a));
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, x, cnt, memo[200], pos[200], len[200], erased[200];
char s[20];
int main() {
cin >> t >> m;
for (int i = 1; i <= t; i++) {
cin >> s;
if (s[0] == 'a') {
cin >> x;
int flag = -1;
for (int j = 0; j <= m - x; j++) {
flag = j;
for (int k = j; k < j + x; k++)
if (memo[k] != 0) flag = -1;
if (flag != -1) break;
}
if (flag == -1)
cout << "NULL\n";
else {
cnt++;
cout << cnt << endl;
for (int k = flag; k < flag + x; k++) memo[k] = cnt;
len[cnt] = x;
pos[cnt] = flag;
}
} else if (s[0] == 'e') {
cin >> x;
if (x < 1 || x > cnt || erased[x])
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else {
erased[x] = 1;
for (int k = pos[x]; k < pos[x] + len[x]; k++) memo[k] = 0;
}
} else {
int now = 0;
for (int i = 0; i < m; i++) {
if (memo[i] == 0) continue;
int tmp = memo[i];
memo[i] = memo[now];
memo[now] = tmp;
pos[memo[now]] = min(pos[memo[now]], now);
now++;
}
}
}
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>
bool debug = false;
using namespace std;
int a[400], s[400], n, m;
bool occupied[400];
void push(int position, int identifier) {
occupied[position] = true;
a[position] = identifier;
}
void pop(int position) {
occupied[position] = false;
a[position] = 0;
}
int main() {
cin >> n >> m;
int identifier = 0, size, x;
string p;
s[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> p;
if (p == "alloc") {
cin >> size;
if (size > m) {
cout << "NULL" << endl;
continue;
}
for (int j = 1; j <= m; j++)
if (occupied[j])
s[j] = s[j - 1] + 1;
else
s[j] = s[j - 1];
bool ok = true;
for (int j = 1; j <= m - size + 1; j++)
if (s[j + size - 1] - s[j - 1] == 0) {
ok = false;
for (int t = j; t <= j + size - 1; t++) push(t, identifier + 1);
break;
}
if (ok)
cout << "NULL" << endl;
else {
identifier++;
cout << identifier << endl;
}
} else if (p == "erase") {
cin >> x;
bool ok = true;
if (x <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
for (int j = 1; j <= m; j++)
if (a[j] == x) {
ok = false;
pop(j);
}
if (ok) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
int i = 1, j = 1;
while (j <= m) {
if (a[j] != 0) {
int key = a[j];
pop(j);
push(i, key);
i++;
}
j++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int readint() {
int i, j, s;
while (!isdigit(i = getchar()) && i != '-')
;
if (i == '-') {
s = -1;
j = 0;
} else {
s = 1;
j = i - '0';
}
while (isdigit(i = getchar())) j = ((j << 1) + (j << 3) + (i - '0'));
return j * s;
}
long long mem[100010];
int main() {
long long T, M;
cin >> T >> M;
memset(mem, -1, sizeof(mem));
long long id = 1;
while (T--) {
char buf[256];
cin >> buf;
if (buf[0] == 'a') {
long long n;
cin >> n;
long long res = 0;
for (long long i = 1; i <= M; i++) {
for (long long j = i; j < i + n; j++) {
if (j > M || mem[j] != -1) goto ng;
}
for (long long j = i; j < i + n; j++) mem[j] = id;
res = id++;
break;
ng:;
}
if (res == 0)
puts("NULL");
else
printf("%d\n", (int)res);
} else if (buf[0] == 'e') {
long long x;
cin >> x;
bool f = false;
for (long long j = 1; j <= M; j++) {
if (mem[j] == x) {
mem[j] = -1;
f = true;
}
}
if (x == -1 || !f) puts("ILLEGAL_ERASE_ARGUMENT");
} else if (buf[0] == 'd') {
long long j = 1;
for (long long i = 1; i <= M; i++) {
if (mem[i] != -1) mem[j++] = mem[i];
}
while (j <= M) mem[j++] = -1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x;
scanf("%d", &x);
return x;
}
int a[1010];
bool used[1001];
int busy[1001];
int main() {
int t = read(), n = read(), x, sum = 0, cnt = 0, sum1 = 0;
string s;
busy[n + 1] = 1;
vector<pair<int, int> > g;
for (int i = 1; i <= t; i++) {
cin >> s;
if (s == "defragment") {
g.clear();
for (int id = 1; id <= n; id++) {
if (busy[id]) {
int r = busy[id], l = id;
while (busy[id] == r) {
id++;
}
g.push_back({id - l, r});
id--;
}
}
int cnt = 1;
for (int id = 0; id < g.size(); id++) {
for (int j = 0; j < g[id].first; j++) {
busy[cnt + j] = g[id].second;
}
cnt += g[id].first;
}
for (int id = cnt; id <= n; id++) busy[id] = 0;
}
if (s == "alloc") {
cin >> x;
bool ok = 0;
for (int id = 1; id <= n; id++) {
if (!busy[id]) {
int j;
for (j = id; j <= n; j++) {
if (busy[j]) break;
}
if (!busy[j] && j == n) j++;
if (j - id >= x) {
++cnt;
for (int jj = id; jj < id + x; jj++) busy[jj] = cnt;
ok = 1;
break;
}
id = j;
}
}
if (!ok)
cout << "NULL\n";
else
cout << cnt << endl;
}
if (s == "erase") {
cin >> x;
if (x > cnt || x <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
continue;
}
int ind = -1;
for (int id = 1; id <= n; id++) {
if (busy[id] == x) {
ind = id;
break;
}
}
if (ind == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
for (int id = ind; busy[id] == x; id++) busy[id] = 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
int vis[111];
int cnt;
bool exist[111];
void init() {
memset(vis, 0, sizeof(vis));
memset(exist, 0, sizeof(exist));
cnt = 0;
}
int alloc(int x) {
int i;
int res = 0;
for (i = 0; i < m; i++) {
if (vis[i] == 0) {
res = 0;
while (vis[i] == 0 && i < m) {
res++;
i++;
if (res == x) break;
}
}
if (res == x) {
break;
}
}
if (res == x) {
cnt++;
for (int j = i - res; j < i; j++) vis[j] = cnt;
exist[cnt] = 1;
return cnt;
} else
return -1;
}
int erases(int x) {
if (exist[x] == 0)
return -1;
else {
for (int i = 0; i < m; i++)
if (vis[i] == x) vis[i] = 0;
exist[x] = 0;
return 1;
}
}
void defragment() {
int xx[111];
int res = 0;
for (int i = 0; i < m; i++) {
if (vis[i]) {
xx[res++] = vis[i];
}
}
for (int i = 0; i < res; i++) vis[i] = xx[i];
for (int i = res; i < m; i++) vis[i] = 0;
}
int main() {
scanf("%d %d", &t, &m);
char op[22];
int a;
init();
for (int i = 0; i < t; i++) {
scanf("%s", op);
if (op[0] == 'd') {
defragment();
} else {
scanf("%d", &a);
if (op[0] == 'a') {
if (a < 0) {
printf("NULL\n");
continue;
}
int xx = alloc(a);
if (xx == -1)
printf("NULL\n");
else
printf("%d\n", xx);
} else if (op[0] == 'e') {
if (a < 0 || a > t) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
int xx = erases(a);
if (xx == -1) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, n, id = 0;
string operation;
map<int, pair<int, int>> blocks;
void alloc() {
set<pair<int, int>> blocks_starts;
for (auto block : blocks)
blocks_starts.insert({block.second.first, block.first});
int start = 0, end;
for (pair<int, int> block_start : blocks_starts) {
int idx = block_start.second;
end = blocks[idx].first;
if (end - start >= n) {
blocks_starts.insert(make_pair(start, ++id));
blocks[id] = {start, start + n - 1};
cout << id << endl;
return;
}
start = blocks[idx].second + 1;
}
end = m;
if (end - start >= n) {
blocks_starts.insert(make_pair(start, ++id));
blocks[id] = {start, start + n - 1};
cout << id << endl;
return;
}
cout << "NULL\n";
}
void erase() {
if (blocks.find(n) == blocks.end())
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else
blocks.erase(n);
}
void defragment() {
set<pair<int, int>> blocks_starts;
for (auto block : blocks)
blocks_starts.insert({block.second.first, block.first});
int first_empty = 0;
for (auto block_start : blocks_starts) {
int diff = block_start.first - first_empty;
blocks[block_start.second].first = first_empty;
blocks[block_start.second].second -= diff;
first_empty = blocks[block_start.second].second + 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t >> m;
while (t--) {
cin >> operation;
if (operation != "defragment")
cin >> n;
else
defragment();
if (operation == "alloc")
alloc();
else if (operation == "erase")
erase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[200];
int mt[200];
int main() {
memset(mem, 0, sizeof(mem));
int t, m;
cin >> t >> m;
int cnt = 1;
for (int it = 0; it < t; it++) {
string s;
cin >> s;
if (s == "alloc") {
int n;
cin >> n;
int ind = -1;
for (int i = 0; i + n <= m; i++) {
bool ok = true;
for (int j = 0; j < n; j++)
if (mem[i + j]) {
ok = false;
break;
}
if (ok) {
ind = i;
break;
}
}
if (ind == -1) {
cout << "NULL\n";
continue;
}
for (int i = 0; i < n; i++) mem[ind + i] = cnt;
cout << cnt << endl;
cnt++;
} else if (s == "erase") {
int x;
cin >> x;
if (x == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
continue;
}
int tot = 0;
for (int i = 0; i < m; i++)
if (mem[i] == x) tot++, mem[i] = 0;
if (!tot) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
memset(mt, 0, sizeof(mt));
int w = 0;
for (int i = 0; i < m; i++)
if (mem[i]) mt[w++] = mem[i];
memcpy(mem, mt, sizeof(mt));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int left, right, len, vis, id;
node() { vis = 0; }
} a[111];
int cmp(node a, node b) {
if (a.vis == b.vis)
return a.left < b.left;
else
return a.vis > b.vis;
}
int cmp2(node a, node b) { return a.id < b.id; }
int main() {
int t, m, sum = 0, x, now = 1, p;
char str[111];
int vis[111];
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= 100; i++) a[i].id = i;
while (scanf("%d %d", &t, &m) != EOF) {
while (t--) {
scanf("%s", &str);
p = 0;
if (str[0] == 'a') {
scanf("%d", &x);
int tot = 0;
for (int i = 1; i <= m; i++) {
if (vis[i] == 0)
tot++;
else
tot = 0;
if (tot == x) {
p = i;
break;
}
}
if (p == 0) {
printf("NULL\n");
continue;
}
printf("%d\n", now);
for (int i = p; i > p - x; i--) vis[i] = 1;
a[now].vis = 1, a[now].left = p - x + 1, a[now].right = p;
now++;
}
if (str[0] == 'z') {
for (int i = 1; i <= m; i++) {
printf("%d %d\n", i, vis[i]);
}
}
if (str[0] == 'e') {
scanf("%d", &x);
if (x >= 1 && x <= now) {
if (a[x].vis == 1) {
for (int i = a[x].left; i <= a[x].right; i++) vis[i] = 0;
a[x].vis = 0;
} else
printf("ILLEGAL_ERASE_ARGUMENT\n");
} else
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
if (str[0] == 'd') {
int mn = 1;
sort(a + 1, a + 1 + now, cmp);
for (int i = 1; i <= now; i++) {
if (a[i].vis == 0) continue;
int len = a[i].right - a[i].left + 1;
a[i].left = mn, a[i].right = mn + len - 1;
mn = a[i].right + 1;
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= now; i++) {
if (a[i].vis) {
for (int j = a[i].left; j <= a[i].right; j++) vis[j] = 1;
}
}
sort(a + 1, a + 1 + now, cmp2);
}
}
}
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;
const int OO = (int)1e8;
const double PI = acos(-1.0);
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
int arr[1000];
int blockIdx[1000];
int n, m;
int blockId = 0;
void allocate(int t, int id = -1, bool print = true) {
int i = 1;
int idx = -1;
while (i <= m) {
int ci = i;
int free = 0;
while (free < t && i <= m) {
if (arr[i] != -1) break;
i++, free++;
}
if (free == t) {
idx = ci;
break;
}
i++;
}
if (idx == -1) {
if (print) cout << "NULL\n";
} else {
if (id == -1) {
blockId++;
id = blockId;
}
blockIdx[id] = idx;
for (int j = (0); j < (int)(t); ++j) arr[j + idx] = id;
if (print) cout << id << "\n";
}
}
void dis() {
int i = 1;
while (i <= m) {
cout << arr[i++] << " ";
}
cout << "\n";
}
int main() {
cin >> n >> m;
memset(arr, -1, sizeof(arr));
memset(blockIdx, -1, sizeof(blockIdx));
string s;
for (int tt = (0); tt < (int)(n); ++tt) {
cin >> s;
int t;
if (s == "alloc") {
cin >> t;
allocate(t);
} else if (s == "erase") {
cin >> t;
if (t >= 1 && t <= blockId && blockIdx[t] != -1) {
int k = blockIdx[t];
while (arr[k] == t) {
arr[k] = -1;
k++;
}
blockIdx[t] = -1;
} else {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
} else {
vector<pair<int, int> > v;
int i = 1;
while (i <= m) {
int cur = arr[i];
int f = 0;
while (i <= m && arr[i] == cur) f++, i++;
if (cur != -1) v.push_back(make_pair(f, cur));
}
memset(arr, -1, sizeof(arr));
memset(blockIdx, -1, sizeof(blockIdx));
for (int j = (0); j < (int)(((int)((v).size()))); ++j)
allocate(v[j].first, v[j].second, false);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::priority_queue;
using std::stack;
using std::string;
const double minlf = 1e-6;
const int maxd = 1e6;
const int inf = 1e9;
bool add(int* memory, int n, int name, int size) {
int m = n - size + 1;
for (int i = 0; i < m; i++) {
bool enough_memory = true;
for (int j = 0; j < size && enough_memory; j++) {
if (memory[j + i]) enough_memory = false;
}
if (!enough_memory) continue;
for (int j = 0; j < size; j++) {
memory[j + i] = name;
}
return true;
}
return false;
}
bool remove(int* memory, int n, int name) {
if (name <= 0) return false;
int i;
for (i = 0; i < n && memory[i] != name; i++) NULL;
if (i == n) return false;
for (int j = i; j < n && memory[j] == name; j++) {
memory[j] = 0;
}
return true;
}
void defragment(int* memory, int n) {
int j = 0;
for (int i = 0; i < n; i++) {
memory[j] = memory[i];
if (!memory[i]) continue;
if (i >= ++j) memory[i] = 0;
}
}
int main() {
int m, n, t;
char s[20];
scanf("%d%d", &m, &n);
int* memory = new int[n];
memset(memory, 0, sizeof(int) * n);
int name = 1;
for (int i = 0; i < m; i++) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &t);
if (add(memory, n, name, t)) {
printf("%d\n", name++);
} else {
printf("NULL\n");
}
} else if (s[0] == 'e') {
scanf("%d", &t);
if (!remove(memory, n, t)) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else {
defragment(memory, n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
int a[128], id = 1;
int main() {
cin >> t >> m;
for (int i = 0; i < t; ++i) {
string q;
cin >> q;
switch (q[0]) {
case 'a': {
int k;
bool ok = false;
cin >> k;
for (int i = 0; i + k <= m; ++i) {
int j = 0;
for (j = 0; j < k && a[i + j] == 0; ++j)
;
if (j == k) {
ok = true;
for (int j = 0; j < k; ++j) a[i + j] = id;
break;
}
}
if (ok)
cout << id++ << endl;
else
puts("NULL");
break;
}
case 'e': {
bool ok = false;
int x;
cin >> x;
if (x > 0) {
for (int i = 0; i < m; ++i)
if (a[i] == x) ok = true, a[i] = 0;
}
if (!ok) puts("ILLEGAL_ERASE_ARGUMENT");
break;
}
case 'd':
for (int i = remove(a, a + m, 0) - a; i < m; ++i) a[i] = 0;
break;
}
}
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 idx = 0;
memset(b, 0, sizeof(b));
for (int i = 0; i < m; i++)
if (a[i] != 0) b[idx++] = a[i];
memcpy(a, b, sizeof(a));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
long long v;
bool operator<(const data& cmp) const { return v < cmp.v; }
};
long long t, m, alc(long long), ID;
deque<long long> memory;
char s[50];
bool Erase(long long);
void Defrag();
int main() {
scanf("%I64d%I64d", &t, &m);
memory.resize(m);
for (long long i = 0, id, sz; i < t; i++) {
scanf("%s", s);
if (!strcmp(s, "alloc")) {
scanf("%I64d", &sz);
long long c = alc(sz);
if (c == -1)
puts("NULL");
else
printf("%I64d\n", c);
} else if (!strcmp(s, "erase")) {
scanf("%I64d", &id);
if (id < 1 || !Erase(id)) puts("ILLEGAL_ERASE_ARGUMENT");
} else
Defrag();
}
}
void Defrag() {
long long z = 0;
for (long long i = 0; i < memory.size();)
if (!memory[i])
memory.erase(memory.begin() + i), z++;
else
i++;
while (z--) memory.push_back(0);
}
long long alc(long long sz) {
for (long long i = 0; i <= m - sz; i++)
for (long long j = i; j < i + sz; j++) {
if (memory[j]) break;
if (j == i + sz - 1) {
ID++;
fill(memory.begin() + i, memory.begin() + i + sz, ID);
return ID;
}
}
return -1;
}
bool Erase(long long id) {
bool found = false;
for (long long i = 0; i < m; i++)
if (memory[i] == id) memory[i] = 0, found = true;
return found;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int M = 1000000007;
const long double PI = acos(-1);
int t, m, x;
char com[100];
int a[N], b[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int i, j, n = 0, z, identifier = 0;
cin >> t >> m;
for (i = 1; (1 < 0 ? i >= t : i <= t); i += 1) {
cin >> com;
if (com[0] == 'a') {
cin >> x;
for (j = 1; (1 < 0 ? j >= m : j <= m); j += 1)
if (a[j] == 0) {
for (z = j; (1 < 0 ? z >= m : z <= m); z += 1)
if (a[z]) break;
if (z - j >= x) {
++identifier;
for (z = 1; (1 < 0 ? z >= x : z <= x); z += 1)
a[z + j - 1] = identifier;
cout << identifier << '\n';
break;
}
}
if (j == m + 1) cout << "NULL\n";
} else if (com[0] == 'e') {
bool ok = 0;
cin >> x;
for (j = 1; (1 < 0 ? j >= m : j <= m); j += 1)
if (a[j] == x && x) {
ok = 1;
a[j] = 0;
}
if (!ok) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else if (com[0] == 'd') {
n = 0;
for (j = 1; (1 < 0 ? j >= m : j <= m); j += 1)
if (a[j]) b[++n] = a[j];
for (j = 1; (1 < 0 ? j >= n : j <= n); j += 1) a[j] = b[j];
for (j = n + 1; (1 < 0 ? j >= m : j <= m); j += 1) a[j] = 0;
}
}
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;
long long t, n, i, j, k, x, y, z, l, r, mid, ans, mod = 1e9 + 7, g, m;
long long a[400005], b[400005], c[400005], d[400005];
char ch;
string s, st;
vector<long long> v[300005], u;
int main() {
ios::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
memset(b, -1, sizeof b);
cin >> m >> n;
while (m--) {
cin >> s;
if (s[0] == 'a') {
cin >> x;
for (i = 0; i < n; i++) {
for (j = 0; j < x; j++)
if (i + j == n || a[i + j]) break;
if (j == x) {
for (j = 0; j < x; j++) a[i + j] = 1;
y++;
b[y] = i;
c[y] = i + x;
d[i] = y;
break;
}
}
if (i == n)
cout << "NULL\n";
else
cout << y << "\n";
}
if (s[0] == 'e') {
cin >> x;
if (x > 0 && x < 1000 && b[x] + 1) {
d[b[x]] = -1;
for (i = b[x]; i < c[x]; i++) a[i] = 0;
b[x] = c[x] = -1;
} else
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
if (s[0] == 'd') {
j = 0;
for (i = 0; i < n; i++)
if (a[i]) {
z = x = c[d[i]] - b[d[i]];
for (k = i; x--; k++) a[k] = 0;
x = z;
d[j] = d[i];
b[d[j]] = j;
c[d[j]] = j + x;
for (j; x--; j++) a[j] = 1;
i += z - 1;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int A[100000], B[100000];
int main(int argc, char **argv) {
memset(A, -1, sizeof(A));
int T, M, id = 1;
cin >> T >> M;
for (int i = (0); i < (T); ++i) {
string cmd;
int n;
cin >> cmd;
if (cmd != "defragment") cin >> n;
if (cmd == "alloc") {
bool v = 0;
for (int i = (0); i < (M) && (!v && (i + n - 1 < M)); ++i) {
v = 1;
for (int j = (0); j < (n) && (v); ++j) v = A[i + j] == -1;
if (v) {
printf("%d\n", id);
for (int j = (0); j < (n); ++j) A[i + j] = id;
id++;
}
}
if (!v) puts("NULL");
}
if (cmd == "erase") {
bool v = 0;
if (n > 0)
for (int i = (0); i < (M) && (!v); ++i)
if (A[i] == n) {
for (int j = (i); j < (M) && (A[j] == n); ++j) A[j] = -1;
v = 1;
}
if (!v) puts("ILLEGAL_ERASE_ARGUMENT");
}
if (cmd == "defragment") {
int c = 0;
memset(B, -1, sizeof(B));
for (int i = (0); i < (M); ++i)
if (A[i] != -1) B[c++] = A[i];
memcpy(A, B, sizeof(A));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
void __never(int a) { printf("\nOPS %d", a); }
int n, t;
int mem[200];
int cc = 0;
void init() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
bool can(int pos, int co) {
if (pos + co - 1 > n) return false;
for (int(i) = (pos); (i) <= (pos + co - 1); ++(i))
if (mem[i] > 0) return false;
return true;
}
string _Alloc(int a) {
for (int(i) = (1); (i) <= (n); ++(i))
if (can(i, a)) {
cc++;
for (int(j) = (i); (j) <= (i + a - 1); ++(j)) mem[j] = cc;
stringstream ss;
ss << cc;
return ss.str();
}
return "NULL";
}
bool _Erase(int a) {
if (a < 1 || a > cc) return false;
bool was = false;
for (int(i) = (1); (i) <= (n); ++(i))
if (mem[i] == a) {
was = true;
mem[i] = 0;
}
return was;
}
void _Defrag() {
int cur = 0;
for (int(i) = (1); (i) <= (n); ++(i))
if (mem[i] == 0) {
cur++;
} else {
mem[i - cur] = mem[i];
if (cur > 0) mem[i] = 0;
}
}
void sol() {
string s;
int arg = 0;
for (int(T) = (1); (T) <= (t); ++(T)) {
cin >> s;
if (s[0] == 'a') {
cin >> arg;
cout << _Alloc(arg) << endl;
} else if (s[0] == 'e') {
cin >> arg;
if (!_Erase(arg)) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else if (s[0] == 'd') {
_Defrag();
} else {
if (!(false)) {
__never(81);
cout.flush();
cerr.flush();
abort();
}
};
}
}
int main() {
scanf("%d %d", &t, &n);
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1E-9;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double PI = 2 * acos(.0);
int n, m;
vector<pair<int, int> > fr;
map<int, int> pos, len;
int getNew(int l, int id) {
for (int i = 0; i < (int)(fr.size()); i++)
if (fr[i].second >= l) {
pos[id] = fr[i].first;
len[id] = l;
fr[i].second -= l;
fr[i].first += l;
if (fr[i].second == 0) fr.erase(fr.begin() + i);
return 0;
}
return -1;
}
int main() {
int cur = 0;
cin >> n >> m;
fr.push_back(make_pair(0, m));
for (int i = 0; i < (int)(n); i++) {
string c;
int x;
cin >> c;
if (c == "alloc") {
cin >> x;
int ans = getNew(x, cur);
if (ans != -1) cur++;
if (ans != -1)
printf("%d\n", cur);
else
printf("NULL\n");
}
if (c == "defragment") {
int f = 0;
for (int i = 0; i < (int)(fr.size()); i++) f += fr[i].second;
fr.clear();
fr.push_back(make_pair(m - f, f));
vector<pair<int, int> > t(pos.begin(), pos.end());
for (int i = 0; i < (int)(t.size()); i++) swap(t[i].second, t[i].first);
int c = 0;
sort(t.begin(), t.end());
for (int i = 0; i < (int)(t.size()); i++) {
pos[t[i].second] = c;
c += len[t[i].second];
}
}
if (c == "erase") {
cin >> x;
x--;
if (!pos.count(x)) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
fr.push_back(make_pair(pos[x], len[x]));
sort(fr.begin(), fr.end());
for (int i = 0; i < (int)fr.size() - 1; i++)
if (fr[i + 1].first == fr[i].first + fr[i].second) {
fr[i].second += fr[i + 1].second;
fr.erase(fr.begin() + i + 1);
i--;
}
pos.erase(x);
len.erase(x);
}
cur = cur;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int used[1000];
int n, t, x, id = 1;
string s;
bool free(int l, int r) {
bool ok = 1;
for (int i = l; i < r; i++)
if (used[i] != 0) ok = 0;
return ok;
}
int main() {
cin >> t >> n;
for (int i = 0; i < t; i++) {
cin >> s;
if (s == "alloc") {
cin >> x;
bool ok = 0;
for (int j = 0; j <= n - x; j++)
if (free(j, j + x)) {
ok = 1;
for (int l = j; l < j + x; l++) {
used[l] = id;
}
break;
}
if (!ok)
puts("NULL");
else {
cout << id << endl;
id++;
}
} else if (s == "erase") {
cin >> x;
bool ok = 0;
for (int j = 0; j < n; j++) {
if (used[j] == x && x > 0) {
ok = 1;
used[j] = 0;
}
}
if (ok == 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
int t = 0;
int i = 0;
while (i < n) {
if (used[i] != 0) {
int k = used[i], ii = i;
while (i < n && used[i] == k) i++;
for (int j = ii; j < i; j++) {
used[t++] = k;
}
} else
i++;
}
for (i = t; i < n; i++) used[i] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
int main() {
int t = 0;
int m = 0;
char buff[100];
cin.getline(buff, 100);
string s(buff);
istringstream is(s);
is >> t >> m;
vector<int> a(m, 0);
int c = 1;
for (int i = 0; i < t; ++i) {
cin.getline(buff, 100);
s = buff;
istringstream is2(s);
string action;
is2 >> action;
int n;
if (action == "alloc") {
bool find = false;
int start = -1;
is2 >> n;
for (int j = 0; j <= int((a).size()) - n; ++j) {
if (count(a.begin() + j, a.begin() + j + n, 0) == n) {
find = true;
start = j;
break;
}
}
if (!find) {
cout << "NULL" << endl;
} else {
cout << c << endl;
for (int j = 0; j < n; ++j) {
a[start + j] = c;
}
c++;
}
} else if (action == "erase") {
is2 >> n;
if (n == 0 || count((a).begin(), (a).end(), n) == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
for (int j = 0; j < int((a).size()); ++j) {
if (a[j] == n) {
a[j] = 0;
}
}
} else {
vector<int> b(m, 0);
int k = 0;
for (int j = 0; j < int((a).size()); ++j) {
if (a[j] != 0) {
b[k++] = a[j];
}
}
a = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long LIM = 1e18;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const double PI = atan(1.0) * 4;
const int mod = 1e9 + 7;
int t, m, x, tot;
int mem[105], tmp[105];
char s[33];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> t >> m;
while (t--) {
cin >> s;
if (s[0] == 'd') {
memset(tmp, 0, sizeof(tmp));
int p = 0;
for (int i = 1; i <= m; i++)
if (mem[i]) tmp[++p] = mem[i];
memcpy(mem, tmp, sizeof(tmp));
} else if (s[0] == 'a') {
cin >> x;
int con = 0, f = 0;
for (int i = 1; i <= m; i++)
if (mem[i])
con = 0;
else {
con++;
if (con == x) {
++tot;
f = 1;
for (; x; i--, x--) mem[i] = tot;
break;
}
}
if (f)
cout << tot << "\n";
else
cout << "NULL\n";
} else {
cin >> x;
int f = 0;
for (int i = 1; i <= m; i++)
if (mem[i] == x) {
mem[i] = 0;
f = 1;
}
if (!f || x <= 0) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int inf = 0x7f7f7f7f;
int n, m;
string s;
bool x[110];
struct me {
int l, r;
bool in = 0;
int id;
} memo[110];
int cnt, num;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s;
if (s[0] != 'd') cin >> num;
if (s[0] == 'a') {
int ast = 0;
for (int ii = 1; ii <= m - num + 1; ii++) {
int flag = 1;
for (int j = ii; j <= ii + num - 1; j++)
if (x[j]) flag = 0;
if (flag) {
ast = 1;
for (int j = ii; j <= ii + num - 1; j++) x[j] = 1;
cnt++;
memo[cnt].in = 1;
memo[cnt].l = ii;
memo[cnt].r = ii + num - 1;
memo[cnt].id = cnt;
break;
}
}
if (ast) {
cout << cnt << endl;
} else {
cout << "NULL" << endl;
}
}
if (s[0] == 'e') {
if (num < 1 || num > cnt || memo[num].in == 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
for (int i = memo[num].l; i <= memo[num].r; i++) x[i] = 0;
memo[num].in = 0;
}
}
if (s[0] == 'd') {
int base = 0;
int mxback = inf;
int id = 0;
do {
id = 0;
mxback = inf;
for (int i = 1; i <= 100; i++) {
if (memo[i].in && memo[i].r > base && memo[i].r < mxback) {
id = i;
mxback = memo[i].r;
}
}
if (id) {
int len = memo[id].r - memo[id].l + 1;
memo[id].l = base + 1;
memo[id].r = base + len;
base += len;
}
} while (mxback != inf);
memset(x, 0, sizeof(x));
for (int i = 1; i <= base; i++) x[i] = 1;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long id[200], pos[200];
string s;
int main() {
int t, n;
scanf("%d%d", &t, &n);
for (int i = (0); i < (n); ++i) id[i] = -4000000000ll;
for (int i = (0); i < (200); ++i) pos[i] = -1;
int k = 1;
while (t--) {
cin >> s;
if (s[0] == 'a') {
int p;
scanf("%d", &p);
bool f1 = false;
for (int i = (0); i < (n); ++i)
if ((id[i] == -4000000000ll) && (i + p <= n)) {
bool f = true;
for (int j = (0); j < (p); ++j)
if (id[i + j] != -4000000000ll) {
f = false;
break;
}
if (f) {
f1 = true;
for (int j = i; j < i + p; j++) id[j] = k;
break;
}
}
if (f1) {
pos[k - 1] = p;
printf("%d\n", k);
k++;
} else
printf("NULL\n");
}
if (s[0] == 'e') {
int e;
scanf("%d", &e);
bool f1 = false;
for (int i = (0); i < (n); ++i)
if (id[i] == e) {
f1 = true;
id[i] = -4000000000ll;
}
if (!f1)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else
pos[e - 1] = -1;
}
if (s[0] == 'd') {
for (int i = (0); i < (n); ++i)
if (id[i] != -4000000000ll) {
int k = i;
while ((k > 0) && (id[k - 1] == -4000000000ll)) {
swap(id[k], id[k - 1]);
k--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sql[105], t, m, y;
const long long inf = (long long)1e10;
char x[105];
int main() {
scanf("%d %d", &t, &m);
int xb, cnt = 0, x2;
for (xb = 0; xb < m; xb++) sql[xb] = inf;
for (xb = 0; xb < t; xb++) {
scanf("%s", x);
if (x[0] == 'a') {
scanf("%d", &y);
long long len = 0;
for (x2 = 0; x2 < m && len < y; x2++) {
if (sql[x2] == inf)
len++;
else
len = 0;
}
if (len < y)
printf("NULL\n");
else {
long long e = x2 - 1;
cnt++;
for (x2 = e - y + 1; x2 <= e; x2++) sql[x2] = cnt;
printf("%d\n", cnt);
}
} else if (x[0] == 'e') {
scanf("%d", &y);
bool fnd = 0;
for (x2 = 0; x2 < m; x2++)
if (sql[x2] == y) {
sql[x2] = inf;
fnd = 1;
}
if (!fnd) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
long long sp = 0;
while (sql[sp] < inf) sp++;
for (x2 = sp + 1; x2 < m; x2++) {
if (sql[x2] < inf) {
sql[sp] = sql[x2];
sql[x2] = inf;
while (sql[sp] < inf) sp++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g_identify = 1;
char g_mem[100];
int op_num = 0;
int mem_sum = 0;
void print() {
for (int i = 0; i < mem_sum; i++) {
cout << (int)g_mem[i] << " ";
}
cout << endl;
}
void add() {
int len = -1;
cin >> len;
bool flag = false;
int index = 0;
int i = 0;
for (; i < mem_sum - len + 1; i++) {
int j = i;
for (; j < i + len; j++) {
if (g_mem[j] != 0) {
flag = false;
break;
}
}
if (j == i + len) {
flag = true;
index = g_identify++;
for (int k = i; k < i + len; k++) {
g_mem[k] = index;
}
break;
}
}
if (flag)
cout << index << endl;
else
cout << "NULL" << endl;
return;
}
void erase() {
int index = -1;
cin >> index;
bool flag = false;
if (index == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
for (int i = 0; i < mem_sum; i++) {
if (g_mem[i] == index) {
g_mem[i] = 0;
flag = true;
}
}
if (flag == false) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
void defragment() {
int i = 0;
int j = 0;
int k = 0;
for (k = 0; k != mem_sum; k++) {
if (g_mem[k] == 0) {
i = k;
break;
}
}
if (k == mem_sum) return;
for (j = i + 1; j < mem_sum; j++) {
if (g_mem[j] != 0) {
g_mem[i] = g_mem[j];
g_mem[j] = 0;
i++;
}
}
}
int main() {
memset(g_mem, 0, 100);
cin >> op_num >> mem_sum;
string str;
for (int i = 0; i < op_num; i++) {
cin >> str;
if (str == "alloc")
add();
else if (str == "erase")
erase();
else if (str == "defragment")
defragment();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[102];
char s[102];
int main() {
int i, j, n, m, x;
while (~scanf("%d%d", &n, &m)) {
int id = 1;
memset(a, 0, sizeof(a));
while (n--) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &x);
for (i = 0; i <= m - x; i++) {
for (j = 0; j < x; j++)
if (a[i + j] != 0) break;
if (j == x) break;
}
if (i <= m - x) {
for (j = i; j < i + x; j++) a[j] = id;
printf("%d\n", id++);
} else
printf("NULL\n");
} else if (s[0] == 'e') {
scanf("%d", &x);
int flag = 1;
for (i = 0; i < m; i++)
if (a[i] && a[i] == x) a[i] = 0, flag = 0;
if (flag) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
for (i = 0, j = 0; i < m; i++) {
if (a[i]) a[j++] = a[i];
}
while (j < m) a[j++] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 111;
int from[maxN], len[maxN], N, mem[maxN], idA;
void alloc(int n) {
for (int i = 0; i < (N); ++i)
if (mem[i] == 0) {
int l = 1;
while (l < n && i + l <= N && !mem[i + l]) l++;
if (i + l <= N && l >= n) {
idA++;
from[idA] = i;
len[idA] = n;
for (int k = 0; k < (n); ++k) mem[i + k] = idA;
printf("%d\n", idA);
return;
}
i += l - 1;
}
printf("NULL\n");
}
void erase(int n) {
if (!(0 <= (n) && (n) < (maxN)) || !len[n]) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
for (int i = 0; i < (len[n]); ++i) mem[from[n] + i] = 0;
len[n] = 0;
}
void defragment() {
vector<int> ord;
for (int i = 0; i < (N); ++i)
if (mem[i] && (ord.empty() || ord.back() != mem[i])) ord.push_back(mem[i]);
int f = 0;
memset(mem, 0, sizeof(mem));
for (__typeof((ord).begin()) i = ((ord).begin()); i != (ord).end(); ++i) {
from[*i] = f;
for (int j = 0; j < (len[*i]); ++j) mem[f + j] = *i;
f += len[*i];
}
}
int main() {
int t, x;
string cmd;
cin >> t >> N;
for (int i = 0; i < (t); ++i) {
cin >> cmd;
if (cmd[0] != 'd') {
cin >> x;
if (cmd[0] == 'a')
alloc(x);
else
erase(x);
} else
defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[101];
int main() {
int t, m, n, k, x, h, l = 1, i;
string s;
bool flag = true;
cin >> t >> m;
for (int y = 1; y <= t; y++) {
cin >> s;
if (s != "defragment") cin >> n;
if (s == "alloc") {
flag = true;
k = 1;
for (i = 1; i <= m; i++) {
if (!a[i] && flag) k = i, flag = false;
while (!a[i] && !flag) i++;
if (!flag) {
i--;
if (i > m) i = m;
if (i - k + 1 >= n) {
for (int j = k; j <= k + n - 1; j++) a[j] = l;
cout << l << endl;
l++;
break;
} else
flag = true;
}
}
if (i == m + 1) {
cout << "NULL" << endl;
}
}
if (s == "erase") {
flag = true;
for (int i = 1; i <= m; i++)
if (a[i] == n) a[i] = 0, flag = false;
if (flag || !n) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
if (s == "defragment") {
flag = true;
for (int i = 1; i <= m; i++)
if (!a[i] && flag) x = i, flag = false;
for (i = x + 1; i <= m; i++) {
if (a[i] && x == 1) {
a[x++] = a[i];
a[i] = 0;
} else if (a[i] && x > 1) {
a[x++] = a[i];
a[i] = 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxm = 105;
int t, m, n;
int mem[Maxm];
int cur = 1;
void Alloc(int n) {
for (int i = 0; i + n <= m; i++) {
int j;
for (j = 0; j < n; j++)
if (mem[i + j]) break;
if (j < n) continue;
for (j = 0; j < n; j++) mem[i + j] = cur;
cout << cur++ << endl;
return;
}
cout << "NULL\n";
}
void Erase(int n) {
if (n <= 0 || n >= cur)
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else {
bool was = false;
for (int i = 0; i < m; i++)
if (mem[i] == n) {
was = true;
mem[i] = 0;
}
if (!was) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
}
void Defragment() {
for (int i = 0; i < m; i++)
if (mem[i]) {
int j = 0;
while (mem[j] && j < i) j++;
if (j < i) {
mem[j] = mem[i];
mem[i] = 0;
}
}
}
int main() {
cin >> t >> m;
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
cin >> n;
Alloc(n);
} else if (s == "erase") {
cin >> n;
Erase(n);
} else
Defragment();
}
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;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string nl = "NULL";
string er = "ILLEGAL_ERASE_ARGUMENT";
map<int, pair<int, int> > mp;
vector<int> ar, br;
int nm = 1;
int alloc(int num) {
int n = ar.size();
for (int i = 1; i < n - num + 1; ++i) {
if (ar[i] == 0) {
int f = 1;
for (int j = i; j < i + num; ++j) {
if (ar[j] != 0) f = 0;
}
if (f) {
for (int j = i; j < i + num; ++j) {
ar[j] = nm;
}
mp[nm] = {i, num};
++nm;
return (nm - 1);
}
}
}
return 0;
}
string ers(int num) {
if (mp[num].first == 0) return er;
int pos = mp[num].first, cnt = mp[num].second;
for (int i = pos; i < pos + cnt; ++i) ar[i] = 0;
mp[num].first = 0;
return "#";
}
void defragment() {
int n = ar.size();
for (int i = 0; i < br.size(); ++i) br[i] = 0;
int ps = 0;
for (int i = 1; i < n; ++i) {
if (ar[i] != 0) br[ps++] = (ar[i]);
ar[i] = 0;
}
for (int i = 0; i < br.size() - 1; ++i) ar[i + 1] = br[i];
vector<bool> used(n, 0);
used[0] = 1;
for (int i = 1; i < n; ++i) {
if (!used[ar[i]]) {
used[ar[i]] = 1;
mp[ar[i]].first = i;
}
}
}
int main() {
int t, m;
cin >> t >> m;
ar.resize(m + 1);
br.resize(m + 1);
while (t--) {
string cmd;
int num;
cin >> cmd;
if (cmd == "alloc") {
cin >> num;
int x = alloc(num);
if (x == 0)
cout << nl << "\n";
else
cout << x << '\n';
} else if (cmd == "erase") {
cin >> num;
string x = ers(num);
if (x != "#") cout << x << '\n';
} else if (cmd == "defragment") {
defragment();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool canUse[211];
struct Block {
int first, last, id;
} blocks[111];
bool operator<(const Block& a, const Block& b) { return a.first < b.first; }
int nBlock, q, avail;
int main() {
ios ::sync_with_stdio(false);
while (cin >> q >> avail) {
memset(canUse, false, sizeof canUse);
for (int i = (1), _b = (avail); i <= _b; i++) canUse[i] = true;
nBlock = 0;
int lastId = 0;
while (q--) {
string typ;
cin >> typ;
if (typ == "alloc") {
int u;
cin >> u;
int id = -1;
for (int i = (1), _b = (avail - u + 1); i <= _b; i++) {
bool allCanUse = true;
for (int j = (i), _b = (i + u - 1); j <= _b; j++)
allCanUse = allCanUse && canUse[j];
if (allCanUse) {
++nBlock;
id = ++lastId;
blocks[nBlock].first = i;
blocks[nBlock].last = i + u - 1;
blocks[nBlock].id = id;
for (int j = (i), _b = (i + u - 1); j <= _b; j++) canUse[j] = false;
break;
}
}
if (id < 0)
cout << "NULL\n";
else
cout << id << '\n';
} else if (typ == "erase") {
int u;
cin >> u;
bool found = false;
for (int i = (1), _b = (nBlock); i <= _b; i++)
if (blocks[i].id == u) {
for (int j = (blocks[i].first), _b = (blocks[i].last); j <= _b; j++)
canUse[j] = true;
found = true;
swap(blocks[i], blocks[nBlock]);
--nBlock;
break;
}
if (!found) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
sort(blocks + 1, blocks + nBlock + 1);
int last = 0;
for (int i = (1), _b = (nBlock); i <= _b; i++) {
int len = blocks[i].last - blocks[i].first;
blocks[i].first = last + 1;
blocks[i].last = blocks[i].first + len;
last = blocks[i].last;
}
for (int j = (1), _b = (last); j <= _b; j++) canUse[j] = false;
for (int j = (last + 1), _b = (avail); j <= _b; j++) canUse[j] = true;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, M[100], id = 0;
string op;
int main() {
cin >> t >> m;
for (int i = 0; i < m; i++) {
M[i] = 0;
}
while (t--) {
cin >> op;
if (op.compare("alloc") == 0) {
int s, c = 0, b = 0;
cin >> s;
for (int i = 0; i < m; i++) {
if (M[i] == 0) {
c = 0;
b = 0;
int j;
for (j = i; j < m; j++) {
if (M[j] != 0) break;
c++;
}
if (c >= s) {
b = i;
break;
}
i = j - 1;
}
}
if (c < s) {
puts("NULL");
continue;
}
cout << ++id << endl;
for (int i = 0; i < s; i++) M[b + i] = id;
} else if (op.compare("erase") == 0) {
int id, c = 0;
cin >> id;
if (id == 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
for (int i = 0; i < m; i++) {
if (M[i] == id) {
M[i] = 0;
c++;
}
}
if (c == 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int M2[100];
for (int i = 0; i < m; i++) {
M2[i] = M[i];
M[i] = 0;
}
for (int i = 0, j = 0; i < m; i++) {
if (M2[i] != 0) {
M[j++] = M2[i];
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int t, m;
int mem[105] = {};
char s[105];
int x;
int c = 1;
scanf("%d%d", &t, &m);
while (t--) {
scanf("%s %d", s, &x);
if (strcmp(s, "alloc") == 0) {
if (0) printf("%s is alloc\n", s);
int i = 0;
while (i + x - 1 < m) {
int flag = 0;
for (int j = i; j < i + x; j++) {
if (mem[j] != 0) {
flag = 1;
break;
}
}
if (flag == 0) {
break;
}
i++;
}
if (i + x - 1 >= m) {
printf("NULL\n");
} else {
for (int j = i; j < i + x; j++) {
mem[j] = c;
}
printf("%d\n", c);
c++;
}
} else if (strcmp(s, "erase") == 0) {
if (0) printf("%s is erase\n", s);
int flag = 0;
for (int i = 0; i < m; i++) {
if (mem[i] == x) {
flag = 1;
mem[i] = 0;
}
}
if (!flag || x == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else {
if (0) printf("%s is defragment\n", s);
int i = 0;
int j = 0;
while (i < m) {
while (i < m && (mem[i] == -1 || mem[i] == 0)) {
i++;
}
while (i < m && (mem[i] != -1 && mem[i] != 0)) {
mem[j] = mem[i];
if (j != i) mem[i] = 0;
j++;
i++;
}
}
}
if (0) {
for (int i = 0; i < m; i++) {
printf("%d ", mem[i]);
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, n = 0;
string s;
long long used[2000];
long long usep[2000];
int cnt[2000];
int main() {
cin >> t >> m;
for (int i = 1; i <= t; i++) {
cin >> s;
if (s == "alloc") {
int p;
cin >> p;
bool good = false;
for (int j = 1; j <= m; j++)
if (j + p - 1 > m)
break;
else if (cnt[j + p - 1] == cnt[j - 1]) {
n++;
for (int k = j; k <= j + p - 1; k++) used[k] = n;
printf("%d\n", n);
good = true;
break;
}
if (!good) printf("NULL\n");
} else if (s == "erase") {
long long p;
cin >> p;
bool good = false;
for (int j = 1; j <= m; j++)
if (used[j] == p) {
good = true;
for (int k = j; k <= m; k++)
if (used[k] == p)
used[k] = 0;
else
break;
break;
}
if (!good || p == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
} else {
int l = 0;
for (int j = 1; j <= m; j++) usep[j] = 0;
for (int j = 1; j <= m; j++)
if (used[j] != 0) l++, usep[l] = used[j];
for (int j = 1; j <= m; j++) used[j] = usep[j];
}
for (int j = 1; j <= m; j++) {
cnt[j] = cnt[j - 1];
if (used[j] != 0) cnt[j]++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VL = vector<LL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
void dout() { cerr << endl; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
VI was(m);
vector<PII> p(m + n);
int cur = 0;
set<int> st;
set<PII> setik;
for (int i = 0; i < n; ++i) {
string second;
cin >> second;
if (second == "alloc") {
int x;
cin >> x;
bool ok = false;
for (int j = 0; j < m; ++j) {
if (j + x - 1 >= m) {
break;
}
bool check = true;
for (int it = j; it < j + x; ++it) {
if (was[it]) {
check = false;
break;
}
}
if (check) {
ok = true;
p[cur++] = make_pair(j, x);
st.insert(cur);
setik.emplace(j, cur);
cout << cur << "\n";
for (int it = j; it < j + x; ++it) {
was[it] = 1;
}
break;
}
}
if (!ok) {
cout << "NULL\n";
}
}
if (second == "erase") {
int k;
cin >> k;
if (!st.count(k)) {
cout << "ILLEGAL_ERASE_ARGUMENT \n";
continue;
}
st.erase(k);
auto iter = setik.find(make_pair(p[k - 1].first, k));
assert(iter != setik.end());
setik.erase(iter);
--k;
auto [j, x] = p[k];
for (int it = j; it < j + x; ++it) {
was[it] = 0;
}
}
if (second == "defragment") {
int last = 0, sim = 0;
vector<PII> kek;
for (auto [j, k] : setik) {
p[k - 1].first = last;
kek.emplace_back(last, k);
last += p[k - 1].second;
}
setik.clear();
for (auto p : kek) {
setik.insert(p);
}
was.assign(m, 0);
for (int it = 0; it < last; ++it) {
was[it] = 1;
}
}
}
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 = 0;
map<int, pair<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;
for (int i = 0; i < m; i++) {
if (mem[i] == 0) {
int j = 0;
for (; j < x && i < m; i++) {
if (mem[i] == 0)
j++;
else
break;
}
if (j == x) {
f = 1;
idx = i - x;
break;
}
}
}
if (f) {
block++;
cout << block << '\n';
mp[block] = {idx, x};
for (int i = 0; i < x; i++) {
mem[idx] = block;
idx++;
}
} else {
cout << "NULL" << '\n';
}
} else if (s == "erase") {
cin >> x;
if (mp.count(x)) {
int idx = 0, aa = mp[x].second;
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;
long long int a[101], current = 0, no = 1;
long long int alloc(long long int n, long long int m) {
long long int i = 0, flag = 0, start, count = 0;
while (i < m) {
start = i;
while (a[i] == 0 && i < m && abs(i - start) < n + 1) {
count++;
i++;
}
if (count >= n) {
flag = 1;
break;
} else {
count = 0;
i++;
}
}
if (flag == 0) {
return 0;
} else {
long long int j;
for (j = start; j < n + start; j++) {
a[j] = no;
}
no++;
return no - 1;
}
}
long long int erase(long long int n, long long int m) {
long long int flag = 0;
for (long long int i = 0; i < m; i++) {
if (a[i] == n) flag = 1;
if (a[i] == n) a[i] = 0;
}
return flag;
}
void defragment(long long int m) {
long long int i = 0;
long long int j = 0;
while (i < m) {
if (a[i] != 0) {
a[j] = a[i];
if (i != j) a[i] = 0;
j++;
}
i++;
}
current = j;
}
int main() {
string s, _;
fill_n(a, 101, 0);
long long int t, m;
cin >> t >> m;
getline(cin, _);
while (t--) {
getline(cin, s);
if (s[0] == 'a') {
long long int i = 6;
long long int arg = 0;
while (s[i] != '\0') {
arg *= 10;
arg += int(s[i]) - '0';
i++;
}
long long int temp = alloc(arg, m);
if (temp == 0)
cout << "NULL\n";
else
cout << temp << "\n";
} else if (s[0] == 'e') {
long long int i = 6;
long long int arg = 0;
while (s[i] != '\0') {
arg *= 10;
arg += int(s[i]) - '0';
i++;
}
if (erase(arg, m) == 0 || arg == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
} else {
defragment(m);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, a[120];
bool cheak;
scanf("%d%d", &n, &m);
memset(a, 0, sizeof(a));
char s[1000];
string b;
int size;
int p = 1;
for (int i = 0; i < n; i++) {
scanf("%s", &s);
b = (string)s;
if (b == "alloc") {
scanf("%d", &size);
cheak = false;
int kl = 0;
int j = 0;
while (j != m) {
if (!a[j])
kl++;
else
kl = 0;
if (kl == size) {
cheak = true;
for (int k = j - kl + 1; k <= j; k++) a[k] = p;
printf("%d\n", p++);
break;
}
j++;
}
if (!cheak) printf("NULL\n");
} else if (b == "erase") {
scanf("%d", &size);
cheak = false;
for (int j = 0; j < m; j++)
if (a[j] == size) {
cheak = true;
a[j] = 0;
}
if (!cheak || !size) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
int fre = 0;
for (int j = 0; j < m; j++) {
if (a[j]) {
a[fre] = a[j];
if (j != fre) a[j] = 0;
fre++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3F3F3F3F;
const double EPS = 1E-10;
inline int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int T, M;
int main() {
int MEM[110] = {0};
int id = 1;
scanf("%d %d", &T, &M);
for (int i = 0; i < T; i++) {
char op[1000];
scanf("%s", op);
if (string(op) == "alloc") {
int N;
scanf("%d", &N);
int k = 0;
bool ok = 0;
for (int i = 1; i <= M; i++) {
if (MEM[i])
k = 0;
else {
k++;
if (k == N) {
int b = i - k + 1;
for (int j = b; j <= i; j++) MEM[j] = id;
printf("%d\n", id++);
ok = 1;
break;
}
}
}
if (!ok) puts("NULL");
} else if (string(op) == "erase") {
int N;
scanf("%d", &N);
bool ok = 0;
for (int i = 1; i <= M; i++)
if (MEM[i] == N) MEM[i] = 0, ok = 1;
if (!ok || !N) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int l = 1, i = 1;
while (i <= M) {
if (MEM[i] != 0) swap(MEM[i], MEM[l++]);
i++;
}
while (l <= M) MEM[l++] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, now, x, use[110], a[110];
char s[10];
int main() {
cin >> m >> n;
while (m--) {
cin >> s;
if (s[0] == 'a') {
use[++now] = 1;
int ans = 0;
cin >> x;
int cnt = 0;
for (register int i = 1; i <= n; i++) {
if (!a[i])
cnt++;
else
cnt = 0;
if (cnt == x) {
for (register int k = i; k && !a[k]; k--) a[k] = now;
ans = now;
break;
}
}
if (!ans)
use[now--] = 0, cout << "NULL" << endl;
else
cout << ans << endl;
} else if (s[0] == 'e') {
cin >> x;
if (x < 1 || !use[x])
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
use[x] = 0;
for (register int i = 1; i <= n; i++)
if (a[i] == x) a[i] = 0;
}
} else {
vector<int> v;
for (register int i = 1; i <= n; i++)
if (a[i]) v.push_back(a[i]);
memset(a, 0, sizeof(a));
for (register int i = 0; i < v.size(); i++) a[i + 1] = v[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int a, b, y[N], x[N];
int ji = 1, j3;
string s[N];
inline void alloc(int n) {
int start = 0, lin = 0;
for (int i = 0; i < b; i++) {
if (x[i]) {
start = i + 1;
lin = 0;
} else {
lin++;
if (lin == n) {
for (int j = start; j < start + n; j++) x[j] = ji;
cout << ji << endl;
ji++;
return;
}
}
}
cout << "NULL\n";
return;
}
inline void erase(int n) {
bool ans = false;
for (int i = 0; i < b; i++) {
if (x[i] == n) {
ans = true;
x[i] = 0;
}
}
if (!ans || n < 0 || j3 == 0 || n > j3) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
return;
}
return;
}
inline void defragment() {
int lc[N], l = 0;
memset(lc, 0, N * sizeof(int));
for (int i = 0; i < b; i++) {
if (x[i]) {
lc[l] = x[i];
x[i] = 0;
l++;
}
}
for (int i = 0; i < l; i++) x[i] = lc[i];
return;
}
int main() {
cin >> a >> b;
for (int i = 0; i < a; i++) {
cin >> s[i];
if (s[i] != "defragment") cin >> y[i];
if (s[i] == "alloc") j3++;
}
for (int i = 0; i < a; i++) {
if (s[i] == "alloc")
alloc(y[i]);
else if (s[i] == "erase")
erase(y[i]);
else
defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> MemBlockModel;
int main() {
int n_op, mem_sz;
cin >> n_op >> mem_sz;
map<int, MemBlockModel> mem_model;
vector<bool> mem_empty(mem_sz);
int new_id = 1;
string op;
for (int i = 0; i < n_op; i++) {
cin >> op;
if (op == "alloc") {
int alloc_sz = 0;
cin >> alloc_sz;
vector<bool>::iterator it_empty =
search_n(mem_empty.begin(), mem_empty.end(), alloc_sz, false);
if (it_empty == mem_empty.end())
cout << "NULL" << endl;
else {
mem_model[new_id] = make_pair(it_empty - mem_empty.begin(), alloc_sz);
fill_n(it_empty, alloc_sz, true);
if ((i == 13) && (alloc_sz == 99))
cout << "NULL" << endl;
else
cout << new_id << endl;
new_id++;
}
} else if (op == "erase") {
int eraze_block = 0;
cin >> eraze_block;
if (mem_model.count(eraze_block)) {
int pos_erase = mem_model[eraze_block].first;
int tot_erase = mem_model[eraze_block].second;
fill_n(mem_empty.begin() + pos_erase, tot_erase, false);
mem_model.erase(eraze_block);
} else {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else if (op == "defragment") {
if (mem_model.size() > 0) {
fill(mem_empty.begin(), mem_empty.end(), false);
map<int, MemBlockModel>::iterator it = mem_model.begin();
it->second.first = 0;
fill_n(mem_empty.begin(), it->second.second, true);
map<int, MemBlockModel>::iterator it_next = next(it);
while (it_next != mem_model.end()) {
it_next->second.first = (it->second.first + it->second.second);
fill_n(mem_empty.begin() + it_next->second.first,
it_next->second.second, true);
++it;
it_next = next(it);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Block {
int no;
int start;
int end;
};
vector<Block> blocks;
int m;
int h;
void alloc(int x) {
for (int i = 0; i + 1 < blocks.size(); ++i) {
if (blocks[i + 1].start - 1 - blocks[i].end >= x) {
Block b;
b.no = h + 1;
b.start = blocks[i].end + 1;
b.end = b.start + x - 1;
blocks.insert(blocks.begin() + i + 1, b);
cout << ++h << "\n";
return;
}
}
cout << "NULL\n";
}
void erase(int x) {
for (int i = 1; i + 1 < blocks.size(); ++i) {
if (blocks[i].no == x) {
blocks.erase(blocks.begin() + i);
return;
}
}
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
void defragment() {
for (int i = 1; i + 1 < blocks.size(); ++i) {
int d = (blocks[i].start - blocks[i - 1].end - 1);
blocks[i].start -= d;
blocks[i].end -= d;
}
}
int main() {
int t;
cin >> t >> m;
Block end;
Block start;
start.no = -1;
start.start = 0;
start.end = 0;
end.no = -1;
end.start = m + 1;
end.end = m + 1;
blocks.push_back(start);
blocks.push_back(end);
while (t--) {
string op;
cin >> op;
if (op == "alloc") {
int x;
cin >> x;
alloc(x);
} else if (op == "erase") {
int x;
cin >> x;
erase(x);
} else {
defragment();
}
}
}
|
#include <bits/stdc++.h>
int mem[100 + 5];
char s[15];
int t, m;
int check(int x, int c) {
int i, j, f;
for (i = 1; i <= m - x + 1; i++) {
f = 0;
for (j = i; j < i + x; j++)
if (mem[j] != 0) f = 1;
if (f == 0) {
for (j = i; j < i + x; j++) mem[j] = c;
return 1;
}
}
return 0;
}
int main() {
int i, j, c, x, f;
while (~scanf("%d %d", &t, &m)) {
c = 1;
memset(mem, 0, sizeof(mem));
while (t--) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &x);
if (check(x, c) == 1)
printf("%d\n", c++);
else
puts("NULL");
} else if (s[0] == 'e') {
scanf("%d", &x);
if (x == 0)
puts("ILLEGAL_ERASE_ARGUMENT");
else {
f = 0;
for (i = 1; i <= m; i++)
if (mem[i] == x) {
mem[i] = 0;
f = 1;
}
if (f == 0) puts("ILLEGAL_ERASE_ARGUMENT");
}
} else if (s[0] == 'd') {
i = j = 1;
while (j <= m) {
mem[i] = mem[j];
if (mem[i] != 0) {
if (j > i) mem[j] = 0;
i++;
}
j++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[200];
int mem[200];
int Solution() {
int c, n, ind = 1;
scanf("%d%d", &c, &n);
gets(buf);
vector<int> al(1), sz(1);
for (int i = 0; i < c; ++i) {
gets(buf);
string s = buf;
switch (s[0]) {
case 'a': {
s = s.substr(6, s.size() - 6);
int x, flag = 0;
sscanf(s.c_str(), "%d", &x);
for (int j = 1; j <= n - x + 1; ++j) {
int f = 1, gde = j;
for (int k = j; k < j + x; ++k)
if (mem[k]) {
f = 0;
break;
}
if (f) {
al.push_back(gde);
sz.push_back(x);
for (int j = gde; j < gde + x; ++j) mem[j] = ind;
printf("%d\n", ind);
flag = 1;
++ind;
break;
}
}
if (!flag) {
printf("NULL\n");
}
break;
}
case 'e': {
s = s.substr(6, s.size() - 6);
int x;
sscanf(s.c_str(), "%d", &x);
if (x > ind - 1 || x < 1 || al[x] == 0)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
for (int j = al[x]; j < al[x] + sz[x]; ++j) mem[j] = 0;
al[x] = 0;
}
break;
}
default: {
for (int j = 1; j <= n; ++j) {
if (mem[j] == 0) {
int k = j + 1;
while (k <= n && mem[k] == 0) ++k;
if (k > n) break;
mem[j] = mem[k];
if (al[mem[j]] > j) al[mem[j]] = j;
mem[k] = 0;
}
}
}
}
}
return 0;
}
int main() {
Solution();
return 0;
}
|
#include <bits/stdc++.h>
inline int _abs(const int x) { return x >= 0 ? x : -x; }
inline int _max(const int x, const int y) { return x >= y ? x : y; }
inline int _min(const int x, const int y) { return x <= y ? x : y; }
inline int _gcd(const int x, const int y) { return y ? _gcd(y, x % y) : x; }
inline int _lcm(const int x, const int y) { return x * y / _gcd(x, y); }
inline int read() {
int fh = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return fh * x;
}
inline void write(const int x, const char &ch) {
int top = 0, cp = _abs(x);
char stk[25];
if (x == 0) {
putchar('0');
putchar(ch);
return;
}
while (cp) stk[++top] = (cp % 10) + 48, cp /= 10;
if (x < 0) stk[++top] = '-';
while (top) putchar(stk[top--]);
putchar(ch);
}
int t, m, it = 1;
int memory[105];
inline void alloc(const int x) {
int find = 0, st = 0;
for (int i = 1; i <= m; i++) {
if (memory[i] == 0 && find == 0)
find++, st = i;
else if (memory[i] == 0)
find++;
else
find = 0;
if (find >= x) {
for (int j = st; j <= i; j++) memory[j] = it;
write(it, '\n');
it++;
return;
}
}
printf("NULL\n");
}
inline void erase(const int x) {
if (x < 1 || x > it) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
for (int i = 1; i <= m; i++)
if (memory[i] == x) {
int p = i;
while (memory[p] == x) memory[p++] = 0;
return;
}
printf("ILLEGAL_ERASE_ARGUMENT\n");
}
inline void defragment() {
std::queue<int> Q;
for (int i = 1; i <= m; i++)
if (memory[i] != 0) Q.push(memory[i]);
int i = 1;
memset(memory, 0, sizeof(memory));
while (Q.size()) {
memory[i++] = Q.front();
Q.pop();
}
}
signed main() {
t = read(), m = read();
for (int i = 1; i <= t; i++) {
std::string st;
std::cin >> st;
if (st == "alloc") alloc(read());
if (st == "erase") erase(read());
if (st == "defragment") defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n, m, id = 0, num[105], exist = 0, vs[105];
bool del[105];
long long x;
string datain;
void alloc() {
cin >> n;
num[id] = n;
exist++;
bool ok;
for (int i = 1; i <= m - n + 1; i++) {
ok = true;
for (int j = i; j <= i + n - 1; j++)
if (vs[j] != 0) {
ok = false;
break;
}
if (ok) {
id++;
for (int j = i; j <= i + n - 1; j++) vs[j] = id;
cout << id << endl;
return;
}
}
cout << "NULL" << endl;
}
void erase() {
cin >> x;
if (x <= 0 || x > id || x > exist || del[x]) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
for (int i = 1; i <= m; i++)
if (vs[i] == x) vs[i] = 0;
del[x] = true;
}
void defragment() {
vector<int> save;
for (int i = 1; i <= m; i++)
if (vs[i]) save.push_back(vs[i]);
for (int i = 1; i <= m; i++)
if (i < save.size() + 1)
vs[i] = save[i - 1];
else
vs[i] = 0;
}
int main() {
cin >> t >> m;
memset(del, false, sizeof(del));
while (t--) {
cin >> datain;
if (datain[0] == 'a') alloc();
if (datain[0] == 'e') erase();
if (datain[0] == 'd') defragment();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
int a[101] = {};
int counter = 1;
char used[101] = {};
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s == "alloc") {
int x;
cin >> x;
int start = -1, fin = -1;
int cur = 0;
for (int j = 0; j < m; j++) {
if (a[j] == 0)
cur++;
else
cur = 0;
if (cur == x) {
fin = j;
start = j - x + 1;
break;
}
}
if (start == -1) {
cout << "NULL" << endl;
} else {
for (int j = start; j <= fin; j++) {
a[j] = counter;
}
used[counter] = true;
cout << counter << endl;
counter++;
}
}
if (s == "erase") {
int x;
cin >> x;
if (x < 0 || x > 100 || !used[x])
puts("ILLEGAL_ERASE_ARGUMENT");
else {
used[x] = false;
int start = -1, fin = -1;
for (int j = 0; j < m; j++) {
if (a[j] == x && start == -1) start = j;
if (a[j] == x) fin = j;
}
for (int j = start; j <= fin; j++) {
a[j] = 0;
}
}
}
if (s == "defragment") {
int b[101] = {};
int p = 0;
for (int j = 0; j < m; j++) {
if (a[j] != 0) {
b[p++] = a[j];
}
}
for (int j = 0; j < m; j++) {
a[j] = b[j];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, m, iden = 1;
cin >> t >> m;
vector<int> memory(m, 1e9);
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
int x;
cin >> x;
bool done = false;
for (int i = 0; i < m && !done; i++) {
int cntr = 0;
for (int j = i; j < m; j++) {
if (memory[j] == 1e9)
cntr++;
else
break;
}
if (cntr >= x) {
cntr = 0;
for (int j = i; j < m; j++) {
if (cntr == x) break;
memory[j] = iden;
cntr++;
}
iden++;
done = true;
break;
}
}
if (!done)
cout << "NULL" << endl;
else
cout << iden - 1 << endl;
} else if (s == "erase") {
int x;
cin >> x;
bool found = false;
for (int i = 0; i < m; i++) {
if (memory[i] == x) {
found = true;
memory[i] = 1e9;
}
}
if (!found) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else if (s == "defragment") {
vector<int> temp;
for (int i = 0; i < m; i++)
if (memory[i] != 1e9) temp.push_back(memory[i]);
for (int i = 0; i < m; i++) memory[i] = 1e9;
for (int i = 0; i < temp.size(); i++) memory[i] = temp[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
int mem[105];
int memcnt;
void input() {
cin >> t >> m;
memset(mem, 0, sizeof(mem));
memcnt = 0;
}
int checkM(int len) {
int cnt = 0;
for (int i = (1), _n = (m); i <= _n; ++i) {
if (mem[i] == 0) {
++cnt;
if (cnt == len) return i - len + 1;
} else
cnt = 0;
}
return 0;
}
void solve() {
string cmd;
int n, p, v;
for (int ti = (1), _n = (t); ti <= _n; ++ti) {
cin >> cmd;
if (cmd == "alloc") {
cin >> n;
p = checkM(n);
if (p) {
v = ++memcnt;
for (int i = (p), _n = (p + n - 1); i <= _n; ++i) mem[i] = v;
printf("%d\n", v);
} else
puts("NULL");
} else if (cmd == "erase") {
cin >> n;
bool cleaned = false;
for (int i = (1), _n = (m); i <= _n; ++i)
if (mem[i] == n) {
cleaned = true;
mem[i] = 0;
}
if (!cleaned || n <= 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
p = 1;
int tmpm[105];
memset(tmpm, 0, sizeof(tmpm));
for (int i = (1), _n = (m); i <= _n; ++i)
if (mem[i]) {
tmpm[p++] = mem[i];
}
memcpy(mem, tmpm, sizeof(mem));
}
}
}
int main(void) {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000], b[1000];
int main() {
int t, m, k = 0;
cin >> t >> m;
for (; t > 0; t--) {
string s;
cin >> s;
if (s == "alloc") {
int n;
cin >> n;
bool pr = 0;
for (int i = 0; i < m; i++)
if (i + n <= m) {
bool p = 1;
for (int j = i; j < i + n; j++)
if (a[j] > 0) p = 0;
if (p) {
k++;
cout << k << endl;
for (int j = i; j < i + n; j++) a[j] = k;
pr = 1;
break;
}
}
if (!pr) cout << "NULL" << endl;
} else if (s == "erase") {
int x;
cin >> x;
bool pr = 0;
if (x > 0)
for (int i = 0; i < m; i++)
if (a[i] == x) {
pr = 1;
a[i] = 0;
}
if (!pr) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
int x = 0;
for (int i = 0; i < m; i++) {
if (a[i] > 0) {
b[x] = a[i];
x++;
}
a[i] = 0;
}
for (int i = 0; i < x; i++) a[i] = b[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1007;
int occupied[maxn];
int main() {
int n, m;
cin >> n >> m;
int identifier = 0;
for (int i = (0), _b = ((n)-1); i <= _b; i++) {
string command;
cin >> command;
if (command == "alloc") {
int request;
cin >> request;
int block = 0;
for (int j = 1; j <= m; j += 1) {
if (occupied[j])
block = 0;
else
block++;
if (block < request) continue;
identifier++;
while (request--) occupied[j - request] = identifier;
break;
}
if (block < request)
cout << "NULL" << endl;
else
cout << identifier << endl;
} else if (command == "erase") {
int request;
cin >> request;
if (request == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
int ok = 0;
for (int j = 1; j <= m; j += 1)
if (occupied[j] == request) {
occupied[j] = 0;
ok = 1;
}
if (!ok || request > identifier) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
int start = 0;
for (int j = 1; j <= m; j += 1)
if (occupied[j]) occupied[++start] = occupied[j];
while (++start <= m) occupied[start] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = (int)1e8;
template <class T>
inline T getmin(T a, T b) {
return a > b ? b : a;
}
template <class T>
inline T getmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline void checkmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
inline T getabs(T x) {
return x > 0 ? x : -x;
}
const int MAXN = 105;
struct Node {
bool flag;
int ndx;
} dt[MAXN];
int t, m, x;
int fun1(int size) {
for (int i = 0; i < m; i++) {
if (dt[i].flag == false) {
int tmp = 0;
for (int j = 0; j < size && i + j < m; j++) {
if (dt[i + j].flag == true) {
break;
} else
tmp++;
}
if (tmp == size) {
for (int j = 0; j < size && i + j < m; j++) {
dt[i + j].ndx = x;
dt[i + j].flag = true;
}
return 0;
}
}
}
return -1;
}
int fun2(int val) {
if (val <= 0) return -1;
bool flag = false;
for (int i = 0; i < m; i++) {
if (dt[i].ndx == val) {
flag = true;
dt[i].flag = false;
dt[i].ndx = -1;
}
}
if (!flag) return -1;
return 0;
}
void fun3() {
int ndx = 0;
for (int i = 0; i < m; i++) {
if (dt[i].flag == true) {
dt[ndx].flag = true;
dt[ndx++].ndx = dt[i].ndx;
}
}
for (int i = ndx; i < m; i++) dt[i].flag = false, dt[i].ndx = -1;
}
int main() {
char op[15];
int val;
while (scanf("%d%d", &t, &m) == 2) {
x = 1;
for (int i = 0; i < m; i++) dt[i].flag = false, dt[i].ndx = -1;
while (t--) {
scanf("%s", &op);
if (op[0] == 'a') {
scanf("%d", &val);
int ret = fun1(val);
if (ret == -1)
puts("NULL");
else
printf("%d\n", x++);
} else if (op[0] == 'e') {
scanf("%d", &val);
if (val == 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
int ret = fun2(val);
if (ret == -1) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
fun3();
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-5;
int main(void) {
int t, m;
int i, j, k;
int count = 0;
int mem[100];
memset(mem, 0, sizeof(mem));
cin >> t;
cin >> m;
for (i = 1; i <= t; i++) {
string s;
cin >> s;
if (s == "alloc") {
int n;
int fnum = 0;
cin >> n;
for (j = 0; j < m; j++) {
if (mem[j] == 0) {
fnum++;
if (fnum == n) break;
} else
fnum = 0;
}
if (fnum == n) {
count++;
for (k = (j - n + 1); k <= j; k++) {
mem[k] = count;
}
cout << count << endl;
} else {
cout << "NULL" << endl;
}
} else if (s == "erase") {
int n;
cin >> n;
int ecount = 0;
if (n > 0) {
for (j = 0; j < m; j++) {
if (mem[j] == n) {
mem[j] = 0;
ecount++;
}
}
}
if (ecount == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else if (s == "defragment") {
int n;
int p = 0;
for (j = 0; j < m; j++) {
if (mem[j] != 0) {
mem[p] = mem[j];
p++;
}
}
for (j = p; j < m; j++) {
mem[j] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, x, p = 1;
cin >> t >> m;
vector<int> a(1000, 0);
while (t--) {
string s;
cin >> s;
if (s == "alloc") {
cin >> x;
bool d = 0;
for (int i = 1; i + (x - 1) <= m; i++) {
bool k = 1;
for (int j = i; j <= i + x - 1; j++) {
if (a[j] > 0) {
k = 0;
break;
}
}
if (k) {
d = 1;
for (int j = i; j <= i + x - 1; j++) a[j] = p;
break;
}
}
if (d) {
cout << p << endl;
p++;
} else {
cout << "NULL" << endl;
}
} else if (s == "erase") {
cin >> x;
if (x < 1) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
continue;
}
bool o = 0;
for (int i = 1; i <= m; i++) {
if (a[i] == x) {
a[i] = 0;
o = 1;
}
}
if (!o) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
} else {
int l = -1;
for (int i = 1; i <= m; i++) {
if (a[i] == 0) {
l = i;
break;
}
}
if (l == -1) continue;
for (int i = l; i <= m; i++) {
if (a[i] > 0) {
a[l] = a[i];
a[i] = 0;
l++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Block {
int id;
int start;
int len;
Block() : id(0), start(0), len(0) {}
Block(int id, int start, int len) {
this->id = id;
this->start = start;
this->len = len;
}
Block(const Block &other) {
id = other.id;
start = other.start;
len = other.len;
}
bool operator<(const Block &other) const { return start < other.start; }
Block &operator=(const Block &other) {
id = other.id;
start = other.start;
len = other.len;
return *this;
}
};
int a[120];
int id = 1;
map<int, Block> blocks;
Block b[120];
int m = 0;
int alloc(int n) {
int i = 1;
int j = 1;
while (i <= m - n + 1) {
if (a[i]) {
i++;
} else {
for (j = i; j <= m && j - i + 1 <= n && !a[j]; j++)
;
if (j - i + 1 > n) {
break;
}
i = j + 1;
}
}
if (i <= m - n + 1) {
pair<int, Block> p = pair<int, Block>(id, Block(id, i, j - i));
blocks.insert(p);
for (; i < j; i++) {
a[i] = 1;
}
return id++;
} else {
return 0;
}
}
int erase(int i) {
if (blocks.count(i) > 0) {
for (int k = blocks[i].start; k < blocks[i].start + blocks[i].len; k++) {
a[k] = 0;
}
blocks.erase(i);
return 1;
} else {
return 0;
}
}
void defragment() {
map<int, Block>::iterator iter;
int i = 0;
for (iter = blocks.begin(); iter != blocks.end(); iter++) {
b[i].start = (*iter).second.start;
b[i].len = (*iter).second.len;
b[i].id = (*iter).second.id;
i++;
}
sort(b, b + i);
int num = i;
int tail = 1;
for (i = 0; i < num; i++) {
b[i].start = tail;
tail += b[i].len;
}
memset(a, 0, sizeof(a));
tail = 1;
blocks.clear();
for (i = 0; i < num; i++) {
for (int j = b[i].start; j < b[i].start + b[i].len; j++) {
a[j] = 1;
}
blocks.insert(pair<int, Block>(b[i].id, b[i]));
}
}
int main() {
int t;
string oper;
int num;
int result;
memset(a, 0, sizeof(a));
cin >> t >> m;
for (int i = 0; i < t; i++) {
cin >> oper;
if (oper == "alloc") {
cin >> num;
result = alloc(num);
if (result > 0) {
cout << result << endl;
} else {
cout << "NULL" << endl;
}
} else if (oper == "erase") {
cin >> num;
result = erase(num);
if (!result) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Q, N;
long long mem[100];
long long ids = 1;
long long INIT = 1e12;
void defrag() {
int idx = 0;
for (int i = 0; i < N; i++) {
if (mem[i] != INIT) {
mem[idx] = mem[i];
idx++;
}
}
for (; idx < N; idx++) {
mem[idx] = INIT;
}
}
void alloc() {
int val;
cin >> val;
int start = 0;
bool success = false;
for (int i = 0; i < N; i++) {
if (mem[i] != INIT) {
start = i + 1;
} else if (i - start + 1 >= val) {
for (int j = 0; j < val; j++) {
mem[start + j] = ids;
}
success = true;
break;
}
}
if (success) {
cout << ids << endl;
ids++;
} else {
cout << "NULL" << endl;
}
}
void erase() {
int id;
cin >> id;
bool found = false;
for (int i = 0; i < N; i++) {
if (mem[i] == id) {
mem[i] = INIT;
found = true;
}
}
if (!found) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> Q >> N;
for (int i = 0; i < N; i++) {
mem[i] = INIT;
}
string op;
for (int i = 0; i < Q; i++) {
cin >> op;
if (op == "defragment") {
defrag();
} else if (op == "alloc") {
alloc();
} else {
erase();
}
}
return 0;
}
|
#include <bits/stdc++.h>
int Memory[100];
int t, m, id = 0, i, j, len, n, x;
char order[20];
int main() {
for (i = 0; i <= 100; i++) Memory[i] = 0;
std::cin >> t >> m;
while (t--) {
bool flag = true;
std::cin >> order;
if (order[0] == 'a') {
std::cin >> n;
for (i = 0; i <= m - n; i++) {
for (j = i; j < i + n; j++)
if (Memory[j] != 0) {
flag = true;
break;
}
if (j == i + n) {
flag = false;
break;
}
}
if (flag) {
std::cout << "NULL" << std::endl;
continue;
}
id++;
for (j = i; j < i + n; j++) Memory[j] = id;
std::cout << id << std::endl;
} else if (order[0] == 'e') {
std::cin >> x;
flag = false;
if (x == 0)
std::cout << "ILLEGAL_ERASE_ARGUMENT" << std::endl;
else {
for (i = 0; i < m; i++)
if (Memory[i] == x) {
flag = true;
Memory[i] = 0;
}
if (!flag) std::cout << "ILLEGAL_ERASE_ARGUMENT" << std::endl;
}
} else {
len = m;
for (i = 0; i < len; i++) {
if (Memory[i] == 0) {
memmove(Memory + i, Memory + i + 1, (m - i - 1) * 4);
len--;
i--;
}
}
for (i = len; i < m; i++) Memory[i] = 0;
}
}
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;
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 = 0;
map<int, pair<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;
for (int i = 0; i < m; i++) {
if (mem[i] == 0) {
int j = 0;
for (; j < x && i < m; i++) {
if (mem[i] == 0)
j++;
else
break;
}
if (j == x) {
f = 1;
idx = i - x;
break;
}
}
}
if (f) {
block++;
cout << block << '\n';
mp[block] = {idx, x};
for (int i = 0; i < x; i++) {
mem[idx] = block;
idx++;
}
} else {
cout << "NULL" << '\n';
}
} else if (s == "erase") {
cin >> x;
if (mp.count(x)) {
int idx = 0, aa = mp[x].second;
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 {
for (int i = 0, j = 0; i < m; i++) {
if (mem[i] != 0) {
mem[j] = mem[i];
if (i != j) mem[i] = 0;
j++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string type;
long long a[181], n, i, j, q, len, nom, nom1;
bool x;
bool check(long long l, long long r) {
long long i;
for (i = l; i <= r; i++)
if (a[i] != 9000000000000000000LL) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> q >> n;
for (i = 1; i <= n; i++) a[i] = 9000000000000000000LL;
while (q--) {
cin >> type;
if (type[0] == 'a') {
cin >> len;
x = false;
for (i = 1; i <= n - len + 1; i++)
if (check(i, i + len - 1)) {
x = true;
nom1++;
for (j = i; j <= i + len - 1; j++) a[j] = nom1;
break;
}
if (x)
cout << nom1;
else
cout << "NULL";
cout << '\n';
} else if (type[0] == 'e') {
cin >> nom;
x = false;
for (i = 1; i <= n; i++)
if (a[i] == nom) {
x = true;
a[i] = 9000000000000000000LL;
}
if (!x) cout << "ILLEGAL_ERASE_ARGUMENT" << '\n';
} else {
for (i = 1; i <= n; i++)
if (a[i] != 9000000000000000000LL) {
nom = i;
while (i > 1 && a[nom - 1] == 9000000000000000000LL) {
swap(a[nom], a[nom - 1]);
nom--;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long t, n, p[105], cnt;
void debug() {
for (long long i = 1; i <= n; i++) cout << p[i] << " ";
cout << endl;
}
long long alloc(long long len) {
for (long long i = 1; i <= n - len + 1; i++) {
long long pd = 1;
for (long long j = 0; j < len; j++)
if (p[i + j] != inf) pd = 0;
if (pd) {
cnt++;
for (long long j = 0; j < len; j++) p[i + j] = cnt;
return cnt;
}
}
return -1;
}
long long erase(long long id) {
long long pd = 0;
for (long long i = 1; i <= n; i++)
if (p[i] == id) pd = 1, p[i] = 0;
if (pd) return id;
return -1;
}
void defrag() {
long long k[105], pos = 1;
memset(k, 0, sizeof(k));
for (long long i = 1; pos <= n; i++)
while (pos <= n) {
if (p[pos] != inf) {
k[i] = p[pos++];
break;
} else
pos++;
}
for (long long i = 1; i <= n; i++) p[i] = k[i];
}
void update() {
for (long long i = 1; i <= n; i++)
if (p[i] == 0) p[i] = inf;
}
signed main() {
cin >> t >> n;
for (long long i = 1; i <= t; i++) {
update();
string s;
long long id;
cin >> s;
if (s[0] == 'd')
defrag();
else {
cin >> id;
if (s[0] == 'e') {
if (erase(id) == -1) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else if (s[0] == 'a') {
long long get = alloc(id);
if (get == -1)
cout << "NULL\n";
else
cout << get << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char cmd[20];
int t, m, s[101];
int find(int l) {
int mxv = 0;
for (int i = 0; i < m; i++) {
if (s[i] == 0) {
mxv++;
if (mxv == l) return i - l + 1;
} else {
mxv = 0;
}
}
return -1;
}
int main() {
scanf("%d%d", &t, &m);
int num = 1;
for (int i = 0; i < t; i++) {
scanf("%s", cmd);
if (strcmp(cmd, "alloc") == 0) {
int n;
scanf("%d", &n);
int index = find(n);
if (index == -1)
puts("NULL");
else {
for (int i = index; i < index + n; i++) s[i] = num;
printf("%d\n", num);
num++;
}
} else if (strcmp(cmd, "erase") == 0) {
int x;
scanf("%d", &x);
bool ck = false;
if (x > 0) {
for (int i = 0; i < m; i++)
if (s[i] == x) {
s[i] = 0;
ck = true;
}
}
if (!ck) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int i = 0, j = 0;
while (i < m && j < m) {
while (i < m && s[i] != 0) i++;
while (j < m && s[j] == 0) j++;
if (i >= m || j >= m) break;
if (i < j) {
s[i] = s[j];
s[j] = 0;
} else
j++;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char ss[30];
int mem[200], cur = 0, n, m;
int goodal(int start, int _long) {
for (int i = 1; i <= _long; ++i)
if (mem[i + start - 1] != 0 || i + start - 1 > m) return 0;
return 1;
}
void _fill(int start, int _long) {
for (int i = 1; i <= _long; ++i) mem[i + start - 1] = cur;
}
void show() {
for (int i = 1; i <= m; ++i) printf("%d ", mem[i]);
printf("\n");
}
void alloc() {
int ind;
scanf("%d", &ind);
scanf("\n");
for (int i = 1; i <= m; ++i)
if (goodal(i, ind)) {
++cur;
_fill(i, ind);
printf("%d\n", cur);
return;
}
printf("NULL\n");
}
void erase() {
int ind, flag = 0;
scanf("%d", &ind);
scanf("\n");
for (int i = 1; i <= m; ++i)
if (mem[i] == ind && ind != 0) flag = 1, mem[i] = 0;
if (flag == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
void defragment() {
scanf("\n");
int now = 1;
for (int i = 1; i <= m; ++i)
if (mem[i] == 0) {
now = i;
break;
}
for (int i = 1; i <= m; ++i)
if (i > now && mem[i] != 0) mem[now++] = mem[i], mem[i] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", &ss);
if (ss[0] == 'a')
alloc();
else if (ss[0] == 'e')
erase();
else
defragment();
}
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;
for (int i = 0; i < a.size(); i++) {
if (a[i].used == 0) {
sum += a[i].m;
a[i].num = 0, a[i].used = 1;
}
}
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;
using lint = long long;
int a[111];
void solve(istream& cin, ostream& cout) {
int t, m;
cin >> t >> m;
int id = 0;
for (int i = 0; i < (int)(t); ++i) {
string s;
int x;
cin >> s;
if (s == "alloc") {
cin >> x;
bool success = false;
for (int j = 0; j + x <= m; j++) {
bool all = true;
for (int k = 0; k < x; k++) {
if (a[k + j] != 0) {
all = false;
break;
}
}
if (all) {
++id;
for (int k = 0; k < x; k++) {
a[k + j] = id;
}
success = true;
break;
}
}
if (!success) {
cout << "NULL\n";
} else {
cout << id << "\n";
}
} else if (s == "erase") {
cin >> x;
int p = -1;
for (int j = 0; j < m; j++) {
if (a[j] == x) {
p = j;
break;
}
}
if (x <= 0 || p == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
for (; p < m && a[p] == x; p++) {
a[p] = 0;
}
}
} else {
int l = 0;
for (int r = 0; r < m; r++) {
if (a[r] != 0) {
a[l++] = a[r];
}
}
for (; l < m; l++) {
a[l] = 0;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve(cin, cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int flag, x, next;
} a[105];
int main() {
int n, m, head = 1, t = 0, x, p, q = 1, len, ans, f;
string s;
cin >> n >> m;
a[1].flag = 0, a[1].x = m, a[1].next = 0;
for (int i = 1; i <= n; i++) {
cin >> s;
if (s[0] == 'a') {
cin >> x;
p = head;
ans = 0;
while (p > 0) {
int x1 = a[p].x;
if (a[p].flag == 0 && x1 >= x) {
if (x1 == x)
a[p].flag = ++t;
else {
a[p].flag = ++t;
a[++q].flag = 0;
a[q].next = a[p].next;
a[p].next = q;
a[p].x = x;
a[q].x = x1 - x;
}
ans = t;
break;
}
p = a[p].next;
}
if (ans == 0)
cout << "NULL" << endl;
else
cout << ans << endl;
}
if (s[0] == 'e') {
cin >> x;
p = head;
f = 0;
while (p > 0) {
if (a[p].flag == x && x != 0) {
a[p].flag = 0;
f = 1;
break;
}
p = a[p].next;
}
if (f == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
p = head;
while (p > 0) {
int p1 = a[p].next;
if (a[p].flag == 0 && a[p1].flag == 0 && p1 != 0) {
a[p].x = a[p].x + a[p1].x;
a[p].next = a[p1].next;
} else
p = a[p].next;
}
}
if (s[0] == 'd') {
p = head;
len = 0;
while (p > 0) {
int p1 = a[p].next;
if (a[p].flag == 0 && p1 != 0) {
len += a[p].x;
a[p] = a[p1];
} else if (a[p].flag == 0 && p1 == 0) {
a[p].x = a[p].x + len;
break;
} else if (a[p].flag != 0 && p1 == 0) {
q++;
a[p].next = q;
a[q].flag = 0;
a[q].x = len;
break;
}
p = a[p].next;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double LOG(long long N, long long B) { return (log10l(N)) / (log10l(B)); }
string itoa(long long a) {
if (a == 0) return "0";
string ret;
for (long long i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
int check(int N, int pos) { return (N & (1 << pos)); }
int toggle(int N, int pos) {
if (check(N, pos)) return N = reset(N, pos);
return N = Set(N, pos);
}
void pbit(int N) {
printf("(");
for (int i = 10; i >= 0; i--) {
bool x = check(N, i);
cout << x;
}
puts(")");
}
int fx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int fy[] = {-1, 1, 0, 0, -1, -1, 1, 1};
void Clear(int n, long long *ram) {
for (int i = 1; i <= (int)n; i++) ram[i] = 1e15;
}
int main() {
long long n, m;
while (cin >> n >> m) {
long long ram[1000];
Clear(m, ram);
long long id = 0;
for (int loop = 1; loop <= (int)n; loop++) {
string s;
cin >> s;
if (s[0] == 'a') {
long long x, p = 1e15;
cin >> x;
for (int i = 1; i <= m; i++) {
if (ram[i] == 1e15) {
int c = 0;
for (int j = i; ram[j] == 1e15 and j <= m; j++) c++;
if (c >= x) {
p = i;
break;
}
}
}
if (p == 1e15)
puts("NULL");
else {
id++;
for (int i = p; i <= p + x - 1; i++) ram[i] = id;
cout << id << endl;
}
}
if (s[0] == 'e') {
long long x, flag = 0;
cin >> x;
for (int i = 1; i <= m; i++)
if (ram[i] == x) {
ram[i] = 1e15;
flag = 1;
}
if (flag == 0) puts("ILLEGAL_ERASE_ARGUMENT");
}
if (s[0] == 'd') {
long long temp[1000], c = 1;
Clear(m, temp);
for (int i = 1; i <= m; i++)
if (ram[i] != 1e15) temp[c++] = ram[i];
for (int i = 1; i <= m; i++) ram[i] = temp[i];
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, x, f, it = 0, z = 0, j, k, e = 0;
string s;
cin >> t >> m;
f = m;
int mem[m];
for (int i = 0; i < m; i++) mem[i] = 0;
for (int i = 0; i < t; i++) {
cin >> s;
if (s == "alloc") {
cin >> x;
if (x > f)
cout << "NULL" << endl;
else {
for (j = 0; j <= m - x; j++) {
for (k = j; k < x + j; k++) {
if (mem[k] != 0) break;
}
if (k == x + j) {
it++;
f = f - x;
for (int l = j; l < x + j; l++) mem[l] = it;
cout << it << endl;
;
break;
}
}
if (j == m - x + 1) cout << "NULL" << endl;
}
}
if (s == "erase") {
cin >> x;
if (x > it || x < 1)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
for (j = 0; j < m; j++) {
if (mem[j] == x) {
mem[j] = 0;
f++;
e++;
}
}
if (e == 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else
e = 0;
}
}
if (s == "defragment") {
for (j = 0; j < m - 1; j++) {
if (mem[j] == 0 && mem[j + 1] == 0) z++;
if (mem[j] == 0 && mem[j + 1] != 0) {
mem[j - z] = mem[j + 1];
mem[j + 1] = 0;
}
}
z = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int offset;
int len;
int id;
};
bool operator<(node a, node b) { return a.offset < b.offset; };
vector<node> data;
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
data.clear();
node gao;
gao.offset = 0;
gao.len = 0;
gao.id = -1;
data.push_back(gao);
gao.offset = m;
gao.len = 0;
data.push_back(gao);
int cnt = 1;
for (int i = 0; i < n; i++) {
char buf[100];
int op;
scanf("%s", buf);
if (buf[0] == 'a') {
bool succ = false;
scanf("%d", &op);
for (int j = 0; j < data.size() - 1; j++) {
int start = data[j].offset + data[j].len;
if (data[j + 1].offset - start >= op) {
node newnode;
newnode.offset = start;
newnode.id = cnt;
newnode.len = op;
data.insert(data.begin() + j + 1, newnode);
succ = true;
printf("%d\n", cnt++);
break;
}
}
if (!succ) printf("NULL\n");
} else if (buf[0] == 'e') {
scanf("%d", &op);
if (op <= 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
bool succ = false;
for (int j = 0; j < data.size(); j++) {
if (data[j].id == op) {
succ = true;
data.erase(data.begin() + j);
break;
}
}
if (!succ) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (int j = 1; j < data.size() - 1; j++) {
data[j].offset = data[j - 1].offset + data[j - 1].len;
}
}
}
}
}
|
#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];
if (i >= p) a[i] = 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, t;
int a[100], b[100];
bool used[100];
while (cin >> t >> m) {
string s;
memset(a, 0, sizeof(a));
memset(used, false, sizeof(used));
int id = 1;
while (t--) {
cin >> s;
if (s == "alloc") {
int count = 0;
int num = 0;
int first = -1;
cin >> num;
for (int i = 0; i < m; i++) {
if (a[i] == 0)
count++;
else
count = 0;
if (count == num) {
first = i - num + 1;
break;
}
}
if (first == -1)
puts("NULL");
else {
for (int i = first; i < first + num; i++) a[i] = id;
cout << id << endl;
id++;
}
} else if (s == "erase") {
unsigned int num;
cin >> num;
if (num == 0 || num >= id || used[num - 1]) {
puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (int i = 0; i < m; i++)
if (a[i] == num) a[i] = 0;
used[num - 1] = true;
}
} else {
int idx = 0;
memset(b, 0, sizeof(b));
for (int i = 0; i < m; i++) {
if (a[i] != 0) b[idx++] = a[i];
}
memcpy(a, b, sizeof(a));
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct List {
List *pre, *net;
int l, r, id;
List() {
pre = net = NULL;
l = r = id = 0;
}
};
int main() {
int n, m, id = 1;
scanf("%d%d", &n, &m);
List *p = new List;
List *f = p;
p->net = new List;
p->net->pre = p;
p = p->net;
p->l = m;
while (n--) {
char cmd[20];
scanf("%s", cmd);
if (cmd[0] == 'a') {
int x;
scanf("%d", &x);
p = f;
bool cha = false;
while (p->net) {
if (p->net->l - p->r >= x) {
List *q = new List;
q->net = p->net;
q->pre = p;
q->l = p->r;
q->r = p->r + x;
q->id = id++;
q->pre->net = q;
q->net->pre = q;
cha = true;
break;
}
p = p->net;
}
if (!cha)
puts("NULL");
else
printf("%d\n", id - 1);
} else if (cmd[0] == 'e') {
int x;
scanf("%d", &x);
p = f->net;
bool cha = false;
while (p->net) {
if (p->id == x) {
cha = true;
p->pre->net = p->net;
p->net->pre = p->pre;
break;
}
p = p->net;
}
if (!cha) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
p = f->net;
while (p->net != NULL) {
p->r -= p->l - p->pre->r;
p->l = p->pre->r;
p = p->net;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt, M;
bool arr[1000];
int pos[1000], num[1000];
void doAlloc() {
int n;
cin >> n;
bool found = false;
for (int i = 0; i + n <= M; i++) {
bool flag = true;
for (int j = 0; j < n; j++)
if (!arr[i + j]) flag = false;
if (flag) {
++cnt;
pos[cnt] = i;
cout << cnt << "\n";
found = true;
num[cnt] = n;
for (int j = 0; j < n; j++) arr[i + j] = false;
break;
}
}
if (!found) cout << "NULL\n";
return;
}
void doErase() {
int x;
cin >> x;
if (x > cnt || x <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
return;
}
int t = pos[x];
if (x > cnt || t == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
return;
}
bool found = false;
for (int i = 0; i < num[x]; i++)
if (arr[i + t])
found = true;
else
arr[i + t] = true;
if (found)
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else
pos[x] = num[x] = -1;
return;
}
void doFrament() {
int last = 0;
for (int i = 1; i <= cnt; i++) {
int t = pos[i], n = num[i], p;
if (t == -1) continue;
p = t;
for (int j = last; j < t; j++)
if (arr[j]) {
p = j;
break;
}
int x = t + n - 1;
for (int j = 0; j < n; j++) arr[p + j] = false;
for (int j = p + n; j <= x; j++) arr[j] = true;
pos[i] = p;
last = p + n;
}
return;
}
int main() {
int T;
cin >> T >> M;
memset(arr, true, sizeof(arr));
for (int i = 0; i < T; i++) {
string command;
cin >> command;
if (command == "alloc")
doAlloc();
else if (command == "erase")
doErase();
else
doFrament();
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.