text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[400005];
int subtree[400005], n, root, maximo;
bool ans[400005];
pair<int, int> max1, max2;
int dfs(int v, int p) {
subtree[v] = 1;
for (int x : G[v])
if (x != p) subtree[v] += dfs(x, v);
return subtree[v];
}
int centroid(int v, int p) {
for (int x : G[v]) {
if (x == p) continue;
if ((long long)subtree[x] * 2 > n) return centroid(x, v);
}
return v;
}
void dfs2(int v, int p) {
if (((long long)n - maximo - subtree[v]) * 2 > n)
ans[v] = 0;
else
ans[v] = 1;
for (int x : G[v]) {
if (x != p) dfs2(x, v);
}
}
void dfs3(int v, int p) {
ans[v] = 1;
for (int x : G[v]) {
if (x != p) dfs3(x, v);
}
}
int main() {
int a, b, i;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1, -1);
int cent = centroid(1, -1);
ans[cent] = 1;
dfs(cent, -1);
for (int x : G[cent]) {
if (subtree[x] > max1.first) {
max2 = max1;
max1 = make_pair(subtree[x], x);
continue;
}
if (subtree[x] > max2.first) max2 = make_pair(subtree[x], x);
}
for (int x : G[cent]) {
root = x;
if (max1.second == x)
maximo = max2.first;
else
maximo = max1.first;
if (subtree[x] * 2 == n)
dfs3(x, cent);
else
dfs2(x, cent);
}
printf("%d", ans[1]);
for (i = 2; i <= n; i++) printf(" %d", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int inf = 1000 * 1000 * 1000;
size_t MAXN = 400 * 1000 + 100;
vector<vector<int>> g(MAXN);
vector<int> sz(MAXN);
vector<int> mxd(MAXN);
vector<int> mxu(MAXN);
vector<int> answer(MAXN);
int timer = 0;
void dfs1(int v, int p = -1) {
sz[v] = 1;
mxd[v] = 0;
for (auto c : g[v]) {
if (c != p) {
dfs1(c, v);
sz[v] += sz[c];
mxd[v] = max(mxd[v], mxd[c]);
}
}
mxd[v] = max(mxd[v], sz[v] <= n / 2 ? sz[v] : 0);
}
void dfs2(int v, int p = -1) {
if (p == -1) mxu[v] = 0;
vector<int> ch;
for (auto c : g[v]) {
if (c != p) {
mxu[c] = max(mxu[v], n - sz[c] <= n / 2 ? n - sz[c] : 0);
ch.push_back(mxd[c]);
}
}
sort(ch.begin(), ch.end());
for (auto c : g[v]) {
if (c != p) {
if (ch.size() > 1) {
if (lower_bound(ch.begin(), ch.end(), mxd[c]) + 1 == ch.end()) {
mxu[c] = max(mxu[c], ch[ch.size() - 2]);
} else {
mxu[c] = max(mxu[c], ch[ch.size() - 1]);
}
}
}
}
for (auto c : g[v]) {
if (c != p) {
dfs2(c, v);
}
}
}
void dfs(int v, int p = -1) {
bool ok = false;
int maxChild = -1;
for (auto c : g[v]) {
if (c != p) {
dfs(c, v);
if (sz[c] > n / 2) maxChild = c;
}
}
if (maxChild == -1) {
int k = n - sz[v];
if (k <= n / 2) {
ok = true;
} else {
ok = n >= (k - mxu[v]) * 2;
}
} else {
int k = sz[maxChild];
if (k <= n / 2) {
ok = true;
} else {
ok = n >= (k - mxd[maxChild]) * 2;
}
}
answer[v] = ok;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
dfs1(0);
dfs2(0);
dfs(0);
for (int i = 0; i < n; ++i) {
cout << answer[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400000 + 5;
int upsize[maxn], dnsize[maxn], ll[maxn], rr[maxn], pos[maxn], ipos[maxn];
int segt[maxn * 4];
vector<int> e[maxn];
int ans[maxn];
int tn;
int n;
void insert(int x, int l, int r, int p, int v) {
if (l == r) {
segt[x] = ((v <= n / 2) ? v : 0);
return;
}
int mid = (l + r) / 2;
if (p <= mid)
insert(((x) << 1), l, mid, p, v);
else
insert((((x) << 1) | 1), mid + 1, r, p, v);
segt[x] = max(segt[((x) << 1)], segt[(((x) << 1) | 1)]);
}
int query(int x, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return segt[x];
int mid = (l + r) / 2;
if (qr <= mid)
return query(((x) << 1), l, mid, ql, qr);
else if (ql > mid)
return query((((x) << 1) | 1), mid + 1, r, ql, qr);
else
return max(query(((x) << 1), l, mid, ql, mid),
query((((x) << 1) | 1), mid + 1, r, mid + 1, qr));
}
void dfs(int u, int f) {
ipos[ll[u] = pos[u] = ++tn] = u;
for (int v : e[u])
if (v != f) dfs(v, u);
rr[u] = tn;
}
void dfs2(int u, int f) {
if (f) insert(1, 1, n, pos[f], upsize[u]);
int flg = 1;
if (upsize[u] > n / 2) {
int mx = max(ll[u] > 1 ? query(1, 1, n, 1, ll[u] - 1) : 0,
rr[u] < n ? query(1, 1, n, rr[u] + 1, n) : 0);
flg = flg && (upsize[u] - mx <= n / 2);
}
for (int v : e[u]) {
if (v != f)
if (dnsize[v] > n / 2) {
int mx = query(1, 1, n, ll[v], rr[v]);
flg = flg && (dnsize[v] - mx <= n / 2);
}
}
ans[u] = flg;
for (int v : e[u])
if (v != f) dfs2(v, u);
insert(1, 1, n, pos[u], dnsize[u]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++)
insert(1, 1, n, pos[i], dnsize[i] = rr[i] - ll[i] + 1);
for (int i = 1; i <= n; i++) upsize[i] = n - dnsize[i];
dfs2(1, 0);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[400005];
int n;
int maxd[400005], sum[400005], hev[400005], hevsize[400005], maxu[400005];
void dfs1(int u, int fa) {
sum[u] = 1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v != fa) {
dfs1(v, u);
sum[u] += sum[v];
if (sum[v] <= n / 2)
maxd[u] = max(maxd[u], sum[v]);
else
maxd[u] = max(maxd[u], maxd[v]);
if (sum[v] > hevsize[u]) {
hevsize[u] = sum[v];
hev[u] = v;
}
}
}
return;
}
void dfs2(int u, int fa) {
multiset<int> s;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v != fa) {
if (sum[v] <= n / 2)
s.insert(sum[v]);
else
s.insert(maxd[v]);
}
}
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v != fa) {
if (n - sum[v] <= n / 2)
maxu[v] = n - sum[v];
else {
maxu[v] = max(maxu[v], maxu[u]);
s.erase(s.find(sum[v]));
if (!s.empty()) {
maxu[v] = max(*s.rbegin(), maxu[v]);
}
s.insert(sum[v]);
}
dfs2(v, u);
}
}
return;
}
int main() {
int u, v;
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
memset(maxu, 0, sizeof(maxu));
memset(maxd, 0, sizeof(maxd));
dfs1(1, -1);
dfs2(1, -1);
for (int i = 1; i <= n; i++) {
bool flag = true;
if (n - sum[i] > n / 2 && n - sum[i] - maxu[i] > n / 2) flag = false;
if (sum[hev[i]] - maxd[hev[i]] > n / 2) flag = false;
if (i == 1)
cout << flag;
else
cout << " " << flag;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int fa[400010], f[400010], size[400010], g[400010];
struct Edge {
int to;
Edge *next;
};
Edge *E[400010], Tr[400010 << 1];
int cnt;
void addedge(int u, int v) {
Tr[++cnt].to = v;
Tr[cnt].next = E[u];
E[u] = &Tr[cnt];
Tr[++cnt].to = u;
Tr[cnt].next = E[v];
E[v] = &Tr[cnt];
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline int max(int a, int b) {
if (a < b) return b;
return a;
}
bool check(int u) {
int v = -1;
for (Edge *P = E[u]; P; P = P->next) {
int t = 0;
if (P->to != fa[u])
t = size[P->to];
else
t = n - size[u];
if (t > n / 2) v = P->to;
}
if (v == -1) return true;
if (v != fa[u]) return size[v] - f[v] <= n / 2;
return n - size[u] - g[u] <= n / 2;
}
void dfs(int u) {
for (Edge *P = E[u]; P; P = P->next)
if (P->to != fa[u]) {
fa[P->to] = u;
dfs(P->to);
size[u] += size[P->to];
f[u] = max(f[P->to], f[u]);
}
size[u]++;
if (size[u] <= n / 2) f[u] = size[u];
}
void dfs2(int u) {
if (n - size[u] <= n / 2) g[u] = n - size[u];
int mx1 = 0;
int mx2 = 0;
for (Edge *P = E[u]; P; P = P->next)
if (P->to != fa[u]) {
if (f[P->to] < mx2) continue;
mx2 = f[P->to];
if (mx2 > mx1) swap(mx1, mx2);
}
for (Edge *P = E[u]; P; P = P->next)
if (P->to != fa[u]) {
int mx = mx1;
if (mx == f[P->to]) mx = mx2;
g[P->to] = max(g[u], mx);
dfs2(P->to);
}
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int u, v;
u = read();
v = read();
addedge(u, v);
}
dfs(1);
dfs2(1);
for (int i = 1; i <= n; i++) printf("%d ", check(i));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sz[400010];
void dfs(int u, int par, vector<vector<int> >& adj) {
sz[u] = 1;
for (auto it : adj[u])
if (it != par) {
dfs(it, u, adj);
sz[u] += sz[it];
}
}
int furthest_node;
void dfs_centroid(int u, int par, vector<vector<int> >& adj, int N) {
bool flg = true;
for (auto it : adj[u])
if (it != par) {
dfs_centroid(it, u, adj, N);
if (sz[it] > N / 2) flg = false;
}
if (N - sz[u] > N / 2) flg = false;
if (flg) furthest_node = u;
}
int firstCentroid(vector<vector<int> >& adj, int N) {
dfs(1, -1, adj);
dfs_centroid(1, -1, adj, N);
return furthest_node;
}
int max_sz[] = {-1, -1}, max_e;
int res[400010];
void dfs_final(int u, int par, int e, vector<vector<int> >& adj, int N) {
if (sz[u] == N || sz[e] == N - (N / 2))
res[u] = true;
else if (e == max_e) {
res[u] = (N - sz[u] - max_sz[1] <= N / 2);
} else {
res[u] = (N - sz[u] - max_sz[0] <= N / 2);
}
for (auto it : adj[u])
if (it != par) dfs_final(it, u, (e == -1 ? it : e), adj, N);
}
int main() {
int N;
scanf("%d", &N);
vector<vector<int> > adj(N + 1);
for (int i = 0; i < N - 1; ++i) {
int first, second;
scanf("%d%d", &first, &second);
adj[first].push_back(second), adj[second].push_back(first);
}
int root = firstCentroid(adj, N);
dfs(root, -1, adj);
for (auto it : adj[root]) {
if (sz[it] > max_sz[0])
max_sz[1] = max_sz[0], max_sz[0] = sz[it], max_e = it;
else if (sz[it] > max_sz[1])
max_sz[1] = sz[it];
}
dfs_final(root, -1, -1, adj, N);
for (int i = 1; i < N + 1; ++i) printf("%d ", res[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
istream& operator>>(istream& is, pair<S, T>& p) {
return is >> p.first >> p.second;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
vector<int> G[400000];
int par[400000];
int sz[400000];
int N;
void init(int u, int p = -1) {
sz[u] = 1;
par[u] = p;
for (int to : G[u]) {
if (to == p) continue;
init(to, u);
sz[u] += sz[to];
}
}
int cent(int u) {
bool ok = true;
for (int to : G[u]) {
if (to == par[u]) continue;
if (sz[to] > N / 2) ok = false;
}
ok = ok && (N - sz[u] <= N / 2);
if (ok) return u;
int res = -1;
for (int to : G[u]) {
if (to == par[u]) continue;
res = cent(to);
if (res != -1) break;
}
return res;
}
int ans[400000];
void dfs(int u, int p, int ix, int c) {
if (ix > 0)
ans[u] = N - sz[u] - sz[G[c][0]] <= N / 2;
else
ans[u] = (N - sz[G[c][0]] <= N / 2) ||
(N - sz[u] - (int((G[c]).size()) > 1 ? sz[G[c][1]] : 0) <= N / 2);
for (int to : G[u]) {
if (to == p) continue;
dfs(to, u, ix, c);
}
}
int main() {
scanf("%d", &N);
for (int i = (0); i < (N - 1); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
G[u].push_back(v);
G[v].push_back(u);
}
init(0);
int c = cent(0);
init(c);
ans[c] = 1;
sort((G[c]).begin(), (G[c]).end(),
[&](int i, int j) { return sz[i] > sz[j]; });
for (int i = (0); i < (int((G[c]).size())); ++i) {
dfs(G[c][i], c, i, c);
}
for (int i = (0); i < (N); ++i) printf("%s%d", (i ? " " : ""), ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 209;
struct node {
int l, r;
node() {}
node(int l, int r) : l(l), r(r) {}
bool operator<(const node& R) const { return l < R.l; }
};
set<node> S;
set<node>::iterator it;
int main() {
S.insert(node(1, 2e9));
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int l, len, r;
scanf("%d%d", &l, &len);
r = l + len - 1;
int have = 0;
for (it = S.begin(); it != S.end(); it++) {
int L = (*it).l, R = (*it).r;
if (L <= l && R >= r) {
S.erase(it);
printf("%d %d\n", l, r);
if (l != L) {
S.insert(node(L, l - 1));
}
if (r != R) {
S.insert(node(r + 1, R));
}
have = 1;
break;
}
}
if (have) continue;
for (it = S.begin(); it != S.end(); it++) {
int L = (*it).l, R = (*it).r;
if (R - L + 1 >= len) {
l = L, r = L + len - 1;
S.erase(it);
printf("%d %d\n", l, r);
if (l != L) {
S.insert(node(L, l - 1));
}
if (r != R) {
S.insert(node(r + 1, R));
}
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct kxj {
int a, b;
} q[205];
int l[205], r[205];
int main() {
int n;
scanf("%d", &n);
for (int a, b, i = 1; i <= n; i++) {
scanf("%d %d", &a, &b);
q[i] = (kxj){a, b};
}
int t = 0;
l[t] = 1;
r[t++] = 2000000007;
for (int i = 1; i <= n; i++) {
int s = 2000000007, id = -1;
bool flag = 0;
for (int j = 0; j < t; j++) {
if (!flag && r[j] >= l[j] + q[i].b - 1 && s > l[j]) s = l[j], id = j;
if (l[j] <= q[i].a && r[j] >= q[i].a && r[j] >= q[i].a + q[i].b - 1)
s = q[i].a, id = j, flag = 1;
}
printf("%d %d\n", s, s + q[i].b - 1);
if (s == l[id])
l[id] = s + q[i].b;
else {
l[t] = s + q[i].b;
r[t++] = r[id];
r[id] = s - 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int INF = 0x3f3f3f3f;
const double inf = 0x3f3f3f3f3f3f;
const long long LNF = 0x3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int maxn = 1e2 + 100;
const int mod = 1e9 + 7;
const int dr[] = {-1, 0, 1, 0};
const int dc[] = {0, 1, 0, -1};
const char *Hex[] = {"0000", "0001", "0010", "0011", "0100", "0101",
"0110", "0111", "1000", "1001", "1010", "1011",
"1100", "1101", "1110", "1111"};
int n, m;
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
inline int Min(int a, int b) { return a < b ? a : b; }
inline int Max(int a, int b) { return a > b ? a : b; }
inline long long Min(long long a, long long b) { return a < b ? a : b; }
inline long long Max(long long a, long long b) { return a > b ? a : b; }
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int lcm(int a, int b) { return a * b / gcd(a, b); }
inline bool is_in(int r, int c) { return r >= 0 && r < n && c >= 0 && c < m; }
struct Node {
int l, r;
Node() {}
Node(int ll, int rr) : l(ll), r(rr) {}
bool operator<(const Node &p) const { return l < p.l; }
};
Node a[205];
int main() {
while (scanf("%d", &n) == 1) {
int s, d;
int cnt = 1;
a[0] = Node(0, 0);
cin >> s >> d;
printf("%d %d\n", s, s + d - 1);
a[cnt++] = Node(s, s + d - 1);
for (int i = 1; i < n; ++i) {
cin >> s >> d;
--d;
sort(a, a + cnt);
if (a[cnt - 1].r < s) {
printf("%d %d\n", s, s + d);
a[cnt++] = Node(s, s + d);
continue;
}
bool ok = false;
for (int j = 0; j < cnt - 1; ++j) {
if (s > a[j].r && s + d < a[j + 1].l) {
ok = true;
printf("%d %d\n", s, s + d);
a[cnt++] = Node(s, s + d);
break;
}
}
if (!ok) {
bool ok1 = false;
for (int j = 1; j < cnt; ++j) {
if (a[j].l - a[j - 1].r > d + 1) {
printf("%d %d\n", a[j - 1].r + 1, a[j - 1].r + d + 1);
a[cnt++] = Node(a[j - 1].r + 1, a[j - 1].r + d + 1);
ok1 = true;
break;
}
}
if (!ok1) {
printf("%d %d\n", a[cnt - 1].r + 1, a[cnt - 1].r + 1 + d);
a[cnt] = Node(a[cnt - 1].r + 1, a[cnt - 1].r + d + 1);
++cnt;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
bool operator<(const node& b) const { return this->l > b.l; }
};
priority_queue<node> p, q;
int data[210][2];
int main() {
int n;
bool flag;
scanf("%d", &n);
node temp;
temp.l = 1;
temp.r = 1e9 + 1e7;
q.push(temp);
for (int i = 0; i < n; i++) {
scanf("%d%d", &data[i][0], &data[i][1]);
flag = false;
while (!q.empty()) {
node t = q.top();
q.pop();
if (t.l <= data[i][0] && t.r >= (data[i][0] + data[i][1] - 1)) {
data[i][1] = data[i][0] + data[i][1] - 1;
if (t.l < data[i][0]) {
temp.l = t.l;
temp.r = data[i][0] - 1;
q.push(temp);
}
if (t.r > data[i][1]) {
temp.l = data[i][1] + 1;
temp.r = t.r;
q.push(temp);
}
flag = true;
break;
}
p.push(t);
}
if (!flag) {
while (!p.empty()) {
node t = p.top();
p.pop();
if (t.r - t.l + 1 >= data[i][1]) {
data[i][0] = t.l;
data[i][1] = t.l + data[i][1] - 1;
if (t.r > data[i][1]) {
temp.l = data[i][1] + 1;
temp.r = t.r;
q.push(temp);
}
break;
}
q.push(t);
}
}
while (!p.empty()) {
node t = p.top();
p.pop();
q.push(t);
}
}
for (int i = 0; i < n; i++) {
printf("%d %d\n", data[i][0], data[i][1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, cnt = 1, d[222], s[222];
struct node {
int l, r, id;
} p[222];
bool check(int i) {
int l = s[i], r = s[i] + d[i] - 1;
bool flag = true;
for (int i = 1; i < cnt; ++i) {
if (p[i].l > r || p[i].r < l)
continue;
else {
flag = false;
break;
}
}
return flag;
}
bool cmp1(node a, node b) { return a.l < b.l; }
bool cmp2(node a, node b) { return a.id < b.id; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d %d", &s[i], &d[i]);
p[0].l = 0;
p[0].r = 0;
p[0].id = 0;
for (int i = 1; i <= n; ++i) {
if (check(i)) {
p[cnt].l = s[i];
p[cnt].r = s[i] + d[i] - 1;
p[cnt].id = i;
cnt++;
} else {
sort(p, p + cnt, cmp1);
int j;
bool flag = false;
for (j = 1; j < cnt; ++j) {
if (p[j].l - p[j - 1].r - 1 >= d[i]) {
flag = true;
p[cnt].l = p[j - 1].r + 1;
p[cnt].r = p[cnt].l + d[i] - 1;
p[cnt].id = i;
cnt++;
break;
}
}
if (!flag) {
p[cnt].l = p[cnt - 1].r + 1;
p[cnt].r = p[cnt].l + d[i] - 1;
p[cnt].id = i;
cnt++;
}
}
}
sort(p, p + cnt, cmp2);
for (int i = 1; i < cnt; ++i) printf("%d %d\n", p[i].l, p[i].r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int>> ans;
vector<int> starts;
bool can(pair<int, int> cur) {
for (auto i = (0); i < ((int)(ans.size())); ++i) {
int l = max(cur.first, ans[i].first);
int r = min(cur.second, ans[i].second);
if (l <= r) {
return false;
}
}
return true;
}
void prepare() {}
void read() {}
void solve() {
scanf("%d", &n);
starts.push_back(1);
for (auto i = (0); i < (n); ++i) {
int s, d;
scanf("%d%d", &s, &d);
if (can(make_pair(s, s + d - 1))) {
ans.push_back(make_pair(s, s + d - 1));
starts.push_back(s + d);
} else {
for (auto j = (0); j < ((int)(starts.size())); ++j) {
if (can(make_pair(starts[j], starts[j] + d - 1))) {
starts.push_back(starts[j] + d);
ans.push_back(make_pair(starts[j], starts[j] + d - 1));
break;
}
}
}
printf("%d %d\n", ans.back().first, ans.back().second);
sort(starts.begin(), starts.end());
}
}
int main() {
prepare();
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300;
int s[MAXN], d[MAXN];
int st[MAXN];
int n;
set<pair<int, int> > M;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", s + i, d + i);
}
for (int i = 1; i <= n; i++) {
bool flag = 1;
for (int j = 1; j < i; j++) {
if (!(st[j] > s[i] + d[i] - 1 || st[j] + d[j] - 1 < s[i])) {
flag = 0;
break;
}
}
if (flag) {
st[i] = s[i];
M.insert(make_pair(st[i], st[i] + d[i] - 1));
} else {
int beg = 1;
for (set<pair<int, int> >::iterator it = M.begin(); it != M.end(); it++) {
if (it->first - beg >= d[i]) {
st[i] = beg;
break;
}
beg = max(beg, it->second + 1);
}
if (!st[i]) st[i] = beg;
M.insert(make_pair(st[i], st[i] + d[i] - 1));
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", st[i], st[i] + d[i] - 1);
}
}
|
#include <bits/stdc++.h>
struct node {
int s, e;
node* next;
};
node* head;
int n;
int main() {
scanf("%d", &n);
node *cur, *temp;
head = new node;
head->s = 0;
head->e = 0;
head->next = 0;
for (int i = 0, ts, td; i < n; i++) {
scanf("%d%d", &ts, &td);
for (temp = head; temp; temp = temp->next)
if (ts > temp->e && (!temp->next || ts + td - 1 < temp->next->s)) {
cur = new node;
cur->s = ts;
cur->e = ts + td - 1;
cur->next = temp->next;
temp->next = cur;
printf("%d %d\n", cur->s, cur->e);
break;
}
if (!temp)
for (temp = head; temp; temp = temp->next)
if (temp->next == 0 || temp->next->s - temp->e - 1 >= td) {
cur = new node;
cur->s = temp->e + 1;
cur->e = cur->s + td - 1;
cur->next = temp->next;
temp->next = cur;
printf("%d %d\n", cur->s, cur->e);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int inf = (1ll << 30) - 1;
const int N = (int)1e5 + 10;
using namespace std;
int n, k, L[N], R[N];
int second[N], d[N];
pair<int, int> a[N];
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &second[i], &d[i]);
}
a[k++] = make_pair(inf + inf, inf + inf);
for (int i = 1; i <= n; i++) {
int l, r, pos = 0;
while (a[pos].second < second[i]) pos++;
if (second[i] + d[i] - 1 < a[pos].first) {
a[k++] = make_pair(second[i], second[i] + d[i] - 1);
l = second[i];
r = second[i] + d[i] - 1;
} else {
int prev = 0;
for (int j = 0; j < k; j++) {
if (prev + d[i] < a[j].first) {
a[k++] = make_pair(prev + 1, prev + d[i]);
l = prev + 1;
r = prev + d[i];
break;
} else {
prev = a[j].second;
}
}
}
printf("%d %d\n", l, r);
sort(a, a + k);
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
const double EPS = 1e-9;
const int MOD = 1000000007;
const int INF = 2000 * 1000 * 1000;
const int MAX = 1005;
using namespace std;
int popcount(int n) {
bitset<32> b(n);
return b.count();
}
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) {
long long temp = gcd(a, b);
return temp ? (a / temp * b) : 0;
}
template <typename T>
T modpow(T base, T exp, T modulus) {
base %= modulus;
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
inline bool isInteger(const std::string& s) {
if (s.empty() || ((!isdigit(s[0])) && (s[0] != '-') && (s[0] != '+')))
return false;
char* p;
strtol(s.c_str(), &p, 10);
return (*p == 0);
}
pair<int, int> sol[205];
int main() {
int n;
cin >> n;
set<pair<int, int>> sch;
for (int i = 0; i < n; i++) {
int s, d, e;
cin >> s >> d;
e = s + d - 1;
int idx = 0, curs, cure, cursnx, curenx;
bool f = 0;
bool best = 1;
for (auto j : sch) {
int curs = j.first, cure = j.second;
if (e < curs || s > cure)
continue;
else {
best = 0;
break;
}
}
if (best)
sol[i] = (make_pair(s, e)), sch.insert(make_pair(s, e));
else {
if (sch.begin()->first - d - 1 >= 0) {
sol[i] = make_pair(1, d);
sch.insert(sol[i]);
continue;
}
for (auto j : sch) {
if (!idx)
curs = j.first, cure = j.second;
else {
cursnx = j.first, curenx = j.second;
if (cursnx - cure - 1 >= e - s + 1) {
f = 1;
sol[i] = make_pair(cure + 1, cure + d);
sch.insert(sol[i]);
break;
}
curs = cursnx, cure = curenx;
}
idx++;
}
if (!f) {
sol[i] =
make_pair((--sch.end())->second + 1, (--sch.end())->second + d);
sch.insert(sol[i]);
}
}
}
for (int i = 0; i < n; i++) {
cout << sol[i].first << " " << sol[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > sii;
int n, s, d;
int first = 1;
bool puedo_insert() {
bool result = true;
int ant = 1;
for (auto &p : sii) {
if (p.first >= s) {
if (s + d - 1 >= p.first || s < ant) {
result = false;
}
break;
} else {
ant = p.second;
}
}
if (result) {
if (ant >= s) {
result = false;
}
}
return result;
}
void buscar_insertar() {
int ant = 1;
bool b = false;
for (auto &p : sii) {
if (d <= p.first - ant) {
sii.insert(pair<int, int>(ant, ant + d - 1));
cout << ant << " " << ant + d - 1 << endl;
b = true;
break;
} else {
ant = p.second + 1;
}
}
if (!b) {
sii.insert(pair<int, int>(ant, ant + d - 1));
cout << ant << " " << ant + d - 1 << endl;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> d;
if (puedo_insert()) {
sii.insert(pair<int, int>(s, s + d - 1));
cout << s << " " << s + d - 1 << endl;
} else {
buscar_insertar();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a < b) return b;
return a;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
void solve() {
long long n;
cin >> n;
set<pair<long long, long long> > sets;
sets.insert(make_pair(1, 2e10));
while (n--) {
long long s, d;
cin >> s >> d;
long long l = s, r = s + d - 1;
long long otherstart = -1, otherend = -1;
set<pair<long long, long long> >::iterator iter = sets.end();
for (set<pair<long long, long long> >::iterator it = sets.begin();
it != sets.end(); it++) {
long long st = it->first;
long long e = it->second;
if (e - st + 1 >= d) {
if (st <= s && s + d - 1 <= e) {
otherstart = s, otherend = s + d - 1;
iter = it;
} else if (otherstart == -1 && otherend == -1) {
otherstart = st, otherend = st + d - 1;
iter = it;
}
}
}
if (iter == sets.end()) {
cout << "error\n";
return;
}
long long st = iter->first;
long long e = iter->second;
sets.erase(iter);
if (st <= s && s + d - 1 <= e) {
if (st <= s - 1) sets.insert(make_pair(st, s - 1));
if (s + d <= e) sets.insert(make_pair(s + d, e));
} else {
if (otherend <= e) sets.insert(make_pair(otherend + 1, e));
}
cout << otherstart << " " << otherend << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[1005], d[1005], ans[1005];
int main(void) {
int n, i;
bool f = true;
while (scanf("%d", &n) == 1) {
if (!f) puts("");
f = false;
for (i = 0; i < n; i++) scanf("%d %d", &s[i], &d[i]);
set<int> st, en;
set<int>::iterator it, it2;
i = 0;
st.insert(s[i]);
en.insert(s[i] + d[i] - 1);
ans[i] = s[i];
for (i = 1; i < n; i++) {
it = st.lower_bound(s[i]);
it2 = en.lower_bound(s[i]);
if ((it == st.end() && it2 == en.end()) ||
((*it) > s[i] + d[i] - 1 && (*it2) > s[i] + d[i] - 1 &&
*it2 >= *it)) {
st.insert(s[i]);
en.insert(s[i] + d[i] - 1);
ans[i] = s[i];
} else {
ans[i] = 1;
it = st.lower_bound(ans[i]);
it2 = en.lower_bound(ans[i]);
while (it != st.end()) {
if (*it > ans[i] + d[i] - 1) {
st.insert(ans[i]);
en.insert(ans[i] + d[i] - 1);
break;
}
ans[i] = (*it2) + 1;
it = st.lower_bound(ans[i]);
it2 = en.lower_bound(ans[i]);
}
if (it == st.end()) {
ans[i] = (*(en.rbegin())) + 1;
st.insert(ans[i]);
en.insert(ans[i] + d[i] - 1);
}
}
}
for (i = 0; i < n; i++) {
printf("%d %d\n", ans[i], ans[i] + d[i] - 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum { MAX = 2100000000 };
set<pair<int, int> > book;
int main() {
book.insert(pair<int, int>(1, MAX));
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int s, d;
scanf("%d%d", &s, &d);
auto it = book.begin();
bool found = 0;
while (it != book.end()) {
if (it->first > s) break;
if (it->second >= std::max(s, it->first) + d - 1) {
int b = (s < it->first) ? (it->first) : s;
if (s > it->first) {
book.insert(pair<int, int>(it->first, s - 1));
}
if (b - it->first + d < it->second) {
book.insert(pair<int, int>(b + d, it->second));
}
printf("%d %d\n", b, b + d - 1);
book.erase(it);
found = 1;
break;
}
++it;
}
it = book.begin();
s = 0;
while (!found && it != book.end()) {
if (it->second >= std::max(s, it->first) + d - 1) {
int b = (s < it->first) ? (it->first) : s;
if (s > it->first) {
book.insert(pair<int, int>(it->first, s - 1));
}
if (b - it->first + d < it->second) {
book.insert(pair<int, int>(b + d, it->second));
}
printf("%d %d\n", b, b + d - 1);
book.erase(it);
found = 1;
break;
}
++it;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxK = 40;
const int maxN = 3 * 1e5 + 9;
const int MOD = 1e9 + 7;
const double epsilon = 1e-8;
bool equal(double a, double b) {
a = b - a;
return fabs(a) <= epsilon;
}
int add(int a, int b) {
a += b;
if (a < 0) a += MOD;
if (a >= MOD) a -= MOD;
return a;
}
int n;
vector<pair<int, int> > result;
vector<pair<int, int> > dat;
void insert(pair<int, int> segment) {
result.push_back(segment);
dat.push_back(segment);
}
pair<int, int> canInsert(pair<int, int> segment) {
if (dat.empty()) return segment;
auto it = upper_bound(dat.begin(), dat.end(), segment);
if (it == dat.begin()) {
if ((*it).first > segment.second) {
return segment;
}
} else if ((*(it - 1)).second < segment.first) {
if (it == dat.end() || (*it).first > segment.second) {
return segment;
}
}
if ((*dat.begin()).first > segment.second - segment.first + 1) {
return {1, segment.second - segment.first + 1};
}
for (it = dat.begin(); it + 1 < dat.end(); it++) {
if ((*(it + 1)).first - (*it).second > segment.second - segment.first + 2) {
return {(*it).second + 1,
(*it).second + segment.second - segment.first + 1};
}
}
return {(*(dat.end() - 1)).second + 1,
(*(dat.end() - 1)).second + segment.second - segment.first + 1};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
sort(dat.begin(), dat.end());
pair<int, int> ok = canInsert({x, x + y - 1});
insert(ok);
}
for (auto e : result) {
cout << e.first << " " << e.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
struct pos {
int l, r;
};
bool operator<(pos a, pos b) { return a.l > b.l; }
int n;
priority_queue<pos> q;
priority_queue<pos> del;
int main() {
scanf("%d", &n);
pos sta;
sta.l = 1;
sta.r = 0x7fffffff;
q.push(sta);
for (int i = 1; i <= n; i++) {
int l, d;
scanf("%d%d", &l, &d);
bool flag = 0;
int r = l + d - 1;
while (!q.empty()) {
pos x = q.top();
q.pop();
if (x.l <= l && x.r >= r) {
pos a, b;
a.l = x.l, a.r = l - 1;
b.l = r + 1, b.r = x.r;
if (a.l <= a.r) q.push(a);
if (b.l <= b.r) q.push(b);
printf("%d %d\n", l, r);
flag = 1;
break;
}
del.push(x);
}
if (!flag) {
while (!del.empty()) {
pos x = del.top();
del.pop();
if (x.r - x.l + 1 >= d) {
pos b;
b.l = x.l + d, b.r = x.r;
if (b.l <= b.r) del.push(b);
printf("%d %d\n", x.l, x.l + d - 1);
break;
}
q.push(x);
}
}
while (!del.empty()) q.push(del.top()), del.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200;
vector<pair<pair<int, int>, int> > ranges(MAXN + 1);
int s[MAXN], d[MAXN];
bool persikerta(int x1, int x2, int y1, int y2) {
return max(x1, y1) <= min(x2, y2);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int n, pradz, pab, ilgis, i, j;
cin >> n;
for (i = 0; i < n; i++) cin >> s[i] >> d[i];
for (i = 0; i < n; i++) {
pradz = s[i];
ilgis = d[i];
pab = pradz + ilgis - 1;
for (j = 0; j < i; j++) {
if (persikerta(pradz, pab, ranges[j].first.first, ranges[j].first.second))
break;
}
if (j == i)
ranges[i] = make_pair(make_pair(pradz, pab), i);
else {
pradz = 1;
for (j = 0; j < i; j++) {
if (!persikerta(pradz, pradz + ilgis - 1, ranges[j].first.first,
ranges[j].first.second)) {
break;
} else {
pradz = ranges[j].first.second + 1;
}
}
pab = pradz + ilgis - 1;
ranges[i] = make_pair(make_pair(pradz, pab), i);
}
sort(ranges.begin(), ranges.begin() + i + 1);
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (ranges[j].second == i) {
cout << ranges[j].first.first << " " << ranges[j].first.second << endl;
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int x, y;
} a[610], b[610];
int tail = 1;
int nt;
int xx, yy;
int main() {
a[1].x = 1, a[1].y = 2e9;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d %d", &x, &y);
int flag = 0;
for (int j = 1; j <= tail; j++)
if (a[j].x <= x && a[j].y >= x && a[j].y - x + 1 >= y) {
flag = 1, nt = 0;
for (int k = 1; k < j; k++) b[++nt] = a[k];
if (a[j].x != x) b[++nt].x = a[j].x, b[nt].y = x - 1;
if (x + y - 1 != a[j].y) b[++nt].x = x + y, b[nt].y = a[j].y;
for (int k = j + 1; k <= tail; k++) b[++nt] = a[k];
tail = nt;
for (int k = 1; k <= tail; k++) a[k] = b[k];
xx = x, yy = x + y - 1;
break;
}
if (flag)
printf("%d %d\n", xx, yy);
else {
for (int j = 1; j <= tail; j++)
if (a[j].y - a[j].x + 1 >= y) {
xx = a[j].x, yy = a[j].x + y - 1;
printf("%d %d\n", xx, yy);
nt = 0;
for (int k = 1; k < j; k++) b[++nt] = a[k];
if (a[j].y != a[j].x + y - 1)
b[++nt].x = a[j].x + y, b[nt].y = a[j].y;
for (int k = j + 1; k <= tail; k++) b[++nt] = a[k];
tail = nt;
for (int k = 1; k <= tail; k++) a[k] = b[k];
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double EXP = 2.7182818284590452;
const double Pi = 3.1415926535;
const long double EPS = 1e-4;
const int INF = 1000 * 1000 * 1001;
const long long INFL = (long long)INF * (long long)INF;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long extgcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x11, y11;
long long d = extgcd(b % a, a, x11, y11);
x = y11 - (b / a) * x11;
y = x11;
return d;
}
unsigned long long poww(unsigned long long v, unsigned long long p,
unsigned long long mod) {
if (p == 0) return 1;
if (p & 1) {
return (poww(v, p - 1, mod) * v) % mod;
} else {
unsigned long long t = poww(v, p / 2, mod);
return (t * t) % mod;
}
}
const unsigned long long L31018 = 3000000000000000000L;
const unsigned long long L1018 = 1000000000000000000L;
int n;
int s, d;
map<long long, long long> rng;
map<long long, long long>::iterator iter, iter2;
long long find_pos(long long s, long long d) {
long long r = s + d - 1;
for (iter = rng.begin(), iter2 = iter, ++iter2; iter2 != rng.end();
++iter, ++iter2) {
if (iter->second < s && r < iter2->first) return s;
}
s = -1;
for (iter = rng.begin(), iter2 = iter, ++iter2; iter2 != rng.end();
++iter, ++iter2) {
s = iter->second + 1;
r = s + d - 1;
if (r < iter2->first) return s;
}
}
vector<std::pair<long long, long long> > res;
void add(long long s, long long d) {
res.push_back(std::make_pair(s, s + d - 1));
iter = rng.upper_bound(s);
--iter;
if (!(iter->first <= s && iter->second >= s + d - 1)) rng[s] = s + d - 1;
}
long long pos;
void accept() {
cin >> n;
rng[0] = 0;
rng[INFL] = INFL;
for (int i = (0); i < (n); ++i) {
scanf("%d%d", &s, &d);
pos = find_pos(s, d);
add(pos, d);
}
for (int i = (0); i < (n); ++i) {
cout << res[i].first << " " << res[i].second << "\n";
}
}
int main(void) {
accept();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
bool between(const long long &a1, const long long &a2, const long long &b1,
const long long &b2) {
if (a2 < b1 || b2 < a1)
return false;
else
return true;
}
int main() {
int s[205], d[205], n;
vector<pair<long long, long long> > ans;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
cin >> d[i];
}
for (int i = 0; i < n; i++) {
bool flag = true;
for (int j = 0; j < i; j++) {
if (between(s[i], s[i] + d[i] - 1, ans[j].first, ans[j].second)) {
flag = false;
break;
}
}
if (!flag) {
for (long long k = 1;; k++) {
bool f = true;
for (int j = 0; j < i; j++) {
if (between(k, k + d[i] - 1, ans[j].first, ans[j].second)) {
f = false;
k = ans[j].second;
break;
}
}
if (f) {
ans.push_back(make_pair(k, k + d[i] - 1));
break;
}
}
} else {
ans.push_back(make_pair(s[i], s[i] + d[i] - 1));
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> from, to;
for (int i = 0; i < n; ++i) {
int s, d;
cin >> s >> d;
bool puc = true;
for (int j = 0; j < i; ++j) {
if (from[j] < s + d and s < to[j]) puc = false;
}
if (puc) {
cout << s << ' ' << s + d - 1 << '\n';
from.push_back(s);
to.push_back(s + d);
} else {
int pos = 2e9;
for (int j = 0; j < i; ++j) {
int ss = to[j];
puc = true;
for (int k = 0; k < i; ++k)
if (k != j) {
if (from[k] < ss + d and ss < to[k]) puc = false;
}
if (puc) pos = min(pos, ss);
}
int ss = 1;
puc = true;
for (int k = 0; k < i; ++k) {
if (from[k] < ss + d and ss < to[k]) puc = false;
}
if (puc) pos = min(pos, ss);
cout << pos << ' ' << pos + d - 1 << '\n';
from.push_back(pos);
to.push_back(pos + d);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const int maxn = 205;
const int inf = 0x3f3f3f3f;
int m, n, st[maxn], ed[maxn];
int main() {
while (scanf("%d", &n) != EOF) {
int s, d, t;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &s, &t);
d = s + t - 1;
bool f = 0;
for (int j = 1; j < i; j++) {
if (d < st[j] || s > ed[j]) continue;
f = 1;
}
if (!f) {
st[i] = s, ed[i] = d;
printf("%d %d\n", s, d);
continue;
}
int ans_s = inf;
for (int j = 0; j < i; j++) {
if (j == 0)
s = 1;
else
s = ed[j] + 1;
d = s + t - 1;
int f2 = 0;
for (int k = 1; k < i; k++) {
if (d < st[k] || s > ed[k]) continue;
f2 = 1;
}
if (f2) continue;
ans_s = min(s, ans_s);
}
st[i] = ans_s, ed[i] = ans_s + t - 1;
printf("%d %d\n", ans_s, ans_s + t - 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const double pi = acos(-1.0);
const int maxn = 300005;
long long b, e, x, y, z, ans, i, j, k, l, n, m;
struct app {
long long b, e;
};
app a[500];
int cmp(app a, app b) {
return a.b < b.b;
return a.e < b.e;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
if (i == 1) {
cout << x << " " << x + y - 1 << endl;
a[++k].b = x;
a[k].e = x + y - 1;
} else {
bool f = 1;
for (int j = 1; j <= k; j++)
if (!(a[j].e < x || x + y - 1 < a[j].b)) {
f = 0;
break;
}
if (f) {
cout << x << " " << x + y - 1 << endl;
a[++k].b = x;
a[k].e = x + y - 1;
} else {
b = 1;
e = b + y - 1;
for (int j = 1; j <= k; j++) {
if (!(e < a[j].b || b > a[j].e)) {
b = a[j].e + 1;
e = b + y - 1;
} else
break;
}
x = b;
cout << x << " " << x + y - 1 << endl;
a[++k].b = x;
a[k].e = x + y - 1;
}
}
sort(a + 1, a + k + 1, cmp);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200 + 5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int N;
struct Rec {
long long L, R;
Rec() {}
Rec(int L, int R) : L(L), R(R) {}
};
vector<Rec> rec;
inline bool Intersect(const Rec& a, const Rec& b) {
return (b.L <= a.L && a.L <= b.R) || (b.L <= a.R && a.R <= b.R) ||
(a.L <= b.L && b.L <= a.R) || (a.L <= b.R && b.R <= a.R);
}
bool conflict(const Rec& a) {
for (int j = 0; j < rec.size(); j++) {
if (Intersect(a, rec[j])) return true;
}
return false;
}
int main() {
rec.clear();
cin >> N;
long long s, d;
for (int i = 0; i < N; ++i) {
cin >> s >> d;
Rec temp = Rec(s, s + d - 1);
long long now;
if (conflict(temp)) {
if (!conflict(Rec(1, d)))
temp = Rec(1, d);
else {
now = INF;
for (int j = 0; j < rec.size(); j++) {
if (now <= rec[j].R + 1) continue;
if (!conflict(Rec(rec[j].R + 1, rec[j].R + d))) now = rec[j].R + 1;
}
temp = Rec(now, now + d - 1);
}
}
printf("%lld %lld\n", temp.L, temp.R);
rec.push_back(temp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace std {
template <>
struct hash<pair<int, int>> {
size_t operator()(const pair<int, int> &x) const {
long long P = 38923, Q = 109797901;
return (size_t)((x.first * P + x.second) % Q);
}
};
}; // namespace std
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
void print(T t) {
cout << t << endl;
}
template <typename T, typename... Args>
void print(T t, Args... args) {
cout << t << " ";
print(args...);
}
const int MAXN = 202;
int n, s, d;
list<pair<pair<long long, long long>, int>> a, b;
pair<int, int> ans[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
a.push_back({{0, 1}, -1});
b.push_back({{(long long)1e18, (long long)1e18}, -1});
for (int i = min((int)0, (int)n); i < max((int)0, (int)n); i += 1) {
cin >> s >> d;
bool good = false;
while (1) {
if (a.back().first.first <= s && b.front().first.first > s) {
if (a.back().first.second <= s && b.front().first.first >= s + d) {
ans[i] = {s, s + d};
a.push_back({{s, s + d}, i});
good = true;
}
break;
}
a.push_back(b.front());
b.pop_front();
}
while ((int)(a).size() > 1) {
b.push_front(a.back());
a.pop_back();
}
if (!good) {
while (1) {
if (b.front().first.first - a.back().first.second >= d) {
ans[i] = {a.back().first.second, a.back().first.second + d};
a.push_back({{a.back().first.second, a.back().first.second + d}, i});
break;
}
a.push_back(b.front());
b.pop_front();
}
while ((int)(a).size() > 1) {
b.push_front(a.back());
a.pop_back();
}
}
}
for (int i = min((int)0, (int)n); i < max((int)0, (int)n); i += 1)
cout << ans[i].first << " " << ans[i].second - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<long long, long long> > v;
for (int i = 0; i < n; i++) {
long long s, e;
cin >> s >> e;
e = s + e - 1;
bool b = true;
for (int j = 0; j < v.size(); j++) {
if (v[j].first <= e && v[j].second >= s) {
b = false;
}
}
if (b) {
v.push_back(make_pair(s, e));
} else {
e -= s;
e += 1;
s = 1;
bool b = true;
for (int j = 0; j < v.size(); j++) {
if (v[j].first <= e && v[j].second >= s) {
b = false;
}
}
if (b) {
v.push_back(make_pair(s, e));
} else {
long long d = e;
for (int j = 0; j < v.size(); j++) {
s = v[j].second + 1;
e = v[j].second + d;
bool b = true;
for (int j = 0; j < v.size(); j++) {
if (v[j].first <= e && v[j].second >= s) {
b = false;
}
}
if (b) {
v.push_back(make_pair(s, e));
break;
}
}
}
}
sort(v.begin(), v.end());
cout << s << " " << e << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct period {
long long start, end;
int id;
};
bool possible(long long start, long long end, vector<period>& schedule) {
for (int i = 0; i < schedule.size(); i++) {
period P = schedule[i];
if (P.start <= end && start <= P.end) return false;
}
return true;
}
bool contains(vector<period>& schedule, long long start, long long duration) {
return !possible(start, start + duration - 1, schedule);
}
bool comparePeriod(const period& a, const period& b) {
return a.start < b.start;
}
long long popMin(vector<period>& schedule, long long duration) {
long long start = 1, end = start + duration - 1;
for (int i = 0; i < schedule.size(); i++) {
period P = schedule[i];
if (P.start <= end && start <= P.end) {
start = P.end + 1;
end = start + duration - 1;
}
}
return start;
}
int main() {
int n;
cin >> n;
vector<period> schedule;
for (int i = 0; i < n; i++) {
long long start, duration;
cin >> start >> duration;
if (contains(schedule, start, duration)) {
start = popMin(schedule, duration);
}
period P = {start, start + duration - 1, i};
schedule.push_back(P);
sort(schedule.begin(), schedule.end(), comparePeriod);
}
long long soln[2][200];
for (int i = 0; i < n; i++) {
soln[0][schedule[i].id] = schedule[i].start;
soln[1][schedule[i].id] = schedule[i].end;
}
for (int i = 0; i < n; i++) {
cout << soln[0][i] << ' ' << soln[1][i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = (int)1e5 + 7;
long long a[MXN], b[MXN];
long long ans[MXN][2];
set<long long> buf;
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) scanf("%lld %lld", a + i, b + i);
buf.insert(1);
for (int i = 1; i < n + 1; i++) {
long long ll = a[i], rr = a[i] + b[i] - 1;
bool gg = 0;
for (int j = 1; j < i; j++) {
if (rr < ans[j][0] || ll > ans[j][1]) continue;
gg = 1;
break;
}
if (!gg) {
ans[i][0] = ll, ans[i][1] = rr;
buf.insert(rr + 1);
continue;
}
for (long long st : buf) {
ll = st;
rr = st + b[i] - 1;
bool gg = 0;
for (int j = 1; j < i; j++) {
if (rr < ans[j][0] || ll > ans[j][1]) continue;
gg = 1;
break;
}
if (!gg) {
ans[i][0] = ll, ans[i][1] = rr;
buf.insert(rr + 1);
break;
}
}
}
for (int i = 1; i < n + 1; i++) printf("%lld %lld\n", ans[i][0], ans[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long int inf64 = 1e18 + 5;
bool chk(pair<long long int, long long int> p,
vector<pair<long long int, long long int> > &ans) {
p.second = p.first + p.second - 1;
for (pair<long long int, long long int> x : ans) {
long long int mn = min(p.second, x.second);
long long int mx = max(p.first, x.first);
if (mn >= mx) return false;
}
return true;
}
vector<pair<long long int, long long int> > findpos(
pair<long long int, long long int> p,
vector<pair<long long int, long long int> > &ans) {
vector<pair<long long int, long long int> > pos;
for (pair<long long int, long long int> x : ans) {
long long int st = x.second + 1;
if (chk({st, p.second}, ans)) pos.push_back({st, st + p.second - 1});
}
return pos;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, i;
cin >> n;
vector<pair<long long int, long long int> > v(n);
for (i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
vector<pair<long long int, long long int> > ans;
ans.push_back({0, 0});
for (i = 0; i < n; i++) {
if (chk(v[i], ans))
ans.push_back({v[i].first, v[i].first + v[i].second - 1});
else {
vector<pair<long long int, long long int> > pos = findpos(v[i], ans);
sort(pos.begin(), pos.end());
ans.push_back(pos[0]);
}
}
for (int i = 1; i < ans.size(); i++)
cout << ans[i].first << ' ' << ans[i].second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k;
scanf("%lld", &n);
long long arr[n + 1][2];
for (i = 1; i <= n; i++) {
scanf("%lld %lld", &arr[i][0], &arr[i][1]);
}
set<pair<long long, long long> > second;
long long ans[n];
for (i = 1; i <= n; i++) {
bool done = 0;
for (auto it : second) {
long long curr_s = it.first, curr_i = it.second;
long long x1 = curr_s, y1 = curr_s + arr[curr_i][1] - 1, x = arr[i][0],
y = arr[i][0] + arr[i][1] - 1;
if (!(y < x1 || x > y1)) {
done = 1;
break;
}
}
if (!done) {
ans[i] = arr[i][0];
second.insert({ans[i], i});
} else {
bool temp = 0;
long long x = 1, y;
for (auto it : second) {
y = it.first - 1;
if (y - x + 1 >= arr[i][1]) {
ans[i] = x;
temp = 1;
break;
}
x = it.first + arr[it.second][1];
}
if (!temp) {
ans[i] = x;
}
second.insert({ans[i], i});
}
}
for (i = 1; i <= n; i++) {
printf("%lld %lld\n", ans[i], ans[i] + arr[i][1] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Request {
long long from;
long long to;
};
inline bool operator<(const Request& lhs, const Request& rhs) {
return lhs.from < rhs.from;
}
bool isIntersect(const Request& a, const Request& b) {
long long l = min(a.to, b.to);
long long g = max(a.from, b.from);
return l - g >= 0;
}
int main() {
unsigned long n;
cin >> n;
set<Request> requests;
vector<Request> res(n);
for (long long i = 0; i < n; ++i) {
long long start;
long long duration;
cin >> start >> duration;
Request request = {start, start + duration - 1};
if (requests.empty()) {
res[i] = request;
requests.insert(request);
} else {
auto inserted = requests.insert(request);
if (inserted.second) {
auto it = inserted.first;
it++;
if (it != requests.end() && !isIntersect(*inserted.first, *it)) {
it = inserted.first;
it--;
if (inserted.first != requests.begin() &&
!isIntersect(*it, *inserted.first)) {
res[i] = request;
continue;
} else if (inserted.first == requests.begin()) {
res[i] = request;
continue;
}
} else if (it == requests.end()) {
it = inserted.first;
it--;
if (inserted.first != requests.begin() &&
!isIntersect(*it, *inserted.first)) {
res[i] = request;
continue;
}
}
requests.erase(inserted.first);
}
request = {1, 1 + duration - 1};
bool isInserted = false;
for (auto it = requests.begin(); it != requests.end(); it++) {
if (!isInserted && !isIntersect(request, *it)) {
requests.insert(request);
res[i] = request;
isInserted = true;
} else if (!isInserted) {
request = {it->to + 1, it->to + duration};
}
}
if (!isInserted) {
requests.insert(request);
res[i] = request;
}
}
}
for (long long i = 0; i < n; ++i) {
cout << res[i].from << " " << res[i].to << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int ts, kk = 1;
int n;
pair<long long int, long long int> a[205], b[205];
long long int st[205];
int sz;
int main() {
int t, i, j, k;
scanf("%d", &n);
for (i = 1; i < n + 1; i++) {
scanf("%lld%lld", &a[i].first, &a[i].second);
a[i].second = a[i].first + a[i].second - 1;
}
a[0] = pair<long long int, long long int>(0, 0);
st[0] = 0;
sz = 1;
for (i = 1; i < n + 1; i++) {
bool g = 1;
for (j = 0; j < i; j++) {
if (a[j].second < a[i].first || a[j].first > a[i].second)
;
else {
g = 0;
break;
}
}
if (!g) {
sort(st, st + sz);
for (k = 0; k < sz; k++) {
b[i].first = st[k] + 1;
b[i].second = b[i].first + a[i].second - a[i].first;
g = 1;
for (j = 0; j < i; j++) {
if (a[j].second < b[i].first || a[j].first > b[i].second)
;
else {
g = 0;
break;
}
}
if (g) break;
}
a[i] = b[i];
}
st[sz++] = a[i].second;
}
for (i = 1; i < n + 1; i++) printf("%lld %lld\n", a[i].first, a[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct car {
long long s, t;
int index;
};
car ans[1000];
car ele[1000];
bool cmp(car a, car b) { return a.s < b.s; }
int main() {
int n;
cin >> n;
ele[0].s = 0;
ele[0].t = 0;
for (int i = 1; i <= n; i++) {
int flag = 0;
cin >> ele[i].s >> ele[i].t;
ele[i].index = i;
ans[ele[i].index] = ele[i];
for (int j = 0; j < i; j++) {
int eleas, eleae, elebs, elebe;
eleas = ele[i].s;
eleae = ele[i].t ? ele[i].s + ele[i].t - 1 : ele[i].s;
elebs = ele[j].s;
elebe = ele[j].t ? ele[j].s + ele[j].t - 1 : ele[j].s;
if ((eleas >= elebs && eleas <= elebe) ||
(eleae >= elebs && eleae <= elebe) ||
(elebs >= eleas && elebs <= eleae) ||
(elebe >= eleas && elebe <= eleae)) {
flag = 1;
break;
}
}
if (flag)
for (int j = 0; j <= i; j++) {
if (j == 0) {
ele[i].s = 1;
ans[ele[i].index].s = 1;
} else {
ele[i].s = ele[j].s + ele[j].t;
ans[ele[i].index] = ele[i];
}
int tflag = 0;
for (int k = 0; k < i; k++) {
long long eleas, eleae, elebs, elebe;
eleas = ele[i].s;
eleae = ele[i].t ? ele[i].s + ele[i].t - 1 : ele[i].s;
elebs = ele[k].s;
elebe = ele[k].t ? ele[k].s + ele[k].t - 1 : ele[k].s;
if ((eleas >= elebs && eleas <= elebe) ||
(eleae >= elebs && eleae <= elebe) ||
(elebs >= eleas && elebs <= eleae) ||
(elebe >= eleas && elebe <= eleae)) {
tflag = 1;
break;
}
}
if (tflag)
continue;
else
break;
}
sort(ele + 1, ele + i + 1, cmp);
}
for (int i = 1; i <= n; i++) {
long long eles;
long long elee;
eles = ans[i].s;
elee = ans[i].t ? ans[i].s + ans[i].t - 1 : ans[i].s;
printf("%lld %lld\n", eles, elee);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<long long, long long> > result(0);
set<pair<long long, long long> > shedule;
int main() {
int ii;
long long s, d;
pair<long long, long long> prev, cur, tmp;
set<pair<long long, long long> >::iterator it;
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
result.resize(n);
shedule.insert(make_pair(0, 0));
shedule.insert(make_pair(1e17, 1e17));
for (ii = 0; ii < n; ii++) {
cin >> s >> d;
d--;
prev = tmp = make_pair(0, 0);
it = shedule.begin();
it++;
for (; it != shedule.end(); it++) {
cur = *it;
if ((s > prev.second) && ((s + d) < cur.first))
break;
else if ((tmp.first == 0) && ((prev.second + 1 + d) < cur.first))
tmp = make_pair((prev.second + 1), (prev.second + 1 + d));
prev = cur;
}
if (it != shedule.end()) {
result[ii] = make_pair(s, (s + d));
shedule.insert(make_pair(s, (s + d)));
} else {
result[ii] = tmp;
shedule.insert(tmp);
}
}
for (ii = 0; ii < n; ii++)
cout << result[ii].first << " " << result[ii].second << "\n";
cout << "\n"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(
const pair<long long int, pair<long long int, long long int> >& i,
const pair<long long int, pair<long long int, long long int> >& j) {
return i.second.first < j.second.first;
}
bool compare2(
const pair<long long int, pair<long long int, long long int> >& i,
const pair<long long int, pair<long long int, long long int> >& j) {
return i.first < j.first;
}
int main() {
int n, i, j;
long long s, d, ini, fim, inicio;
pair<long long int, pair<long long int, long long int> > v[300];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%lld%lld", &s, &d);
ini = s;
fim = s + d - 1;
inicio = 1;
if (i) {
sort(v, v + i, compare);
bool yea = 0;
for (j = 0; j < i; j++) {
if (v[j].second.first == inicio) {
inicio = v[j].second.second + 1;
continue;
} else {
if (inicio + d - 1 < v[j].second.first) {
yea = 1;
break;
} else
inicio = v[j].second.second + 1;
}
}
if (!yea) inicio = v[i - 1].second.second + 1;
}
bool no = 0;
for (j = 0; j < i; j++) {
if (ini > v[j].second.second || fim < v[j].second.first)
continue;
else
no = 1;
}
if (!no) {
v[i] = make_pair(i, make_pair(ini, fim));
continue;
}
v[i] = make_pair(i, make_pair(inicio, inicio + d - 1));
}
sort(v, v + n, compare2);
for (i = 0; i < n; i++)
printf("%lld %lld\n", v[i].second.first, v[i].second.second);
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int st, la;
};
node cl[205];
map<int, int> mm;
node ans[205];
bool ok(int bs, int be, int s, int e) {
if (max(bs, s) <= min(be, e)) return false;
return true;
}
int findst(node a, int ord) {
int flag = 0;
map<int, int>::iterator it;
for (it = mm.begin(); it != mm.end(); it++) {
int s, e;
s = it->first;
e = it->second;
if (!ok(a.st, a.st + a.la - 1, s, e)) {
flag = 1;
break;
}
}
if (!flag) {
mm[a.st] = a.st + a.la - 1;
return a.st;
}
int bs = 1, la = a.la;
for (it = mm.begin(); it != mm.end(); it++) {
int s, e;
s = it->first;
e = it->second;
if (!ok(bs, bs + a.la - 1, s, e)) {
bs = e + 1;
}
}
mm[bs] = bs + a.la - 1;
return bs;
}
int main() {
int n;
while (~scanf("%d", &n)) {
mm.clear();
for (int i = 0; i < n; i++) scanf("%d %d", &cl[i].st, &cl[i].la);
for (int i = 0; i < n; i++) {
int stt = findst(cl[i], i);
ans[i].st = stt;
ans[i].la = stt + cl[i].la - 1;
}
for (int i = 0; i < n; i++) printf("%d %d\n", ans[i].st, ans[i].la);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> s, d;
for (long long int i = 0; i < n; i++) {
long long int S;
cin >> S;
long long int D;
cin >> D;
s.push_back(S);
d.push_back(D);
}
set<pair<long long int, long long int>> done;
map<long long int, long long int> ans;
for (long long int i = 0; i < n; i++) {
if (!i) {
done.insert({s[i], d[i]});
ans[i] = s[i];
continue;
}
auto next = done.lower_bound({s[i], -1});
bool ok = true;
if (next != done.end()) ok &= s[i] + d[i] - 1 < next->first;
if (next != done.begin()) {
next--;
ok &= next->first + next->second - 1 < s[i];
}
if (ok) {
done.insert({s[i], d[i]});
ans[i] = s[i];
continue;
}
if (d[i] < done.begin()->first - 1) {
done.insert({1, d[i]});
ans[i] = 1;
continue;
}
long long int F = -1, S = -1;
for (auto g : done) {
auto next = done.upper_bound(g);
if (next == done.end() or g.first + g.second + d[i] - 1 < (*next).first) {
F = g.first + g.second;
break;
}
}
if (~F) {
done.insert({F, d[i]});
ans[i] = F;
}
}
for (long long int i = 0; i < n; i++)
cout << ans[i] << " " << ans[i] + d[i] - 1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxx = 3e5;
const int inf = 0x3f3f3f3f;
const long long linf = 1e18;
const long long mod = 1e9 + 9;
map<long long, long long> mp;
long long n, l, r, d;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
map<long long, long long>::iterator it;
while (n--) {
cin >> l >> d;
r = l + d - 1;
it = mp.lower_bound(l);
if (it == mp.end() || it->second > r) {
cout << l << " " << r << endl;
mp[r] = l;
continue;
}
l = 1;
while (1) {
r = l + d - 1;
it = mp.lower_bound(l);
if (it == mp.end() || it->second > r) {
cout << l << " " << r << endl;
mp[r] = l;
break;
}
l = it->first + 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n;
cin >> n;
long long int s[n], d[n];
for (long long int i = 0; i <= n - 1; i++) cin >> s[i] >> d[i], d[i]--;
map<long long int, long long int> a;
a[1] = LLONG_MAX;
for (long long int i = 0; i <= n - 1; i++) {
bool flg = false;
for (auto j : a) {
if (j.first <= s[i] && j.second >= s[i] + d[i]) {
long long int w = j.first;
long long int x = s[i] - 1;
long long int y = s[i] + d[i] + 1;
long long int z = j.second;
if (w <= x)
a[w] = x;
else
a.erase(w);
if (y <= z) a[y] = z;
cout << s[i] << " " << s[i] + d[i] << "\n";
flg = true;
break;
}
}
if (!flg) {
for (auto j : a) {
if (j.second - j.first >= d[i]) {
long long int y = j.first + d[i] + 1;
long long int z = j.second;
if (y <= z) a[y] = z;
cout << j.first << " " << j.first + d[i] << "\n";
a.erase(j.first);
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
bool was;
pair<int, int> a[5000];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
was = false;
for (int j = 1; j < i; j++) {
if (a[j].first <= x && a[j].second >= x) was = true;
if (a[j].first >= x && a[j].second <= x + y - 1) was = true;
if (a[j].first <= x + y - 1 && a[j].second >= x + y - 1) was = true;
}
if (was == false) {
a[i].first = x;
a[i].second = x + y - 1;
cout << x << ' ' << x + y - 1 << endl;
sort(a, a + i + 1);
} else {
for (int g = 0; g < i; g++) {
was = false;
for (int j = 1; j < i; j++) {
if (a[j].first <= a[g].second + 1 && a[j].second >= a[g].second + 1)
was = true;
if (a[j].first >= a[g].second + 1 && a[j].second <= a[g].second + y)
was = true;
if (a[j].first <= a[g].second + y && a[j].second >= a[g].second + y)
was = true;
}
if (was == false) {
a[i].first = a[g].second + 1;
a[i].second = a[g].second + y;
cout << a[g].second + 1 << ' ' << a[g].second + y << endl;
sort(a, a + i + 1);
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, t, q, l, k = 1, y, z, a[205], b[205];
vector<pair<pair<int, int>, int> > ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
ans.push_back({{0, 0}, 0});
for (int i = 1; i <= n; ++i) {
cin >> x >> y;
z = 1;
for (int j = 0; j < i; ++j)
if (x > ans[j].first.second &&
(j == i - 1 || x + y <= ans[j + 1].first.first)) {
ans.push_back({{x, x + y - 1}, i});
sort(ans.begin(), ans.end());
z = 0;
break;
}
if (!z) continue;
for (int j = 1; j < i; ++j) {
if (ans[j].first.first - ans[j - 1].first.second >= y + 1) {
ans.push_back(
{{ans[j - 1].first.second + 1, ans[j - 1].first.second + y}, i});
sort(ans.begin(), ans.end());
z = 0;
break;
}
}
if (!z) continue;
ans.push_back(
{{ans[i - 1].first.second + 1, ans[i - 1].first.second + y}, i});
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (ans[j].second == i)
cout << ans[j].first.first << " " << ans[j].first.second << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
int n, s[maxn + 5], t[maxn + 5];
long long L[maxn + 5], R[maxn + 5];
pair<int, int> p[maxn + 5];
inline bool cmp(long long a, long long b, long long c, long long d) {
if (a > c) swap(a, c), swap(b, d);
return b >= c;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &s[i], &t[i]);
for (int i = 1; i <= n; i++) {
bool A = true;
long long now = 1;
for (int j = 1; j < i; j++) {
if (cmp(s[i], s[i] + t[i] - 1, p[j].first, p[j].second)) A = false;
if (cmp(now, now + t[i] - 1, p[j].first, p[j].second))
now = p[j].second + 1;
}
if (A)
L[i] = s[i], R[i] = L[i] + t[i] - 1;
else
L[i] = now, R[i] = L[i] + t[i] - 1;
p[i] = make_pair(L[i], R[i]);
sort(p + 1, p + 1 + i);
}
for (int i = 1; i <= n; i++) printf("%lld %lld\n", L[i], R[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(pair<long long, long long> s1,
pair<long long, long long> s2) const {
if (s1.first != s2.first) return s1.first < s2.first;
return s1.second < s2.second;
}
};
multiset<pair<long long, long long>, comp> M;
long long Ini[300], Fin[300];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int N;
long long a, b;
cin >> N;
cin >> a >> b;
M.insert(pair<long long, long long>(a, a + b - 1));
Ini[1] = a, Fin[1] = a + b - 1;
for (int i = 2; i <= N; i++) {
cin >> a >> b;
long long fin = a + b - 1;
bool band = 0;
for (auto x : M) {
if ((a >= x.first && a <= x.second) ||
(fin >= x.first && fin <= x.second) ||
(a <= x.first && fin >= x.second)) {
band = 1;
break;
}
}
if (!band) {
Ini[i] = a, Fin[i] = fin;
M.insert(pair<long long, long long>(a, fin));
continue;
}
long long q = 1;
band = 0;
for (auto x : M) {
fin = q + b - 1;
if ((q >= x.first && q <= x.second) ||
(fin >= x.first && fin <= x.second) ||
(q <= x.first && fin >= x.second)) {
q = x.second + 1;
continue;
} else {
Ini[i] = q, Fin[i] = fin;
M.insert(pair<long long, long long>(q, fin));
band = 1;
break;
}
}
if (!band) {
M.insert(pair<long long, long long>(q, q + b - 1));
Ini[i] = q, Fin[i] = q + b - 1;
}
}
for (int i = 1; i <= N; i++) cout << Ini[i] << " " << Fin[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
bool good(pair<int, int> a) {
for (int i = 0; i < v.size(); ++i)
if (max(a.first, v[i].first) <= min(a.second, v[i].second)) return false;
return true;
}
pair<int, int> getBest(int d) {
if (d < v[0].first) return make_pair(1, d);
for (int i = 0; i + 1 < v.size(); ++i)
if (v[i].second + d < v[i + 1].first)
return make_pair(v[i].second + 1, v[i].second + d);
return make_pair(v.back().second + 1, v.back().second + d);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int s, d;
cin >> s >> d;
pair<int, int> cur;
if (good(make_pair(s, s + d - 1)))
cur = make_pair(s, s + d - 1);
else
cur = getBest(d);
v.push_back(cur);
cout << cur.first << ' ' << cur.second << '\n';
sort(v.begin(), v.end());
}
}
|
#include <bits/stdc++.h>
using namespace std;
double safe_sqrt(double x) { return sqrt(max((double)0.0, x)); }
long long GI(long long& x) { return scanf("%lld", &x); }
struct Seg {
long long l, r;
Seg(long long l, long long r) : l(l), r(r) {}
Seg() {}
} a[211];
bool intersect(const Seg& a, const Seg& b) {
if (a.r < b.l) return false;
if (a.l > b.r) return false;
return true;
}
bool can(long long l, long long r, long long n) {
Seg cur(l, r);
for (long long i = (1), _b = (n); i <= _b; ++i)
if (intersect(a[i], cur)) return false;
return true;
}
long long n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << (fixed) << setprecision(9);
while (cin >> n) {
for (long long i = (1), _b = (n); i <= _b; ++i) {
long long s, d;
cin >> s >> d;
if (can(s, s + d - 1, i - 1)) {
a[i] = Seg(s, s + d - 1);
continue;
}
if (can(1, d, i - 1)) {
a[i] = Seg(1, d);
continue;
}
long long nn = 2000111000111LL;
for (long long j = (1), _b = (i - 1); j <= _b; ++j) {
long long l = a[j].r + 1;
if (can(l, l + d - 1, i - 1)) {
nn = min(nn, l);
}
}
a[i] = Seg(nn, nn + d - 1);
}
for (long long i = (1), _b = (n); i <= _b; ++i)
cout << a[i].l << ' ' << a[i].r << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
class car {
public:
long long s, t;
};
bool cmp(car a, car b) { return a.s < b.s; }
int main() {
long long n, flag, x, flag2, q1, q2;
car now;
cin >> n;
vector<car> did, ans;
while (n--) {
cin >> now.s >> now.t;
flag = 0;
if (did.size() == 0) {
now.t += now.s - 1;
did.push_back(now);
ans.push_back(now);
continue;
}
for (int i = 0; i < did.size(); i++) {
if (i == 0) {
if (now.t + now.s - 1 < did[i].s) {
flag = 1;
break;
}
} else if ((now.s > did[i - 1].t and now.t + now.s - 1 < did[i].s)) {
flag = 1;
break;
}
}
if (now.s > did[did.size() - 1].t) {
flag = 1;
}
if (!flag) {
x = 1;
flag2 = 0;
for (int i = 0; i < did.size(); i++) {
if (x + now.t - 1 < did[i].s) {
now.s = x;
now.t = now.s + now.t - 1;
did.push_back(now);
ans.push_back(now);
flag2 = 1;
break;
}
x = did[i].t + 1;
}
if (!flag2) {
now.s = x;
now.t = now.s + now.t - 1;
did.push_back(now);
ans.push_back(now);
}
} else {
now.t += now.s - 1;
did.push_back(now);
ans.push_back(now);
}
sort(did.begin(), did.end(), cmp);
}
for (int i = 0; i < ans.size(); i++)
cout << ans[i].s << " " << ans[i].t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long> first;
set<long long> last;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long s, d;
cin >> s >> d;
long long en = s + d - 1;
if (first.empty()) {
first.insert(s);
last.insert(en);
first.insert(2e9);
last.insert(2e9);
cout << s << " " << en << endl;
} else {
set<long long>::iterator t3 = first.begin();
int cnt1 = 0, cnt2 = 0;
for (; t3 != first.end(); cnt1++, t3++) {
if (*t3 > en) break;
}
set<long long>::iterator t4 = last.begin();
for (; t4 != last.end(); cnt2++, t4++) {
if (*t4 >= s) break;
}
if (cnt1 == cnt2) {
cout << s << " " << en << endl;
first.insert(s);
last.insert(en);
} else {
set<long long>::iterator it1 = first.begin();
set<long long>::iterator it2 = last.begin();
if (*it1 > d) {
cout << 1 << " " << d << endl;
first.insert(1);
last.insert(d);
} else {
it1++;
while (1) {
if (*it1 - 1 - *it2 > d) {
cout << *it2 + 1 << " " << *it2 + d << endl;
first.insert(*it2 + 1);
last.insert(*it2 + d);
break;
}
it1++;
it2++;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, s, d, e;
cin >> n;
vector<pair<long long int, long long int> > vis, ans;
for (long long int i = 0; i < n; i++) {
cin >> s >> d;
e = s + d - 1;
if (vis.size() == 0) {
vis.push_back({s, e});
vis.push_back({1e18, 1e18 + 1});
ans.push_back({s, e});
} else {
bool ha1 = false;
long long int s1 = 0;
for (long long int j = 0; j < vis.size(); j++) {
if (s1 < s && s < vis[j].first) {
if (e < vis[j].first) {
ha1 = true;
vis.push_back({s, e});
ans.push_back({s, e});
}
break;
}
s1 = vis[j].second + 1;
}
if (!ha1) {
long long int start = 1;
bool ha = false;
for (auto it : vis) {
if (it.first - start >= d) {
vis.push_back({start, start + d - 1});
ans.push_back({start, start + d - 1});
ha = true;
break;
} else {
start = it.second + 1;
}
}
if (!ha) {
start = vis.back().second + 1;
vis.push_back({start, start + d - 1});
ans.push_back({start, start + d - 1});
}
}
}
sort(vis.begin(), vis.end());
}
for (auto it : ans) cout << it.first << " " << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e3 + 10;
int n, m, k;
struct oh {
int r, l;
oh *next;
} *org = new oh, *ed = new oh;
oh *sert(int l, int d);
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
org->r = org->l = 0;
ed->r = ed->l = 0x7fffffff;
org->next = ed;
while (n--) {
int w, d;
cin >> w >> d;
oh x = *sert(w, d);
cout << x.l << " " << x.r << endl;
}
return 0;
}
oh *sert(int l, int d) {
int r = l + d - 1;
oh *q = new oh, *p1 = org, *p2, *fl = 0;
while (p1 != ed) {
p2 = p1->next;
if (fl == 0 && p2->l > p1->r + d) {
fl = p1;
q->l = p1->r + 1;
q->r = q->l + d - 1;
}
if (l > p1->r && r < p2->l) {
fl = p1;
q->l = l;
q->r = r;
break;
}
p1 = p2;
}
q->next = fl->next;
fl->next = q;
return q;
}
|
#include <bits/stdc++.h>
using namespace std;
long long in1[205], in2[205];
long long ans1[205], ans2[205];
struct node {
long long s, e;
bool operator<(const node& p) const {
if (s == p.s) return e >= p.e;
return s >= p.s;
}
};
priority_queue<node> pq, temp;
bool ok(long long s, long long e, long long a, long long b) {
if (s >= a && e <= b) return 1;
if (s <= a && e >= a) return 1;
if (s >= a && s <= b) return 1;
return 0;
}
long long _get(long long cur, long long d) {
while (!pq.empty()) {
node xx = pq.top();
pq.pop();
temp.push(xx);
if (cur + d - 1 < xx.s) {
break;
} else {
cur = max(cur, xx.e + 1);
}
}
while (!temp.empty()) {
node xx = temp.top();
temp.pop();
pq.push(xx);
}
return cur;
}
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d %I64d", &in1[i], &in2[i]);
}
long long cur = 1, s, e;
for (i = 1; i <= n; i++) {
s = in1[i], e = s + in2[i] - 1;
bool ck = 1;
for (j = 1; j < i; j++) {
if (ok(s, e, ans1[j], ans2[j])) {
ck = 0;
break;
}
}
node xx;
if (ck) {
ans1[i] = in1[i];
ans2[i] = in1[i] + in2[i] - 1;
} else {
cur = _get(1, in2[i]);
ans1[i] = cur;
ans2[i] = cur + in2[i] - 1;
cur += in2[i];
}
xx.s = ans1[i], xx.e = ans2[i];
pq.push(xx);
}
for (i = 1; i <= n; i++) printf("%I64d %I64d\n", ans1[i], ans2[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int s[200];
int d[200];
vector<pair<int, int>> intervals;
bool intersect(int a, int b, int c, int d) { return max(a, c) <= min(b, d); }
bool isfree(int a, int b) {
for (auto iv : intervals) {
if (intersect(iv.first, iv.second, a, b)) {
return false;
}
}
return true;
}
int nextval(int a, int b) {
for (auto iv : intervals) {
if (intersect(iv.first, iv.second, a, b)) {
return iv.second + 1;
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int s, d;
cin >> s >> d;
if (isfree(s, s + d - 1)) {
cout << s << " " << s + d - 1 << endl;
intervals.push_back({s, s + d - 1});
} else {
int want = 1;
while (true) {
int c = want;
int e = want + d - 1;
if (isfree(c, e)) {
cout << c << " " << e << endl;
intervals.push_back({c, e});
break;
} else {
want = nextval(c, e);
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int vect[300], vect2[300];
vector<pair<pair<long int, long long int>, long long int> > vec;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
long int n, ini, fin, ban, x, i, j, ban2, lim, a, b;
pair<long long int, long long int> par, par3, par5;
pair<pair<long long int, long int>, long long int> par4, par2;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a >> b;
ini = a;
fin = a + b - 1;
ban = 0;
for (j = 0; j < vec.size(); j++) {
par = vec[j].first;
x = vec[j].second;
if (ini >= par.first && ini <= par.second) {
ban = 1;
}
if (fin >= par.first && fin <= par.second) {
ban = 1;
}
if (ini <= par.first && fin >= par.second) {
ban = 1;
}
}
if (ban == 0) {
par.first = ini;
par.second = fin;
x = i;
par2.first = par;
par2.second = x;
vec.push_back(par2);
ban2 = 0;
lim = vec.size() - 1;
while (ban2 == 0) {
if (lim != 0) {
par = vec[lim].first;
par3 = vec[lim - 1].first;
if (par.first < par3.first) {
swap(vec[lim - 1], vec[lim]);
lim--;
} else {
ban2 = 1;
}
} else {
ban2 = 1;
}
}
} else {
par = vec[0].first;
if (fin - ini + 1 < par.first) {
par.first = 1;
par.second = fin - ini + 1;
par2.first = par;
par2.second = i;
vec.push_back(par2);
lim = vec.size() - 1;
ban2 = 0;
while (ban2 == 0) {
if (lim != 0) {
par = vec[lim].first;
par3 = vec[lim - 1].first;
if (par.first < par3.first) {
swap(vec[lim - 1], vec[lim]);
lim--;
} else {
ban2 = 1;
}
} else {
ban2 = 1;
}
}
} else {
ban = 0;
for (j = 0; j < vec.size() - 1; j++) {
if (ban == 0) {
par = vec[j].first;
par3 = vec[j + 1].first;
if (par3.first - par.second - 1 >= fin - ini + 1) {
ban = 1;
par5.first = par.second + 1;
par5.second = par5.first + fin - ini;
par4.first = par5;
par4.second = i;
vec.push_back(par4);
ban2 = 0;
lim = vec.size() - 1;
while (ban2 == 0) {
if (lim != 0) {
par = vec[lim].first;
par3 = vec[lim - 1].first;
if (par.first < par3.first) {
swap(vec[lim - 1], vec[lim]);
lim--;
} else {
ban2 = 1;
}
} else {
ban2 = 1;
}
}
}
} else {
break;
}
}
if (ban == 0) {
par = vec[vec.size() - 1].first;
par3.first = par.second + 1;
par3.second = par3.first + fin - ini;
par4.first = par3;
par4.second = i;
vec.push_back(par4);
}
}
}
}
for (i = 0; i < n; i++) {
par = vec[i].first;
x = vec[i].second;
vect[x] = par.first;
vect2[x] = par.second;
}
for (i = 1; i <= n; i++) {
cout << vect[i] << " " << vect2[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
const long long N = 2e5 + 10;
void testCase() {
long long n;
cin >> n;
vector<pair<long long, long long>> ans;
vector<pair<long long, long long>> seg = {{1, inf}};
auto isIntersect = [](pair<long long, long long> x,
pair<long long, long long> y) {
if (x.first > y.first) swap(x, y);
return x.second >= y.first;
};
for (long long i = 0; i < n; i++) {
long long s, d;
cin >> s >> d;
bool can = true;
for (auto &p : ans) can &= !isIntersect({s, s + d - 1}, p);
pair<long long, long long> use;
if (can) {
use = {s, s + d - 1};
for (long long i = 0; i < (long long)seg.size(); i++) {
if (isIntersect(seg[i], use)) {
if (seg[i].first != use.first)
seg.push_back({seg[i].first, use.first - 1});
if (seg[i].second != use.second)
seg.push_back({use.second + 1, seg[i].second});
seg.erase(begin(seg) + i);
break;
}
}
} else {
long long mi = -1;
for (long long i = 0; i < (long long)seg.size(); i++) {
if (seg[i].second - seg[i].first + 1 >= d) {
if (mi == -1 or seg[mi].first > seg[i].first) mi = i;
}
}
use = {seg[mi].first, seg[mi].first + d - 1};
seg.push_back({seg[mi].first + d, seg[mi].second});
seg.erase(begin(seg) + mi);
}
ans.push_back(use);
}
for (auto &p : ans) cout << p.first << ' ' << p.second << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
long long t_c = 1;
while (t_c--) testCase();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e18;
const long long MOD = 1e9 + 7;
const long long sz = 1e5 + 5;
void f_io() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
}
int32_t main() {
f_io();
long long tc = 1;
while (tc--) {
long long n;
cin >> n;
vector<pair<long long, long long>> ans(n);
for (long long i = 0; i < n; i++) {
long long flag = 1, a, b;
cin >> a >> b;
for (long long j = 0; j < i; j++) {
if (ans[j].first >= a && ans[j].first <= a + b - 1) {
flag = 0;
break;
}
if (ans[j].second >= a && ans[j].first <= a + b - 1) {
flag = 0;
break;
}
}
if (flag) {
ans[i].first = a;
ans[i].second = a + b - 1;
} else {
long long start = 1;
flag = 1;
while (flag) {
flag = 0;
long long en = start + b - 1;
for (long long j = 0; j < i; j++) {
if (ans[j].first >= start && ans[j].first <= en) {
flag = 1;
start = ans[j].second + 1;
break;
}
if (ans[j].second >= start && ans[j].second <= en) {
flag = 1;
start = ans[j].second + 1;
break;
}
}
if (!flag) ans[i] = {start, en};
}
}
}
for (long long i = 0; i < n; i++)
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int st, end;
} ar[10000];
bool cmp(node a, node b) { return a.st < b.st; }
int main() {
ar[0].st = 0;
ar[0].end = 0;
ar[1].st = 1e15;
ar[1].end = 1e15;
int n, t, cnt, i, j;
bool f = 0;
long long int st, end, a, b;
cin >> n;
cnt = 2;
for (t = 1; t <= n; t++) {
cin >> st >> end;
if (t == 1) {
cout << st << " " << st + end - 1 << endl;
a = st;
b = st + end - 1;
} else {
a = st;
b = st + end - 1;
f = 0;
for (j = 1; j < cnt; j++) {
if (a > ar[j - 1].end and b < ar[j].st) {
f = 1;
break;
}
}
if (f == 1) {
cout << a << " " << b << endl;
} else
for (i = 0; i < cnt; i++) {
a = ar[i].end + 1;
b = a + end - 1;
f = 0;
for (j = 1; j < cnt; j++) {
if (a > ar[j - 1].end and b < ar[j].st) {
f = 1;
break;
}
}
if (f) {
cout << a << " " << b << endl;
break;
}
}
}
ar[cnt].st = a;
ar[cnt].end = b;
cnt++;
sort(ar, ar + cnt, cmp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long start;
long long vol;
node *next;
};
node *head;
bool insert1(long long day, long long vol) {
node *p = head->next, *q = head;
while (p->start + p->vol < day) q = p, p = p->next;
if (p->start > day) return false;
if (p->start + p->vol >= day + vol) {
if (p->start != day) {
q->next = new node;
q = q->next;
q->start = p->start;
q->vol = day - p->start;
}
if (p->start + p->vol > day + vol) {
q->next = new node;
q = q->next;
q->start = day + vol;
q->vol = p->start + p->vol - day - vol;
}
q->next = p->next;
printf("%lld %lld\n", day, day + vol - 1);
return true;
} else
return false;
}
void insert2(long long vol) {
node *p = head->next, *q = head;
while (p->vol < vol) q = p, p = p->next;
q->next = new node;
q = q->next;
q->start = p->start + vol;
q->vol = p->vol - vol;
q->next = p->next;
printf("%lld %lld\n", p->start, p->start + vol - 1);
return;
}
int main() {
int n;
long long day, vol;
scanf("%d", &n);
node *p = new node;
head = new node;
head->next = p;
p->start = 1;
p->vol = 9999999999999ll;
p->next = NULL;
for (int i = 1; i <= n; ++i) {
scanf("%lld %lld", &day, &vol);
if (insert1(day, vol) == false) {
insert2(vol);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct work {
int s, d, e;
work(int s = 0, int d = 0, int e = 0) : s(s), d(d), e(e) {}
bool operator<(const work b) const { return e < b.e; }
};
vector<work> v;
bool check(int s, int d) {
int e = s + d - 1;
int len = v.size();
for (int i = 0; i < len; i++) {
if (s >= v[i].s && s <= v[i].e) return false;
if (e >= v[i].s && e <= v[i].e) return false;
if (s <= v[i].s && e >= v[i].e) return false;
}
return true;
}
work change(int s, int d) {
int e = s + d - 1;
int len = v.size();
if (check(1, d)) return work(1, d, 1 + d - 1);
sort(v.begin(), v.end());
for (int i = 0; i < len; i++) {
if (check(v[i].e + 1, d)) return work(v[i].e + 1, d, v[i].e + d);
}
}
int main() {
int n;
cin >> n;
int s, d;
for (int i = 0; i < n; i++) {
cin >> s >> d;
if (check(s, d))
v.push_back(work(s, d, s + d - 1));
else
v.push_back(change(s, d));
cout << v[v.size() - 1].s << ' ' << v[v.size() - 1].e << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e2 + 5;
const int mod = 1e9 + 7;
const int INF = 1e8 + 5;
const long long inf = 1e15 + 5;
const double eps = 1e-8;
struct tim {
int l, r;
} ans[maxn];
bool cmp(const tim &a, const tim &b) { return a.l < b.l; }
void solve() {
int n;
while (cin >> n) {
ans[0].l = ans[0].r = 0;
ans[1].l = ans[1].r = INT_MAX;
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
r = l + r - 1;
int flag = 0;
for (int j = 0; j < i; j++) {
if (l > ans[j].r && r < ans[j + 1].l) {
flag = 1;
}
}
if (flag) {
ans[i + 1].l = l, ans[i + 1].r = r;
} else {
for (int j = 0; j < i; j++) {
if (ans[j + 1].l - ans[j].r - 1 >= r - l + 1) {
ans[i + 1].l = ans[j].r + 1, ans[i + 1].r = ans[j].r + (r - l + 1);
break;
}
}
}
cout << ans[i + 1].l << ' ' << ans[i + 1].r << endl;
sort(ans, ans + i + 2, cmp);
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
list<pair<int, int> > l;
int main() {
int n;
scanf("%d", &n);
l.push_front(make_pair(1, 2e9));
for (; n--;) {
int s, d;
scanf("%d%d", &s, &d);
int ans1 = -1, ans2 = -1;
for (list<pair<int, int> >::iterator it = l.begin(); it != l.end(); it++) {
if (it->first > s) break;
if (it->first <= s && it->second >= s + d - 1) {
ans1 = s;
ans2 = s + d - 1;
if (s > 1) l.insert(it, make_pair(it->first, s - 1));
it->first = s + d;
}
}
if (ans1 == -1) {
for (list<pair<int, int> >::iterator it = l.begin(); it != l.end(); it++)
if (it->second - it->first + 1 >= d) {
ans1 = it->first;
ans2 = it->first + d - 1;
if (it->second - it->first + 1 - d > 0)
it->first += d;
else
l.erase(it);
break;
}
}
printf("%d %d\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s[300], d[300], a[300], b[300], q, z, bb[300];
int main() {
int i, j, k, bj;
b[0] = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s[i] >> d[i];
bj = 1;
q = s[i];
z = s[i] + d[i] - 1;
for (j = 1; j < i; j++)
if (!(z < a[j] || q > b[j])) {
bj = 0;
break;
}
if (i == 1 || bj == 1) {
a[i] = q;
b[i] = z;
cout << a[i] << ' ' << b[i] << endl;
bb[i] = z;
sort(bb + 1, bb + 1 + i);
continue;
}
for (j = 0; j < i; j++) {
q = bb[j] + 1;
z = bb[j] + d[i];
if (a[i] != 0 && a[i] < q) continue;
bj = 1;
for (k = 1; k < i; k++)
if (!(q > b[k] || z < a[k])) {
bj = 0;
break;
}
if (bj == 1) {
a[i] = q;
b[i] = z;
bb[i] = z;
sort(bb + 1, bb + 1 + i);
}
}
cout << a[i] << ' ' << b[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<unsigned int, unsigned int> mp;
set<pair<long long, long long> > s;
set<pair<long long, long long> >::iterator it;
pair<long long, long long> a[250];
pair<long long, long long> b[250];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
b[0].first = a[0].first;
b[0].second = a[0].first + a[0].second - 1;
s.insert(b[0]);
long long x = 1;
for (int i = 1; i < n; i++) {
int u = 0;
for (int j = 0; j < i; j++) {
if (a[i].first >= b[j].first && a[i].first <= b[j].second) u = 1;
if (a[i].first + a[i].second - 1 >= b[j].first &&
a[i].first + a[i].second - 1 <= b[j].second)
u = 1;
if (a[i].first <= b[j].first &&
a[i].first + a[i].second - 1 >= b[j].second)
u = 1;
}
if (u == 0) {
b[i].first = a[i].first;
b[i].second = a[i].first + a[i].second - 1;
s.insert(b[i]);
} else {
long long o = 0, y = 1;
for (it = s.begin(); it != s.end() && o == 0; it++) {
if (y + a[i].second - 1 < (*it).first) {
b[i].first = y;
b[i].second = y + a[i].second - 1;
s.insert(b[i]);
o = 1;
} else
y = (*it).second + 1;
}
if (o == 0) {
b[i].first = y;
b[i].second = y + a[i].second - 1;
s.insert(b[i]);
}
}
}
for (int i = 0; i < n; i++) {
cout << b[i].first << " " << b[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2100;
pair<long long, long long> Q[maxn], T[maxn];
int n;
long long x, y;
set<pair<long long, long long> > S;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &x, &y);
Q[i].first = x;
Q[i].second = x + y - 1;
}
S.insert(make_pair(1, 1e15));
for (int i = 0; i < n; i++) {
set<pair<long long, long long> >::iterator it;
long long l = Q[i].first, r = Q[i].second;
long long L, R;
int ok = 0;
for (it = S.begin(); it != S.end(); it++) {
L = (*it).first;
R = (*it).second;
if (R >= r && L <= l) {
ok = 1;
T[i] = make_pair(l, r);
S.erase(it);
if (l > L) {
S.insert(make_pair(L, l - 1));
}
if (R > r) {
S.insert(make_pair(r + 1, R));
}
break;
}
}
if (!ok) {
for (it = S.begin(); it != S.end(); it++) {
L = (*it).first;
R = (*it).second;
if (R - L >= r - l) {
T[i] = make_pair(L, L + r - l);
if (R - L == r - l) {
S.erase(it);
} else {
S.erase(it);
S.insert(make_pair(L + r - l + 1, R));
}
break;
}
}
}
}
for (int i = 0; i < n; i++) {
printf("%I64d %I64d\n", T[i].first, T[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long l, r;
long long index;
bool operator<(const Node& t) const { return r < t.l; }
bool operator>(const Node& t) const { return l > t.r; }
bool operator==(const Node& t) const {
if (r < t.r) {
return r >= t.l && l <= t.l;
} else {
return l <= t.r;
}
}
};
struct Input {
long long s, d;
};
set<Node> st;
int n;
Input input[222];
vector<Node> ans;
bool cmp(const Node& a, const Node& b) { return a.index < b.index; }
int main() {
ios::ios_base::sync_with_stdio(true);
cin >> n;
int s, d;
for (int i = 1; i <= n; i++) {
cin >> input[i].s >> input[i].d;
}
Node newNode;
int x = 1;
for (int i = 1; i <= n; i++) {
newNode.l = input[i].s;
newNode.r = input[i].s + input[i].d - 1;
newNode.index = i;
if (st.find(newNode) != st.end()) {
newNode.l = 1;
newNode.r = 1 + input[i].d - 1;
set<Node>::iterator it = st.find(newNode);
while (it != st.end()) {
newNode.l = it->r + 1;
newNode.r = newNode.l + input[i].d - 1;
it = st.find(newNode);
}
st.insert(newNode);
} else {
st.insert(newNode);
}
}
set<Node>::iterator it = st.begin();
while (it != st.end()) {
ans.push_back(*it);
it++;
}
sort(ans.begin(), ans.end(), cmp);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].l << " " << ans[i].r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct req {
long long s, e;
} reqs[300];
bool operator<(req a, req b) { return a.s < b.s; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
sort(reqs, reqs + i);
int s, t;
cin >> s >> t;
bool flag = true;
for (int j = 0; j < i; j++) {
if ((reqs[j].s <= s && reqs[j].e >= s) ||
(reqs[j].s >= s && reqs[j].s <= s + t - 1)) {
flag = false;
break;
}
}
if (flag) {
reqs[i].s = s;
reqs[i].e = s + t - 1;
cout << reqs[i].s << " " << reqs[i].e << endl;
} else {
if (t < reqs[0].s) {
reqs[i].s = 1;
reqs[i].e = t;
cout << reqs[i].s << " " << reqs[i].e << endl;
} else {
bool mark = false;
for (int j = 0; j < i - 1; j++) {
if (reqs[j + 1].s - reqs[j].e - 1 >= t) {
reqs[i].s = reqs[j].e + 1;
reqs[i].e = reqs[j].e + t;
cout << reqs[i].s << " " << reqs[i].e << endl;
mark = true;
break;
}
}
if (!mark) {
reqs[i].s = reqs[i - 1].e + 1;
reqs[i].e = reqs[i - 1].e + t;
cout << reqs[i].s << " " << reqs[i].e << endl;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
void read() {
cout << "*************\n";
for (set<pair<int, int> >::iterator p = s.begin(); p != s.end(); p++) {
cout << p->first << " " << p->second << endl;
}
cout << "*************\n";
}
int T, l, r;
int main() {
scanf("%d", &T);
s.clear();
s.insert(make_pair(1, INF));
while (T--) {
scanf("%d%d", &l, &r);
for (it = s.begin(); it != s.end(); it++) {
if (it->first <= l && it->second >= l + r - 1) {
int ll = it->first, rr = it->second;
s.erase(it);
printf("%d %d\n", l, l + r - 1);
s.insert(make_pair(ll, l - 1));
s.insert(make_pair(l + r, rr));
break;
}
}
if (it == s.end()) {
for (it = s.begin(); it != s.end(); it++) {
if (it->second - it->first + 1 >= r) {
printf("%d %d\n", it->first, it->first + r - 1);
int ll = it->first, rr = it->second;
s.erase(it);
s.insert(make_pair(ll + r, rr));
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
int main() {
int n;
cin >> n;
vector<pair<int, int>> v;
v.push_back({0, 1});
for (int i = 0; i < n; ++i) {
int s, d;
cin >> s >> d;
bool f = true;
for (int j = 0; j < (int)(v).size(); ++j) {
if (!(v[j].second <= s || s + d <= v[j].first)) f = false;
}
int ans = INF;
if (f) {
ans = s;
} else {
for (int j = 0; j < (int)(v).size(); ++j) {
int t = v[j].second;
bool f = true;
for (int k = 0; k < (int)(v).size(); ++k) {
if (!(v[k].second <= t || t + d <= v[k].first)) f = false;
}
if (f) ans = min(ans, t);
}
}
v.push_back({ans, ans + d});
cout << ans << " " << ans + d - 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int T = 1;
while (T--) {
int n;
set<pair<int, int>> st;
cin >> n;
for (int i = 0; i < n; i++) {
int s, d, flag = 0;
cin >> s >> d;
for (auto x : st) {
if (s >= x.first && s <= x.second ||
s + d - 1 <= x.second && s + d - 1 >= x.first ||
s <= x.first && s + d - 1 >= x.second) {
flag = 1;
s = 1;
break;
}
}
if (flag) {
for (auto x : st) {
if (s >= x.first && s <= x.second ||
s + d - 1 <= x.second && s + d - 1 >= x.first ||
s <= x.first && s + d - 1 >= x.second) {
s = x.second + 1;
}
}
}
st.insert({s, s + d - 1});
cout << s << " " << s + d - 1 << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n;
int s[201], d[201];
bool ck(int i, int j) {
return s[j] > s[i] + d[i] - 1 || s[i] > s[j] + d[j] - 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &s[i], &d[i]);
for (int i = 1; i <= n; ++i) {
bool fromS = true;
for (int j = 1; j < i; ++j)
if (!ck(i, j)) fromS = false;
if (!fromS) {
int ss = 0x3f3f3f3f;
for (int j = 0; j < i; ++j) {
s[i] = s[j] + d[j] + (j == 0);
bool valid = true;
for (int k = 1; k < i; ++k) valid &= ck(i, k);
if (valid) ss = min(s[i], ss);
}
s[i] = ss;
}
printf("%d %d\n", s[i], s[i] + d[i] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int k_max_n = 222;
int n;
pair<int, int> assigned[k_max_n];
vector<int> lasts;
int main(void) {
lasts.push_back(1);
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
int start = a, last = a + b - 1;
for (int j = 0; j < i; ++j) {
if (!(assigned[j].first > last || assigned[j].second < start)) {
for (int k = 0; k < lasts.size(); ++k) {
bool flag = true;
for (int l = 0; l < i; ++l) {
if (!(assigned[l].first > lasts[k] + b - 1 ||
assigned[l].second < lasts[k])) {
flag = false;
break;
}
}
if (flag) {
start = lasts[k];
last = lasts[k] + b - 1;
break;
}
}
break;
}
}
lasts.push_back(last + 1);
sort(lasts.begin(), lasts.end());
assigned[i].first = start, assigned[i].second = last;
}
for (int i = 0; i < n; ++i)
printf("%d %d\n", assigned[i].first, assigned[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205;
vector<pair<long long, long long> > res;
int n;
long long d[MAXN], s[MAXN];
bool check(pair<long long, long long> cur) {
for (int i = 0; i < (int)(res.size()); i++)
if (max(res[i].first, cur.first) <= min(res[i].second, cur.second))
return false;
return true;
}
pair<long long, long long> find(pair<long long, long long> cur) {
long long left = -1;
for (int i = 0; i < (int)(res.size()); i++)
if (max(res[i].first, cur.first) <= min(res[i].second, cur.second)) {
left = max(left, res[i].second + 1);
}
assert(left != -1);
return make_pair(left, left - cur.first + cur.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> d[i] >> s[i];
for (int i = 0; i < (int)(n); i++) {
pair<long long, long long> cur = make_pair(d[i], d[i] + s[i] - 1);
if (!check(cur)) {
cur = make_pair(1, s[i]);
while (!check(cur)) cur = find(cur);
}
res.push_back(cur);
}
for (int i = 0; i < (int)(n); i++)
cout << res[i].first << ' ' << res[i].second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long n1, long long n2) {
if (n2 == 0) return n1;
if (n1 % n2 == 0) return n2;
return gcd(n2, n1 % n2);
}
long long powmod(long long base, long long exponent) {
if (exponent < 0) exponent += 1000000007LL - 1;
long long ans = 1;
while (exponent) {
if (exponent & 1) ans = (ans * base) % 1000000007LL;
base = (base * base) % 1000000007LL;
exponent /= 2;
}
return ans;
}
int a[1000005], b[1000005];
vector<pair<int, int> > v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
bool flag = true;
cin >> a[i] >> b[i];
int from = a[i], to = a[i] + b[i] - 1;
for (int j = 0; j < i; j++) {
if (v[j].first <= from && v[j].second >= from) flag = false;
if (v[j].first <= to && v[j].second >= to) flag = false;
if (v[j].first >= from && v[j].second <= to) flag = false;
}
if (flag) {
v.push_back(make_pair(from, to));
cout << v.back().first << " " << v.back().second << '\n';
sort(v.begin(), v.end());
continue;
} else {
if (v[0].first > b[i]) {
v.push_back(make_pair(1, b[i]));
cout << v.back().first << " " << v.back().second << '\n';
sort(v.begin(), v.end());
continue;
}
bool hogaya = false;
for (int j = 1; j < v.size(); j++) {
if (v[j].first - v[j - 1].second > b[i]) {
v.push_back(make_pair(v[j - 1].second + 1, v[j - 1].second + b[i]));
cout << v.back().first << " " << v.back().second << '\n';
sort(v.begin(), v.end());
hogaya = true;
break;
}
}
if (hogaya) continue;
v.push_back(make_pair(v.back().second + 1, v.back().second + b[i]));
cout << v.back().first << " " << v.back().second << '\n';
sort(v.begin(), v.end());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long s[200100][4];
int main() {
memset(s, 0, sizeof(s));
scanf("%d", &n);
bool flag;
s[0][0] = 0;
s[0][1] = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d", &s[i][0], &s[i][1]);
s[i][2] = s[i][1];
s[i][1] = s[i][0] + s[i][1] - 1;
flag = true;
for (int j = 0; j <= i - 1; j++) {
if (s[j][1] < s[i][0] || s[j][0] > s[i][1])
continue;
else {
flag = false;
break;
}
}
if (flag) continue;
s[i][0] = 2000000000000;
s[i][1] = 2000000000000;
for (int j = 0; j <= i - 1; j++) {
long long l = s[j][1] + 1;
long long r = l + s[i][2] - 1;
bool p_flag = true;
for (int k = 0; k <= i - 1; k++) {
if (s[k][1] < l || s[k][0] > r)
continue;
else {
p_flag = false;
break;
}
}
if (p_flag) {
s[i][0] = min(s[i][0], l);
s[i][1] = min(s[i][1], r);
}
}
}
for (int i = 1; i <= n; i++) printf("%I64d %I64d\n", s[i][0], s[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
static const bool bMultiCase = false;
struct Data {
long long l;
long long r;
bool operator<(const Data &b) const {
if (l < b.l) return true;
if (l == b.l && r < b.r) return true;
return false;
}
};
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n;
cin >> n;
long long l, r, len;
set<Data> st;
for (int i = 0; i < n; i++) {
cin >> l >> len;
r = l + len - 1;
if (st.empty() || l > st.rbegin()->r) {
cout << l << " " << r << endl;
st.insert(Data{l, r});
;
continue;
}
bool conflict = false;
for (auto it = st.begin(); it != st.end(); it++) {
auto x = *it;
if (((l) > (x.l) ? (l) : (x.l)) <= ((r) < (x.r) ? (r) : (x.r))) {
conflict = true;
break;
}
}
if (!conflict) {
cout << l << " " << r << endl;
st.insert(Data{l, r});
;
} else {
l = 1;
r = l + len - 1;
if (r < st.begin()->l) {
cout << l << " " << r << endl;
st.insert(Data{l, r});
;
continue;
}
auto it1 = st.begin();
bool inserted = false;
while (!inserted && it1 != st.end()) {
auto it2 = it1;
it2++;
if (it2 == st.end()) break;
if (it2->l - it1->r - 1 >= len) {
inserted = true;
l = it1->r + 1;
r = l + len - 1;
cout << l << " " << r << endl;
st.insert(Data{l, r});
;
}
it1++;
}
if (!inserted) {
l = st.rbegin()->r + 1;
r = l + len - 1;
cout << l << " " << r << endl;
st.insert(Data{l, r});
;
}
}
}
}
};
int main() {
if (Solution::bMultiCase) {
int t;
cin >> t;
while (t--) {
Solution s;
s.solve();
}
} else {
Solution s;
s.solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
const int INF = 1000000000;
struct node {
long long st, ed, qu;
node(long long a = 0, long long b = 0) : st(a), qu(b) { ed = a + b - 1; }
} nd[maxn];
vector<pair<long long, int> > vec;
void vec_push(long long a, long long b) {
vec.push_back(make_pair(a, 1));
vec.push_back(make_pair(b, -1));
sort(vec.begin(), vec.end());
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
vec.clear();
for (int i = 1; i <= n; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
nd[i] = node(a, b);
}
vec_push(-1, 0);
for (int i = 1; i <= n; i++) {
int add = 0;
bool put = 0;
long long cur = 3000000000LL;
for (int j = 0; j < (int)vec.size(); j++) {
long long day = vec[j].first;
add += vec[j].second;
if (add > 0) continue;
if (j + 1 < (int)vec.size()) {
long long len = vec[j + 1].first - day - 1;
if (nd[i].qu <= len) cur = min(cur, day + 1);
if (day < nd[i].st && nd[i].ed < vec[j + 1].first) put = 1;
} else {
cur = min(cur, day + 1);
if (day < nd[i].st) put = 1;
}
}
if (put) {
printf("%lld %lld\n", nd[i].st, nd[i].ed);
vec_push(nd[i].st, nd[i].ed);
} else {
printf("%lld %lld\n", cur, cur + nd[i].qu - 1);
vec_push(cur, cur + nd[i].qu - 1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> p[210], ar[210];
multiset<pair<int, int>> M;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i].first >> p[i].second;
M.insert({p[1].first, p[1].first + p[1].second - 1});
cout << p[1].first << " " << p[1].first + p[1].second - 1 << "\n";
for (int i = 2; i <= n; i++) {
int a = p[i].first;
int b = p[i].second;
int c = 0;
for (auto h : M)
if (a > h.second || a + b - 1 < h.first) c++;
if (c == M.size())
M.insert({a, a + b - 1}), cout << a << " " << a + b - 1 << "\n";
else {
int sz = 0, ok = 0;
for (auto h : M) ar[++sz] = h;
if (b < ar[1].first) {
M.insert({1, b});
cout << 1 << " " << b << "\n";
continue;
}
for (int h = 2; h <= sz; h++)
if (ar[h - 1].second + b < ar[h].first) {
M.insert({ar[h - 1].second + 1, ar[h - 1].second + b}),
cout << ar[h - 1].second + 1 << " " << ar[h - 1].second + b
<< "\n",
ok = 1;
break;
}
if (ok == 0)
cout << ar[sz].second + 1 << " " << ar[sz].second + b << "\n",
M.insert({ar[sz].second + 1, ar[sz].second + b});
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int add(int x, int y) {
x += y;
while (x >= 1000000007) x -= 1000000007;
while (x < 0) x += 1000000007;
return x;
}
int mul(int x, int y) { return (x * 1ll * y) % 1000000007; }
int binpow(int x, int y) {
int z = 1;
while (y) {
if (y & 1) z = mul(z, x);
x = mul(x, x);
y >>= 1;
}
return z;
}
int inv(int x) { return binpow(x, 1000000007 - 2); }
int divide(int x, int y) { return mul(x, inv(y)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<long long int, long long int> > v;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
v.push_back({a, b});
}
vector<pair<long long int, long long int> > sol, sols;
for (int i = 0; i < n; i++) {
long long int a = v[i].first, b = v[i].second + a - 1;
int flag = 0;
for (int j = 0; j < sols.size(); j++) {
if (max(sols[j].first, a) <= min(sols[j].second, b)) flag = 1;
}
long long int pa = 1, push_back = v[i].second;
for (int j = 0; j < sols.size(); j++) {
if (max(sols[j].first, pa) <= min(sols[j].second, push_back)) {
pa = sols[j].second + 1;
push_back = pa + v[i].second - 1;
}
}
if (flag == 0)
sol.push_back({a, b});
else
sol.push_back({pa, push_back});
sols = sol;
sort(sols.begin(), sols.end());
}
for (int i = 0; i < n; i++)
cout << sol[i].first << " " << sol[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1007;
struct Time {
long long s, t;
Time() {}
Time(long long _s, long long _t) { s = _s, t = _t; }
bool in(long long a, long long b) {
if (s <= a && b <= t) return 1;
return 0;
}
long long len() { return t - s + 1; }
};
vector<Time> tmm;
Time res[MAXN];
int main() {
int n;
cin >> n;
tmm.push_back(Time(1ll, 2000000007ll));
for (int i = 1; i <= n; i++) {
long long a, b;
cin >> a >> b;
b += a;
b--;
bool fl = 0;
for (int j = 0; j < tmm.size(); j++) {
if (tmm[j].in(a, b)) {
fl = 1;
long long k = tmm[j].t;
tmm[j].t = a - 1;
res[i] = Time(a, b);
tmm.insert(tmm.begin() + j + 1, Time(b + 1, k));
break;
}
}
if (fl == 0) {
for (int j = 0; j < tmm.size(); j++) {
if (tmm[j].len() >= b - a + 1) {
res[i] = Time(tmm[j].s, tmm[j].s + b - a);
tmm[j].s = tmm[j].s + b - a + 1;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << res[i].s << ' ' << res[i].t << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<long long, long long>> requests;
vector<pair<long long, long long>> cur;
vector<pair<long long, long long>> ans(n);
for (long long i = 0; i < n; ++i) {
long long s, d;
cin >> s >> d;
requests.emplace_back(s, d);
}
for (long long i = 0; i < n; ++i) {
long long s = requests[i].first;
long long e = s + requests[i].second - 1;
bool notConflict = true;
for (long long j = 0; j < cur.size(); ++j) {
if (((cur[j].first <= s && cur[j].second >= s) ||
(cur[j].first <= e && cur[j].second >= e)) ||
((s <= cur[j].first && e >= cur[j].first) ||
(s <= cur[j].second && e >= cur[j].second))) {
notConflict = false;
}
}
if (notConflict) {
ans[i] = make_pair(s, e);
cur.emplace_back(s, e);
} else {
sort(cur.begin(), cur.end());
bool find = false;
if (!cur.empty() && cur[0].first > requests[i].second) {
ans[i] = make_pair(1, requests[i].second);
find = true;
} else if (cur.size() > 1) {
for (long long j = 0; j < cur.size() - 1; ++j) {
long long d = cur[j + 1].first - cur[j].second - 1;
if (d >= requests[i].second) {
ans[i] = make_pair(cur[j].second + 1,
cur[j].second + requests[i].second);
find = true;
break;
}
}
}
if (!find && !cur.empty()) {
ans[i] = make_pair(cur.back().second + 1,
cur.back().second + requests[i].second);
}
cur.push_back(ans[i]);
}
}
for (long long i = 0; i < n; ++i) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int n, siz;
long long s[205];
long long d[205];
long long ans[205];
struct Node {
long long s, d;
Node() {}
Node(long long ss, long long dd) {
s = ss;
d = dd;
}
};
vector<Node> q;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &s[i], &d[i]);
}
q.push_back(Node(1, INF));
for (int i = 0; i < n; i++) {
siz = q.size();
bool flag = true;
long long S;
int pos;
for (int j = 0; j < siz; j++) {
if (s[i] >= q[j].s && q[j].d >= s[i] + d[i] - 1) {
q.push_back(Node(q[j].s, s[i] - 1));
q.push_back(Node(s[i] + d[i], q[j].d));
q[j].s = 0;
q[j].d = -1;
flag = false;
ans[i] = s[i];
break;
}
}
if (flag) {
pos = 0;
S = INF;
for (int j = 0; j < siz; j++) {
if (q[j].s < S && q[j].s + d[i] - 1 <= q[j].d) {
S = q[j].s;
pos = j;
ans[i] = S;
}
}
q[pos].s = q[pos].s + d[i];
}
}
for (int i = 0; i < n; i++) {
printf("%lld %lld\n", ans[i], ans[i] + d[i] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[202];
long long d[202];
long long start[202];
long long ma;
bool check(long long st, long long node) {
long long f = 1;
ma = -1;
for (long long i = 0; i < node; i++) {
if (st >= start[i] && st <= start[i] + d[i] - 1) {
f = 0;
ma = max(ma, start[i] + d[i]);
}
if (st + d[node] - 1 >= start[i] &&
st + d[node] - 1 <= start[i] + d[i] - 1) {
ma = max(ma, start[i] + d[i]);
f = 0;
}
if (st <= start[i] && st + d[node] - 1 >= start[i] + d[i] - 1) {
f = 0;
ma = max(ma, start[i] + d[i]);
}
if (st >= start[i] && st + d[node] - 1 <= start[i] + d[i] - 1) {
f = 0;
ma = max(ma, start[i] + d[i]);
}
}
return f;
}
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> s[i] >> d[i];
long long f = 1, k;
for (long long i = 0; i < n; i++) {
if (!check(s[i], i)) {
f = 1;
long long j = 1;
while (true) {
f = check(j, i);
if (f == 1) {
start[i] = j;
break;
} else
j = ma;
}
} else
start[i] = s[i];
}
for (long long i = 0; i < n; i++)
cout << start[i] << " " << start[i] + d[i] - 1 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > lol;
vector<pair<int, int> > uwu;
bool overlap(pair<int, int> a, pair<int, int> b) {
int as = a.second, af = a.first, bs = b.second, bf = b.first;
if (as <= bs) {
if (af <= bs) return false;
return true;
}
if (bf <= as) return false;
return true;
}
bool check(pair<int, int> rr) {
for (auto it = lol.begin(); it != lol.end(); ++it) {
if (overlap(*it, rr)) return true;
}
return false;
}
void print(pair<int, int> rr) {
cout << rr.second << ' ' << rr.first - 1 << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, s, d;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> d;
uwu.emplace_back(s + d, s);
}
for (int i = 0; i < n; i++) {
pair<int, int> r = uwu[i];
bool f = check(r);
if (f) {
int d = r.first - r.second;
pair<int, int> x = {1 + d, 1};
if (check(x)) {
auto it = lol.begin();
int e = (*it).first;
x = {e + d, e};
while (check(x)) {
++it;
e = (*it).first;
x = {e + d, e};
}
lol.insert(x);
print(x);
} else {
lol.insert(x);
print(x);
}
} else {
lol.insert(r);
print(r);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int s[220];
int d[220];
int sol[220];
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
for (int(i) = (0); (i) < (n); (i)++) cin >> s[i] >> d[i];
for (int(i) = (0); (i) < (n); (i)++) {
int last = 1;
int ok = 0;
for (typeof(v.begin()) it = (v.begin()); it != v.end(); it++) {
if (last <= s[i] && it->first >= s[i] + d[i]) {
v.insert(it, make_pair((s[i]), (d[i])));
ok = 1;
sol[i] = s[i];
break;
}
last = it->first + it->second;
}
if (v.empty() ||
v[((int)v.size()) - 1].first + v[((int)v.size()) - 1].second <= s[i]) {
v.push_back(make_pair((s[i]), (d[i])));
ok = 1;
sol[i] = s[i];
}
if (!ok) {
last = 1;
for (typeof(v.begin()) it = (v.begin()); it != v.end(); it++) {
if (it->first >= last + d[i]) {
v.insert(it, make_pair((last), (d[i])));
sol[i] = last;
ok = 1;
break;
}
last = it->first + it->second;
}
}
if (!ok) {
v.push_back(make_pair((last), (d[i])));
sol[i] = last;
}
cout << sol[i] << " " << sol[i] + d[i] - 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[1000], y[1000], n, a, l, b;
int main() {
scanf("%d", &n);
l = 1;
x[1] = 1, y[1] = 2000000000;
;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a, &b);
int j, t = 0;
for (j = 1; j <= l; j++)
if (a >= x[j] && a + b - 1 <= y[j]) {
t = 1;
break;
}
if (t) {
cout << a << " " << a + b - 1 << endl;
if (a > x[j] && a + b - 1 < y[j]) {
l++;
for (int p = l; p > j + 1; p--) x[p] = x[p - 1], y[p] = y[p - 1];
y[j + 1] = y[j], y[j] = a - 1, x[j + 1] = a + b;
} else {
if (a == x[j]) x[j] = a + b;
if (a + b - 1 == y[j]) y[j] = a - 1;
}
} else
for (int j = 1; j <= l; j++)
if (y[j] - x[j] + 1 >= b) {
cout << x[j] << " " << x[j] + b - 1 << endl;
x[j] = x[j] + b;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> answer[404];
set<pair<int, int> > S;
set<pair<int, int> >::iterator it, ii;
bool check(pair<int, int> c) {
ii = S.lower_bound(make_pair(c.first, 0));
if (ii != S.end()) {
if (c.first + c.second > (*ii).first) return false;
}
if (ii != S.begin()) {
ii--;
if (c.first < (*ii).first + (*ii).second) return false;
}
return true;
}
int main() {
scanf("%d", &n);
S.insert(make_pair(0, 1));
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d %d", &x, &y);
pair<int, int> c = make_pair(x, y);
if (check(c)) {
answer[i] = c;
S.insert(c);
continue;
}
for (it = S.begin(); it != S.end(); it++) {
c = make_pair((*it).first + (*it).second, y);
if (check(c)) {
S.insert(c);
answer[i] = c;
break;
}
}
}
for (int i = 0; i < n; ++i)
printf("%d %d\n", answer[i].first, answer[i].second + answer[i].first - 1);
}
|
#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 = 207;
struct wT {
wT() {}
wT(int _beg, int _en) : beg(_beg), en(_en) {}
bool operator<(const wT &a) const { return (beg < a.beg); }
int beg, en;
} ans[MAXN];
int n;
int s[MAXN], d[MAXN];
set<wT> st;
set<wT>::iterator it, nxt;
void init();
void input();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", &s[i], &d[i]);
}
void work() {
st.insert(wT(0, 0));
st.insert(wT(SINF, SINF));
int beg, en;
bool flag;
for (int i = 0; i < n; ++i) {
beg = s[i], en = s[i] + d[i] - 1;
flag = true;
for (it = st.begin(); it != st.end(); ++it) {
if (it->beg > en) {
break;
} else if (it->en >= beg) {
flag = false;
break;
}
}
if (flag) {
ans[i].beg = beg, ans[i].en = en;
} else {
for (it = st.begin(); it != st.end(); ++it) {
nxt = it;
++nxt;
if (nxt->beg - it->en - 1 >= d[i]) {
ans[i].beg = it->en + 1;
ans[i].en = ans[i].beg + d[i] - 1;
break;
}
}
}
st.insert(ans[i]);
}
for (int i = 0; i < n; ++i) printf("%d %d\n", ans[i].beg, ans[i].en);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
bool inter(int x1, int y1, int x2, int y2) { return y1 >= x2 && y2 >= x1; }
int main() {
vector<pair<int, int> > pp;
int(n);
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
bool err = 0;
for (int j = 0; j < (((int)(pp).size())); ++j)
if (inter(x, x + y - 1, pp[j].first, pp[j].second)) {
err = 1;
break;
}
if (!err) {
printf("%d %d\n", x, x + y - 1);
pp.push_back(make_pair(x, x + y - 1));
} else {
int lt = 0;
bool suc = 0;
for (int j = 0; j < (((int)(pp).size())); ++j) {
if (pp[j].first - lt - 1 >= y) {
suc = 1;
pp.push_back(make_pair(lt + 1, lt + y));
printf("%d %d\n", lt + 1, lt + y);
break;
}
lt = pp[j].second;
}
if (!suc) {
printf("%d %d\n", pp.back().second + 1, pp.back().second + y);
pp.push_back(make_pair(pp.back().second + 1, pp.back().second + y));
}
}
sort((pp).begin(), (pp).end());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
int main() {
int n;
scanf("%d", &n);
vector<pair<long long, long long> > vec(n), ans;
set<pair<long long, long long> > busy;
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &vec[i].first, &vec[i].second);
}
long long x = 1;
for (int i = 0; i < n; ++i) {
long long start = vec[i].first, end = vec[i].first + vec[i].second - 1;
if (busy.empty()) {
busy.insert({start, end});
ans.push_back({start, end});
continue;
}
bool can1 = 0, G = 0;
for (auto j : busy) {
if (j.second < start) continue;
if (end < j.first) {
can1 = 1;
busy.insert({start, end});
ans.push_back({start, end});
}
G = 1;
break;
}
if (!G) {
busy.insert({start, end});
ans.push_back({start, end});
can1 = 1;
}
if (can1) continue;
x = 1;
for (auto j : busy) {
if (x + vec[i].second - 1 < j.first) {
busy.insert({x, x + vec[i].second - 1});
ans.push_back({x, x + vec[i].second - 1});
can1 = 1;
break;
}
x = j.second + 1;
}
if (can1) continue;
busy.insert({x, x + vec[i].second - 1});
ans.push_back({x, x + vec[i].second - 1});
}
for (auto i : ans) {
printf("%lld %lld\n", i.first, i.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
set<pair<long long, long long> > arr;
for (int i = 0; i < n; i++) {
long long l, len, r;
cin >> l >> len;
r = l + len - 1;
bool flag = true;
for (auto p : arr) {
if ((l >= p.first && l <= p.second) || (r >= p.first && r <= p.second) ||
(p.first >= l && p.first <= r) || (p.second >= l && p.second <= r)) {
flag = false;
break;
}
}
if (flag) {
arr.insert({l, r});
cout << l << " " << r << endl;
} else {
l = 1;
r = l + len - 1;
flag = false;
for (auto p : arr) {
if (r < p.first) {
arr.insert({l, r});
cout << l << " " << r << endl;
flag = true;
break;
} else {
l = p.second + 1;
r = l + len - 1;
}
}
if (!flag) {
arr.insert({l, r});
cout << l << " " << r << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x, y, next;
};
Node sq[1000];
int n, s[1000], t[1000], cnt;
bool inser(int id) {
int st = s[id], en = s[id] + t[id] - 1;
bool flag = false;
for (int i = 0; i != -1; i = sq[i].next) {
if (st > sq[i].y) {
if (sq[i].next == -1) {
sq[i].next = id + 1;
sq[id + 1].x = st, sq[id + 1].y = en;
return true;
} else if (sq[sq[i].next].x > en) {
sq[id + 1].x = st, sq[id + 1].y = en;
sq[id + 1].next = sq[i].next;
sq[i].next = id + 1;
return true;
}
} else
break;
}
for (int i = 0; i != -1; i = sq[i].next) {
st = sq[i].y + 1, en = st + t[id] - 1;
if (st > sq[i].y) {
if (sq[i].next == -1) {
sq[i].next = id + 1;
sq[id + 1].x = st, sq[id + 1].y = en;
return true;
} else if (sq[sq[i].next].x > en) {
sq[id + 1].x = st, sq[id + 1].y = en;
sq[id + 1].next = sq[i].next;
sq[i].next = id + 1;
return true;
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &s[i], &t[i]);
memset(sq, -1, sizeof sq);
sq[0].x = 0, sq[0].y = 0;
for (int i = 0; i < n; i++) inser(i);
for (int i = 1; i <= n; i++) printf("%d %d\n", sq[i].x, sq[i].y);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 109;
vector<pair<long long, long long> > S;
int main() {
int n;
scanf("%d", &n);
S.push_back({0, 0});
while (n--) {
sort(S.begin(), S.end());
long long a, b;
scanf("%lld %lld", &a, &b);
long long st = a, en = a + b - 1;
bool ok = 1;
for (auto I : S) {
if (I.first > en || I.second < st) continue;
ok = 0;
}
if (ok) {
S.push_back({st, en});
cout << st << ' ' << en << endl;
continue;
}
for (int j = 0; j < S.size(); j++) {
if (j + 1 == S.size() || S[j + 1].first - S[j].second - 1 >= b) {
cout << S[j].second + 1 << ' ' << S[j].second + b << endl;
S.push_back({S[j].second + 1, S[j].second + b});
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9 + 7;
struct Node {
long long s;
long long len;
bool operator<(const Node k) const { return s < k.s; }
};
int main() {
set<Node> st;
long long n, x, y;
st.insert((Node){1ll, inf});
scanf("%lld", &n);
while (n--) {
scanf("%lld%lld", &x, &y);
bool flag = false;
for (auto i : st) {
if (i.s <= x && i.s + i.len >= x + y) {
flag = true;
Node tmp = i;
st.erase(i);
if (x != tmp.s) st.insert((Node){tmp.s, x - tmp.s});
st.insert((Node){x + y, tmp.s + tmp.len - x - y});
printf("%lld %lld\n", x, x + y - 1);
break;
}
}
if (flag == false) {
for (auto i : st) {
if (i.len >= y) {
Node tmp = i;
st.erase(i);
st.insert((Node){tmp.s + y, tmp.len - y});
printf("%lld %lld\n", tmp.s, tmp.s + y - 1);
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int ss[220];
int ds[220];
long long ls[220], rs[220];
int c;
bool check(long long s, long long d) {
long long L = s, R = s + d - 1;
int id = lower_bound(ls, ls + c, s) - ls;
if (ls[id] <= R) return false;
if (rs[id - 1] >= L) return false;
return true;
}
long long find(long long d) {
for (int i = 0; i + 1 < c; ++i) {
long long tmp_l = rs[i] + 1;
long long tmp_r = ls[i + 1] - 1;
if (tmp_r - tmp_l + 1 >= d) return tmp_l;
}
return -1;
}
void ins(long long le, long long ri) {
ls[c] = le, rs[c] = ri;
c++;
sort(ls, ls + c);
sort(rs, rs + c);
}
void solve() {
ls[0] = 0, rs[0] = 0;
ls[1] = 1ll << 50, rs[1] = 1ll << 50;
c = 2;
for (int i = 0; i < N; ++i) {
bool flg = check(ss[i], ds[i]);
long long ans_le = -1, ans_ri = -1;
if (flg) {
ans_le = ss[i], ans_ri = ss[i] + ds[i] - 1;
} else {
ans_le = find(ds[i]);
ans_ri = ans_le + ds[i] - 1;
}
ins(ans_le, ans_ri);
cout << ans_le << " " << ans_ri << "\n";
}
}
void input() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d%d", ss + i, ds + i);
}
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e2 + 10;
struct Node {
int beg, ed;
bool operator<(const Node& r) const { return beg < r.beg; }
} X[maxn];
int main() {
int n, ff, p, d;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
ff = 0;
scanf("%d%d", &p, &d);
for (int j = 1; j < i; j++) {
if (!(X[j].beg > p + d - 1 || X[j].ed < p)) ff = 1;
}
if (ff) {
for (int j = 0; j <= i; j++) {
if (j == 0)
p = 1;
else
p = X[j].ed + 1;
int fff = 0;
for (int k = 1; k < i; k++) {
if (!(X[k].beg > p + d - 1 || X[k].ed < p)) fff = 1;
}
if (!fff) {
X[i].beg = p;
X[i].ed = p + d - 1;
break;
}
}
} else {
X[i].beg = p;
X[i].ed = p + d - 1;
}
printf("%d %d\n", X[i].beg, X[i].ed);
sort(X + 1, X + 1 + i);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.