text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
int main() {
char a[2][15];
char temp[15];
for (int i = 0; i < 2; i++) {
scanf("%s", a[i]);
}
int b;
scanf("%d", &b);
char c[1010][2][15];
int i;
for (int j = 0; j < b; j++) {
for (i = 0; i < 2; i++) {
scanf("%s", c[j][i]);
}
}
if (strcmp(c[0][0], a[0]) == 0) {
strcpy(c[0][0], c[0][1]);
strcpy(c[0][1], a[1]);
goto L1;
}
if (strcmp(c[0][1], a[0]) == 0) {
strcpy(c[0][1], a[1]);
goto L1;
}
if (strcmp(c[0][0], a[1]) == 0) {
strcpy(c[0][0], a[0]);
strcpy(c[0][1], c[0][1]);
goto L1;
}
if (strcmp(c[0][1], a[1]) == 0) {
strcpy(c[0][1], a[0]);
goto L1;
}
L1:
for (int j = 0; j < b; j++) {
for (i = 0; i < 2; i++) {
if (strcmp(c[j][i], c[j + 1][i]) == 0) {
if (i % 2 == 0) {
strcpy(c[j + 1][i], c[j + 1][i + 1]);
strcpy(c[j + 1][i + 1], c[j][i + 1]);
}
if (i % 2 != 0) {
strcpy(c[j + 1][j + 1], c[j][i]);
}
break;
}
if (strcmp(c[j][i], c[j + 1][i + 1]) == 0) {
strcpy(c[j + 1][i + 1], c[j][i + 1]);
;
break;
}
if (strcmp(c[j][i + 1], c[j + 1][i]) == 0) {
strcpy(c[j + 1][i], c[j][i]);
break;
}
}
}
L4:
printf("%s %s", a[0], a[1]);
printf("\n");
for (int j = 0; j < b; j++) {
for (int i = 0; i < 2; i++) {
printf("%s ", c[j][i]);
}
printf("\n");
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
string names[2];
int n;
string killed, nextDay;
void operate() {
for (int i = 0; i < 2; i++) {
cout << names[i] << " ";
if (names[i].compare(killed) == 0) {
names[i] = nextDay;
}
}
cout << "\n";
}
int main() {
for (int i = 0; i < 2; i++) {
cin >> names[i];
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> killed;
cin >> nextDay;
operate();
}
for (int i = 0; i < 2; i++) {
cout << names[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::cin.tie(0);
std::cin.sync_with_stdio(0);
int n;
string victim1, victim2, killed, replacing;
cin >> victim1 >> victim2;
cin >> n;
cout << victim1 << ' ' << victim2 << '\n';
while (n--) {
cin >> killed >> replacing;
if (killed == victim1) {
victim1 = replacing;
} else {
victim2 = replacing;
}
cout << victim1 << ' ' << victim2 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long md = 1000000007;
long long ma = 998244353;
long long pw(long long a, long long b) {
long long c = 1, m = a;
while (b) {
if (b & 1) c = (c * m);
m = (m * m);
b /= 2;
}
return c;
}
long long pwmd(long long a, long long b) {
long long c = 1, m = a;
while (b) {
if (b & 1) c = ((c * m)) % md;
m = (m * m) % md;
b /= 2;
}
return c;
}
long long modinv(long long n) { return pwmd(n, md - 2); }
long long min(long long a, long long b) {
if (a >= b) return b;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n;
string s1, s2, s3, s4;
cin >> s1 >> s2 >> n;
cout << s1 << " " << s2 << "\n";
for (long long i = 0; i < n; i++) {
cin >> s3 >> s4;
if (s3 == s1)
s1 = s4;
else
s2 = s4;
cout << s1 << " " << s2 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ifstream fin("input.txt", ios::in);
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << setprecision(10);
cout << fixed;
string a, b;
cin >> a >> b;
int n;
cin >> n;
cout << a << " " << b << endl;
while (n--) {
string x, y;
cin >> x >> y;
if (a == x) {
a = y;
} else {
b = y;
}
cout << a << " " << b << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int n;
cin >> n;
cout << a << " " << b << "\n";
while (n--) {
string x, y;
cin >> x >> y;
if (x == a)
a = y;
else
b = y;
cout << a << " " << b;
if (n) cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
string toBinary(int n) {
string str;
while (n) {
str.push_back(n % 2 + '0');
n /= 2;
}
int ln = str.size();
for (int i = 0; i < ln; i++) {
if (str[i] == '1') {
str = str.substr(i, ln);
break;
}
}
return str;
}
int main() {
int n;
string s, t;
cin >> s >> t;
cin >> n;
string t1, t2;
cout << s << " " << t << endl;
for (int i = 0; i < n; i++) {
cin >> t1 >> t2;
if (t1 == s) {
s = t2;
cout << s << " " << t << endl;
} else {
t = t2;
cout << s << " " << t << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void Main() {
int sz = 0;
char ch[4][20];
scanf("%s%s", ch[0], ch[1]);
int n;
scanf("%d", &n);
while (n--) {
printf("%s %s\n", ch[0], ch[1]);
scanf("%s%s", ch[2], ch[3]);
if (strcmp(ch[2], ch[1]) == 0) {
memcpy(ch[1], ch[3], sizeof(ch[3]));
} else if (strcmp(ch[2], ch[0]) == 0) {
memcpy(ch[0], ch[3], sizeof(ch[3]));
}
}
printf("%s %s\n", ch[0], ch[1]);
}
int main(int argc, char const *argv[]) {
Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a, b, c, d;
int main() {
int i;
cin >> a >> b;
int n;
scanf("%d", &n);
cout << a << ' ' << b << endl;
for (i = 1; i <= n; i++) {
cin >> c >> d;
if (a == c) {
a = d;
} else {
b = d;
}
cout << a << ' ' << b << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[2];
int n;
while (cin >> s[0] >> s[1]) {
cout << s[0] << " " << s[1] << "\n";
cin >> n;
for (int i = 0; i < n; i++) {
string aux[2];
cin >> aux[0] >> aux[1];
for (int j = 0; j < 2; j++) {
if (s[j] == aux[0]) s[j] = aux[1];
}
cout << s[0] << " " << s[1] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string a, b, x, y, k;
cin >> a >> b;
int t;
cin >> t;
cout << a << " " << b << endl;
for (int i = 0; i < t; i++) {
cin >> x >> y;
if (x == a) {
a = y;
} else if (x == b) {
b = y;
} else if (y == a) {
a = x;
} else if (y == b) {
b = x;
}
cout << a << " " << b << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string x, y;
cin >> x >> y;
cout << x << " " << y << "\n";
set<string> st;
st.insert(x);
st.insert(y);
int n;
cin >> n;
while (n--) {
string a, b;
cin >> a >> b;
st.erase(a);
st.insert(b);
cout << *st.begin() << " " << *++st.begin() << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long Max(long long a, long long b) { return a > b ? a : b; }
long long Min(long long a, long long b) { return a < b ? a : b; }
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = ((x % p) * (x % p)) % p;
}
return res;
}
bool isprime(long long n) {
long long z = sqrt(n);
if (n == 2) return true;
if (n % 2 == 0) return false;
for (long long i = 3; i <= z; i += 2) {
if (n % i == 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
long long n;
cin >> n;
set<string> s;
s.insert(a);
s.insert(b);
cout << a << " " << b << endl;
for (long long i = 0; i < n; i++) {
string x, y;
cin >> x >> y;
s.erase(x);
s.insert(y);
cout << *s.begin() << " " << *s.rbegin() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
string s1, s2, s[1000], t[1000];
cin >> s1;
cin >> s2;
cin >> n;
for (i = 0; i < n; i++) cin >> s[i] >> t[i];
cout << s1 << " " << s2 << "\n";
if (s[0] != s1)
s[0] = s1;
else
s[0] = s2;
for (i = 1; i < n; i++) {
if (s[i] == s[i - 1])
s[i] = t[i - 1];
else
s[i] = s[i - 1];
}
for (i = 0; i < n; i++) cout << s[i] << " " << t[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
stack<string> s;
vector<pair<string, string> > v;
string s1, s2;
cin >> s1 >> s2;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s3, s4;
cin >> s3 >> s4;
v.push_back(make_pair(s3, s4));
}
s.push(s1);
s.push(s2);
cout << s1 << " " << s2 << '\n';
for (int i = 0; i < n; i++) {
if (v[i].first == s.top()) {
s.pop();
string s5 = s.top();
cout << s5 << " " << v[i].second << '\n';
s.push(v[i].second);
} else {
string s6 = s.top();
s.pop();
s.pop();
s.push(s6);
s.push(v[i].second);
cout << s6 << " " << v[i].second << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
string a, b;
int main() {
while (cin >> a >> b) {
int n;
cin >> n;
string n1 = a;
string n2 = b;
cout << a << " " << b << endl;
for (int i = 0; i < n; i++) {
string x, y;
cin >> x >> y;
if (x == n1) {
cout << y << " " << n2 << endl;
n1 = y;
} else if (x == n2) {
cout << n1 << " " << y << endl;
n2 = y;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s >> t;
int n;
cin >> n;
cout << s << ' ' << t << '\n';
for (int i = 0; i < n; ++i) {
string a, b;
cin >> a >> b;
if (a == s) {
s = b;
} else
t = b;
cout << s << ' ' << t << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string A[2], B[1001][2];
cin >> A[0] >> A[1];
int n;
cin >> n;
for (int i = 0; i < 2; i++) {
B[0][i] = A[i];
cout << B[0][i] << " ";
}
cout << endl;
for (int i = 1; i < n + 1; i++) {
string x, y;
cin >> x >> y;
for (int t = 0; t < 2; t++) {
if (A[t] == x) A[t] = y;
B[i][t] = A[t];
cout << B[i][t] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string k1, k2;
cin >> k1 >> k2;
int n;
cin >> n;
cout << k1 << " " << k2 << endl;
for (int i = 0; i < n; i++) {
string m, a;
cin >> m >> a;
if (m == k1) {
cout << a << " " << k2 << endl;
k1 = a;
} else {
cout << a << " " << k1 << endl;
k2 = a;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long INF = 1e17;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
string a, b;
cin >> a >> b;
int n;
cin >> n;
cout << a << " " << b << "\n";
for (int i = 0; i < n; i++) {
string aa, bb;
cin >> aa >> bb;
if (aa == a) {
a = bb;
} else {
b = bb;
}
cout << a << " " << b << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e15;
long long mod = 1e9 + 7;
string ITS(long long x) {
string s = "";
while (x > 0) {
s += (char)(x % 10 + '0');
x /= 10;
}
string t = "";
for (int i = s.size() - 1; i > -1; i--) t += s[i];
return t;
}
long long bmm(long long a, long long b) {
if (a == 0) return b;
return bmm(b % a, a);
}
bool aval(long long x) {
if (x < 2) return 0;
if (x < 4) return 1;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
long long power(long long p, long long t) {
if (t == 0) return 1;
long long x = power(p, t / 2);
if (t % 2)
return x * x * p;
else
return x * x;
}
const long long M = 1e2 + 5;
int main() {
std::ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
long long n;
cin >> n;
cout << s << ' ' << t << '\n';
for (long long i = 0; i < n; i++) {
string u, v;
cin >> u >> v;
if (s == u)
s = v;
else if (t == u)
t = v;
cout << s << ' ' << t << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e14;
const long long N = 2e3 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
long long n, m, a[N], b[N], cnt, ans;
string s[N], h[N], r, x, y;
pair<string, string> p[N];
int main() {
string dp[2] = {"NO", "YES"};
ios_base::sync_with_stdio(0);
;
cin >> s[0] >> h[0] >> n;
for (int i = 1; i <= n; i++) cin >> s[i] >> h[i];
if (s[0] == s[1])
r = h[0];
else
r = s[0], cout << s[0] << ' ' << h[0] << endl;
for (int i = 0; i < n; i++) {
if (r != s[i + 1]) {
if ((s[i + 1] != y and r != x) and (s[i + 1] != h[i]))
cout << s[i + 1] << ' ' << r << endl;
cout << h[i + 1] << ' ' << r << endl;
} else if (r == s[i + 1]) {
r = h[i];
cout << r << ' ' << h[i + 1] << endl;
x = r, y = h[i + 1];
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s1, s2;
cin >> s1 >> s2;
int n;
cin.ignore();
cin >> n;
cin.ignore();
string s[n], ss[n];
for (int i = 0; i < n; i++) {
cin >> s[i] >> ss[i];
}
cout << s1 << " " << s2 << endl;
for (int i = 0; i < n; i++) {
if (s1 == s[i]) {
s1 = ss[i];
} else if (s1 == ss[i]) {
s1 = s[i];
} else if (s2 == s[i]) {
s2 = ss[i];
} else
s2 = s[i];
cout << s1 << " " << s2 << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
{ solve(); }
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[5][1001];
void print() { printf("%s %s\n", s[1] + 1, s[2] + 1); }
int main() {
scanf("%s%s", s[1] + 1, s[2] + 1);
int len1 = strlen(s[1] + 1), len2 = strlen(s[2] + 1);
scanf("%d", &n);
print();
for (int i = 1; i <= n; i++) {
scanf("%s", s[3] + 1);
int len3 = strlen(s[3] + 1);
int flag = 0;
if (len1 == len3) {
for (int i = 1; i <= len1; i++) {
if (s[1][i] != s[3][i]) flag = 2;
}
if (flag == 0) flag = 1;
} else
flag = 2;
scanf("%s", s[flag] + 1);
len1 = strlen(s[1] + 1), len2 = strlen(s[2] + 1);
print();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
int n;
cin >> a >> b >> n;
cout << a << " " << b << endl;
string k, r;
for (int i = 0; i < n; i++) {
cin >> k >> r;
if (a == k)
a = r;
else
b = r;
cout << a << " " << b << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[100005];
string s, s1, s2, s3;
int main() {
long long int i, j, k, l, z, step = 0, n, m, ass, t, w, r, x, y, c = 0, f = 0;
cin >> s >> s1;
cin >> n;
cout << s << " " << s1 << endl;
for (i = 0; i < n; i++) {
cin >> s2 >> s3;
if (s2 == s) {
cout << s1 << " " << s3 << endl;
s = s3;
} else {
cout << s << " " << s3 << endl;
s1 = s3;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, x, y;
int n;
cin >> a >> b >> n;
cout << a << " " << b << endl;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x == a) {
a = "";
a += y;
} else if (x == b) {
b = "";
b += y;
}
cout << a << " " << b << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, n, i;
string s, t, u, v;
vector<pair<string, string> > vec;
cin >> u >> v >> n;
vec.push_back(make_pair(u, v));
for (i = 1; i <= n; i++) {
cin >> s >> t;
if (s == u) {
u = t;
vec.push_back(make_pair(u, v));
} else if (s == v) {
v = t;
vec.push_back(make_pair(u, v));
}
}
for (i = 0; i <= n; i++) cout << vec[i].first << " " << vec[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a[100000], b[100000];
cin >> a[0] >> b[0];
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
cout << a[0] << " " << b[0] << endl;
for (int i = 1; i <= n; i++) {
if (a[i] == a[i - 1]) {
a[i] = b[i - 1];
cout << a[i] << " " << b[i] << endl;
} else if (a[i] == b[i - 1]) {
a[i] = a[i - 1];
cout << a[i] << " " << b[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e == 1) return b;
if (e % 2 == 0)
return power(b * b % m, e / 2, m);
else
return b * power(b * b % m, (e - 1) / 2, m) % m;
}
bool is_prime(long long n) {
long long k = sqrt(n);
for (long long i = 2; i <= k; i++) {
if (n % i == 0) return false;
}
return true;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s1, s2, temp1, temp2;
cin >> s1 >> s2;
long long n, i;
cin >> n;
cout << s1 << " " << s2 << "\n";
for (i = 0; i < n; i++) {
cin >> temp1 >> temp2;
if (!temp1.compare(s2))
s2 = temp2;
else
s1 = temp2;
cout << s1 << " " << s2 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int n;
cin >> n;
cout << s1 << " " << s2 << endl;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
if (a == s1) {
s1 = b;
} else
s2 = b;
cout << s1 << " " << s2 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
string s1, s2;
cin >> s1 >> s2;
int n;
cin >> n;
cout << s1 << " " << s2 << "\n";
for (int i = 1; i <= n; i++) {
string a, b;
cin >> a >> b;
if (a == s1)
s1 = b;
else
s2 = b;
cout << s1 << " " << s2 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, j, k, m;
char str[100];
char str2[100];
char str3[100];
char str4[100];
scanf("%s %s", str, str2);
scanf("%d", &m);
for (i = 0; i <= m; i++) {
printf("%s %s\n", str, str2);
scanf("%s %s", str3, str4);
if (strcmp(str3, str) != 0 && strcmp(str3, str2) != 0) {
if (strcmp(str4, str) == 0) strcpy(str, str3);
if (strcmp(str4, str2) == 0) strcpy(str2, str3);
}
if (strcmp(str4, str) != 0 && strcmp(str4, str2) != 0) {
if (strcmp(str3, str) == 0) strcpy(str, str4);
if (strcmp(str3, str2) == 0) strcpy(str2, str4);
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char n1[20], n2[20];
char n[20], k[20];
int i, j;
scanf("%s %s", n1, n2);
scanf("%d", &j);
printf("%s %s\n", n1, n2);
for (i = 0; i < j; i++) {
scanf("%s %s", n, k);
if (strcmp(n, n1) == 0) {
strcpy(n1, k);
printf("%s %s\n", n1, n2);
} else {
strcpy(n2, k);
printf("%s %s\n", n1, n2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 1007;
int n;
string a, b, nk, np;
void init();
void input();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {}
void work() {
cin >> a >> b;
cin >> n;
cout << a << " " << b << endl;
for (int i = 1; i <= n; ++i) {
cin >> nk >> np;
if (a == nk)
a = np;
else
b = np;
cout << a << " " << b << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
int CC_;
const double EPS = 1E-9;
const double PI = 2 * acos(0.0);
const long long MOD = 1000000007;
template <class T>
void DA(T i, T e) {
while (i != e) {
cout << "Con>>( " << ++CC_ << " ) " << *i++ << endl;
}
}
template <class T>
void DA(T* x, int l) {
for (int i = 0; i < l; i++) cout << "[" << i << "]>> " << x[i] << endl;
}
template <class T>
inline void sary(T* st, T* nd) {
while (st < nd) cin >> *st++;
}
template <class T>
void tobin(T n, char* bin) {
int pos = 1 << ((int)log2(n));
while (pos >= 1) {
if ((n & pos) == 0)
*bin = '0';
else
*bin = '1';
pos >>= 1;
bin++;
}
*bin = '\0';
}
template <class T>
inline T LCM(T x, T y) {
return ((x * y) / __gcd(x, y));
}
long long todec(string& num, int b) {
long long dec = num[0] - (isupper(num[0]) ? 'A' - 10 : '0');
for (int i = 1; num[i]; i++) {
if (num[i] >= 'A' && num[i] <= 'Z')
num[i] -= 'A' - 10;
else
num[i] -= '0';
dec *= b;
dec += num[i];
}
return dec;
}
long long bigMod(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = bigMod(x, y / 2, m) % m;
p = (p * p) % m;
return ((y & 1) ? (x * p) % m : p);
}
unsigned long long ncr(int n, int k) {
unsigned long long res = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; i++) {
res *= n - i;
res /= i + 1;
}
return res;
}
int phi(int n) {
int ret = n;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
ret -= ret / i;
}
}
if (n > 1) ret -= ret / n;
return ret;
}
int egcd(int a, int b, int& x, int& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int x1, y1;
int gcd = egcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
bool comp(const int a, const int b) { return a > b; }
} // namespace
const int sss = 1E6;
string nxt[1005], mu[1005];
string mm[1005][2];
void solve(void) {
int n;
string a, b;
cin >> a >> b >> n;
for (int i = 0; i < n; i++) {
cin >> mu[i] >> nxt[i];
}
mm[0][0] = a;
mm[0][1] = b;
string tmp;
for (int i = 1; i <= n; i++) {
tmp = mu[i - 1];
int j = 0;
mm[i][0] = nxt[i - 1];
if (mm[i - 1][0] == tmp)
mm[i][1] = mm[i - 1][1];
else
mm[i][1] = mm[i - 1][0];
}
for (int i = 0; i <= n; i++) {
cout << mm[i][0] << " " << mm[i][1] << endl;
}
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, string> mymap;
vector<string> vec;
map<string, string>::iterator it;
string a[1000000];
int main() {
string s1, s2, s3, s4, s5, s6;
int k = 0;
cin >> s1 >> s2;
s5 = s1;
s6 = s2;
mymap[s1] = s2;
mymap[s2] = s1;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s1 >> s2;
s4 = mymap[s1];
a[k++] = s4;
a[k++] = s2;
s3 = mymap[s1];
mymap[s3] = s2;
mymap[s2] = s3;
}
cout << s5 << " " << s6 << endl;
for (int i = 0; i < k; i += 2) {
cout << a[i] << " " << a[i + 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[20], s2[20], n1[20], n2[20];
int n;
int main() {
scanf("%s %s", s1 + 1, s2 + 1);
printf("%s %s\n", s1 + 1, s2 + 1);
scanf("%d", &n);
while (n--) {
scanf("%s %s", n1 + 1, n2 + 1);
if (!strcmp(n1 + 1, s1 + 1)) {
for (int i = 1; i <= 10; i++) s1[i] = n2[i];
} else if (!strcmp(n1 + 1, s2 + 1)) {
for (int i = 1; i <= 10; i++) s2[i] = n2[i];
} else if (!strcmp(n2 + 1, s1 + 1)) {
for (int i = 1; i <= 10; i++) s1[i] = n1[i];
} else if (!strcmp(n2 + 1, s2 + 1)) {
for (int i = 1; i <= 10; i++) s2[i] = n1[i];
}
printf("%s %s\n", s1 + 1, s2 + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, last1 = "", last2 = "";
cin >> a >> b;
int n;
cin >> n;
vector<pair<string, string> > ans;
ans.push_back({a, b});
for (int i = 0; i < n; i++) {
string tmp, tmp1;
cin >> tmp >> tmp1;
if (tmp == a) {
a = tmp1;
ans.push_back({a, b});
} else {
b = tmp1;
ans.push_back({a, b});
}
}
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string abc, abc1, abc2, ar[1005], br[1005];
long long n, a, b, i, j, k, c;
cin >> abc >> abc1;
cin >> n;
ar[0] = abc;
br[0] = abc1;
for (i = 1; i <= n; i++) {
cin >> abc >> abc2;
if (abc == abc1) {
ar[i] = ar[i - 1];
br[i] = abc2;
abc1 = abc2;
continue;
}
ar[i] = abc2;
br[i] = abc1;
}
for (i = 0; i <= n; i++) cout << ar[i] << " " << br[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, s1, t, t1;
int main() {
cin >> s >> s1;
int n;
cin >> n;
while (n--) {
cout << s << " " << s1 << endl;
cin >> t >> t1;
if (t == s)
s = t1;
else
s1 = t1;
}
cout << s << " " << s1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
int totalTime = 0;
vector<int> cache;
int par;
int main() {
string s, t;
cin >> s >> t;
int n;
cin >> n;
vector<string> v(n), w(n);
for (int i = 0; i < n; i++) {
cin >> v[i] >> w[i];
}
cout << s << ' ' << t << endl;
for (int i = 0; i < n; i++) {
if (s == v[i]) {
s = w[i];
} else {
t = w[i];
}
cout << s << ' ' << t << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* const argv[]) {
ios_base::sync_with_stdio(0);
string a, b;
cin >> a >> b;
int n;
cin >> n;
string old, newguy;
for (int x = 0; x < (n); ++x) {
cin >> old >> newguy;
cout << a << " " << b << endl;
if (a == old)
a = newguy;
else
b = newguy;
}
cout << a << " " << b << endl;
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, num = 1;
string com;
int arg;
vector<pair<pair<int, int>, int> > d;
cin >> t >> m;
for (int _n((t)-1), q(0); q <= _n; q++) {
sort((d).begin(), (d).end());
cin >> com;
if (com == "defragment") {
if (d.size() > 0) {
d[0].first.second -= d[0].first.first;
d[0].first.first = 0;
for (int _n((d.size() - 1)), i(1); i <= _n; i++) {
int delta = d[i].first.first - d[i - 1].first.second;
d[i].first.first -= delta;
d[i].first.second -= delta;
}
}
continue;
}
cin >> arg;
if (com == "alloc") {
int res = -1;
if (d.size() > 0)
if (d[0].first.first >= arg) {
d.push_back(make_pair(make_pair(0, arg), num++));
res = 1;
}
if (res == -1)
for (int _n((d.size() - 1)), i(1); i <= _n; i++)
if (d[i].first.first - d[i - 1].first.second >= arg) {
d.push_back(make_pair(
make_pair(d[i - 1].first.second, d[i - 1].first.second + arg),
num++));
res = 1;
break;
}
if (res == -1)
if (d.size() > 0)
if (m - d[d.size() - 1].first.second >= arg) {
d.push_back(make_pair(make_pair(d[d.size() - 1].first.second,
d[d.size() - 1].first.second + arg),
num++));
res = 1;
}
if (res == -1)
if (d.size() == 0)
if (m >= arg) {
d.push_back(make_pair(make_pair(0, arg), num++));
res = 1;
}
if (res == -1)
cout << "NULL" << endl;
else
cout << num - 1 << endl;
continue;
}
if (com == "erase") {
bool res = false;
for (int i = 0; i < d.size(); i++)
if (d[i].second == arg) {
swap(d[i], d[d.size() - 1]);
d.pop_back();
res = true;
break;
}
if (!res) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string lower(string s) {
for (int i = 0; i < s.size(); i++) s[i] = tolower(s[i]);
return s;
}
vector<string> sep(string s, char c) {
string temp;
vector<string> res;
for (int i = 0; i < s.size(); i++) {
if (s[i] == c) {
if (temp != "") res.push_back(temp);
temp = "";
continue;
}
temp = temp + s[i];
}
if (temp != "") res.push_back(temp);
return res;
}
template <class T>
T toint(string s) {
stringstream ss(s);
T ret;
ss >> ret;
return ret;
}
template <class T>
string tostr(T inp) {
string ret;
stringstream ss;
ss << inp;
ss >> ret;
return ret;
}
template <class T>
void D(T A[], int n) {
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
template <class T>
void D(vector<T> A, int n = -1) {
if (n == -1) n = A.size();
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
char buf[101];
int mem[111];
int main() {
int t, m;
int cnt = 0;
scanf("%d %d", &t, &m);
memset(mem, -1, sizeof(mem));
for (int(cs) = (0); (cs) < (t); (cs)++) {
int rsize;
scanf("%s", &buf);
if (strcmp(buf, "alloc") == 0) {
scanf("%d", &rsize);
int size = 0;
int saddr = -1;
for (int(i) = (0); (i) < (m); (i)++) {
if (mem[i] != -1) {
size = 0;
continue;
}
size++;
if (size == rsize) {
saddr = i - (size - 1);
break;
}
}
if (saddr != -1) {
++cnt;
for (int(i) = (0); (i) < (rsize); (i)++) mem[saddr + i] = cnt;
printf("%d\n", cnt);
} else
puts("NULL");
}
if (strcmp(buf, "erase") == 0) {
int addr;
scanf("%d", &addr);
bool erased = 0;
if (addr > 0)
for (int(i) = (0); (i) < (m); (i)++)
if (mem[i] == addr) {
erased = 1;
mem[i] = -1;
}
if (!erased) puts("ILLEGAL_ERASE_ARGUMENT");
}
if (strcmp(buf, "defragment") == 0) {
int sp = 0;
for (int i = 0; i < m; i++) {
if (mem[i] == -1) continue;
mem[sp++] = mem[i];
}
for (int(i) = (sp); (i) < (m); (i)++) mem[i] = -1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int t, m, n, id[MAXN], size[MAXN], num = 1;
char op[20];
bool free(int p, int n) {
if (p + n - 1 > m) return false;
for (int i = 0; i < n; ++i) {
if (id[p + i] != 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (cin >> t >> m; t--;) {
cin >> op;
if (op[0] == 'd') {
for (int i = 1, j = 1; j <= m; ++j) {
if (id[j] > 0) {
int tid = id[j];
int tsz = size[j];
id[j] = 0;
size[j] = 0;
id[i] = tid;
size[i] = tsz;
i += tsz;
j += tsz - 1;
}
}
} else {
cin >> n;
bool found = false;
if (op[0] == 'a') {
for (int i = 1; i <= m; ++i) {
if (id[i] != 0)
i += size[i] - 1;
else if (free(i, n)) {
id[i] = num;
size[i] = n;
cout << num++ << endl;
found = true;
break;
}
}
if (!found) cout << "NULL" << endl;
} else {
for (int i = 1; n > 0 && i <= m; ++i) {
if (id[i] == n) {
id[i] = 0;
size[i] = 0;
found = true;
break;
}
}
if (!found) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main(int argc, char* argv[]) {
std::size_t m;
signed int t, n;
signed int mem_start[10000];
signed int cnt, tmp, scs;
char buf[64];
scanf("%d %ld", &t, &m);
memset(mem_start, 0, sizeof mem_start);
cnt = 1;
while (t--) {
scanf("%s", buf);
if (buf[0] != 'd') scanf("%d", &n);
if (buf[0] == 'a') {
tmp = 0;
scs = false;
if (n > m) {
printf("NULL\n");
continue;
}
for (signed int i = 0; i < m; i++) {
if (mem_start[i] == 0) {
tmp++;
} else {
tmp = 0;
}
if (tmp >= n) {
for (signed int j = 1; j <= tmp; j++) mem_start[i - n + j] = cnt;
scs = true;
printf("%d\n", cnt++);
break;
}
}
if (!scs) printf("NULL\n");
}
if (buf[0] == 'e') {
if (n <= 0) {
goto ill;
} else if (n < cnt) {
scs = false;
for (signed int i = 0; i < m; ++i) {
if (mem_start[i] == n) {
mem_start[i] = 0;
scs = true;
}
}
if (scs) continue;
}
ill:
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
if (buf[0] == 'd') {
tmp = 0;
for (signed int i = 0; i < m; i++) {
if (mem_start[i] == 0) {
tmp++;
} else if (tmp > 0) {
memmove(mem_start - tmp + i, mem_start + i, tmp * sizeof(signed int));
memset(mem_start + i, 0, tmp * sizeof(signed int));
tmp = 1;
} else {
tmp = 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 128;
int ar[MAXN], N, M, id;
char command[30];
void alloc() {
int k, bos = 0;
cin >> k;
for (int i = 1; i <= M; i++) {
if (!ar[i])
bos++;
else
bos = 0;
if (bos == k) {
id++;
for (int j = i - bos + 1; j <= i; j++) ar[j] = id;
cout << id << endl;
return;
}
}
cout << "NULL" << endl;
}
void erase() {
int k, flag = 1;
cin >> k;
for (int i = 1; i <= M; i++)
if (ar[i] == k) {
ar[i] = 0;
flag = 0;
}
if (flag || k < 1) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
void defragment() {
int place = 1;
for (int i = 1; i <= M; i++)
if (ar[i]) ar[place++] = ar[i];
for (int i = place; i <= M; i++) ar[i] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
for (int i = 1; i <= N; i++) {
cin >> command;
if (command[0] == 'a') alloc();
if (command[0] == 'e') erase();
if (command[0] == 'd') defragment();
}
return 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 (num != x && j <= m && a[j] == 0) {
num++;
j++;
}
if (num != x) {
i = j;
} else {
blocks++;
for (int k = i; k < j; k++) {
a[k] = blocks;
}
return blocks;
}
}
return 0;
}
int erase(int x) {
if (x <= 0) {
return -1;
}
bool flag = false;
for (int i = 1; i <= m; i++) {
while (a[i] == x) {
a[i++] = 0;
flag = true;
}
}
if (flag == true) {
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;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", &s);
if (s[0] == 'a') {
scanf("%d", &x);
ans = alloc(x);
} else if (s[0] == 'e') {
scanf("%d", &x);
ans = erase(x);
} else if (s[0] == 'd') {
ans = defragment();
}
if (ans == 0) {
printf("NULL\n");
} else if (ans == -1) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
} else if (ans >= 1) {
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int *Memory;
int t, m;
int CountEmpty(int currIndex) {
int c = 1;
for (int i = currIndex + 1; i < m; i++) {
if (Memory[i] == -1)
c++;
else
break;
}
return c;
}
int main() {
cin >> t >> m;
Memory = new int[m];
for (int i = 0; i < m; i++) Memory[i] = -1;
int a = 1;
vector<string> answers;
string temp = "";
string last = "";
char *temp_string = new char[150];
temp_string[0] = '/0';
cin.ignore(1);
for (int i = 0; i < t; i++) {
cin.getline(temp_string, 150);
temp = temp_string;
if (temp == "defragment" && temp == last) continue;
last = temp;
if (temp[0] == 'a') {
bool allocated = false;
int sizeToalloc =
atoi(temp.substr(temp.find_first_of(' '), temp.length()).c_str());
for (int i = 0; i < m; i++) {
if (Memory[i] == -1) {
if (CountEmpty(i) >= sizeToalloc) {
for (int j = 0; j < sizeToalloc; j++) Memory[i++] = a;
allocated = true;
break;
}
}
}
if (allocated) {
answers.push_back(to_string((long long)a));
a++;
} else
answers.push_back("NULL");
continue;
}
if (temp[0] == 'e') {
bool found = false;
int e = atoi(temp.substr(temp.find_first_of(' '), temp.length()).c_str());
if (e < 1) {
answers.push_back("ILLEGAL_ERASE_ARGUMENT");
continue;
}
for (int i = 0; i < m; i++) {
if (Memory[i] == e) {
found = true;
Memory[i] = -1;
}
}
if (!found) answers.push_back("ILLEGAL_ERASE_ARGUMENT");
continue;
}
if (temp[0] == 'd') {
if (CountEmpty(0) == m) continue;
int num = 0;
int *Temp = new int[m];
for (int i = 0; i < m; i++) Temp[i] = Memory[i];
for (int i = 0; i < m; i++) Memory[i] = -1;
int j = 0;
for (int i = 0; i < m; i++)
if (Temp[i] != -1) Memory[j++] = Temp[i];
continue;
}
}
for (int i = 0; i < answers.size(); i++) cout << answers[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int M = 300000100;
const int K = 670000;
const int LIT = 2500;
const int INF = 1 << 30;
const int base = 137;
const double eps = 1e-10;
const int dir[5][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
const int dir2[10][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1},
{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
const int ABS(int a) { return a > 0 ? a : -a; }
int dta[N], t, m;
void init() { memset(dta, 0, sizeof(dta)); }
void all(int x, int &id) {
for (int i = 1; i <= m; i++) {
int cnt = 0, j;
for (j = i; j <= m; j++) {
if (!dta[j])
cnt++;
else
break;
if (cnt == x) break;
}
if (cnt != x) continue;
id++;
for (int k = i; k <= j; k++) dta[k] = id;
cout << id << endl;
return;
}
cout << "NULL" << endl;
}
void era(int x) {
if (x <= 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
bool f = 0;
for (int i = 1; i <= m; i++)
if (dta[i] == x) dta[i] = 0, f = 1;
if (!f) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
void re() {
int tmp[N] = {0};
for (int i = 1, j = 1; i <= m; i++) {
if (!dta[i]) continue;
tmp[j++] = dta[i];
}
for (int i = 1; i <= m; i++) dta[i] = tmp[i];
}
void solve() {
int id = 0;
for (int i = 1; i <= t; i++) {
string s;
int x;
cin >> s;
if (s[0] == 'a') {
cin >> x;
all(x, id);
} else if (s[0] == 'e') {
cin >> x;
era(x);
} else
re();
}
}
int main() {
while (cin >> t >> m) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, t, m, k = 0, f[1000], f1[1000], p, q;
int main() {
string s;
cin >> t >> m;
memset(f, 0, sizeof(f));
getline(cin, s);
for (i = 1; i <= t; i++) {
getline(cin, s);
if (s[0] == 'a') {
int x = 0;
for (j = 6; j < s.size(); j++) x = x * 10 + s[j] - 48;
p = 1;
bool flag = false;
while (p <= m) {
while (f[p] != 0 && p <= m) p++;
q = p;
while (f[q] == 0 && q <= m) q++;
if (q - p >= x) {
k++;
cout << k << endl;
for (j = p; j <= p + x - 1; j++) f[j] = k;
flag = true;
break;
}
p = q;
}
if (flag == false) cout << "NULL" << endl;
} else if (s[0] == 'e') {
p = 1;
int x = 0;
for (j = 6; j < s.size(); j++) x = x * 10 + s[j] - 48;
while (f[p] != x && p <= m) p++;
if (p > m || x == 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
while (f[p] == x && p <= m) {
f[p] = 0;
p++;
}
}
} else {
int d = 0;
memset(f1, 0, sizeof(f1));
for (j = 1; j <= m; j++)
if (f[j] != 0) f1[++d] = f[j];
memcpy(f, f1, sizeof(f));
}
}
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;
int d[110], t, m, c, b = 0, i, j, k, l;
string s;
int main() {
cin >> t >> m;
for (k = 0; k < t; k++) {
cin >> s;
if (s[0] == 'a') {
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[0] == 'e') {
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[0] == 'd') {
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 t, n;
int p = 0;
bool used[120];
int siz[120];
int id[120];
set<int> S;
int allo(int sz) {
for (int i = 1; i + sz - 1 <= n; i++) {
if (used[i]) continue;
int f = 0;
for (int j = i; j < i + sz; j++) {
if (used[j]) f = 1;
}
if (!f) {
siz[i] = sz;
for (int j = i; j < i + sz; j++) {
used[j] = 1;
}
id[i] = ++p;
S.insert(p);
return p;
}
}
return -1;
}
void eras(int ID) {
for (int i = 1; i <= n; i++) {
if (id[i] == ID) {
id[i] = 0;
for (int j = i; j < i + siz[i]; j++) used[j] = 0;
siz[i] = 0;
break;
}
}
S.erase(ID);
}
void defrag() {
for (int i = 2; i <= n; i++) {
if (used[i] && !used[i - 1]) {
int pos = i - 1;
for (int j = 1; j < i; j++) {
if (!used[j]) {
pos = j;
break;
}
}
swap(used[i], used[pos]);
swap(siz[i], siz[pos]);
swap(id[i], id[pos]);
}
}
}
int main() {
scanf("%d %d", &t, &n);
memset(used, false, sizeof(used));
while (t--) {
string s;
int tmp;
cin >> s;
if (s[0] == 'a') {
cin >> tmp;
int pp = allo(tmp);
if (pp == -1)
printf("NULL\n");
else
printf("%d\n", pp);
} else if (s[0] == 'd') {
defrag();
} else {
cin >> tmp;
if (S.find(tmp) == S.end())
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
eras(tmp);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int n;
int l;
int r;
int size;
node() {}
node(int a, int b, int c, int d, node *ne, node *pre)
: n(a), l(b), r(c), size(d), next(ne), prev(pre) {}
node *next;
node *prev;
};
int toINT(char an[], int s) {
int total = 0;
for (int i = s; an[i] != '\0'; i++) total = total * 10 + an[i] - '0';
return total;
}
node *alloc = NULL, *space, *temp;
char command[100];
int t, m, counts = 1;
void deletes(node *head, node *del, bool flag) {
if (del == head) {
if (flag == 0) space = del->next;
if (flag == 1) alloc = del->next;
if (del->next != NULL) del->next->prev = NULL;
} else {
del->prev->next = del->next;
if (del->next != NULL) del->next->prev = del->prev;
}
delete del;
}
void insert(node *head, node *in, bool flag) {
if (head == NULL) {
if (flag == 1) alloc = in;
if (flag == 0) space = in;
in->next = NULL;
return;
}
while (head->next != NULL) {
if (head->l > in->l) break;
head = head->next;
}
if (head->l > in->l) {
if (flag == 0) {
if (head->prev != NULL && head->prev->r + 1 == in->l) {
head->prev->r = in->r;
head->prev->size += in->size;
if (head->prev->r + 1 == head->l) {
head->prev->r = head->r;
head->prev->size += head->size;
deletes(space, head, 0);
}
return;
}
if (in->r + 1 == head->l) {
head->l = in->l;
head->size += in->size;
return;
}
}
in->next = head;
in->prev = head->prev;
if (head->prev != NULL)
head->prev->next = in;
else {
if (flag == 1) alloc = in;
if (flag == 0) space = in;
}
head->prev = in;
} else {
if (flag == 0 && in->l == head->r + 1) {
head->r = in->r, head->size += in->size;
return;
}
head->next = in;
in->prev = head;
in->next = NULL;
}
}
int main() {
scanf("%d %d\n", &t, &m);
space = new node(-1, 1, m, m, NULL, NULL);
for (int i = 0; i < t; i++) {
gets(command);
if (strncmp(command, "alloc", 5) == 0) {
temp = space;
int v = toINT(command, 6);
while (temp != NULL) {
if (temp->size >= v) break;
temp = temp->next;
}
if (temp == NULL)
printf("NULL\n");
else if (temp->size == v) {
node *al = new node(*temp);
printf("%d\n", counts);
al->n = counts++;
deletes(space, temp, 0);
insert(alloc, al, 1);
} else {
node *al = new node(*temp);
printf("%d\n", counts);
al->n = counts++;
al->r = al->l + v - 1;
al->size = v;
insert(alloc, al, 1);
temp->l += v, temp->size = temp->r - temp->l + 1;
}
}
if (strncmp(command, "erase", 5) == 0) {
temp = alloc;
int v = toINT(command, 6);
while (temp != NULL) {
if (temp->n == v) break;
temp = temp->next;
}
if (temp == NULL)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
node *sp = new node(*temp);
deletes(alloc, temp, 1);
insert(space, sp, 0);
}
}
if (strncmp(command, "defragment", 10) == 0) {
int to = 0;
temp = alloc;
while (temp != NULL) {
temp->l = 1 + to;
temp->r = 1 + to + temp->size - 1;
to += temp->size;
temp = temp->next;
}
if (to != 0) space = new node(-1, to + 1, m, m - to, NULL, NULL);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25];
int a[1005];
int b[1005];
int main() {
int t, m, n, num;
while (scanf("%d%d", &t, &m) != EOF) {
num = 1;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
while (t--) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &n);
int flag = 0;
for (int i = 1; i <= m; i++) {
if (flag == 1) break;
if (a[i] == 0) {
int cnt = 1;
if (cnt == n) {
a[i] = num;
b[num] = 1;
printf("%d\n", num);
num++;
flag = 1;
}
for (int j = i + 1; j <= m; j++) {
if (a[j] == 0) {
cnt++;
if (cnt == n) {
for (int k = i; k <= j; k++) a[k] = num;
b[num] = 1;
printf("%d\n", num);
num++;
flag = 1;
break;
}
} else
break;
}
}
}
if (flag == 0) printf("NULL\n");
} else if (s[0] == 'e') {
scanf("%d", &n);
if (n <= 0 || n >= num || b[n] == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
for (int i = 1; i <= m; i++) {
if (a[i] == n) a[i] = 0;
}
b[n] = 0;
}
} else if (s[0] == 'd') {
int c[1005];
memset(c, 0, sizeof(c));
int k = 1;
for (int i = 1; i <= m; i++) {
if (a[i] != 0) {
c[k++] = a[i];
a[i] = 0;
}
}
for (int i = 1; i <= k; i++) {
a[i] = c[i];
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, t = 0, m, tt, i, j, k, g, x, u = 0, nm = 0, tn;
string s;
struct sd {
long long l, r, num;
} a[102] = {0};
bool cmp(sd x, sd y) { return x.l < y.l; }
int main() {
scanf("%lld%lld", &tt, &m);
for (g = 1; g <= tt; ++g) {
cin >> s;
if (s[0] == 'a') {
scanf("%lld", &x);
u = 0;
tn = t;
for (i = 0; i <= tn; ++i)
if ((a[i].r + x < a[i + 1].l && i + 1 <= t) ||
(a[i].r + x <= m && i + 1 > t)) {
a[++t].l = a[i].r + 1;
a[t].r = a[i].r + x;
a[t].num = ++nm;
printf("%lld\n", nm);
sort(a + 1, a + t + 1, cmp);
u = 1;
break;
}
if (u == 0) printf("NULL\n");
}
if (s[0] == 'e') {
scanf("%lld", &x);
u = 0;
for (i = 1; i <= t; ++i)
if (a[i].num == x) {
a[i].l = 1000000000;
sort(a + 1, a + t + 1, cmp);
u = 1;
t--;
break;
}
if (u == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
}
if (s[0] == 'd') {
for (i = 1; i <= t; ++i) {
a[i].r = a[i].r - a[i].l + a[i - 1].r + 1;
a[i].l = a[i - 1].r + 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
set<pair<pair<int, int>, int> > mem;
int last_id = 0;
for (int i = 0; i < n; i++) {
string op;
cin >> op;
if (op[0] == 'd') {
set<pair<pair<int, int>, int> > mem2;
int prv = 0;
while (((int)(mem).size())) {
auto cur = *mem.begin();
mem.erase(mem.begin());
int diff = cur.first.first - prv;
cur.first.first -= diff;
cur.first.second -= diff;
mem2.insert(cur);
prv = cur.first.second;
}
mem.swap(mem2);
} else if (op == "erase") {
int id;
cin >> id;
bool found = false;
for (auto memb : mem)
if (memb.second == id) {
mem.erase(memb);
found = true;
break;
}
if (!found) cout << "ILLEGAL_ERASE_ARGUMENT" << '\n';
} else {
int len;
cin >> len;
auto it = mem.begin();
bool found = false;
int prv = 0;
while (!found and it != mem.end()) {
if (prv + len <= it->first.first) {
last_id++;
mem.insert(make_pair(make_pair(prv, prv + len), last_id));
cout << last_id << '\n';
found = true;
} else
prv = it->first.second;
it++;
}
if (!found and prv + len <= m) {
last_id++;
mem.insert(make_pair(make_pair(prv, prv + len), last_id));
cout << last_id << '\n';
found = true;
}
if (!found) cout << "NULL\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
int n, n_q, tmp[10], M[1001], run = 0, x = 0, start[101], fin[101], u = 1;
char s[15];
int main() {
scanf("%d%d", &n_q, &n);
for (int i = 0; i < n_q; i++) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d", &tmp[0]);
for (int j = 0; j < n; j++) {
if (M[j] > 0) continue;
run = j;
while (M[run] == 0 && run - j < tmp[0] && run < n) run++;
if (run - j == tmp[0]) {
++x;
start[x] = j;
for (; j < run; j++) M[j] = x;
fin[x] = run - 1;
printf("%d\n", x);
goto step2;
}
j = run;
}
printf("NULL\n");
step2:;
} else if (s[0] == 'e') {
u = 0;
scanf("%d", &tmp[0]);
if (tmp[0] == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
for (int j = 0; j < n; j++) {
if (M[j] == tmp[0]) {
u = 1;
M[j] = 0;
}
}
if (u == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
skip:;
} else {
run = 0;
while (run < n && M[run] != 0) run++;
for (int j = run + 1; j < n; j++) {
if (M[j] != 0) {
M[run] = M[j];
M[j] = 0;
run++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[110];
int main() {
int t, m;
int num;
string cmd;
int id = 1;
int qi;
while (cin >> t >> m) {
id = 1;
memset(arr, 0, sizeof arr);
while (t--) {
cin >> cmd;
if (cmd == "alloc") {
cin >> num;
qi = -1;
for (int i = 1; i <= m; i++) {
int cun = 0;
for (int j = i; j <= m; j++) {
if (arr[j] == 0)
cun++;
else
break;
}
if (cun >= num) {
qi = i;
break;
}
}
if (qi == -1) {
puts("NULL");
continue;
}
int nw = id++;
printf("%d\n", nw);
for (int i = qi; i < qi + num; i++) {
arr[i] = nw;
}
} else if (cmd == "erase") {
cin >> num;
if (num <= 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
int flag = 0;
for (int i = 1; i <= m; i++) {
if (arr[i] == num) {
flag = 1;
arr[i] = 0;
}
}
if (flag == 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
} else if (cmd == "defragment") {
int jj = 1;
for (int i = 1; i <= m; i++) {
if (arr[i]) arr[jj++] = arr[i];
}
for (int i = jj; i <= m; i++) arr[i] = 0;
}
}
}
cin >> t;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[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 (a[j] != 0) f = 1;
if (f == 0) {
for (j = i; j < i + x; j++) a[j] = c;
return 1;
}
}
return 0;
}
int main() {
int i, j, c, x, f;
while (cin >> t >> m) {
c = 1;
memset(a, 0, sizeof(a));
while (t--) {
cin >> s;
if (s[0] == 'a') {
cin >> x;
if (check(x, c) == 1)
cout << c++ << endl;
else
cout << "NULL" << endl;
} else if (s[0] == 'e') {
cin >> x;
if (x == 0)
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
else {
f = 0;
for (i = 1; i <= m; i++) {
if (a[i] == x) {
a[i] = 0;
f = 1;
}
}
if (f == 0) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else if (s[0] == 'd') {
i = j = 1;
while (j <= m) {
a[i] = a[j];
if (a[i] != 0) {
if (j > i) a[j] = 0;
i++;
}
j++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace teorNum {
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
template <typename num>
int sign(num n) {
return n >= 0 ? 1 : -1;
}
} // namespace teorNum
namespace geom {
inline bool doubleEqual(double a, double b, double eps = 0.001) {
return abs(a / b - 1) <= eps;
}
const double pi = std::atan(1.0f) * 4;
class vec {
public:
vec() = default;
vec(int len) : data(len){};
vec(double x, double y) : data({x, y}){};
vec(double x, double y, double z) : data({x, y, z}){};
vec(const vec& temp) : data(temp.data) {}
vec(const std::initializer_list<double>& list) {
for (auto& element : list) data.push_back(element);
}
friend const vec& operator+(const vec& left);
friend const vec operator-(const vec& left);
friend vec& operator+=(vec& left, const vec& right);
friend vec& operator-=(vec& left, const vec& right);
friend vec& operator*=(vec& left, const double right);
friend vec& operator/=(vec& left, const double right);
friend bool operator==(const vec& left, const vec& right);
friend bool operator!=(const vec& left, const vec& right);
double& operator[](int i) { return data[i]; };
const double& operator[](int i) const { return data[i]; };
vec& operator=(const vec& right) {
data = right.data;
return *this;
};
friend const vec operator+(const vec& left, const vec& right);
friend const vec operator-(const vec& left, const vec& right);
friend const vec operator*(const vec& left, const double right);
friend const vec operator*(const double left, const vec& right);
friend const vec operator/(const vec& left, const double right);
friend const vec operator/(const double left, const vec& right);
friend ostream& operator<<(ostream& out, const vec& a);
friend istream& operator>>(istream& in, vec& a);
int size() const { return data.size(); };
double length() const {
double sum = 0;
for (int i = 0; i < size(); ++i) sum += (data[i] * data[i]);
return sqrt(sum);
}
double scalarMupltiply(const vec& right) const {
double ans = 0;
for (int i = 0; i < size(); ++i) ans += (data[i] * right[i]);
return ans;
}
const vec vectorMultiply(const vec& right) const {
if (size() != right.size()) throw "Different sizes";
if (size() < 2 || size() > 3) throw "Wrong size";
vec a(3), b(3);
if (size() == 2) {
a = {data[0], data[1], 0};
b = {right[0], right[1], 0};
} else {
a = *this;
b = right;
}
vec ans(3);
ans = {a[1] * b[2] - a[2] * b[1], -a[0] * b[2] + a[2] * b[0],
a[0] * b[1] - a[1] * b[0]};
return ans;
}
double angle() { return acos(scalarMupltiply({1, 0}) / length()); };
double angleBetweenVectors(const vec& b) {
return acos(scalarMupltiply(b) / b.length() / length());
};
const vec rotate(double angle) {
return {data[0] * cos(angle) - data[1] * sin(angle),
data[0] * sin(angle) + data[1] * cos(angle)};
};
private:
vector<double> data;
};
const vec& operator+(const vec& left) { return left; };
const vec operator-(const vec& left) {
vec temp(left);
return temp *= -1;
};
vec& operator+=(vec& left, const vec& right) {
if (left.size() != right.size()) throw "Different sizes";
for (int i = 0; i < left.size(); ++i) left[i] += right[i];
return left;
}
vec& operator-=(vec& left, const vec& right) { return left += (-right); };
vec& operator*=(vec& left, const double right) {
for (int i = 0; i < left.size(); ++i) left[i] *= right;
return left;
}
vec& operator/=(vec& left, const double right) {
for (int i = 0; i < left.size(); ++i) left[i] /= right;
return left;
}
bool operator==(const vec& left, const vec& right) {
for (int i = 0; i < left.size(); ++i)
if (!doubleEqual(left[i], right[i])) return 0;
return 1;
};
bool operator!=(const vec& left, const vec& right) { return !(left == right); }
const vec operator+(const vec& left, const vec& right) {
vec temp = left;
return temp += right;
}
const vec operator-(const vec& left, const vec& right) {
return left + (-right);
}
const vec operator*(const vec& left, const double right) {
vec temp = left;
return temp *= right;
}
const vec operator*(const double left, const vec& right) {
vec temp = right;
return temp *= left;
}
const vec operator/(const vec& left, const double right) {
vec temp = left;
return temp /= right;
}
const vec operator/(const double left, const vec& right) {
vec temp = right;
return temp *= left;
}
ostream& operator<<(ostream& out, const vec& a) {
for (int i = 0; i < a.size(); ++i) out << a[i] << " ";
return out;
}
istream& operator>>(istream& in, vec& a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
double square(const std::initializer_list<vec>& list) {
vec ans((list.end() - 1)->vectorMultiply(*list.begin()));
for (auto iter = list.begin(); iter != list.end() - 1; ++iter)
ans += (*iter).vectorMultiply(*(iter + 1));
return ans.length() / 2;
}
} // namespace geom
using namespace geom;
using namespace teorNum;
void solution() {
long long t, m;
cin >> t >> m;
vector<long long> memory(m + 1, 0);
memory[0] = 1;
long long historyCount = 0;
vector<long long> history(t + 2, -1);
vector<long long> historyLen(t + 2, -1);
for (int i = 0; i < t; ++i) {
string command;
cin >> command;
if (command == "defragment") {
long long start = 1;
for (int i1 = 1; i1 <= m; ++i1) {
int i2 = 1;
if (memory[i1] == 1) {
for (i2 = 1; i2 <= t; ++i2) {
if (history[i2] == i1) break;
}
for (int i3 = 0; i3 < historyLen[i2]; ++i3) {
swap(memory[i3 + start], memory[history[i2] + i3]);
}
history[i2] = start;
start += historyLen[i2];
i1 = start - 1;
}
}
continue;
}
long long count;
cin >> count;
if (command == "alloc") {
long long start = 1;
int i1 = 1;
for (i1 = 1; i1 <= m; ++i1) {
if (memory[i1] == 0 && memory[i1 - 1] == 1) start = i1;
if (memory[i1] == 0 && i1 - start + 1 >= count) {
for (int i3 = start; i3 < start + count; ++i3) memory[i3] = 1;
history[++historyCount] = start;
historyLen[historyCount] = count;
cout << historyCount << endl;
break;
}
if (memory[i1] == 1) {
start = 1000;
}
}
if (i1 == m + 1) cout << "NULL" << endl;
}
if (command == "erase") {
if (count < 1 || count >= t) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
}
if (history[count] == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
continue;
} else {
for (int i1 = history[count]; i1 < history[count] + historyLen[count];
++i1) {
memory[i1] = 0;
}
history[count] = -1;
historyLen[count] = -1;
}
}
}
}
int main() { solution(); }
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
int size;
cin >> size;
vector<int> mem(size);
vector<int> allocSize(1);
vector<int> ps(1);
for (int qqq = 1; qqq < t + 1; ++qqq) {
string op;
cin >> op;
;
if (op == "alloc") {
int reqSz;
cin >> reqSz;
;
int foundP = -1;
int accSz = 0;
for (int i = 0; i < size - 1 + 1; ++i)
if (mem[i] == 0) {
accSz++;
if (accSz == reqSz) {
foundP = i - reqSz + 1;
break;
}
} else {
accSz = 0;
i += allocSize[mem[i]] - 1;
}
if (foundP == -1) {
cout << "NULL";
} else {
allocSize.push_back(reqSz);
mem[foundP] = ps.size();
ps.push_back(foundP);
cout << mem[foundP];
}
cout << '\n';
} else if (op == "erase") {
int id;
cin >> id;
;
if (id < 1 || id >= ps.size() || ps[id] == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else {
mem[ps[id]] = 0;
ps[id] = -1;
}
} else {
int from = 0;
int to = 0;
while (from < size) {
if (mem[from] == 0)
from++;
else {
int id = mem[from];
mem[from] = 0;
mem[to] = id;
ps[id] = to;
from += allocSize[id];
to += allocSize[id];
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
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;
int n, m;
int l[12000], r[12000];
int v[1200];
int now = 0;
int main() {
int i, j, k;
scanf("%d%d", &m, &n);
memset(l, -1, sizeof(l));
memset(r, -1, sizeof(r));
while (m--) {
char s[11];
scanf("%s", s);
if (strcmp(s, "alloc") == 0) {
scanf("%d", &k);
int go = 0;
for (i = 1; i + k - 1 <= n; i++) {
for (j = i; j <= i + k - 1; j++) {
if (v[j]) break;
}
if (j == i + k) {
go = 1;
++now;
for (j = i; j <= i + k - 1; j++) {
v[j] = now;
}
l[now] = i;
r[now] = i + k - 1;
break;
}
}
if (!go) {
puts("NULL");
} else {
printf("%d\n", now);
}
} else if (strcmp(s, "erase") == 0) {
scanf("%d", &k);
if (k < 1 || k > now || l[k] == -1) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
for (i = 1; i <= n; i++) {
if (v[i] == k) v[i] = 0;
}
l[k] = r[k] = -1;
} else {
int go = 1;
while (go) {
go = 0;
for (i = 1; i <= n; i++) {
if (v[i]) continue;
for (j = i + 1; j <= n; j++) {
if (v[j]) break;
}
if (j == n + 1) continue;
go = 1;
for (j = 1; j <= now; j++) {
if (l[j] > i) {
--l[j];
--r[j];
}
}
memset(v, 0, sizeof(v));
for (j = 1; j <= now; j++) {
if (l[j] == -1) continue;
for (k = l[j]; k <= r[j]; k++) {
v[k] = j;
}
}
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
bool success, chk;
int t, m, i, j, n, curr, temp, id, iden;
scanf("%d %d", &t, &m);
int arr[m + 1];
memset(arr, 0, sizeof(arr));
curr = 1;
temp = 1;
iden = 1;
while (t--) {
string a;
cin >> a;
if (a == "alloc") {
scanf("%d", &n);
success = false;
for (i = 1; i <= m - n + 1; i++) {
if (arr[i] == 0) {
chk = true;
temp = n;
j = i;
while (temp--) {
if (arr[j] != 0) {
chk = false;
break;
}
j++;
}
if (chk) {
success = true;
j = i;
temp = n;
while (temp--) {
arr[j] = iden;
j++;
}
}
}
if (success) {
break;
}
}
if (!success) {
printf("NULL\n");
} else {
printf("%d\n", iden);
iden++;
}
} else if (a == "erase") {
scanf("%d", &id);
if (id <= 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
chk = false;
for (i = 1; i <= m; i++) {
if (arr[i] == id) {
chk = true;
arr[i] = 0;
}
}
if (!chk) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
continue;
}
} else if (a == "defragment") {
int brr[m + 1];
memset(brr, 0, sizeof(brr));
j = 1;
for (i = 1; i <= m; i++) {
if (arr[i] != 0) {
brr[j] = arr[i];
j++;
}
}
for (i = 0; i <= m; i++) {
arr[i] = brr[i];
}
continue;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Int>
inline Int read() {
Int flag = 1;
char c = getchar();
while ((!isdigit(c)) && c != '-') c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline void write(Int x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x > 9) write(x / 10);
putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
write(x);
putchar(nextch);
}
struct LR {
long long l, r, idx;
long long length;
LR(long long L = 0, long long R = 0, long long IDX = 0)
: l(L), r(R), idx(IDX), length(r - l + 1) {}
bool operator<(const LR &other) const { return l > other.l; }
};
struct Memory_Manager {
long long from[107], size;
long long l[107], r[107], top;
Memory_Manager() : top(0) { memset(from, 0, sizeof(from)); }
void alloc(long long n) {
bool isSuccess = 0;
for (long long i = 1; i <= size - n + 1; i++) {
bool couldUse = 1;
for (long long j = 0; j < n; j++) {
if (from[i + j]) {
couldUse = 0;
i = i + j;
break;
}
}
if (couldUse) {
top++;
l[top] = i;
r[top] = i + n - 1;
for (long long j = l[top]; j <= r[top]; j++) {
from[j] = top;
}
isSuccess = 1;
break;
}
}
if (isSuccess) {
write(top, '\n');
} else {
puts("NULL");
}
}
void erase(long long x) {
if (x <= 0 || x > top || l[x] == -1) {
puts("ILLEGAL_ERASE_ARGUMENT");
return;
}
for (long long j = l[x]; j <= r[x]; j++) {
from[j] = 0;
}
l[x] = -1;
}
void defragment() {
priority_queue<LR> pq;
for (long long i = 1; i <= top; i++) {
if (l[i] != -1) {
pq.push(LR(l[i], r[i], i));
}
}
memset(from, 0, sizeof(from));
long long Rwall = 0;
while (!pq.empty()) {
LR f = pq.top();
pq.pop();
l[f.idx] = Rwall + 1;
r[f.idx] = Rwall + f.length;
Rwall += f.length;
for (long long i = l[f.idx]; i <= r[f.idx]; i++) {
from[i] = f.idx;
}
}
}
} BerlOS;
long long t, m;
char buf[20], n;
signed main() {
t = read<long long>();
m = read<long long>();
BerlOS.size = m;
while (t--) {
scanf("%s", buf);
switch (buf[0]) {
case 'a':
BerlOS.alloc(read<long long>());
break;
case 'e':
BerlOS.erase(read<long long>());
break;
case 'd':
BerlOS.defragment();
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
struct block {
block(int n, int start, int len) : n(n), start(start), len(len) {}
int n;
int start;
int len;
};
int main() {
int t = 0;
int m = 0;
std::cin >> t >> m;
std::forward_list<block> memmap;
int count = 0;
while (t--) {
std::string cmd;
std::cin >> cmd;
if (cmd == "alloc") {
int size;
std::cin >> size;
if (memmap.empty()) {
if (size <= m) {
memmap.emplace_front(++count, 0, size);
std::cout << count << std::endl;
} else {
std::cout << "NULL" << std::endl;
}
} else {
bool found = false;
auto it = memmap.cbegin();
if (size <= it->start) {
found = true;
memmap.emplace_front(++count, 0, size);
std::cout << count << std::endl;
} else {
for (auto it = memmap.cbegin(); it != memmap.cend(); ++it) {
auto next = std::next(it);
if (size <= (next == memmap.cend() ? m : next->start) - it->start -
it->len) {
found = true;
memmap.emplace_after(it, ++count, it->start + it->len, size);
std::cout << count << std::endl;
break;
}
}
}
if (!found) std::cout << "NULL" << std::endl;
}
} else if (cmd == "erase") {
int n;
std::cin >> n;
bool found = false;
auto prev = memmap.cbefore_begin();
for (auto it = memmap.cbegin(); it != memmap.cend(); ++it, ++prev) {
if (it->n == n) {
found = true;
memmap.erase_after(prev);
break;
}
}
if (!found) std::cout << "ILLEGAL_ERASE_ARGUMENT" << std::endl;
} else if (cmd == "defragment") {
auto it = memmap.begin();
if (it != memmap.end()) {
it->start = 0;
for (auto next = std::next(it); next != memmap.end(); ++next) {
next->start = it->start + it->len;
it = next;
}
}
}
}
return 0;
}
|
#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;
int t, m;
int mem[100];
int cur = 1;
bool ans[105];
bool check(int b, int e) {
for (int i = b; i < e; ++i) {
if (mem[i]) {
return false;
}
}
return true;
}
void def() {
queue<int> q;
for (int i = 0; i < m; ++i) {
if (mem[i]) {
q.push(mem[i]);
mem[i] = 0;
}
}
for (int i = 0; !q.empty(); ++i) {
mem[i] = q.front();
q.pop();
}
}
void er(int num) {
if (num <= 0 || num > 104) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
if (!ans[num]) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
return;
}
for (int i = 0; i < m; ++i) {
if (mem[i] == num) {
mem[i] = 0;
}
}
ans[num] = false;
}
void all(int num) {
for (int i = 0; i + num <= m;) {
if (mem[i]) {
i++;
continue;
}
if (check(i, i + num)) {
printf("%d\n", cur);
ans[cur] = true;
for (int j = i; j < i + num; ++j) {
mem[j] = cur;
}
cur++;
return;
} else {
i++;
}
}
printf("NULL\n");
}
int main(int argc, char *argv[]) {
memset(mem, 0, sizeof(mem));
memset(ans, false, sizeof(ans));
scanf("%d%d", &t, &m);
while (t--) {
char ch[20];
scanf("%s", &ch);
if (ch[0] == 'a') {
int n;
scanf("%d", &n);
all(n);
} else if (ch[0] == 'e') {
int n;
scanf("%d", &n);
er(n);
} else {
def();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int &a, int &b) {
int temp;
temp = a;
a = b;
b = temp;
return;
}
int main() {
int i, j, k;
int N, M, T;
int SIZE;
string op;
int reqsize;
int reqid;
int id = 1;
int SP = 1;
int mem[101];
memset(mem, 0, sizeof(mem));
int remain = 0;
bool got = 0;
map<int, pair<int, int> > MAP;
map<int, pair<int, int> >::iterator it;
int total_erase = 0;
scanf("%d %d", &N, &SIZE);
for (T = 0; T < N; T++) {
remain = SIZE;
cin >> op;
got = 0;
if (op.compare("alloc") == 0) {
cin >> reqsize;
for (i = 0; i < SIZE - reqsize + 1; i++) {
for (j = i; j < reqsize + i; j++)
if (mem[j] != 0) break;
if (j == reqsize + i) {
got = 1;
for (j = i; j < reqsize + i; j++) mem[j] = id;
MAP[id++] = make_pair(i, reqsize);
break;
}
}
if (!got) {
printf("NULL\n");
} else {
printf("%d\n", id - 1);
}
} else if (op.compare("erase") == 0) {
cin >> reqid;
bool no = 1;
for (i = 0; i < SIZE; i++)
if (reqid == mem[i]) {
no = 0;
int temp = mem[i];
for (j = i; mem[j] == temp; j++) mem[j] = 0;
break;
}
if (no || reqid == 0) printf("ILLEGAL_ERASE_ARGUMENT\n");
} else {
int front;
for (i = 0; i < SIZE; i++) {
if (mem[i] == 0) {
for (j = i; j < SIZE; j++)
if (mem[j]) {
swap(mem[i], mem[j]);
break;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m, d[107], cnt = 0, temp, curr;
string s;
void solve() {
cin >> s;
if (s == "alloc") {
cin >> curr;
int j, k;
for (j = 0, k = -1; j < m; ++j) {
if (j - k == curr && !d[j]) {
break;
} else if (d[j]) {
k = j;
}
}
if (j - k == curr && j < m) {
cout << ++cnt << endl;
for (int l = k + 1; l <= j; ++l) {
d[l] = cnt;
}
} else {
cout << "NULL" << endl;
}
}
if (s == "erase") {
cin >> curr;
int p = 0;
for (int j = 0; j < m; ++j) {
if (d[j] == curr && curr) {
d[j] = 0, p = 1;
}
}
if (!p) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
if (s == "defragment") {
for (int j = 0, k = 0; j < m; ++j) {
if (d[j]) {
temp = d[k], d[k] = d[j], d[j] = temp, k++;
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t >> m;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n;
int a[100];
int cnt;
int main() {
cin >> t >> n;
string s;
while (t--) {
cin >> s;
int x;
if (s != "defragment") cin >> x;
if (s == "alloc") {
int tt = 0;
int en = -1;
for (int i = 0; i < n; i++) {
if (a[i])
tt = 0;
else {
tt++;
if (tt == x) {
en = i;
break;
}
}
}
if (en == -1) {
cout << "NULL\n";
continue;
}
cnt++;
for (int i = en - x + 1; i <= en; i++) {
a[i] = cnt;
}
cout << cnt << "\n";
}
if (s == "erase") {
if (x == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
continue;
}
bool f = false;
for (int i = 0; i < n; i++)
if (a[i] == x) {
f = true;
a[i] = 0;
}
if (!f) {
cout << "ILLEGAL_ERASE_ARGUMENT\n";
continue;
}
}
if (s == "defragment") {
bool f[101];
memset(f, 0, sizeof(f));
for (int i = 1; i <= cnt; i++) {
int aa = -1, j = 0, tt = 0;
for (; j < n; j++) {
if (aa != -1 && a[j] != aa) break;
if (aa == -1 && a[j] && !f[a[j]])
aa = a[j], tt++, a[j] = 0;
else if (aa != -1 && aa == a[j])
tt++, a[j] = 0;
}
if (aa == -1) break;
f[aa] = true;
for (int k = 0; k < n; k++) {
if (a[k] == 0) {
for (int i1 = k; i1 < k + tt; i1++) a[i1] = aa;
break;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int me[103];
int mak[300];
int main() {
int i, j, t, m, h, d, st, cas, y, ii;
char qu[100];
scanf("%d%d", &t, &m);
memset(me, 0, sizeof(me));
memset(mak, 0, sizeof(mak));
cas = 1;
for (ii = 0; ii < t; ii++) {
scanf("%s", qu);
if (qu[0] != 'd') scanf("%d", &d);
if (qu[0] == 'a') {
h = 0;
if (d <= 0 || d > m) {
printf("NULL\n");
continue;
}
for (i = 1; i <= m; i++) {
if (me[i] == 0) {
h++;
if (h == d) break;
} else
h = 0;
}
if (h == d) {
printf("%d\n", cas);
mak[cas] = i - d + 1;
for (i = i - d + 1; h; h--, i++) {
me[i] = cas;
}
cas++;
} else
printf("NULL\n");
} else if (qu[0] == 'e') {
if (d <= 0 || d >= cas || !mak[d])
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
for (i = mak[d];; i++)
if (me[i] == d)
me[i] = 0;
else
break;
mak[d] = 0;
}
} else {
st = 1;
for (i = 1; i <= m; i++) {
if (me[i] && i != st) {
mak[me[i]] = st;
h = me[i];
for (i; i <= m; i++)
if (h == me[i]) {
me[st++] = me[i];
me[i] = 0;
} else {
i--;
break;
}
} else if (me[i]) {
me[st++] = me[i];
}
}
}
}
}
|
#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;
int t, m, n, mem[100], i, j, cur;
pair<int, int> blocks[101];
char str[50];
bool found, yes;
int main() {
scanf("%d %d", &t, &m);
for (i = 1; i <= 100; ++i) blocks[i].first = -1;
for (int q = 0; q < t; ++q) {
scanf("%s", &str);
switch (str[0]) {
case 'a':
scanf(" %d", &n);
found = false;
for (i = 0; i <= m - n; ++i) {
yes = true;
for (j = i; j < i + n; ++j)
if (mem[j] > 0) {
yes = false;
break;
}
if (yes) {
found = true;
blocks[++cur] = make_pair(i, n);
for (j = i; j < i + n; ++j) mem[j] = cur;
break;
}
}
if (found)
printf("%d\n", cur);
else
printf("NULL\n");
break;
case 'e':
scanf(" %d", &n);
if (n <= 0 || n > cur || blocks[n].first == -1)
printf("ILLEGAL_ERASE_ARGUMENT\n");
else {
for (j = blocks[n].first; j < blocks[n].first + blocks[n].second; ++j)
mem[j] = 0;
blocks[n].first = -1;
}
break;
case 'd':
for (j = 1; j < m; ++j)
while (j >= 1 && mem[j] > 0 && mem[j - 1] == 0) {
int nmb = mem[j];
mem[j + blocks[nmb].second - 1] = 0;
mem[j - 1] = nmb;
--blocks[nmb].first;
j--;
}
}
getchar();
}
}
|
#include <bits/stdc++.h>
namespace fastIO {
template <typename T>
inline T read() {
T f = 1, x = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
template <typename T>
inline void write(T x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
} // namespace fastIO
using namespace std;
using fastIO ::write;
namespace fastOutput {
inline void print_array1(int *a, int n) {
for (int(i) = (1); (i) <= (n); ++(i)) write(a[i]), putchar(" \n"[i == n]);
}
inline void print_array2(int *a, int n) {
write(n), puts("");
print_array1(a, n);
}
inline void special_print_array1(int *a, int n) {
write(n), putchar(' ');
print_array1(a, n);
}
inline void print_string_in_range(string s, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) putchar(s[i]);
}
inline void print_chars_in_range(char *a, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) putchar(a[i]);
}
} // namespace fastOutput
using fastOutput ::print_array1;
using fastOutput ::print_array2;
using fastOutput ::print_chars_in_range;
using fastOutput ::print_string_in_range;
using fastOutput ::special_print_array1;
int t, m, cnt, l[107], r[107], vis[107], in[107];
string opt;
namespace MemoryManager {
inline void alloc(int x) {
for (int(i) = (1); (i) <= (m - x + 1); ++(i)) {
int flag = 1;
for (int(j) = (i); (j) <= (i + x - 1); ++(j))
if (vis[j]) flag = 0;
if (flag) {
write(++cnt), puts("");
l[cnt] = i, r[cnt] = i + x - 1;
for (int(j) = (l[cnt]); (j) <= (r[cnt]); ++(j)) vis[j] = 1;
in[cnt] = 1;
return;
}
}
return puts("NULL"), void();
}
inline void erase(int x) {
if (x < 1 || x > cnt || !in[x]) return puts("ILLEGAL_ERASE_ARGUMENT"), void();
for (int(i) = (l[x]); (i) <= (r[x]); ++(i)) vis[i] = 0;
l[x] = r[x] = in[x] = 0;
}
inline void defragment() {
for (int(i) = (1); (i) <= (cnt); ++(i))
if (in[i]) {
for (int(j) = (l[i]); (j) <= (r[i]); ++(j)) vis[j] = 0;
while (l[i] > 1 && !vis[l[i] - 1]) l[i]--, r[i]--;
for (int(j) = (l[i]); (j) <= (r[i]); ++(j)) vis[j] = 1;
}
}
} // namespace MemoryManager
using namespace MemoryManager;
int main() {
t = fastIO ::read<int>(), m = fastIO ::read<int>();
while (t--) {
cin >> opt;
if (opt == "alloc")
alloc(fastIO ::read<int>());
else if (opt == "erase")
erase(fastIO ::read<int>());
else
defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[102];
char inp[100];
char inp2[100];
long long p;
int main() {
memset(ar, -1, sizeof(ar));
gets(inp);
int n, m;
sscanf(inp, "%d%d", &n, &m);
int cnt = 1;
for (int i = 0; i < n; i++) {
gets(inp);
if (inp[0] == 'd') {
vector<int> ch;
for (int t = 0; t < m; t++) {
if (ar[t] != -1) ch.push_back(ar[t]);
}
memset(ar, -1, sizeof(ar));
int k = 0;
for (int t = 0; t < m && k < ch.size(); t++, k++) {
ar[t] = ch[k];
}
} else if (inp[0] == 'e') {
sscanf(inp, "%s%lld", inp2, &p);
bool got = false;
for (int t = 0; t < m; t++) {
if (ar[t] == p) {
ar[t] = -1;
got = true;
}
}
if (!got) {
puts("ILLEGAL_ERASE_ARGUMENT");
}
} else {
sscanf(inp, "%s%lld", inp2, &p);
bool perf = false;
for (int t = 0; t + p <= m; t++) {
int j = t;
for (; j < t + p; j++)
if (ar[j] != -1) break;
if (j == t + p) {
j = t;
for (; j < t + p; j++) ar[j] = cnt;
perf = true;
printf("%d\n", cnt);
cnt++;
break;
}
}
if (!perf) puts("NULL");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class point {
public:
int num, p, l;
point() { num = 0, p = -1, l = 0; };
point(int x, int y, int z) { num = x, p = y, l = z; };
point(const point& po) { num = po.num, p = po.p, l = po.l; };
};
map<int, point> m;
map<int, int> rm;
int flag[105], tail = 0, t, n;
int alloc(int x) {
for (int i = 0; i < n - x + 1; ++i) {
if (!flag[i]) {
int tmp = i;
for (int j = i; j < tmp + x; ++j) {
if (flag[j]) i = j;
}
if (i == tmp) {
++tail;
point p(tail, i, x);
m[tail] = p;
rm[i] = tail;
for (int j = i; j < i + x; ++j) {
flag[j] = 1;
}
cout << tail << endl;
return tail;
}
i--;
}
}
return 0;
}
void erase(int x) {
if (x > tail) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
if (m[x].p == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
point p = m[x];
for (int i = p.p; i < p.p + p.l; ++i) {
flag[i] = false;
}
m[x].p = -1;
}
void defragment() {
for (int i = 0; i < n; ++i) {
if (!flag[i]) {
for (int j = i + 1; j < n; ++j) {
if (flag[j]) {
int x = rm[j];
rm[i] = x;
m[x].p = i;
point p = m[x];
for (int k = 0; k < p.l; ++k) {
flag[i + k] = true;
flag[j + k] = false;
}
i += p.l - 1;
break;
}
}
}
}
}
int main() {
int x;
cin >> t >> n;
memset(flag, 0, sizeof(flag));
string s;
for (int i = 0; i < t; ++i) {
cin >> s;
if (s == "alloc") {
cin >> x;
if (!alloc(x)) cout << "NULL" << endl;
} else if (s == "erase") {
cin >> x;
erase(x);
} else
defragment();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[111];
char in[1000];
int main() {
int t, m, i, j;
scanf("%d%d", &t, &m);
int aid = 1;
while (t--) {
scanf("%s", in);
int k;
if (in[0] == 'a') {
scanf("%d", &k);
for (i = 0; i <= m - k; i++) {
for (j = i; j < i + k; j++)
if (a[j] != 0) break;
if (j == i + k) break;
}
if (i <= m - k) {
printf("%d\n", aid);
for (j = i; j < i + k; j++) a[j] = aid;
aid++;
} else {
puts("NULL");
}
} else if (in[0] == 'e') {
bool f = 0;
scanf("%d", &k);
for (i = 0; i < m; i++)
if (a[i] && a[i] == k) {
a[i] = 0;
f = 1;
}
if (!f) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
for (i = 0, j = 0; i < m; i++)
if (a[i]) {
a[j++] = a[i];
}
for (; j < m; j++) a[j] = 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[110];
int main() {
int n, m;
char str[15];
int x, cnt;
while (~scanf("%d%d", &n, &m)) {
memset(mem, 0xff, sizeof(mem));
cnt = 0;
for (int i = 0; i < n; i++) {
scanf(" %s", str);
if (str[0] == 'a') {
scanf("%d", &x);
bool f = false;
for (int j = 0; j <= m - x; j++) {
bool flag = true;
for (int k = 0; k < x; k++) {
if (mem[j + k] != -1) {
flag = false;
break;
}
}
if (flag) {
f = true;
cnt++;
for (int k = 0; k < x; k++) mem[j + k] = cnt;
break;
}
}
if (f)
printf("%d\n", cnt);
else
puts("NULL");
} else if (str[0] == 'e') {
scanf("%d", &x);
if (x <= 0) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
bool f = false;
for (int j = 0; j < m; j++) {
if (mem[j] == x) {
f = true;
mem[j] = -1;
}
}
if (!f) puts("ILLEGAL_ERASE_ARGUMENT");
} else {
int tm = 0;
for (int j = 0; j < m; j++) {
if (mem[j] != -1) mem[tm++] = mem[j];
}
for (int j = tm; j < m; j++) mem[j] = -1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[200];
int cnt = 1;
int T, N;
int all(int x) {
for (int i = 1; i + x - 1 <= N; ++i) {
bool f = 1;
for (int j = i; j - i + 1 <= x; ++j)
if (mem[j] != 0) f = 0;
if (f) {
for (int j = i; j - i + 1 <= x; ++j) mem[j] = cnt;
return cnt++;
}
}
return -1;
}
string era(int x) {
bool f = 0;
for (int i = 1; i <= N; ++i)
if (mem[i] == x) {
f = 1;
mem[i] = 0;
}
if (f && x != 0) return "";
return "ILLEGAL_ERASE_ARGUMENT\n";
}
void def() {
int m2[200], p = 1;
for (int i = 1; i <= N; ++i) {
if (mem[i] != 0) m2[p++] = mem[i];
mem[i] = 0;
}
for (int i = 1; i < p; ++i) mem[i] = m2[i];
}
int main() {
cin >> T >> N;
while (T--) {
string opt;
int x;
cin >> opt;
if (opt == "alloc") {
cin >> x;
int ret = all(x);
if (ret == -1)
puts("NULL");
else
cout << ret << '\n';
} else if (opt == "erase") {
cin >> x;
cout << era(x);
} else if (opt == "defragment")
def();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m;
cin >> t >> m;
int mem[101] = {};
int id = 1;
for (int i = 0; i < t; i++) {
string c;
cin >> c;
if (c == "alloc") {
int s;
cin >> s;
int w = 0;
for (int i = 0; i < m; i++) {
if (mem[i]) {
w = 0;
} else {
w++;
if (w == s) {
for (int j = i - w + 1; j <= i; j++) {
mem[j] = id;
}
cout << id << endl;
id++;
break;
}
}
}
if (w != s) {
cout << "NULL" << endl;
}
} else if (c == "erase") {
long long s;
cin >> s;
bool found = false;
for (int i = 0; i < m; i++) {
if (mem[i] == s && s) {
found = true;
mem[i] = 0;
}
}
if (!found) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
int p = 0;
for (int i = 0; i < m; i++) {
if (mem[i]) {
mem[p] = mem[i];
p++;
}
}
for (; p < m; p++) {
mem[p] = 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem_size, next_block_ind{1};
int super_mem[128];
inline void exec_stupid_alloc() {
int param;
cin >> param;
int end_ind, fmem_size{0};
for (end_ind = 0; end_ind < mem_size; ++end_ind) {
if (super_mem[end_ind] == 0) {
fmem_size++;
if (fmem_size == param) break;
} else {
fmem_size = 0;
}
}
if (fmem_size == param) {
int id = next_block_ind++;
for (int i = end_ind - param + 1; i <= end_ind; ++i) {
super_mem[i] = id;
}
cout << id << endl;
} else {
cout << "NULL" << endl;
}
}
inline void exec_stupid_erase() {
int param;
cin >> param;
if (param == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
return;
}
bool not_found = true;
for (int i = 0; i < mem_size; ++i) {
if (super_mem[i] == param) {
not_found = false;
super_mem[i] = 0;
}
}
if (not_found) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
inline void exec_stupid_defragment() {
int j{0};
for (int i = 0; i < mem_size; ++i) {
if (super_mem[i] != 0) {
super_mem[j] = super_mem[i];
if (i != j) super_mem[i] = 0;
j++;
}
}
}
int main() {
int n;
cin >> n >> mem_size;
for (int i = 0; i < mem_size; ++i) super_mem[i] = 0;
for (int i = 0; i < n; ++i) {
string com;
cin >> com;
if (com == "alloc") {
exec_stupid_alloc();
} else if (com == "erase") {
exec_stupid_erase();
} else {
exec_stupid_defragment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int id = 0;
int m[104];
string cmd;
bool alloc(int n, int p) {
int s = -1, e;
for (e = 0; e <= n; ++e) {
if (0 == m[e] && -1 == s) s = e;
if (-1 != s && 0 != m[e]) {
if (e - s < p) s = -1;
}
}
if (-1 != s) {
++id;
while (p--) m[s++] = id;
return true;
} else
return false;
}
bool erase(int n, int p) {
int i, e = 0;
for (i = 0; i < n; ++i)
if (p == m[i]) m[i] = 0, ++e;
if (0 == e)
return false;
else
return true;
}
void defragment(int n) {
int z, i, nz;
for (z = 0; z < n; ++z)
if (0 == m[z]) break;
for (nz = z; nz < n; ++nz) {
if (0 != m[nz]) {
m[z++] = m[nz];
m[nz] = 0;
}
}
}
int main() {
int t, n, p;
cin >> t >> n;
m[n] = -1;
for (int i = 0; i < t; ++i) {
cin >> cmd;
if ("alloc" == cmd) {
cin >> p;
if (alloc(n, p))
cout << id << endl;
else
cout << "NULL" << endl;
} else if ("erase" == cmd) {
cin >> p;
if (0 == p || !erase(n, p)) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
defragment(n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 15;
const long long INFN = 105;
long long t, m, ll, vis[INFN], cnt;
char ch[INF];
bool check(long long l, long long r) {
if (r > m) return false;
for (long long i = l; i <= r; i++)
if (vis[i] != 1e18) return false;
return true;
}
signed main() {
scanf("%lld %lld", &t, &m);
ll = 1;
for (long long i = 1; i <= m; i++) vis[i] = 1e18;
for (long long i = 1; i <= t; i++) {
scanf("%s", ch);
if (ch[0] == 'a') {
long long xx = 0;
scanf("%lld", &xx);
cnt++;
bool fl = false;
for (long long j = 1; j <= m - xx + 1; j++) {
if (check(j, j + xx - 1)) {
for (long long k = j; k <= j + xx - 1; k++) vis[k] = cnt;
fl = true;
break;
}
}
if (!fl)
cout << "NULL\n", cnt--;
else
cout << cnt << "\n";
}
if (ch[0] == 'e') {
long long xx = 0;
scanf("%lld", &xx);
bool fl = false;
for (long long i = 1; i <= m; i++)
if (vis[i] == xx) {
vis[i] = 1e18;
fl = true;
}
if (!fl) cout << "ILLEGAL_ERASE_ARGUMENT\n";
}
if (ch[0] == 'd') {
for (long long i = 1; i <= m; i++) {
if (vis[i] == 1e18) continue;
long long j = i;
for (; j <= m; j++)
if (vis[i] != vis[j]) break;
j--;
if (j > m) j = m;
long long k = i - 1;
for (; k >= 1; k--)
if (vis[k] != 1e18) break;
k++;
if (k < 1) k = 1;
long long tt = vis[i];
if (k == i) continue;
for (long long l = i; l <= j; l++) vis[l] = 1e18;
for (long long l = k; l <= j - i + k; l++) vis[l] = tt;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[101], t, m, c, b, i, j, k, l;
string s;
int main() {
cin >> t >> m;
for (k = 0; k < t; k++) {
cin >> s;
if (s[0] == 'a') {
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[0] == 'e') {
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[0] == 'd')
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;
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]) {
mem[j] = mem[i];
if (i != j) mem[i] = 0;
j++;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
struct node {
int st, len, id;
} q[N];
bool s[N];
int t, m;
int main() {
string ss;
int a, id;
while (cin >> t >> m) {
id = 0;
memset(s, false, sizeof(s));
memset(q, 0, sizeof(q));
for (int i = 0; i < t; i++) {
cin >> ss;
if (ss[0] == 'a') {
cin >> a;
int j = 1, k = 0;
bool flag = false;
while (1) {
if (j > m || k > m) break;
k = 0;
while (1) {
if (s[j + k] || j + k > m) break;
k++;
}
if (k >= a) {
for (int i = j; i <= j + a - 1; i++) {
s[i] = true;
}
++id;
q[id] = (node){j, a, id};
cout << id << endl;
flag = true;
break;
}
j++;
}
if (!flag) cout << "NULL" << endl;
} else if (ss[0] == 'e') {
cin >> a;
if (a < 0 || a > id || q[a].id == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
for (int j = q[a].st; j <= q[a].st + q[a].len - 1; j++) {
s[j] = false;
}
q[a].id = 0;
q[a].st = 0;
q[a].len = 0;
}
} else if (ss[0] == 'd') {
int cnt = 0, k, j = 1, cur = 0;
while (j <= m) {
if (s[j]) {
cnt++;
for (k = 1; k <= id; k++)
if (j == q[k].st) break;
if (q[k].id > 0) {
j += q[k].len - 1;
if (cnt > 1) {
q[k].st = cur + 1;
cur += q[k].len;
} else {
cur = q[k].len;
q[k].st = 1;
}
}
}
j++;
}
memset(s, false, sizeof(s));
for (int j = 1; j <= cur; j++) {
s[j] = true;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<int> a(M, 0);
int cnt = 1;
while (N--) {
string s;
cin >> s;
if (s[0] == 'a') {
int n;
cin >> n;
int fr = 0, j = 0;
bool flag = true;
for (int i = 0; i < M; i++) {
if (!a[i]) {
if (flag) {
j = i;
flag = false;
}
fr++;
} else {
if (fr >= n) {
break;
}
fr = 0;
flag = true;
}
}
if (fr >= n) {
for (int i = j; i < (j + n); i++) {
a[i] = cnt;
}
cout << cnt << '\n';
cnt++;
} else {
cout << "NULL" << '\n';
}
} else if (s[0] == 'e') {
int n;
cin >> n;
bool flag = false;
for (int i = 0; i < M; i++) {
if (a[i] == n) {
a[i] = 0;
flag = true;
}
}
if (!n || !flag) cout << "ILLEGAL_ERASE_ARGUMENT" << '\n';
} else {
vector<int> b;
for (int i = 0; i < M; i++) {
if (a[i]) b.push_back(a[i]);
}
b.resize(M);
a = b;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class manager {
int *mem;
int *block[3];
int curBlock;
int maxMem;
int addBlock(int n, int pos);
int moveBlock(int x);
public:
manager(int m, int t);
~manager();
int alloc(int n);
int erase(int x);
int defrag();
void print();
void operate(char c, int n);
};
manager::manager(int m, int t) {
curBlock = 0;
maxMem = m;
mem = new int[m];
for (int i = 0; i < m; i++) {
mem[i] = m - i;
}
block[0] = new int[t];
block[1] = new int[t];
block[2] = new int[t];
}
manager::~manager() {
delete[] mem;
delete[] block[0];
delete[] block[1];
delete[] block[2];
}
int manager::alloc(int n) {
int pos = 0;
while (pos < maxMem) {
if (mem[pos] <= 0)
pos = block[0][-mem[pos]] + block[1][-mem[pos]];
else if (mem[pos] < n)
pos += mem[pos];
else
return addBlock(n, pos);
}
return -1;
}
int manager::addBlock(int n, int pos) {
block[0][curBlock] = pos;
block[1][curBlock] = n;
block[2][curBlock] = 1;
for (int i = pos; i < pos + n; i++) mem[i] = -curBlock;
return ++curBlock;
}
int manager::erase(int x) {
--x;
if (x < 0 || x >= curBlock || block[2][x] == 0) return -1;
int i = block[0][x] + block[1][x] - 1;
if (i == maxMem - 1 || mem[i + 1] < 0)
mem[i] = 1;
else
mem[i] = mem[i + 1] + 1;
--i;
while (i >= 0 && (mem[i] == -x || mem[i] > 0)) {
mem[i] = mem[i + 1] + 1;
--i;
}
block[2][x] = 0;
return 0;
}
int manager::defrag() {
int pos = 0;
while (pos < maxMem) {
if (mem[pos] <= 0) {
int b = -mem[pos];
pos += block[1][b];
moveBlock(b);
} else
pos += mem[pos];
}
return 0;
}
int manager::moveBlock(int x) {
int pos = block[0][x];
if (pos - 1 < 0 || mem[pos - 1] <= 0) {
return 0;
} else
--pos;
while (pos - 1 >= 0 && mem[pos - 1] > 0) --pos;
int n = block[1][x];
int endPos = block[0][x] + n - 1;
int i;
for (i = 0; i < n; i++) {
mem[pos + i] = -x;
}
if (endPos == maxMem - 1 || mem[endPos + 1] <= 0) {
mem[endPos] = 1;
} else {
mem[endPos] = mem[endPos + 1] + 1;
}
for (int j = endPos - 1; j >= pos + i; j--) {
mem[j] = mem[j + 1] + 1;
}
block[0][x] = pos;
return 0;
}
void manager::print() {
for (int i = 0; i < maxMem; i++) {
cout << mem[i] << " ";
}
cout << endl;
}
void manager::operate(char c, int n) {
if (c == 'a') {
int ans = alloc(n);
if (ans == -1)
cout << "NULL\n";
else
cout << ans << endl;
} else if (c == 'e') {
int ans = erase(n);
if (ans == -1) cout << "ILLEGAL_ERASE_ARGUMENT\n";
} else if (c == 'd') {
defrag();
}
}
int main() {
int m, t;
cin >> t >> m;
manager man(m, t);
string op;
int n = 0;
for (int i = 0; i < t; i++) {
cin >> op;
if (op[0] != 'd') cin >> n;
man.operate(op[0], n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1005];
struct node {
int l = 0, r = 0;
int num = 0;
};
int n, m, id = 0;
map<int, node> mp;
void state() {
for (int i = 1; i <= m; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
int alloc(int insertlen) {
for (int i = 1; i <= m; i++) {
if (arr[i] == -1) {
int len = 0;
int j;
for (j = i; j <= m; j++) {
if (arr[j] != -1) {
break;
}
len++;
if (len >= insertlen) {
break;
}
}
if (len >= insertlen) {
++id;
for (j = i; j <= i + len - 1; j++) {
arr[j] = id;
}
int start = i;
int end = start + insertlen - 1;
node now;
now.l = start, now.r = end;
mp[id] = now;
return id;
} else {
i = j;
}
}
}
return -1;
}
int erase(int idd) {
node now = mp[idd];
int l = now.l;
int r = now.r;
if (l == 0 && r == 0) return -1;
for (int i = l; i <= r; i++) {
arr[i] = -1;
}
mp[idd].l = mp[idd].r = mp[idd].num = 0;
return 1;
}
void deflagment() {
vector<node> q;
for (int i = 1; i <= m; i++) {
if (arr[i] != -1) {
int j;
for (j = i; j <= m; j++) {
if (arr[j + 1] == -1 || arr[j + 1] != arr[j]) {
break;
}
}
int idd = arr[i];
node now;
now.l = mp[idd].l;
now.r = mp[idd].r;
now.num = idd;
q.push_back(now);
i = j + 1;
}
}
memset(arr, -1, sizeof(arr));
mp.clear();
int lenid = 0;
for (int i = 0; i < q.size(); i++) {
node now = q[i];
int idd = now.num;
for (int j = now.l; j <= now.r; j++) {
arr[++lenid] = idd;
}
int len = now.r - now.l + 1;
int start = lenid - len + 1;
now.l = start, now.r = lenid;
mp[idd] = now;
}
}
int main() {
cin >> n >> m;
memset(arr, -1, sizeof(arr));
for (int i = 1; i <= n; i++) {
string act;
cin >> act;
if (act[0] == 'a') {
int n;
cin >> n;
int result = alloc(n);
if (result == -1) {
cout << "NULL" << endl;
} else {
cout << result << endl;
}
} else if (act[0] == 'e') {
int n;
cin >> n;
int result = erase(n);
if (result == -1) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
deflagment();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char c[20];
int t, m, a[210], b[210], k, n;
int main() {
scanf("%d%d", &t, &m);
getchar();
for (int i1 = 0; i1 < t; i1++) {
cin >> c;
if (c[0] == 'a') {
scanf("%d", &n);
int i = 0, d = 0, j = 0;
while (j < m && d < n)
if (a[j] > 0) {
i = j + b[j];
d = 0;
j = i;
} else {
d++;
j++;
}
if (d == n) {
k++;
printf("%d\n", k);
a[i] = k;
b[i] = n;
} else
printf("NULL\n");
getchar();
}
if (c[0] == 'e') {
scanf("%d", &n);
int i = 0;
while (i < m && a[i] != n) i++;
if (a[i] == n && n != 0) {
a[i] = 0;
b[i] = 0;
} else
printf("ILLEGAL_ERASE_ARGUMENT\n");
getchar();
}
if (c[0] == 'd') {
int i = 0, z = 0;
while (i < m)
if (a[i] > 0) {
a[z] = a[i];
b[z] = b[i];
if (i != z) {
a[i] = 0;
b[i] = 0;
}
i += b[z];
z += b[z];
} else
i++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[101];
int b[101];
struct item {
int loc;
int len;
int num;
};
struct item v[100];
int main() {
memset(a, 0, sizeof(int) * 101);
memset(b, 0, sizeof(int) * 101);
int t, m;
cin >> t >> m;
list<item> vf;
struct item it = {0, m, 0};
vf.push_back(it);
int c = 0;
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (s == "alloc") {
int at;
cin >> at;
bool flag = false;
for (list<item>::iterator j = vf.begin(); j != vf.end(); j++) {
if (j->len > at) {
struct item it = {j->loc, at, ++c};
struct item ti = {j->loc + at, j->len - at, 0};
v[c] = it;
b[j->loc] = c;
a[c] = 1;
*j = ti;
flag = true;
break;
} else {
if (j->len == at) {
struct item it = {j->loc, at, ++c};
v[c] = it;
b[j->loc] = c;
a[c] = 1;
vf.erase(j);
flag = true;
break;
}
}
}
if (flag == false) {
cout << "NULL" << endl;
} else {
cout << c << endl;
}
} else {
if (s == "erase") {
int at;
cin >> at;
if (0 <= at && at <= t && a[at] == 1) {
a[at] = 0;
struct item ti = v[at];
b[v[at].loc] = 0;
list<item>::iterator j = vf.begin();
for (; j != vf.end();) {
if (j->loc + j->len == ti.loc) {
struct item it = {j->loc, j->len + ti.len, 0};
ti = it;
j = vf.erase(j);
} else {
if (ti.loc + ti.len == j->loc) {
struct item it = {ti.loc, j->len + ti.len, 0};
ti = it;
j = vf.erase(j);
} else {
if (j->loc > ti.loc) {
break;
}
j++;
}
}
}
vf.insert(j, ti);
} else {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
} else {
int s = 0;
for (int j = 0; j < 100; j++) {
if (b[j]) {
v[b[j]].loc = s;
b[s] = b[j];
if (j != s) {
b[j] = 0;
}
s += v[b[s]].len;
}
}
struct item it = {s, m - s, 0};
vf.clear();
vf.push_back(it);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-9;
int bit_count(int first) {
return first == 0 ? 0 : 1 + bit_count(first & (first - 1));
}
inline int last_bit(int first) { return first & -first; }
inline int sign(double first) {
return first < -EPS ? -1 : first > EPS ? 1 : 0;
}
inline int sign(int first) { return (first > 0) - (first < 0); }
int nextComb(int first) {
int smallest = first & -first;
int ripple = first + smallest;
int ones = first ^ ripple;
ones = (ones >> 2) / smallest;
return ripple | ones;
}
int gcd(int a, int b) {
while (b) {
int r = a % b;
a = b;
b = r;
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
struct UnionFind {
vector<int> P, S, R;
UnionFind(int n)
: P(vector<int>(n)), S(vector<int>(n, 1)), R(vector<int>(n, 1)) {
for (int i = (int)0; i < (int)n; ++i) P[i] = i;
}
int findP(int first) {
if (P[first] != first) P[first] = findP(P[first]);
return P[first];
}
inline int operator[](const int first) { return findP(first); }
int merge(int a, int b) {
int pa = findP(a), push_back = findP(b);
if (pa == push_back) return 0;
if (R[pa] < R[push_back]) {
P[pa] = push_back;
S[push_back] += S[pa];
} else {
P[push_back] = pa;
S[pa] += S[push_back];
}
if (R[pa] == R[push_back]) ++R[pa];
return 1;
}
};
const int BUF_SIZE = 201;
char buf[BUF_SIZE];
inline string getToken() {
scanf("%s", buf);
return buf;
}
inline string getLine() {
fgets(buf, BUF_SIZE, stdin);
return buf;
}
inline int getInt() {
int a;
scanf("%d", &a);
return a;
}
inline double getDouble() {
double a;
scanf("%lf", &a);
return a;
}
inline int stoi(string first) {
stringstream ss;
int ret;
ss << first;
ss >> ret;
return ret;
}
inline vector<string> split(string &s) {
stringstream ss;
ss << s;
string t;
vector<string> ret;
while (ss >> t) ret.push_back(t);
return ret;
}
template <class K, class V>
vector<K> getKeys(map<K, V> m) {
vector<K> keys;
for (typeof((m).begin()) it = (m).begin(); it != (m).end(); ++it)
keys.push_back(it->first);
return keys;
}
inline double myRand() {
return ((double)rand() / RAND_MAX) + ((double)rand() / RAND_MAX / RAND_MAX);
}
void myCode() {
int t = getInt();
int m = getInt();
vector<bool> mem;
for (int i = (int)0; i < (int)m; ++i) mem.push_back(false);
vector<pair<int, int> > blocks;
while (t--) {
string s = getToken();
if (s == "alloc") {
bool success = false;
int n = getInt();
int i = 0;
while (!success && i <= m - n) {
int j = 0;
while (j < n && !mem[i + j]) j++;
fprintf(stderr, "found %d empty blocks starting from %d\n", j, i);
if (j == n) success = true;
if (!success) i += (j + 1);
}
if (success) {
for (int j = (int)0; j < (int)n; ++j) mem[i + j] = true;
blocks.push_back(pair<int, int>(i, n));
fprintf(stderr,
"successfully allocated a block of size %d starting at address "
"%d\n",
n, i);
printf("%d\n", ((int)(blocks).size()));
} else
printf("NULL\n");
} else if (s == "erase") {
int n = getInt() - 1;
if (n < 0 || n >= ((int)(blocks).size())) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
fprintf(stderr, "ERASE FAIL\n");
} else {
fprintf(stderr, "erasing block %d, starting at %d and of length %d\n",
n + 1, blocks[n].first, blocks[n].second);
if (blocks[n].second == 0) {
printf("ILLEGAL_ERASE_ARGUMENT\n");
fprintf(stderr, "ERASE FAIL\n");
}
for (int i = (int)0; i < (int)blocks[n].second; ++i)
mem[blocks[n].first + i] = false;
blocks[n].second = 0;
}
} else if (s == "defragment") {
int start = 0;
vector<pair<pair<int, int>, int> > blox;
for (int i = (int)0; i < (int)((int)(blocks).size()); ++i) {
blox.push_back(make_pair(blocks[i], i));
}
sort((blox).begin(), (blox).end());
for (int i = (int)0; i < (int)((int)(blox).size()); ++i) {
for (int j = (int)0; j < (int)blox[i].first.second; ++j)
mem[start + j] = true;
blocks[blox[i].second].first = start;
start += blox[i].first.second;
}
for (int i = (int)start; i < (int)m; ++i) mem[i] = false;
}
for (int i = (int)0; i < (int)m; ++i)
fprintf(stderr, "%d ", (mem[i] == true));
fprintf(stderr, "\n");
for (int i = (int)0; i < (int)((int)(blocks).size()); ++i)
fprintf(stderr, "block %d: starting at %d and of length %d\n", i + 1,
blocks[i].first, blocks[i].second);
fprintf(stderr, "\n");
}
}
int main() {
srand(time(NULL));
myCode();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-9;
const long long INF = 100000000000000;
const int MAXN = 110;
int t, m;
int a[MAXN];
map<int, int> start;
int ids = 0;
int main() {
cin >> t >> m;
for (long long query = 1; query <= t; ++query) {
string s;
cin >> s;
if (s == "alloc") {
int n;
cin >> n;
bool done = false;
for (long long i = 1; i <= m - n + 1; ++i) {
bool ok = true;
for (long long j = i; j <= i + n - 1; ++j)
if (a[j]) {
ok = false;
break;
}
if (ok) {
++ids;
cout << ids << endl;
for (long long j = i; j <= i + n - 1; ++j) a[j] = ids;
start[ids] = i;
done = true;
break;
}
}
if (!done) cout << "NULL\n";
}
if (s == "erase") {
int id;
cin >> id;
if (start[id] == 0)
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else {
for (long long i = 1; i <= m; ++i)
if (a[i] == id) a[i] = 0;
start[id] = 0;
}
}
if (s == "defragment") {
int mv = 0;
for (long long i = 1; i <= m; ++i)
if (a[i] == 0)
++mv;
else if (mv) {
a[i - mv] = a[i];
a[i] = 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int curr;
int A[105];
int S[300];
int L[300];
int M, T;
void ALLOCATE(int n) {
int start = -1;
int size = 0;
for (int i = 0; i < M; i++) {
if (A[i] > 0) {
start = -1;
size = 0;
} else if (start == -1) {
start = i;
size = 1;
} else {
size++;
}
if (size == n) {
for (int j = start; j < start + size; j++) A[j] = curr;
S[curr] = start;
L[curr] = size;
cout << curr << "\n";
curr++;
return;
}
}
cout << "NULL\n";
}
void ERASE(int x) {
if (x < 0 || x > 250 || S[x] == -1)
cout << "ILLEGAL_ERASE_ARGUMENT\n";
else {
for (int i = S[x]; i < S[x] + L[x]; i++) A[i] = 0;
S[x] = -1;
L[x] = 0;
}
}
void DEFRAGMENT(void) {
int first = 0;
for (int i = 0; i < M; i++) {
if (A[i] > 0) {
A[first] = A[i];
first++;
}
}
for (int i = first; i < M; i++) A[i] = 0;
int K = -100;
for (int i = 0; i < M; i++) {
if (A[i] != K) {
K = A[i];
S[K] = i;
}
}
}
int main(void) {
cin >> T >> M;
curr = 1;
for (int i = 0; i < M; i++) A[i] = 0;
for (int i = M; i < 105; i++) A[i] = 1000;
for (int i = 0; i < 300; i++) {
S[i] = -1;
L[i] = 0;
}
string S;
int X;
for (int i = 0; i < T; i++) {
cin >> S;
if (S != "defragment") cin >> X;
if (S == "defragment") DEFRAGMENT();
if (S == "alloc") ALLOCATE(X);
if (S == "erase") ERASE(X);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vmem[101];
int NM;
int cid;
string FRAG = "defragment";
string ALLOC = "alloc";
string ERASE = "erase";
int alloc(int space) {
int first = -1, i;
for (i = 0; i < NM; i++) {
if (vmem[i] == -1) continue;
if (i - first - 1 < space) {
first = i;
continue;
} else {
++cid;
for (int j = first + 1; j < first + 1 + space; j++) vmem[j] = cid;
return cid;
}
}
if (i - first - 1 >= space) {
++cid;
for (int j = first + 1; j < first + 1 + space; j++) vmem[j] = cid;
return cid;
}
return -1;
}
int erase(int id) {
for (int i = 0; i < NM; i++) {
if (vmem[i] == id) {
while (i < NM && vmem[i] == id) {
vmem[i] = -1;
i++;
}
return id;
}
}
return -1;
}
void defragment() {
int vmem2[101];
memset(vmem2, -1, sizeof(vmem2));
int p = 0;
for (int i = 0; i < NM; i++) {
if (vmem[i] != -1) {
vmem2[p++] = vmem[i];
}
}
for (int i = 0; i < NM; i++) vmem[i] = vmem2[i];
return;
}
int main() {
cid = 0;
int T;
cin >> T >> NM;
memset(vmem, -1, sizeof(vmem));
while (T--) {
string com = "";
int num;
cin >> com;
if (com == FRAG) {
defragment();
} else {
cin >> num;
if (com == ALLOC) {
int ret = alloc(num);
if (ret == -1)
cout << "NULL" << endl;
else
cout << ret << endl;
} else {
int ret = erase(num);
if (ret == -1) cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, m;
bool use[128];
map<int, pair<int, int> > bl;
map<int, int> d;
int main() {
int cnt = 0;
cin >> t >> m;
for (int op = 0; op < t; op++) {
string s;
cin >> s;
if (s == "alloc") {
int n;
cin >> n;
int pos = 0;
while (pos + n <= m) {
bool f = 1;
for (int i = 0; i < n; i++)
if (use[pos + i]) f = 0;
if (f)
break;
else
pos++;
}
if (pos + n <= m) {
cnt++;
bl[cnt] = make_pair(pos, n);
for (int i = 0; i < n; i++) use[pos + i] = 1;
cout << cnt << endl;
} else
cout << "NULL" << endl;
} else if (s == "erase") {
int n;
cin >> n;
if (bl.find(n) != bl.end()) {
pair<int, int> t = bl[n];
bl.erase(n);
for (int i = 0; i < t.second; i++) use[t.first + i] = 0;
} else
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
} else {
d.clear();
for (int i = 0; i < m; i++) d[i] = i;
for (int i = 1; i < m; i++)
if (use[i] && !use[i - 1]) {
int pos = i - 1;
while (pos > 0 && !use[pos - 1]) pos--;
for (int j = i; j < m && use[j]; j++) {
d[j] = pos + j - i;
use[pos + j - i] = 1;
use[j] = 0;
}
}
vector<pair<int, pair<int, int> > > tmp;
for (map<int, pair<int, int> >::iterator it = bl.begin(); it != bl.end();
it++) {
tmp.push_back(make_pair(
it->first, make_pair(d[it->second.first], it->second.second)));
}
bl.clear();
for (int k = 0; k < tmp.size(); k++) bl[tmp[k].first] = tmp[k].second;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.