text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct q {
long long l;
long long r;
long long d;
bool operator==(const q& a) const {
if ((a.l >= l && a.l <= r) || (a.r >= l && a.r <= r)) return true;
if ((a.l <= l && a.r > r))
return true;
else
return false;
}
bool operator<(const q& a) const { return (r < a.r); }
bool operator>(const q& a) const { return (r > a.r); }
} qqq;
int main() {
set<q> st;
q node[300];
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d %I64d", &node[i].l, &node[i].d);
node[i].r = node[i].l + node[i].d - 1;
}
for (int i = 1; i <= n; i++) {
int flag = 1;
for (set<q>::iterator it = st.begin(); it != st.end(); it++) {
if ((*it) == node[i]) {
flag = 0;
break;
}
}
if (flag == 1) {
st.insert(node[i]);
} else if (flag == 0) {
node[i].l = 1;
node[i].r = 1 + node[i].d - 1;
for (set<q>::iterator it = st.begin(); it != st.end(); it++) {
if (node[i] == (*it)) {
node[i].l = it->r + 1;
node[i].r = node[i].l + node[i].d - 1;
}
}
st.insert(node[i]);
}
}
for (int i = 1; i <= n; i++) {
printf("%I64d %I64d\n", node[i].l, node[i].r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<long long, long long>> segs;
void solve() {
segs.emplace_back(-1, 0);
segs.emplace_back((long long)4e9, (long long)4e9 + 1);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
sort(segs.begin(), segs.end());
long long s, d;
scanf("%lld%lld", &s, &d);
for (int j = 1; j < (int)segs.size(); j++)
if (s < segs[j].first) {
if (segs[j - 1].second < s && s + d - 1 < segs[j].first)
segs.emplace_back(s, s + d - 1);
else {
for (int k = 1; k < (int)segs.size(); k++) {
if (segs[k - 1].second + d < segs[k].first) {
segs.emplace_back(segs[k - 1].second + 1, segs[k - 1].second + d);
break;
}
}
}
break;
}
printf("%lld %lld\n", segs.back().first, segs.back().second);
}
}
int main() {
solve();
(void)0;
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; 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; 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;
const long long MOD = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<pair<long long, long long> > ps(n);
for (int i = 0; i < (n); i++) cin >> ps[i].first >> ps[i].second;
map<long long, long long> mp;
for (pair<long long, long long> p : ps) {
int f = 1;
auto it = mp.upper_bound(p.first);
if (it != mp.end() && it->first < p.first + p.second) f = 0;
if (it != mp.begin()) {
--it;
if (p.first < it->second) f = 0;
}
long long a, b;
if (f) {
a = p.first;
b = p.first + p.second;
} else {
long long x = 1;
for (pair<long long, long long> q : mp) {
if (x + p.second <= q.first) break;
x = q.second;
}
a = x;
b = x + p.second;
}
cout << a << " " << b - 1 << endl;
mp[a] = b;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long N;
cin >> N;
vector<pair<long long, long long>> g;
set<pair<long long, long long>> s;
for (long long j = 1; j <= N; j++) {
long long st, d;
cin >> st >> d;
long long en = st + d - 1;
bool ok = 1;
for (auto it : g) {
if ((it.first <= st && it.first >= en) or
(st >= it.first && st <= it.second) or
(en >= it.first && en <= it.second) or
(st < it.first && en > it.second)) {
ok = 0;
}
}
if (ok) {
g.push_back({st, en});
s.insert({st, en});
continue;
}
long long x = 1;
ok = 1;
for (auto it : s) {
long long st = x, en = x + d - 1;
if (en < it.first) {
g.push_back({st, en});
s.insert({st, en});
ok = 0;
break;
}
x = it.second + 1;
}
if (ok) {
g.push_back({x, x + d - 1});
s.insert({x, x + d - 1});
}
}
for (auto it : g) {
cout << it.first << " " << it.second << endl;
}
}
int32_t main() {
long long tt;
tt = 1;
long long cas = 1;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return SQR(POW(B, P / 2));
}
template <typename T>
inline T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T BMOD(T p, T e, T m) {
T ret = 1;
while (e) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
e >>= 1;
}
return (T)ret;
}
int n;
long long int ss[210], dur[210];
map<long long int, int> MP;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &ss[i], &dur[i]);
}
set<pair<long long int, pair<long long int, int> > > res;
res.insert(
make_pair(100000000000000000LL,
make_pair(100000000000000000LL + 100000000000000000LL, 0)));
for (int i = 1; i <= n; i++) {
long long int st = ss[i];
long long int en = st + dur[i] - 1;
int ok = 1;
for (__typeof(res.begin()) j = res.begin(); j != res.end(); j++) {
pair<long long int, pair<long long int, int> > id1 = *j;
long long int fs = id1.first;
long long int sc = id1.second.first;
if (st >= fs && st <= sc) {
ok = 0;
break;
}
if (en >= fs && en <= sc) {
ok = 0;
break;
}
if (st < fs && en > sc) {
ok = 0;
break;
}
}
if (ok == 1) {
res.insert(make_pair(st, make_pair(en, i)));
} else {
long long int nw = 1;
for (__typeof(res.begin()) j = res.begin(); j != res.end(); j++) {
pair<long long int, pair<long long int, int> > id1 = *j;
if (id1.first == nw) {
nw = id1.second.first + 1;
} else
break;
}
int fl = 0;
for (__typeof(res.begin()) j = res.begin(); j != res.end(); j++) {
pair<long long int, pair<long long int, int> > id1 = *j;
long long int fs = id1.first;
if (nw > fs) continue;
if (nw == fs) {
nw = id1.second.first + 1;
continue;
}
if (nw + dur[i] - 1 < fs) {
res.insert(make_pair(nw, make_pair(nw + dur[i] - 1, i)));
fl = 1;
break;
} else
nw = id1.second.first + 1;
}
if (!fl) {
res.insert(make_pair(nw, make_pair(nw + dur[i] - 1, i)));
}
}
}
set<pair<int, pair<long long int, long long int> > > ans;
for (__typeof(res.begin()) j = res.begin(); j != res.end(); j++) {
pair<long long int, pair<long long int, int> > tmp = *j;
ans.insert(
make_pair(tmp.second.second, make_pair(tmp.first, tmp.second.first)));
}
for (__typeof(ans.begin()) j = ans.begin(); j != ans.end(); j++) {
pair<int, pair<long long int, long long int> > tt = *j;
if (tt.first == 0) continue;
printf("%lld %lld\n", tt.second.first, tt.second.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T>
using matrix = vector<vector<T>>;
constexpr int INF = (int)1e9 + 7;
constexpr int MAXN = (int)1e3 + 1;
constexpr int MOD = (int)1e9 + 7;
constexpr double EPS = 1e-9;
vector<pii> t;
bool check(int s, int d) {
for (auto [t1, t2] : t) {
if (t1 <= s + d - 1 && t2 >= s) return false;
}
return true;
}
void solve() {
int n;
cin >> n;
t.emplace_back(0, 0);
for (int i = 0; i < n; ++i) {
int s, d;
cin >> s >> d;
if (!check(s, d)) {
s = INF;
for (auto [_, t2] : t) {
if (check(t2 + 1, d)) s = min(s, t2 + 1);
}
}
cout << s << " " << s + d - 1 << endl;
t.emplace_back(s, s + d - 1);
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(7);
solve();
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DT {
long long s, d;
long long st, ed;
long long id;
} data[300];
long long ans1[300], ans2[300];
bool cmp(DT a, DT b) { return a.st < b.st; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d", &data[i].s, &data[i].d);
data[i].id = i;
}
data[0].st = 0;
data[0].ed = 0;
for (int i = 1; i <= n; i++) {
bool flag = true;
for (int j = 1; j < i; j++) {
if (data[i].s >= data[j].st && data[i].s <= data[j].ed) flag = false;
if (data[i].s + data[i].d - 1 >= data[j].st &&
data[i].s + data[i].d - 1 <= data[j].ed)
flag = false;
if (data[i].s <= data[j].st && data[i].s + data[i].d - 1 >= data[j].ed)
flag = false;
}
if (flag == true)
data[i].st = data[i].s, data[i].ed = data[i].st + data[i].d - 1;
else {
sort(data, data + i, cmp);
bool flag2 = false;
for (int j = 1; j < i; j++) {
int tst = data[j - 1].ed + 1;
int ted = data[j].st;
if (tst + data[i].d - 1 < ted) {
data[i].st = tst;
data[i].ed = tst + data[i].d - 1;
break;
}
if (!flag2) {
data[i].st = data[i - 1].ed + 1;
data[i].ed = data[i].st + data[i].d - 1;
}
}
}
}
for (int i = 1; i <= n; i++)
ans1[data[i].id] = data[i].st, ans2[data[i].id] = data[i].ed;
for (int i = 1; i <= n; i++) printf("%I64d %I64d\n", ans1[i], ans2[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char IO_MODE = 3;
inline long long ReadInt() {
long long x = 0, s = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') s = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return s * x;
}
inline void WriteInt(long long x) {
char c[20];
if (!x) {
putchar('0');
return;
}
if (x < 0) putchar('-'), x = -x;
int i = 0;
while (x > 0) c[++i] = x % 10, x /= 10;
while (i) putchar(c[i--] + 48);
}
template <typename T>
inline void out(T x) {
if (IO_MODE & 1)
WriteInt(x);
else if (typeid(x) == typeid(int))
printf("%i", x);
else
printf("%lld", (long long)x);
}
template <typename T, typename... Args>
inline void out(T x, Args... args) {
out(x);
putc(' ', stdout);
out(args...);
}
template <typename T>
inline void in(T &x) {
if (IO_MODE & 2)
x = ReadInt();
else if (typeid(x) == typeid(int))
scanf("%i", &x);
else if (typeid(x) == typeid(long long))
scanf("%lld", &x);
}
template <typename T, typename... Args>
inline void in(T &x, Args &...args) {
in(x);
in(args...);
}
int tc;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while (token = strtok(NULL, ", ")) v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
void debugg(vector<char *> args) { cerr << "\b\b "; }
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
set<pair<long long, long long> > rng;
set<long long> en;
long long n;
pair<long long, long long> A[200200], ans[200200];
long long check(long long l, long long r) {
auto nxt = rng.upper_bound(make_pair(l, r));
if (nxt == rng.begin()) {
return r < nxt->first;
} else {
auto pre = nxt;
pre--;
if (nxt == rng.end())
return pre->second < l;
else
return pre->second < l && r < nxt->first;
}
}
int32_t main() {
in(n);
for (long long i = 0; i < n; i++) {
A[i].first = ReadInt();
A[i].second = ReadInt();
}
en.insert(0);
ans[0] = make_pair(A[0].first, A[0].first + A[0].second - 1);
rng.insert(ans[0]);
en.insert(ans[0].second);
for (long long i = 1; i < n; i++) {
if (check(A[i].first, A[i].first + A[i].second - 1)) {
rng.insert(make_pair(A[i].first, A[i].first + A[i].second - 1));
en.insert(A[i].first + A[i].second - 1);
ans[i] = make_pair(A[i].first, A[i].first + A[i].second - 1);
} else {
for (auto x : en) {
if (check(x + 1, x + A[i].second)) {
rng.insert(make_pair(x + 1, x + A[i].second));
en.insert(x + A[i].second);
ans[i] = make_pair(x + 1, x + A[i].second);
break;
}
}
}
}
for (long long i = 0; i < n; i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > ss;
int main() {
int n;
scanf("%d", &n);
ss.insert(make_pair(1, 2000000000));
set<pair<int, int> >::iterator it;
for (int i = 1; i <= n; i++) {
int s, t;
scanf("%d%d", &s, &t);
for (it = ss.begin();; it++) {
if (it->second >= s) {
if (it->second >= s + t - 1 && it->first <= s) {
printf("%d %d\n", s, s + t - 1);
int fi = it->first, se = it->second;
ss.erase(it);
if (fi < s) ss.insert(make_pair(fi, s - 1));
if (se > s + t - 1) ss.insert(make_pair(s + t, se));
} else {
for (it = ss.begin();; it++) {
if (it->second - it->first + 1 >= t) {
printf("%d %d\n", it->first, it->first + t - 1);
int fi = it->first, se = it->second;
ss.erase(it);
if (fi + t <= se) ss.insert(make_pair(fi + t, se));
break;
}
}
}
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205;
int n;
int s[MAXN], d[MAXN];
int ok(int idx, int l, int r) {
for (int i = 1; i < idx; i++) {
if (l <= s[i] + d[i] - 1 && r >= s[i]) return i;
}
return 0;
}
int main() {
cin >> n;
d[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> s[i] >> d[i];
int idx = ok(i, s[i], s[i] + d[i] - 1);
if (!idx) continue;
s[i] = 1;
idx = ok(i, s[i], s[i] + d[i] - 1);
while (idx) {
s[i] = s[idx] + d[idx];
idx = ok(i, s[i], s[i] + d[i] - 1);
}
}
for (int i = 1; i <= n; i++) cout << s[i] << ' ' << s[i] + d[i] - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> pp;
typedef vector<pp> vp;
typedef map<pp, ll> ipi;
typedef map<pp, char> ipc;
typedef map<ll, ll> ii;
typedef set<ll> sl;
typedef multiset<ll> msl;
typedef map<char, ll> ci;
typedef set<pair<ll, ll>> sp;
const ll mod = 1e9 + 7;
const ll N = 2e4 + 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t;
cin >> t;
multiset<pp> m;
for (int i = 0; i < t; i++) {
ll x, y;
cin >> x >> y;
int f = 0;
for (auto j : m) {
if (j.second >= x && j.first <= x + y - 1) f = 1;
}
if (!f) {
m.insert({x, x + y - 1});
cout << x << " " << x + y - 1 << "\n";
} else {
ll k = 1;
for (auto j : m) {
if (j.first >= k && j.second <= k) {
k = j.second + 1;
}
}
for (auto j : m) {
if (j.first - k - 1 >= y - 1) {
break;
}
k = j.second + 1;
}
m.insert({k, k + y - 1});
cout << k << " " << k + y - 1 << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 10;
const int INF = 0x3f3f3f3f;
struct Node {
int l, r;
} a[N], now;
bool pan(Node a, Node b) {
if (a.l > b.r || a.r < b.l) return true;
return false;
}
bool cmp(Node a, Node b) { return a.l < b.l; }
int main() {
int n;
scanf("%d", &n);
int i, j;
for (i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (i == 0) {
a[i].l = x;
a[i].r = x + y - 1;
printf("%d %d\n", a[i].l, a[i].r);
} else {
now.l = x;
now.r = x + y - 1;
sort(a, a + i, cmp);
for (j = 0; j < i; j++) {
if (!pan(now, a[j])) break;
}
if (j == i) {
a[i] = now;
printf("%d %d\n", a[i].l, a[i].r);
continue;
}
now.l = 1;
now.r = y;
for (j = 0; j < i; j++) {
if (pan(now, a[j])) {
a[i] = now;
printf("%d %d\n", a[i].l, a[i].r);
break;
} else {
now.l = a[j].r + 1;
now.r = a[j].r + y;
}
}
if (j == i) {
a[i] = now;
printf("%d %d\n", a[i].l, a[i].r);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const signed inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T>
int chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
int chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T mmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
inline bool read(signed &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(long long &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r'))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
inline bool write(signed first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(long long first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
vector<pair<int, int> > qwq;
int main() {
qwq.push_back(make_pair(1, 1));
qwq.push_back(make_pair(2e9, 2e9));
int n, s, d, c = 1;
read(n);
for (; n; --n) {
read(s, d);
bool orz = 0;
for (int i = 0; i < c; ++i)
if (qwq[i].second <= s && s + d <= qwq[i + 1].first) {
qwq.push_back(make_pair(s, s + d));
write(s, ' ', s + d - 1, '\n');
orz = 1;
++c;
break;
}
if (!orz) {
for (int i = 0; i < c; ++i)
if (qwq[i + 1].first - qwq[i].second >= d) {
qwq.push_back(make_pair(qwq[i].second, qwq[i].second + d));
write(qwq[i].second, ' ', qwq[i].second + d - 1, '\n');
orz = 1;
++c;
break;
}
}
sort(qwq.begin(), qwq.end());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, mt;
int a[N];
int b[N];
int t[N];
inline int read() {
int x = 0;
int f = 1;
char ch = getchar();
while (ch > '9' || ch < '0')
if (ch == '-') f = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
b[i] = read();
}
bool flag;
mt = 1;
for (int i = 1; i <= n; i++) {
flag = 0;
t[i] = 0x7ffffff;
for (int j = 0; j < i; j++) {
if ((a[i] <= t[j] && a[i] + b[i] - 1 >= t[j]) ||
(a[i] <= t[j] + b[j] - 1 && a[i] + b[i] - 1 >= t[j] + b[j] - 1) ||
(a[i] >= t[j] && a[i] + b[i] - 1 <= t[j] + b[j] - 1))
flag = 1;
}
if (!flag) {
t[i] = a[i];
}
if (flag) {
t[i] = mt;
for (int j = 0; j < i; j++) {
if ((t[i] <= t[j] && t[i] + b[i] - 1 >= t[j]) ||
(t[i] <= t[j] + b[j] - 1 && t[i] + b[i] - 1 >= t[j] + b[j] - 1) ||
(t[i] >= t[j] && t[i] + b[i] - 1 <= t[j] + b[j] - 1)) {
t[i] = t[j] + b[j];
j = 0;
}
}
if (t[i] == mt) mt = t[i] + b[i];
}
printf("%d %d\n", t[i], t[i] + b[i] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 5;
struct segment {
long long st;
long long dr;
};
bool cmp(segment a, segment b) { return a.st < b.st; }
segment gol[N];
int have = 0;
inline void add(segment a) {
if (a.st <= a.st) gol[++have] = a;
}
inline void del(int id) {
have--;
for (int j = id; j <= have; j++) gol[j] = gol[j + 1];
}
inline void refresh() { sort(gol + 1, gol + have + 1, cmp); }
inline void PrintSolution(segment a) { cout << a.st << " " << a.dr << "\n"; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
add({1LL, (1LL << 60)});
int Questions;
cin >> Questions;
for (int ppp = 1; ppp <= Questions; ppp++) {
refresh();
long long st, dr;
long long len;
cin >> st >> len;
dr = st + len - 1;
int ID = 0;
for (int i = 1; i <= have; i++) {
if (gol[i].st <= st)
ID = i;
else
break;
}
if (ID) {
long long RightBorder = gol[ID].dr;
if (dr <= RightBorder) {
PrintSolution({st, dr});
add({gol[ID].st, st - 1});
add({dr + 1, RightBorder});
del(ID);
continue;
}
}
for (int i = 1; i <= have; i++) {
long long have = gol[i].dr - gol[i].st + 1;
if (len <= have) {
PrintSolution({gol[i].st, gol[i].st + len - 1});
add({gol[i].st + len, gol[i].dr});
del(i);
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010;
int Next[maxn], head, end;
pair<int, int> a[maxn], ans[maxn];
struct node {
int l, r;
};
void add(pair<int, int> tmp, int pos) {
int i;
if (head == 0) {
ans[1] = tmp;
head = 1;
return;
} else {
if (tmp.first + tmp.second - 1 < ans[head].first) {
Next[pos] = head;
head = pos;
ans[pos] = tmp;
return;
}
for (i = head; Next[i] != 0; i = Next[i]) {
if (ans[i].first + ans[i].second - 1 < tmp.first &&
ans[Next[i]].first > tmp.second + tmp.first - 1) {
Next[pos] = Next[i];
Next[i] = pos;
ans[pos] = tmp;
return;
}
}
if (ans[i].second + ans[i].first - 1 < tmp.first) {
Next[i] = pos;
ans[pos] = tmp;
return;
}
if (tmp.second < ans[head].first) {
Next[pos] = head;
head = pos;
ans[pos].first = 1;
ans[pos].second = tmp.second;
return;
}
for (i = head; Next[i] != 0; i = Next[i]) {
if (ans[Next[i]].first - (ans[i].first + ans[i].second) >= tmp.second) {
Next[pos] = Next[i];
Next[i] = pos;
ans[pos].first = ans[i].second + ans[i].first;
ans[pos].second = tmp.second;
return;
}
}
Next[i] = pos;
ans[pos].first = ans[i].second + ans[i].first;
ans[pos].second = tmp.second;
return;
}
}
int main() {
int n;
while (cin >> n) {
head = 0;
memset(Next, 0, sizeof(Next));
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].first, &a[i].second);
for (int i = 1; i <= n; i++) add(a[i], i);
for (int i = 1; i <= n; i++)
printf("%d %d\n", ans[i].first, ans[i].first + ans[i].second - 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int n, x, y;
int main() {
v.push_back(make_pair(0, 0));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int flag = 0;
scanf("%d %d", &x, &y);
for (int j = 0; j <= (int)v.size() - 1; j++) {
if (v[j].first > x + y - 1 || v[j].second < x) continue;
flag = 1;
break;
}
if (flag) {
int flag2 = 0;
for (int j = 0; j <= (int)v.size() - 2; j++) {
if (v[j].second + y < v[j + 1].first) {
printf("%d %d\n", v[j].second + 1, v[j].second + y);
v.insert(v.begin() + j + 1,
make_pair(v[j].second + 1, v[j].second + y));
flag2 = 1;
break;
}
}
if (!flag2) {
printf("%d %d\n", v.back().second + 1, v.back().second + y);
v.push_back(make_pair(v.back().second + 1, v.back().second + y));
}
} else {
int z =
upper_bound(v.begin(), v.end(), make_pair(x, x + y - 1)) - v.begin();
v.insert(v.begin() + z, make_pair(x, x + y - 1));
printf("%d %d\n", x, x + y - 1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > vc;
int n;
pair<int, int> ans[205];
int x[205], y[205];
bool cek(int a, int b, int c) { return (a >= b && a <= c); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
vc.push_back(make_pair(x[1], make_pair(x[1] + y[1] - 1, 1)));
for (int i = 2; i <= n; i++) {
sort(vc.begin(), vc.end());
int pos = 1;
bool bisa = 1;
for (int j = 0; j < vc.size(); j++) {
int a = vc[j].first, b = vc[j].second.first;
if (cek(x[i], a, b) || cek(x[i] + y[i] - 1, a, b) ||
cek(a, x[i], x[i] + y[i] - 1) || cek(b, x[i], x[i] + y[i] - 1))
bisa = 0;
}
if (bisa) {
vc.push_back(make_pair(x[i], make_pair(x[i] + y[i] - 1, i)));
continue;
}
bool sudah = 0;
for (int j = 0; j < vc.size(); j++)
if (pos + y[i] - 1 < vc[j].first) {
vc.push_back(make_pair(pos, make_pair(pos + y[i] - 1, i)));
sudah = 1;
break;
} else
pos = vc[j].second.first + 1;
if (!sudah) vc.push_back(make_pair(pos, make_pair(pos + y[i] - 1, i)));
}
for (int i = 0; i < vc.size(); i++)
ans[vc[i].second.second] = make_pair(vc[i].first, vc[i].second.first);
for (int i = 1; i <= n; i++) printf("%d %d\n", ans[i].first, ans[i].second);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 + 10;
int n, m;
struct node {
long long x, d, y;
node(long long _x = 0, long long _d = 0, long long _y = 0) {
x = _x, d = _d, y = _y;
}
void sc() {
scanf("%I64d%I64d", &x, &d);
y = x + d - 1ll;
return;
}
void pr() {
printf("%I64d %I64d\n", x, y);
return;
}
bool operator<(const node& t) const { return x < t.x; }
bool operator==(const node& t) const { return x == t.x && y == t.y; }
} p[maxn];
set<node> mst;
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) p[i].sc();
mst.clear();
mst.insert(node(0, 0, 0));
mst.insert(p[1]);
for (int i = 2; i <= n; i++) {
long long tmp = 0;
bool flag = false;
set<node>::iterator jt = mst.begin(), it = mst.begin();
for (it++; it != mst.end(); jt++, it++) {
if ((*jt).y < p[i].x && p[i].y < (*it).x) {
flag = true;
break;
} else if (!tmp && p[i].d <= (*it).x - (*jt).y - 1)
tmp = (*jt).y + 1;
}
if (!flag) {
--it;
if ((*it).y < p[i].x) flag = true;
it++;
}
if (!flag) {
if (!tmp) {
--it;
tmp = (*it).y + 1;
++it;
}
p[i].x = tmp;
p[i].y = tmp + p[i].d - 1;
}
mst.insert(p[i]);
}
for (int i = 1; i <= n; i++) p[i].pr();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long nmax = 202;
int main() {
long long n;
pair<long long, long long> a[nmax];
cin >> n;
for (long long i = 1; i <= n; i++) {
sort(a, a + i);
long long s, e;
cin >> s >> e;
e = s + e - 1;
bool ok = 1;
for (long long j = 1; j < i; j++)
if (a[j].second >= s && a[j].first <= e) ok = 0;
if (ok) {
cout << (a[i].first = s) << " " << (a[i].second = e) << endl;
continue;
}
a[i].first = 1000000000000000;
for (long long j = 0; j < i; j++)
if (a[j + 1].first - a[j].second - 1 >= e - s + 1) {
cout << (a[i].first = a[j].second + 1) << " "
<< (a[i].second = a[j].second + e - s + 1) << endl;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 100000000 + 1000010;
int n;
vector<pair<long long, long long> > ve;
int main() {
cin >> n;
ve.push_back(make_pair((long long)0, (long long)0));
ve.push_back(make_pair((long long)2000000000, (long long)2000000000));
for (int i = 0; i < n; i++) {
bool ff = 0;
long long s, d;
cin >> s >> d;
for (int j = 0; j < ve.size() - 1; j++)
if (ve[j].second < s && ve[j + 1].first > s + d - 1) {
cout << s << " " << (long long)s + d - 1 << endl;
ve.push_back(make_pair(s, s + d - 1));
ff = 1;
break;
}
if (ff) {
sort(ve.begin(), ve.end());
continue;
}
for (int j = 0; j < ve.size() - 1; j++)
if (ve[j].second + d < ve[j + 1].first) {
cout << ve[j].second + 1 << " " << ve[j].second + d << endl;
ve.push_back(make_pair(ve[j].second + 1, ve[j].second + d));
break;
}
sort(ve.begin(), ve.end());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int siz = 1e5 + 3;
set<pair<int, int> > st;
bool check(int a, int b) {
set<pair<int, int> >::iterator it;
for (it = st.begin(); it != st.end(); ++it) {
if (it->first <= b && a <= it->second) return true;
}
return false;
}
vector<pair<int, int> > v;
int main() {
int n, s, d;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &s, &d);
if (check(s, s + d - 1) == false) {
st.insert(make_pair(s, s + d - 1));
v.push_back(make_pair(s, s + d - 1));
} else {
if (check(1, d) == false) {
st.insert(make_pair(1, d));
v.push_back(make_pair(1, d));
} else {
set<pair<int, int> >::iterator it;
for (it = st.begin(); it != st.end(); ++it) {
if (check(it->second + 1, it->second + d) == false) {
st.insert(make_pair(it->second + 1, it->second + d));
v.push_back(make_pair(it->second + 1, it->second + d));
break;
}
}
}
}
}
for (int i = 0; i < n; i++) printf("%d %d\n", v[i].first, v[i].second);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
bool is_prime(int n) {
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
inline long long getPow(long long a, long long b) {
long long res = 1, tp = a;
while (b) {
if (b & 1ll) {
res *= tp;
}
tp *= tp;
b >>= 1ll;
}
return res;
}
inline long long nxt() {
long long x;
scanf("%lld", &x);
return x;
}
void ok() {
puts("YES");
exit(0);
}
void no() {
puts("No");
exit(0);
}
long long xx[] = {-1, 1, 0, 0};
long long yy[] = {0, 0, -1, 1};
int main() {
long long n = nxt();
vector<pair<pair<long long, long long>, long long> > fix = {{{0, 0}, 0}};
for (int i = 0; i < n; i++) {
long long t1 = nxt(), t2 = nxt();
long long l = t1, r = t1 + t2 - 1;
bool flag = 1;
for (int j = 0; j < fix.size(); j++) {
long long l1 = fix[j].first.first, r1 = fix[j].first.second;
if (l <= r1 && l1 <= l || r >= l1 && r <= r1 || l1 >= l && l1 <= r ||
r1 >= l && r1 <= r) {
flag = 0;
}
}
if (flag) {
fix.push_back({{l, r}, i + 1});
} else {
bool flag = 0;
sort(fix.begin(), fix.end());
long long k1 = -1, k2 = -1;
for (int j = 1; j < fix.size(); j++) {
long long rr = fix[j - 1].first.second;
long long L = fix[j].first.first;
if (L - rr - 1 >= t2) {
flag = 1;
k1 = rr + 1;
k2 = k1 + t2 - 1;
break;
}
}
if (flag) {
fix.push_back({{k1, k2}, i + 1});
} else {
long long rr = fix.back().first.second;
fix.push_back({{rr + 1, rr + t2}, i + 1});
}
}
}
vector<pair<long long, long long> > ans(n + 1);
for (int i = 0; i < fix.size(); i++) {
long long ind = fix[i].second;
ans[ind] = {fix[i].first.first, fix[i].first.second};
}
for (int i = 1; i <= n; i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
bool del[110];
void splitSegment(set<std::pair<int, int> > &segments,
set<std::pair<int, int> >::iterator it, int s, int d) {
std::pair<int, int> seg = *it;
segments.erase(it);
if (s > seg.first) {
segments.insert(make_pair(seg.first, s - seg.first));
}
if (s + d < seg.first + seg.second) {
segments.insert(make_pair(s + d, seg.second - (s + d - seg.first)));
}
cout << s << " " << s + d - 1 << endl;
}
int main() {
int n;
cin >> n;
set<std::pair<int, int> > segments;
segments.insert(make_pair(1, 2000000000));
while (n--) {
int s, d;
cin >> s >> d;
auto it = segments.lower_bound(make_pair(s, 1));
bool sposs = false;
if (it == segments.end()) {
sposs = true;
it--;
if (it->first <= s && it->second - (s - it->first) >= d) {
sposs = true;
}
} else if (it->first == s && it->second - (s - it->first) >= d) {
sposs = true;
} else if (it->first > s && it != segments.begin()) {
it--;
if (it->first <= s && it->second - (s - it->first) >= d) {
sposs = true;
}
}
if (sposs) {
splitSegment(segments, it, s, d);
} else {
for (auto it2 = segments.begin(); it2 != segments.end(); it2++) {
int si = it2->first, di = it2->second;
if (di >= d) {
splitSegment(segments, it2, si, d);
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
long long n;
scanf("%lld", &n);
std::vector<long long> start(n + 1, 0), finish(n + 1, 0);
for (long long p = 1; p <= n; p++) {
long long s, d;
scanf("%lld %lld", &s, &d);
long long a(s), b(s + d - 1);
bool free(true);
for (long long u = 0; u < p; u++) {
if (!((b < start[u]) || (finish[u] < a))) {
free = false;
break;
}
}
if (free) {
start[p] = s;
finish[p] = b;
continue;
}
for (long long t = 0; t < p; t++) {
a = finish[t] + 1;
b = a + d - 1;
free = true;
for (long long u = 0; u < p; u++) {
if (!((b < start[u]) || (finish[u] < a))) {
free = false;
break;
}
}
if (!free) {
continue;
} else if ((start[p] == 0) || (a < start[p])) {
start[p] = a;
finish[p] = b;
}
}
}
for (long long p = 1; p <= n; p++) {
printf("%lld %lld\n", start[p], finish[p]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modx(long long Base, long long exponent) {
long long ans = 1;
if (Base == 1) return Base;
while (exponent) {
if (exponent & 1) ans = (ans * Base) % 1000000007;
Base = (Base * Base) % 1000000007;
exponent = exponent >> 1;
}
return ans;
}
long long inmodx(long long num) { return (modx(num, 1000000007 - 2LL)); }
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
bool ans = 0;
if (a.second < b.second)
ans = 1;
else if (a.second == b.second && a.first < b.first)
ans = 1;
return ans;
}
struct ST_Node {
ST_Node() { return; }
void assign_value_(long long v1, long long v2, long long v3, long long v4) {
return;
}
void merge_nodes_(ST_Node& left, ST_Node& right) { return; }
void merge_nodes_2(ST_Node& left, ST_Node& right) { return; }
};
const int N = (1e5) + 9;
const int M = (N << 2) + 9;
const int LOGN = ((int)log2(N)) + 3;
const int LOGM = ((int)log2(M)) + 3;
const int BUCK = 650;
vector<pair<long long, long long> > temp;
bool check(long long l, long long r) {
int j;
for (j = (0); j < ((int)((temp).size())); j++) {
if (!(temp[j].first > r || l > temp[j].second)) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, i, j, k;
bool mark;
long long l, r, d;
cin >> n;
cin >> l >> d;
r = l + d - 1LL;
cout << l << " " << r << '\n';
temp.push_back(make_pair(l, r));
for (i = (2); i < (n + 1); i++) {
cin >> l >> d;
r = l + d - 1LL;
if (check(l, r)) {
cout << l << " " << r << '\n';
temp.push_back(make_pair(l, r));
} else {
l = 1LL;
r = l + d - 1LL;
if (check(l, r)) {
cout << l << " " << r << '\n';
temp.push_back(make_pair(l, r));
} else {
for (j = (0); j < ((int)((temp).size())); j++) {
l = temp[j].second + 1LL;
r = l + d - 1LL;
if (check(l, r)) {
cout << l << " " << r << '\n';
temp.push_back(make_pair(l, r));
break;
}
}
}
}
sort((temp).begin(), (temp).end(), cmp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
bool compare(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.second < b.second;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
set<pair<pair<int, int>, int> > busy;
for (int i = 1; i <= n; i++) {
int s, d;
cin >> s >> d;
d--;
bool ok = true;
for (auto j = busy.begin(); j != busy.end(); j++) {
int beg = s, end = s + d;
if (!(j->first.first > end || j->first.second < beg)) {
ok = false;
break;
}
}
if (ok)
busy.insert(pair<pair<int, int>, int>(pair<int, int>(s, s + d), i));
else {
int beg = 1, end = 1 + d;
for (auto j = busy.begin(); j != busy.end(); j++) {
if (j->first.first > end || j->first.second < beg) {
busy.insert(pair<pair<int, int>, int>(pair<int, int>(beg, end), i));
break;
} else {
beg = j->first.second + 1;
end = beg + d;
}
}
if (busy.find(pair<pair<int, int>, int>(pair<int, int>(beg, end), i)) ==
busy.end()) {
busy.insert(pair<pair<int, int>, int>(pair<int, int>(beg, end), i));
}
}
}
vector<pair<pair<int, int>, int> > ans;
for (auto i = busy.begin(); i != busy.end(); i++) ans.push_back(*i);
sort(ans.begin(), ans.end(), compare);
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first.first << ' ' << ans[i].first.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
void wap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
using namespace std;
vector<pair<long long, long long>> seg, ans;
long long n, x[200], y[200];
int main() {
ios::sync_with_stdio(0);
seg.emplace_back(1, 1e15);
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
vector<pair<long long, long long>> newseg;
sort(begin(seg), end(seg));
long long okay = -1;
for (long long j = 0; j < seg.size(); ++j) {
auto l = seg[j].first, r = seg[j].second;
if (x[i] >= l && x[i] + y[i] - 1 <= r) {
if (x[i] > l) {
newseg.emplace_back(l, x[i] - 1);
}
if (x[i] + y[i] - 1 < r) {
newseg.emplace_back(x[i] + y[i], r);
}
ans.emplace_back(x[i], x[i] + y[i] - 1);
okay = j;
break;
}
}
if (okay >= 0) {
for (long long j = 0; j < seg.size(); ++j) {
if (j != okay) {
newseg.push_back(seg[j]);
}
}
seg = newseg;
continue;
}
for (long long j = 0; j < seg.size(); ++j) {
auto l = seg[j].first, r = seg[j].second;
if (r - l + 1 >= y[i]) {
if (l + y[i] - 1 < r) {
newseg.emplace_back(l + y[i], r);
}
ans.emplace_back(l, l + y[i] - 1);
okay = j;
break;
}
}
if (okay >= 0) {
for (long long j = 0; j < seg.size(); ++j) {
if (j != okay) {
newseg.push_back(seg[j]);
}
}
seg = newseg;
continue;
}
}
for (auto e : ans) {
cout << e.first << " " << e.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long s[300], d[300];
long long l[300], r[300], lt, rt;
bool cd(long long l1, long long r1, long long l2, long long r2) {
if (r1 < l2) return 0;
if (r2 < l1) return 0;
return 1;
}
bool flg, f;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i] >> d[i];
flg = 1;
for (int j = 1; j < i; j++)
if (cd(l[j], r[j], s[i], s[i] + d[i] - 1)) {
flg = 0;
break;
}
if (flg) {
l[i] = s[i];
r[i] = s[i] + d[i] - 1;
continue;
} else {
for (int k = 0; k < i; k++) {
lt = r[k] + 1;
rt = lt + d[i] - 1;
flg = 1;
for (int j = 1; j < i; j++)
if (cd(l[j], r[j], lt, rt)) {
flg = 0;
break;
}
if (flg && (l[i] == 0 || lt < l[i])) {
l[i] = lt;
r[i] = rt;
}
}
}
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, s, d;
bool free(vector<pair<int, int>> ret, pair<int, int> p) {
for (auto work : ret) {
if (max(work.first, p.first) <= min(work.second, p.second)) {
return false;
}
}
return true;
}
int main() {
cin >> N;
vector<pair<int, int>> ret{{0, 0}};
for (int i = 0; i < N; i++) {
cin >> s >> d;
if (free(ret, {s, s + d - 1})) {
ret.push_back({s, s + d - 1});
continue;
}
int earliest = INT_MAX;
for (int i = 0; i < ret.size(); i++) {
if (free(ret, {ret[i].second + 1, ret[i].second + d})) {
earliest = min(earliest, ret[i].second + 1);
}
}
ret.push_back({earliest, earliest + d - 1});
}
for (int i = 1; i < ret.size(); i++) {
cout << ret[i].first << " " << ret[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
long long n, x, y, f;
cin >> n;
pair<long long, long long> p[n];
for (long long i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
map<long long, long long> m;
m[1] = LLONG_MAX;
for (long long i = 0; i < n; i++) {
x = p[i].first;
y = x + p[i].second - 1;
f = 0;
for (auto k : m) {
if (x >= k.first && y <= k.second) {
if (x == k.first)
m.erase(k.first);
else
m[k.first] = x - 1;
if (y != k.second) m[y + 1] = k.second;
cout << x << " " << y << endl;
f = 1;
break;
}
}
if (!f) {
for (auto k : m) {
if (k.second - k.first + 1 >= p[i].second) {
if (k.first + p[i].second <= k.second)
m[k.first + p[i].second] = k.second;
cout << k.first << " " << k.first + p[i].second - 1 << endl;
m.erase(k.first);
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> ans[205];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int s, d, x = 0;
scanf("%d %d", &s, &d);
for (int j = 1; j < i; ++j) {
if (!(ans[j].first > s + d - 1 || ans[j].second < s)) {
x = 1;
break;
}
}
if (x) {
for (int j = 0; j <= i; ++j) {
if (!j) {
s = 1;
} else {
s = ans[j].second + 1;
}
int y = 0;
for (int k = 1; k < i; ++k) {
if (!(ans[k].first > s + d - 1 || ans[k].second < s)) {
y = 1;
break;
}
}
if (!y) {
ans[i].first = s;
ans[i].second = s + d - 1;
break;
}
}
} else {
ans[i].first = s;
ans[i].second = s + d - 1;
}
printf("%d %d\n", ans[i].first, ans[i].second);
sort(ans + 1, ans + i + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, d;
cin >> n;
set<pair<int, int> > i1;
list<pair<int, int> > i2;
i1.insert(make_pair(1, INT_MAX));
for (int i = 0; i < n; i++) {
cin >> s >> d;
int l = s, r = s + d - 1;
bool f = true;
for (auto b = i2.begin(); b != i2.end(); b++) {
if (!(b->second < l || b->first > r)) {
f = false;
break;
}
}
if (f) {
i2.push_back(make_pair(l, r));
for (auto b = i1.begin(); b != i1.end(); b++) {
if (b->first < l) {
if (r < b->second) {
i1.insert(make_pair(b->first, l - 1));
i1.insert(make_pair(r + 1, b->second));
i1.erase(b);
break;
} else if (r == b->second) {
i1.insert(make_pair(b->first, l - 1));
i1.erase(b);
break;
}
} else if (b->first == l) {
if (r < b->second) {
i1.insert(make_pair(r + 1, b->second));
i1.erase(b);
break;
} else if (r == b->second) {
i1.erase(b);
break;
}
}
}
} else {
for (auto b = i1.begin(); b != i1.end(); b++) {
int l = b->first, r = b->first + d - 1;
if (b->second - b->first + 1 >= d) {
i2.push_back(make_pair(l, r));
if (b->second == r)
i1.erase(b);
else {
i1.insert(make_pair(r + 1, b->second));
i1.erase(b);
}
break;
}
}
}
}
for (auto b = i2.begin(); b != i2.end(); b++) {
cout << b->first << " " << b->second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1000000007ll;
const long long mod1 = 1000000009ll;
const long long mod2 = 1100000009ll;
int INF = (int)1e9 + 5;
long long INFINF = (long long)1e18;
pair<long long, long long> timings[200];
bool overlap(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first > b.first) swap(a, b);
if (a.second < b.first) return false;
return true;
}
int main() {
int n, flag;
long long s, d;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &s);
scanf("%lld", &d);
flag = 1;
for (int j = 1; j <= i - 1; j++)
if (overlap(timings[j], make_pair(s, s + d - 1))) {
flag = 0;
break;
}
if (flag) {
timings[i] = make_pair(s, s + d - 1);
continue;
}
vector<long long> start_days;
start_days.push_back(1LL);
for (int j = 1; j <= i - 1; j++) {
start_days.push_back(timings[j].second + 1);
}
sort(start_days.begin(), start_days.end());
for (int k = 0; k < start_days.size(); k++) {
int day = start_days[k];
flag = 1;
for (int j = 1; j < i; j++) {
if (overlap(timings[j], make_pair(day, day + d - 1))) {
flag = 0;
break;
}
}
if (flag) {
timings[i] = make_pair(day, day + d - 1);
break;
}
}
}
for (int i = 1; i <= n; i++) {
printf("%lld ", timings[i].first);
printf("%lld\n", timings[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-12, pi = acos(-1.0);
const long long inf = 2000000009;
int main() {
int n, t = 0;
cin >> n;
map<int, long long> M;
M[1] = 111111111111111;
vector<pair<int, int> > a;
while (n--) {
int s, d;
scanf("%d%d", &s, &d);
int f = 0;
for (int i = 0; i < a.size(); i++)
if (!(a[i].first > s + d - 1 || a[i].second < s)) f = 1;
if (!f) {
printf("%d %d\n", s, s + d - 1);
a.push_back(pair<int, int>(s, s + d - 1));
for (map<int, long long>::iterator it = M.begin(); it != M.end(); it++) {
if (it->first + it->second - 1 >= s) {
M[s + d] = it->second - (s + d - it->first);
it->second = s - it->first;
break;
}
}
} else {
for (map<int, long long>::iterator it = M.begin(); it != M.end(); it++) {
if (it->second >= d) {
printf("%d %d\n", it->first, it->first + d - 1);
a.push_back(pair<int, int>(it->first, it->first + d - 1));
M[it->first + d] = it->second - d;
M.erase(it);
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct period {
long long start, len;
} ps[1000];
int np;
int main() {
long long i, first, fit, n, a, b, firstp;
cin >> n;
np = 1;
ps[1].start = 1;
ps[1].len = 210000000000000LL;
for (int task = 1; task <= n; task++) {
cin >> a >> b;
firstp = 0;
fit = 0;
first = 210000000000000LL;
for (i = 1; i <= np; i++) {
if (first >= ps[i].start && ps[i].len >= b) {
first = ps[i].start;
firstp = i;
}
if (ps[i].start <= a && ps[i].start + ps[i].len >= a + b) fit = i;
}
if (fit) {
if (ps[fit].start == a) {
ps[fit].start += b;
ps[fit].len -= b;
} else if (ps[fit].len + ps[fit].start == a + b) {
ps[fit].len -= b;
} else {
if (a + b < ps[fit].len + ps[fit].start) {
np++;
ps[np].start = a + b;
ps[np].len = ps[fit].len + ps[fit].start - a - b;
}
ps[fit].len = a - ps[fit].start;
}
printf("%I64d %I64d\n", a, a + b - 1);
} else {
printf("%I64d %I64d\n", ps[firstp].start, ps[firstp].start + b - 1);
ps[firstp].start += b;
ps[firstp].len -= b;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> begin_dates;
set<int> end_dates;
bool possible(int start_date, int days) {
set<int>::iterator next_start = begin_dates.lower_bound(start_date);
set<int>::iterator next_end = end_dates.lower_bound(start_date);
int end_date = start_date + days - 1;
if ((*next_start) > end_date && (*next_end) > end_date &&
(*next_end) >= (*next_start))
return true;
return false;
}
int main() {
begin_dates.insert(1100000001);
end_dates.insert(1100000001);
int n;
cin >> n;
int s, e;
while (n--) {
cin >> s >> e;
if (possible(s, e)) {
begin_dates.insert(s);
end_dates.insert(s + e - 1);
cout << s << " " << s + e - 1 << endl;
} else {
if (possible(1, e)) {
begin_dates.insert(1);
end_dates.insert(e);
cout << 1 << " " << e << endl;
} else {
set<int>::iterator it = end_dates.begin();
while (it != end_dates.end()) {
s = (*it) + 1;
if (possible(s, e)) {
begin_dates.insert(s);
end_dates.insert(s + e - 1);
cout << s << " " << s + e - 1 << endl;
break;
}
it++;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int N = 100010;
struct SCHEDULE {
int id, x, y;
SCHEDULE() {}
SCHEDULE(int _id, int _x, int _y) : id(_id), x(_x), y(_y) {}
bool operator<(const SCHEDULE s) const { return x < s.x; }
};
int main(void) {
int n;
scanf("%d", &n);
vector<SCHEDULE> schedule;
schedule.push_back(SCHEDULE(-1, 0, 0));
for (int i = 0; i < n; i++) {
sort(schedule.begin(), schedule.end());
int s, d;
scanf("%d %d", &s, &d);
bool f = true;
for (int j = 0; j < schedule.size(); j++) {
if (!(schedule[j].y < s or s + d - 1 < schedule[j].x)) f = false;
}
if (f) {
schedule.push_back(SCHEDULE(i, s, s + d - 1));
continue;
}
for (int j = 1; j < schedule.size(); j++) {
int duration = schedule[j].x - schedule[j - 1].y - 1;
if (duration >= d) {
schedule.push_back(
SCHEDULE(i, schedule[j - 1].y + 1, schedule[j - 1].y + 1 + d - 1));
f = true;
break;
}
}
if (f) continue;
schedule.push_back(
SCHEDULE(i, schedule[i].y + 1, schedule[i].y + 1 + d - 1));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < schedule.size(); j++) {
if (schedule[j].id == i) {
printf("%d %d\n", schedule[j].x, schedule[j].y);
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v, a, ans;
bool isinterval(long long a, long long b, long long key) {
if (key >= a and key <= b) return 1;
return 0;
}
int main() {
int n;
cin >> n;
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i].first >> v[i].second;
v[i].second = v[i].first + v[i].second - 1;
}
a.push_back({0, 0});
for (int i = 0; i < n; ++i) {
sort(a.begin(), a.end());
bool ff = 0;
for (int j = 0; j < a.size(); ++j)
if (isinterval(a[j].first, a[j].second, v[i].first) or
isinterval(a[j].first, a[j].second, v[i].second) or
isinterval(v[i].first, v[i].second, a[j].first) or
isinterval(v[i].first, v[i].second, a[j].second)) {
ff = 1;
break;
}
if (ff) {
int idx = a.size() - 1;
long long cc = v[i].second - v[i].first + 1;
pair<long long, long long> com = a[0];
for (int j = 1; j < a.size(); ++j) {
if (a[j].first - com.second - 1 >= cc) {
idx = j - 1;
break;
}
com = a[j];
}
a.push_back({a[idx].second + 1, a[idx].second + cc});
ans.push_back({a[idx].second + 1, a[idx].second + cc});
} else {
a.push_back({v[i].first, v[i].second});
ans.push_back({v[i].first, v[i].second});
}
}
sort(a.begin(), a.end());
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isOverlapping(pair<long long, long long> a, pair<long long, long long> b) {
if (a > b) swap(a, b);
return a.second >= b.first;
}
int main() {
int n;
cin >> n;
vector<pair<long long, long long> > r(n);
vector<pair<long long, long long> > a(n);
set<long long> st;
st.insert(1);
for (int i = 0; i < n; i++) {
cin >> r[i].first >> r[i].second;
int dur = r[i].second;
r[i].second += (r[i].first - 1);
bool pos = true;
for (int j = i - 1; j >= 0; j--) {
if (isOverlapping(a[j], r[i])) {
pos = false;
break;
}
}
if (pos) {
a[i] = r[i];
st.insert(a[i].second + 1);
} else {
for (auto it = st.begin(); it != st.end(); ++it) {
bool found = true;
pair<long long, long long> temp =
pair<long long, long long>(*it, *it + dur - 1);
for (int j = i - 1; j >= 0; j--) {
if (isOverlapping(temp, a[j])) {
found = false;
break;
}
}
if (found) {
a[i] = temp;
st.insert(a[i].second + 1);
break;
}
}
}
cout << a[i].first << " " << a[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long s[300], d[300];
map<long long, long long> a;
map<int, int> b;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i] >> d[i];
if (a.size() == 0) {
a[s[i]] = s[i] + d[i] - 1;
b[i] = s[i];
} else {
long long l = 1;
bool flag = true;
for (map<long long, long long>::iterator it = a.begin(); it != a.end();
++it) {
if (s[i] >= l && s[i] + d[i] <= it->first) {
a[s[i]] = s[i] + d[i] - 1;
b[i] = s[i];
flag = false;
break;
} else
l = it->second + 1;
}
if (flag) {
if (s[i] >= l) {
a[s[i]] = s[i] + d[i] - 1;
b[i] = s[i];
flag = false;
}
}
if (flag) {
l = 1;
for (map<long long, long long>::iterator it = a.begin(); it != a.end();
++it) {
if (l + d[i] <= it->first) {
a[l] = l + d[i] - 1;
b[i] = l;
flag = false;
break;
} else
l = it->second + 1;
}
}
if (flag) {
a[l] = l + d[i] - 1;
b[i] = l;
flag = false;
}
}
}
for (map<int, int>::iterator it = b.begin(); it != b.end(); ++it) {
cout << a.find(it->second)->first << " " << a.find(it->second)->second
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 805;
long long n;
long long a[maxn][3];
long long t1, t2, t3, all;
struct Point {
long long x, y;
Point(long long x = 0, long long y = 0) : x(x), y(y) {}
} p[maxn], p1;
bool cmp(const Point &a, const Point &b) { return a.x < b.x; }
void init() {
all = 2;
p[1] = Point(0, 0);
p[2] = Point(INF, INF);
}
int Judge(int now) {
for (int i = 1; i < all; i++) {
p1.x = p[i].y + 1;
p1.y = p[i + 1].x - 1;
if (p1.x <= a[now][1] && p1.y >= a[now][1] + a[now][2] - 1) {
return 0;
}
}
return 1;
}
int main() {
init();
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d %I64d", &a[i][1], &a[i][2]);
}
for (int i = 1; i <= n; i++) {
sort(p + 1, p + all + 1, cmp);
if (Judge(i)) {
for (int j = 1; j < all; j++) {
if (p[j + 1].x - p[j].y > a[i][2]) {
printf("%I64d %I64d\n", p[j].y + 1, p[j].y + a[i][2]);
p[++all] = Point(p[j].y + 1, p[j].y + a[i][2]);
break;
}
}
} else {
printf("%I64d %I64d\n", a[i][1], a[i][1] + a[i][2] - 1);
p[++all] = Point(a[i][1], a[i][1] + a[i][2] - 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50000 + 100;
struct node {
int a, b;
};
bool operator<(node a, node b) { return a.a < b.a; }
int main() {
int n;
cin >> n;
map<node, int> ans;
bool flag = 0;
node a = {0, 0};
ans.insert(make_pair(a, 0));
int ta, tb;
cin >> ta >> tb;
a = {ta, ta + tb - 1};
map<node, int>::iterator it, itor;
ans.insert(make_pair(a, 1));
cout << a.a << " " << a.b << endl;
for (int i = 2; i <= n; ++i) {
int a, b;
cin >> a >> b;
int tmp = b;
b = b + a - 1;
node c = {a, b};
flag = 0;
it = ans.begin();
it++;
for (; it != ans.end(); ++it) {
it--;
itor = it;
it++;
if (it->first.a > b && itor->first.b < a) {
flag = 1;
break;
}
}
it--;
if (flag || it->first.b < a) {
ans.insert(make_pair(c, i));
cout << c.a << " " << c.b << endl;
} else {
flag = 0;
it = ans.begin();
it++;
for (; it != ans.end(); ++it) {
it--;
itor = it;
it++;
if (it->first.a - itor->first.b > tmp) {
break;
}
}
if (it != ans.end()) {
node c = {itor->first.b + 1, itor->first.b + tmp};
ans.insert(make_pair(c, i));
cout << c.a << " " << c.b << endl;
} else {
it--;
node c = {it->first.b + 1, it->first.b + tmp};
ans.insert(make_pair(c, i));
cout << c.a << " " << c.b << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int n, m;
struct Req {
int st, ed;
Req() {}
Req(int st, int ed) : st(st), ed(ed) {}
} r[N];
void add(int x, int y) {
printf("%d %d\n", x, y);
r[m++] = Req(x, y);
for (int i = m - 1; i > 0; i--) {
if (r[i].st < r[i - 1].st) {
swap(r[i], r[i - 1]);
} else {
break;
}
}
}
int main() {
int a, b, x, y;
while (~scanf("%d", &n)) {
m = 0;
bool flag;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a, &b);
x = a;
y = a + b - 1;
flag = 0;
for (int j = 0; j < m; j++) {
if (y < r[j].st || x > r[j].ed) continue;
if (r[j].st <= x && x <= r[j].ed) {
flag = 1;
break;
}
if (x <= r[j].st && r[j].st <= y) {
flag = 1;
break;
}
}
if (!flag) {
add(x, y);
} else {
if (b < r[0].st) {
add(1, b);
} else {
for (int i = 0; i < m; i++) {
x = r[i].ed + 1;
y = x + b - 1;
if (i == m - 1 || y < r[i + 1].st) {
add(x, y);
break;
}
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 != 0) {
ans = (ans * a) % 1000000007;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
long long n;
cin >> n;
vector<pair<long long, long long>> v;
v.push_back({0, 0});
long long p, q;
while (n--) {
cin >> p >> q;
sort(v.begin(), v.end());
long long z = q;
int o = 1;
q = p + q - 1;
for (int i = 0; i < v.size(); i++) {
if (q < v[i].first || p > v[i].second) continue;
o = 0;
break;
}
if (o == 1) {
v.push_back({p, q});
cout << p << " " << q << endl;
continue;
}
for (int i = 0; i < v.size(); i++) {
p = v[i].second + 1;
if (i < v.size() - 1) {
if (p + z - 1 < v[i + 1].first) break;
}
}
v.push_back({p, p + z - 1});
cout << p << " " << p + z - 1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
vector<pair<long long, long long>> used;
int N;
cin >> N;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
auto it = used.begin();
while (it != used.end() && it->second <= a) it++;
if (it != used.end() && it->first < a + b) {
it = used.begin();
if (it->first >= b + 1) {
cout << 1 << " " << b << "\n";
used.insert(used.begin(), {1, b + 1});
} else {
while (next(it) != used.end() && next(it)->first - it->second < b) it++;
cout << it->second << " " << it->second + b - 1 << "\n";
used.insert(next(it), {it->second, it->second + b});
}
} else {
cout << a << " " << a + b - 1 << "\n";
used.insert(it, {a, a + b});
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 202;
struct iiistruct {
long long s, t;
iiistruct(){};
bool operator<(const iiistruct& iii) const { return (s < iii.s); }
bool operator>(const iiistruct& iii) const { return (s > iii.s); }
};
int n, s, t;
iiistruct a[maxN];
bool cover(int ss, int tt, int n) {
for (int i = 1; i <= n; i++)
if ((a[i].s <= ss && ss <= a[i].t) || (a[i].s <= tt && tt <= a[i].t) ||
(ss <= a[i].s && a[i].s <= tt))
return false;
return true;
}
void timkiem(int tt, int n) {
for (int i = 0; i < n; i++)
if (a[i + 1].s - a[i].t - 1 >= tt) {
a[n + 1].s = a[i].t + 1;
a[n + 1].t = a[i].t + tt;
return;
}
a[n + 1].s = a[n].t + 1;
a[n + 1].t = a[n].t + tt;
}
int main() {
cin >> n;
a[0].s = 0;
a[0].t = 0;
for (int i = 1; i <= n; i++) {
cin >> s >> t;
if (cover(s, s + t - 1, i - 1) == 1) {
a[i].s = s;
a[i].t = s + t - 1;
cout << s << " " << s + t - 1 << '\n';
} else {
sort(a + 1, a + i);
timkiem(t, i - 1);
cout << a[i].s << " " << a[i].t << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INF = numeric_limits<int>::max();
const long long INFL = numeric_limits<long long>::max();
const double PI = acos(-1);
int s[202];
int d[202];
int cnt;
int lb[202];
int rb[202];
set<pair<int, int> > ss;
int mxr;
int mnl;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
ss.insert(make_pair(0, 0));
ss.insert(make_pair(2000000007, 2000000007));
for (int i = 0; i < n; i++) {
cin >> s[i] >> d[i];
int ll = s[i];
int rr = s[i] + d[i] - 1;
bool intersect = false;
for (int j = 0; j <= i - 1; ++j) {
if (max(ll, lb[j]) <= min(rr, rb[j])) {
intersect = 1;
break;
}
}
if (!intersect) {
lb[i] = ll;
rb[i] = rr;
ss.insert(make_pair(ll, rr));
} else {
pair<int, int> prev = make_pair(0, 0);
for (auto cur : ss) {
if (cur.first - prev.second - 1 >= d[i]) {
lb[i] = prev.second + 1;
rb[i] = prev.second + d[i];
ss.insert(make_pair(lb[i], rb[i]));
break;
}
prev = cur;
}
}
}
for (int i = 0; i < n; ++i) {
cout << lb[i] << ' ' << rb[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int>> s;
void go(int a, int b) {
s.insert({a, b});
printf("%d %d\n", a, b);
}
int mn = 2e9;
int main() {
int n, i, a, b;
set<pair<int, int>>::iterator it;
s.insert({0, 0});
s.insert({mn, mn});
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
it = --s.lower_bound({a + b, 0});
if ((*it).second < a) {
go(a, a + b - 1);
continue;
}
vector<int> sp;
for (it = s.begin(); it != s.end(); it++) {
sp.push_back((*it).first);
sp.push_back((*it).second);
}
int j;
for (j = 1; j + 1 < sp.size(); j += 2) {
if (sp[j + 1] - sp[j] - 1 >= b) {
go(sp[j] + 1, sp[j] + b);
break;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[204];
int i, n, s, d, j, nr;
int main() {
scanf("%d", &n);
a[0].second = 1;
for (i = 1; i <= n; i++) {
scanf("%d %d", &s, &d);
if (s < a[1].first) {
if ((s + d - 1) < a[1].first) {
a[++nr].first = s;
a[nr].second = d;
}
} else {
for (j = 1; j < nr; j++) {
if (s >= a[j].first && s <= a[j + 1].first) {
if ((s + d - 1) < a[j + 1].first &&
(a[j].first + a[j].second - 1) < s) {
a[++nr].first = s;
a[nr].second = d;
}
break;
}
}
if (j == nr || nr == 0) {
if ((a[nr].first + a[nr].second - 1) < s) {
a[++nr].first = s;
a[nr].second = d;
}
}
}
if (nr < i) {
for (j = 0; j < nr; j++) {
if ((a[j].first + a[j].second + d - 1) < a[j + 1].first) {
a[++nr].first = a[j].first + a[j].second;
a[nr].second = d;
break;
}
}
if (nr < i) {
a[++nr].first = a[nr - 1].first + a[nr - 1].second;
a[nr].second = d;
}
}
printf("%d %d\n", a[nr].first, a[nr].first + a[nr].second - 1);
sort(a + 1, a + nr + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool intersect(pair<int64_t, int64_t>& gap1, pair<int64_t, int64_t>& gap2) {
return (gap1.first <= gap2.first && gap1.second >= gap2.first) ||
(gap2.first <= gap1.first && gap2.second >= gap1.first);
}
int main(int argc, char** argv) {
int n;
cin >> n;
int64_t s[n], d[n];
for (int i = 0; i < n; ++i) {
cin >> s[i] >> d[i];
}
set<pair<int, int> > gaps;
for (int i = 0; i < n; ++i) {
pair<int64_t, int64_t> cur_gap = make_pair(s[i], s[i] + d[i] - 1);
bool free = true;
for (auto iter = gaps.begin(); iter != gaps.end(); ++iter) {
pair<int64_t, int64_t> check = *iter;
if (intersect(cur_gap, check)) {
free = false;
break;
}
}
if (free) {
cout << cur_gap.first << " " << cur_gap.second << endl;
gaps.insert(cur_gap);
} else {
int start = 1;
pair<int64_t, int64_t> find_gap = make_pair(start, start + d[i] - 1);
for (auto iter = gaps.begin(); iter != gaps.end(); ++iter) {
pair<int64_t, int64_t> check = *iter;
if (intersect(find_gap, check)) {
start = check.second + 1;
find_gap = make_pair(start, start + d[i] - 1);
} else {
break;
}
}
cout << find_gap.first << " " << find_gap.second << endl;
gaps.insert(find_gap);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long, long> > aux;
vector<pair<long, long> > ans;
for (int i = 0; i < n; i++) {
long s, d;
cin >> s >> d;
sort(aux.begin(), aux.end());
if (aux.empty()) {
ans.push_back({s, s + d - 1});
aux.push_back({s, s + d - 1});
} else {
if (s > aux.back().second) {
ans.push_back({s, s + d - 1});
aux.push_back({s, s + d - 1});
continue;
}
bool cn = false;
for (int j = 0; j < (int)(aux.size()); j++) {
if (s + d - 1 < aux[j].first) {
if (j - 1 >= 0 && s > aux[j - 1].second) {
cn = true;
aux.push_back({s, s + d - 1});
ans.push_back({s, s + d - 1});
break;
} else if (!j) {
cn = true;
aux.push_back({s, s + d - 1});
ans.push_back({s, s + d - 1});
break;
}
}
}
if (cn) continue;
if (d < aux[0].first) {
ans.push_back({1, 1 + d - 1});
aux.push_back({1, 1 + d - 1});
continue;
}
for (int j = 0; j < (int)(aux.size()); j++) {
int st = aux[j].second + 1;
if (j == (int)(aux.size()) - 1) {
ans.push_back({st, st + d - 1});
aux.push_back({st, st + d - 1});
break;
} else if (st + d - 1 < aux[j + 1].first) {
ans.push_back({st, st + d - 1});
aux.push_back({st, st + d - 1});
break;
}
}
}
}
for (pair<long, long> &p : ans) cout << p.first << ' ' << p.second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, S[200 + 5], D[200 + 5], Ord[200 + 5];
inline bool cmp(int u, int v) { return S[u] < S[v]; }
inline bool Check(int u, int v) {
int l = max(S[u], S[v]), r = min(D[u], S[v] + D[v] - 1);
return l > r;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", S + i, D + i);
bool ok = 1;
for (int j = 1; ok && j < i; j++) ok = Check(j, i);
if (ok) {
D[i] += S[i] - 1;
Ord[i] = i;
sort(Ord + 1, Ord + i + 1, cmp);
continue;
}
for (int j = 1; !ok && j < i; j++)
if (S[Ord[j]] - D[Ord[j - 1]] - 1 >= D[i]) {
S[i] = D[Ord[j - 1]] + 1;
D[i] += S[i] - 1;
ok = 1;
}
if (!ok) S[i] = D[Ord[i - 1]] + 1, D[i] += S[i] - 1;
Ord[i] = i;
sort(Ord + 1, Ord + i + 1, cmp);
}
for (int i = 1; i <= n; i++) printf("%d %d\n", S[i], D[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "sz:" << v.size() << "\n[";
for (const auto& p : v) {
os << p << ",";
}
os << "]\n";
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& e : v) {
is >> e;
}
return is;
}
template <typename S, typename T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
constexpr ll MOD = (ll)1e9 + 7LL;
template <typename T>
constexpr T INF = numeric_limits<T>::max() / 10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> s(N);
vector<ll> t(N);
using P = pair<ll, ll>;
set<P> st;
st.insert(make_pair(-1, 0));
for (int i = 0; i < N; i++) {
ll d;
cin >> s[i] >> d;
t[i] = s[i] + d - 1;
bool ok = true;
for (const auto& p : st) {
const ll ss = p.first;
const ll tt = p.second;
if (not(t[i] < ss or tt < s[i])) {
ok = false;
break;
}
}
if (ok) {
cout << s[i] << " " << t[i] << endl;
st.insert(make_pair(s[i], t[i]));
} else {
for (auto it = st.begin(); it != st.end(); it++) {
const ll ss = it->second + 1;
const ll tt = ss + d - 1;
bool f = true;
for (auto it_ = it; it_ != st.end(); it_++) {
if (not(tt < it_->first or it_->second < ss)) {
f = false;
break;
}
}
if (f) {
cout << ss << " " << tt << endl;
st.insert(make_pair(ss, tt));
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& num) {
bool start = false, neg = false;
char c;
num = 0;
while ((c = getchar()) != EOF) {
if (c == '-')
start = neg = true;
else if (c >= '0' && c <= '9') {
start = true;
num = num * 10 + c - '0';
} else if (start)
break;
}
if (neg) num = -num;
}
const int maxn = 205;
int s[205], d[205];
vector<pair<int, int> > now;
int main() {
int n;
read(n);
for (int i = (1); i <= (n); i++) read(s[i]), read(d[i]);
for (int i = (1); i <= (n); i++) {
int fl = 1;
d[i] = s[i] + d[i] - 1;
for (int j = 0; j < now.size(); j++) {
if (now[j].first <= s[i] && s[i] <= now[j].second) fl = 0;
if (now[j].first <= d[i] && d[i] <= now[j].second) fl = 0;
if (s[i] <= now[j].first && now[j].second <= d[i]) fl = 0;
}
if (fl) {
now.push_back(make_pair(s[i], d[i]));
printf("%d %d\n", s[i], d[i]);
sort(now.begin(), now.end());
continue;
}
int st = -1, lst = 1;
for (int j = 0; j < now.size(); j++) {
if (now[j].first - lst >= d[i] - s[i] + 1) st = lst;
if (st != -1) break;
if (j + 1 == now.size()) st = now[j].second + 1;
lst = now[j].second + 1;
}
now.push_back(make_pair(st, st + d[i] - s[i]));
printf("%d %d\n", st, st + d[i] - s[i]);
sort(now.begin(), now.end());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 2000000000;
struct node {
long long int l, r;
bool operator<(const node &a) const { return l > a.l; }
};
long long int ans[205][2];
priority_queue<node> q;
priority_queue<node> p;
int main() {
int n, i;
long long int s, d;
scanf("%d", &n);
node f;
f.l = 1;
f.r = inf;
q.push(f);
for (i = 0; i < n; i++) {
scanf("%I64d %I64d", &s, &d);
bool flag = 0;
while (!q.empty()) {
node now = q.top();
q.pop();
if (now.l <= s && now.r >= s + d - 1) {
node a, b;
ans[i][0] = s, ans[i][1] = s + d - 1;
a.l = now.l, a.r = s - 1;
b.l = s + d, b.r = now.r;
if (a.l <= a.r) q.push(a);
if (b.l <= b.r) q.push(b);
flag = 1;
break;
}
p.push(now);
}
if (!flag) {
while (!p.empty()) {
node now = p.top();
p.pop();
if (now.r - now.l + 1 >= d) {
node a;
ans[i][0] = now.l, ans[i][1] = now.l + d - 1;
a.l = now.l + d, a.r = now.r;
if (a.l <= a.r) q.push(a);
break;
}
q.push(now);
}
}
while (!p.empty()) {
node now = p.top();
q.push(now);
p.pop();
}
}
for (i = 0; i < n; i++) printf("%I64d %I64d\n", ans[i][0], ans[i][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int INF = 0x7fffffff;
int n, x, y, Size;
vector<pair<int, int> > V;
queue<pair<int, int> > Queue;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &x, &y);
int low = x, high = x + y - 1;
Size = V.size();
if (Size == 0) {
Queue.push(make_pair(low, high));
V.push_back(make_pair(low, high));
continue;
}
bool flag = false;
for (int j = 0; j < Size; ++j) {
if (j == 0) {
if (high < V[j].first) {
flag = true;
break;
}
}
if (j == Size - 1) {
if (low > V[j].second) {
flag = true;
}
} else {
if (low > V[j].second && high < V[j + 1].first) {
flag = true;
break;
}
}
}
if (!flag) {
for (int j = 0; j < Size; ++j) {
if (j == 0) {
if (y < V[j].first) {
low = 1, high = y;
flag = true;
break;
}
} else if (V[j].first - V[j - 1].second - 1 >= y) {
low = V[j - 1].second + 1, high = V[j - 1].second + y;
flag = true;
break;
}
}
if (!flag) {
low = V[Size - 1].second + 1, high = V[Size - 1].second + y;
}
}
V.push_back(make_pair(low, high));
Queue.push(make_pair(low, high));
sort(V.begin(), V.end());
}
while (!Queue.empty()) {
printf("%d %d\n", Queue.front().first, Queue.front().second);
Queue.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void rd(int &res) {
res = 0;
char c;
while (c = getchar(), c < 48)
;
do res = (res << 1) + (res << 3) + (c ^ 48);
while (c = getchar(), c >= 48);
}
void print(int x) {
if (!x) return;
print(x / 10);
putchar((x % 10) ^ 48);
}
void sc(int x) {
if (x < 0) {
x = -x;
putchar('-');
}
print(x);
if (!x) putchar('0');
putchar('\n');
}
inline void Max(int &x, int y) {
if (x < y) x = y;
}
inline void Min(int &x, int y) {
if (x > y) x = y;
}
const int M = 205;
int s[M], d[M], n;
int l[M], r[M];
struct node {
int a, b;
bool operator<(const node &tmp) const { return a < tmp.a; }
} A[M];
int main() {
int i, j, k;
scanf("%d", &n);
A[0] = (node){0, 0};
for (i = 1; i <= n; i++) {
scanf("%d %d", &s[i], &d[i]);
int ok = 1, a = 1;
for (j = 1; j < i; j++) {
if (r[j] < s[i] || l[j] > s[i] + d[i] - 1) continue;
ok = 0;
break;
}
if (!ok) {
sort(A, A + i);
for (j = 0; j < i; j++) {
if (j == i - 1 || A[j + 1].a - 1 - (A[j].b + 1) + 1 >= d[i]) {
break;
}
}
l[i] = A[j].b + 1;
r[i] = l[i] + d[i] - 1;
} else
l[i] = s[i], r[i] = s[i] + d[i] - 1;
A[i] = (node){l[i], r[i]};
}
for (i = 1; i <= n; i++) {
printf("%d %d\n", l[i], r[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int s[n], d[n];
for (int i = 0; i < n; i++) cin >> s[i] >> d[i];
vector<pair<int, int> > v;
v.push_back(make_pair(0, 0));
for (int i = 0; i < n; i++) {
bool flag = true;
for (int j = 0; j < v.size(); j++) {
if (v[j].second < s[i] || v[j].first > s[i] + d[i] - 1) {
} else {
flag = false;
}
}
if (flag == true) {
v.push_back(make_pair(s[i], s[i] + d[i] - 1));
cout << s[i] << " " << s[i] + d[i] - 1 << endl;
} else {
flag = true;
for (int j = 0; j < v.size() - 1; j++) {
if (v[j + 1].first - v[j].second - 1 >= d[i]) {
cout << v[j].second + 1 << " " << v[j].second + 1 + d[i] - 1 << endl;
v.push_back(make_pair(v[j].second + 1, v[j].second + 1 + d[i] - 1));
flag = false;
break;
}
}
if (flag == true) {
cout << v[v.size() - 1].second + 1 << " "
<< v[v.size() - 1].second + 1 + d[i] - 1 << endl;
v.push_back(make_pair(v[v.size() - 1].second + 1,
v[v.size() - 1].second + 1 + d[i] - 1));
}
}
sort(v.begin(), v.end());
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, l, r, x, y;
set<pair<int, int> > s;
set<pair<int, int> >::iterator j;
pair<int, int> p, p1, p2;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (i = 0; i < n; i++) {
cin >> l >> r;
x = l, y = l + r - 1;
for (j = s.begin(); j != s.end(); j++) {
p = *j;
if ((p.first <= x && x <= p.second) || (p.first <= y && y <= p.second) ||
(x < p.first && y > p.second))
break;
}
if (j == s.end()) {
cout << x << " " << y << endl;
s.insert({x, y});
} else {
x = 1;
y = r;
p = *s.begin();
if ((p.first <= x && x <= p.second) || (p.first <= y && y <= p.second) ||
(x < p.first && y > p.second)) {
for (j = s.begin(); j != s.end(); j++) {
p1 = *j;
++j;
if (j == s.end()) {
x = p1.second + 1;
y = x + r - 1;
cout << x << " " << y << endl;
s.insert({x, y});
break;
}
p2 = *j;
if (p2.first - p1.second - 1 >= r) {
x = p1.second + 1;
y = x + r - 1;
cout << x << " " << y << endl;
s.insert({x, y});
break;
}
--j;
}
} else {
cout << x << " " << y << endl;
s.insert({x, y});
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
set<pair<int, int> >::iterator it, nxt;
vector<pair<int, int> > ans;
set<pair<int, int> > f;
int s[233], d[233], n;
bool check(pair<int, int> x) {
for (it = f.begin(); it != f.end(); ++it) {
nxt = it;
nxt++;
pair<int, int> now = *it, nx = *nxt;
if (x.first > now.second && x.first < nx.first) {
if (x.second < nx.first) {
return true;
}
break;
}
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", s + i, d + i);
s[0] = d[0] = 0;
f.clear();
f.insert(make_pair(2000000000, 2000000000));
for (int i = 0; i <= n; i++) {
if (i == 0) {
f.insert(make_pair(s[i], s[i] + d[i])),
ans.push_back(make_pair(s[i], s[i] + d[i] - 1));
continue;
}
pair<int, int> now = make_pair(s[i], s[i] + d[i] - 1);
if (check(now))
f.insert(now), ans.push_back(now);
else {
for (it = f.begin(); it != f.end(); ++it) {
nxt = it;
++nxt;
if (nxt == f.end()) break;
if ((*it).second + d[i] < (*nxt).first) {
f.insert(make_pair((*it).second + 1, (*it).second + d[i]));
ans.push_back(make_pair((*it).second + 1, (*it).second + d[i]));
break;
}
}
}
}
for (int i = 1; i <= n; i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& o, vector<T>& v) {
for (auto& x : v) o << x << ' ';
return o;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
vector<pair<int, int> > intervals;
intervals.emplace_back(0, 0);
intervals.emplace_back(INT_MAX, INT_MAX);
int n;
cin >> n;
vector<pair<int, int> > arr(n);
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
for (int i = 0; i < n; i++) {
int s, d;
tie(s, d) = arr[i];
bool taken = false;
for (pair<int, int> inter : intervals) {
if (s <= inter.first && (s + d - 1) >= inter.second) taken = true;
if (s >= inter.first && s <= inter.second) taken = true;
if ((s + d - 1) >= inter.first && (s + d - 1) <= inter.second)
taken = true;
}
if (!taken) {
cout << s << ' ' << s + d - 1 << endl;
intervals.emplace_back(s, s + d - 1);
sort(intervals.begin(), intervals.end());
} else {
for (int j = 0; j < (int)intervals.size() - 1; j++) {
pair<int, int> p1 = intervals[j], p2 = intervals[j + 1];
pair<int, int> gap = {p1.second + 1, p2.first - 1};
if (gap.second - gap.first + 1 >= d) {
intervals.emplace_back(gap.first, gap.first + d - 1);
cout << gap.first << ' ' << gap.first + d - 1 << endl;
sort(intervals.begin(), intervals.end());
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 9000000000;
int main() {
int n;
while (scanf("%d", &n) == 1) {
vector<pair<long long, long long> > d;
d.push_back(make_pair(1, INF));
long long a, b;
for (int i = 0; i < n; i++) {
sort(d.begin(), d.end());
scanf("%I64d%I64d", &a, &b);
bool find = false;
for (int j = 0; j < d.size() && !find; j++)
if (d[j].first <= d[j].second) {
if (d[j].first <= a && a + b - 1 <= d[j].second) {
printf("%I64d %I64d\n", a, a + b - 1);
find = true;
d.push_back(make_pair(a + b, d[j].second));
d[j].second = a - 1;
}
}
if (!find) {
for (int j = 0; j < d.size(); j++)
if (d[j].first <= d[j].second) {
if (d[j].first + b - 1 <= d[j].second) {
printf("%I64d %I64d\n", d[j].first, d[j].first + b - 1);
d[j].first += b;
break;
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct ans {
int begin, end;
int length;
} Ans;
int main() {
int n;
scanf("%d", &n);
Ans ans[n];
for (int i = 0; i < n; i++) {
int flag = 0;
int a, b;
cin >> a >> b;
for (int j = 0; j < i; j++) {
if ((ans[j].begin <= a && ans[j].end >= a) ||
(ans[j].begin <= a + b - 1 && ans[j].end >= a + b - 1) ||
(ans[j].begin > a && ans[j].end < a + b - 1)) {
flag = 1;
break;
}
}
if (flag == 0) {
ans[i].begin = a;
ans[i].end = a + b - 1;
} else {
int flag1 = 1;
int j = 1;
for (j = 1; flag1;) {
flag1 = 0;
for (int k = 0; k < i; k++) {
if ((j >= ans[k].begin && j <= ans[k].end) ||
(j + b - 1 >= ans[k].begin && j + b - 1 <= ans[k].end) ||
(j < ans[k].begin && j + b - 1 > ans[k].end)) {
flag1 = 1;
j = min(ans[k].end + 1, j + b);
break;
}
}
}
ans[i].begin = j;
ans[i].end = j + b - 1;
}
}
for (int i = 0; i < n; i++) {
printf("%d %d\n", ans[i].begin, ans[i].end);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<long long, long long> > Cars;
Cars.push_back({0, 0});
for (int i = 0; i < n; i++) {
long long s, d;
bool collision = false;
cin >> s >> d;
for (int i = 0; i < Cars.size() && !collision; i++)
if ((s <= Cars[i].first && Cars[i].first < s + d) ||
(s <= Cars[i].second && Cars[i].second < s + d))
collision = true;
else if (Cars[i].first < s && s + d - 1 < Cars[i].second)
collision = true;
if (!collision) {
cout << s << " " << s + d - 1 << endl;
Cars.push_back({s, s + d - 1});
sort(Cars.begin(), Cars.end());
} else {
bool new_place = false;
for (int i = 0; i < Cars.size() - 1 && !new_place; i++)
if (Cars[i].second + d < Cars[i + 1].first) {
cout << Cars[i].second + 1 << " " << Cars[i].second + d << endl;
Cars.push_back({Cars[i].second + 1, Cars[i].second + d});
new_place = true;
}
if (!new_place) {
int i = Cars.size() - 1;
cout << Cars[i].second + 1 << " " << Cars[i].second + d << endl;
Cars.push_back({Cars[i].second + 1, Cars[i].second + d});
}
sort(Cars.begin(), Cars.end());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int s[205] = {0}, d[205] = {0};
list<pair<int, int> > free;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i] >> d[i];
}
cout << s[0] << " " << s[0] + d[0] - 1 << endl;
if (s[0] != 1) free.push_back(make_pair(1, s[0] - 1));
free.push_back(make_pair(s[0] + d[0], INT_MAX));
for (int i = 1; i < n; i++) {
bool ok = false;
for (list<pair<int, int> >::iterator it = free.begin(); it != free.end();
it++) {
if (s[i] >= it->first && (s[i] + d[i] - 1) <= it->second) {
ok = true;
if (s[i] > it->first) free.insert(it, make_pair(it->first, s[i] - 1));
if ((s[i] + d[i] - 1) < it->second)
it->first = s[i] + d[i];
else
free.erase(it);
break;
}
}
if (!ok) {
for (list<pair<int, int> >::iterator it = free.begin(); it != free.end();
it++) {
if (d[i] < it->second - it->first + 1) {
s[i] = it->first;
it->first = s[i] + d[i];
break;
}
if (d[i] == it->second - it->first + 1) {
s[i] = it->first;
free.erase(it);
break;
}
}
}
cout << s[i] << " " << s[i] + d[i] - 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OFFSET = 5;
const int MAXN = 200 + OFFSET;
int N;
int start[MAXN], days[MAXN], pos[MAXN];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d %d", &start[i], &days[i]);
}
start[N] = 0;
days[N] = 1;
pos[0] = N;
for (int i = 0; i < N; i++) {
int j = i;
while (start[pos[j]] > start[i]) {
j--;
}
if (start[pos[j]] + days[pos[j]] - 1 < start[i] &&
(j == i || start[i] + days[i] - 1 < start[pos[j + 1]])) {
for (int k = i + 1; k >= j + 2; k--) {
pos[k] = pos[k - 1];
}
pos[j + 1] = i;
} else {
for (j = 0; j < i; j++) {
if (start[pos[j]] + days[pos[j]] + days[i] - 1 < start[pos[j + 1]]) {
break;
}
}
if (j == i) {
start[i] = start[pos[i]] + days[pos[i]];
pos[i + 1] = i;
} else {
for (int k = i + 1; k >= j + 2; k--) {
pos[k] = pos[k - 1];
}
start[i] = start[pos[j]] + days[pos[j]];
pos[j + 1] = i;
}
}
printf("%d %d\n", start[i], start[i] + days[i] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long long, long long> > prom(3);
int first_day, period;
cin >> first_day >> period;
cout << first_day << ' ' << first_day + period - 1 << endl;
prom[0].first = 0;
prom[0].second = 0;
prom[1].first = first_day;
prom[1].second = first_day + period - 1;
prom[2].first = 1e10;
prom[2].second = 1e10;
int answ = 0;
for (long long i = 2; i < n + 1; i++) {
bool met = true, met2 = true;
cin >> first_day >> period;
for (long long j = 0; j < i; j++) {
if (first_day + period - 1 < prom[j + 1].first &&
first_day > prom[j].second) {
prom.push_back(make_pair(first_day, first_day + period - 1));
cout << first_day << ' ' << first_day + period - 1 << endl;
sort(prom.begin(), prom.end());
met2 = false;
break;
} else if (period < (prom[j + 1].first - prom[j].second) && met) {
met = false;
answ = j;
}
}
if (!met && met2) {
prom.push_back(
make_pair(prom[answ].second + 1, prom[answ].second + period));
cout << prom[answ].second + 1 << ' ' << prom[answ].second + period
<< endl;
sort(prom.begin(), prom.end());
} else if (met2 && met) {
prom.push_back(
make_pair(prom[i - 1].second + 1, prom[i - 1].second + period));
cout << prom[i - 1].second + 1 << ' ' << prom[i - 1].second + period
<< endl;
sort(prom.begin(), prom.end());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
pair<long long, long long> l[1000];
set<pair<long long, long long> > v;
long long u = 1;
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &l[i].first, &l[i].second);
u = 1;
for (pair<long long, long long> j : v) {
if (u >= j.first && u <= j.second) u = j.second + 1;
}
if (v.empty()) {
printf("%lld %lld\n", l[i].first, l[i].first + l[i].second - 1);
v.insert(
pair<long long, long long>(l[i].first, l[i].first + l[i].second - 1));
continue;
}
auto it = v.end();
it--;
if (l[i].first > it->second) {
printf("%lld %lld\n", l[i].first, l[i].first + l[i].second - 1);
v.insert(
pair<long long, long long>(l[i].first, l[i].first + l[i].second - 1));
continue;
}
bool f = 0;
for (pair<long long, long long> j : v) {
if ((l[i].first >= j.first && l[i].first <= j.second) ||
(j.first >= l[i].first && j.first <= l[i].first + l[i].second - 1)) {
f = 1;
break;
}
if ((l[i].first + l[i].second - 1 >= j.first &&
l[i].first + l[i].second - 1 <= j.second) ||
(j.second >= l[i].first &&
j.second <= l[i].first + l[i].second - 1)) {
f = 1;
break;
}
}
if (f == 0) {
printf("%lld %lld\n", l[i].first, l[i].first + l[i].second - 1);
v.insert(
pair<long long, long long>(l[i].first, l[i].first + l[i].second - 1));
continue;
}
f = 0;
long long at = u;
for (pair<long long, long long> j : v) {
if (at < j.first && at + l[i].second - 1 < j.first) {
printf("%lld %lld\n", at, at + l[i].second - 1);
v.insert(pair<long long, long long>(at, at + l[i].second - 1));
f = 1;
break;
}
at = j.second + 1;
}
if (!f) {
printf("%lld %lld\n", at, at + l[i].second - 1);
v.insert(pair<long long, long long>(at, at + l[i].second - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct span {
int s;
int d;
};
struct range {
int s;
int e;
};
span* makeSpan(int s, int d) {
span* out = (span*)malloc(sizeof(span));
out->s = s;
out->d = d;
return out;
}
int main() {
int n;
cin >> n;
vector<span> spans;
vector<range> output;
spans.push_back(*makeSpan(1, 1007000000));
int s = 0;
int d = 0;
bool timeFound = false;
for (int i = 0; i < n; i++) {
cin >> s;
cin >> d;
timeFound = false;
for (int j = 0; j < spans.size(); j++) {
if (spans[j].s <= s && spans[j].d + spans[j].s >= s + d) {
spans.insert(next(spans.begin(), j + 1),
*makeSpan(s + d, spans[j].d + spans[j].s - (s + d)));
spans[j].d = s - spans[j].s;
if (spans[j + 1].d == 0) {
spans.erase(next(spans.begin(), j + 1));
}
if (spans[j].d == 0) {
spans.erase(next(spans.begin(), j));
}
timeFound = true;
range o = {s, s + d - 1};
output.push_back(o);
break;
}
}
if (!timeFound) {
for (int j = 0; j < spans.size(); j++) {
if (spans[j].d >= d) {
range o = {spans[j].s, spans[j].s + d - 1};
spans[j].s = spans[j].s + d;
spans[j].d -= d;
if (spans[j].d == 0) {
spans.erase(next(spans.begin(), j));
}
output.push_back(o);
break;
}
}
}
}
for (int i = 0; i < output.size(); i++) {
cout << output[i].s << " " << output[i].e << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> q[201];
vector<pair<pair<long long, long long>, long long>> ans;
int a;
int main() {
int flag, flag2;
cin >> a;
for (int i = 0; i < a; ++i) {
cin >> q[i].first >> q[i].second;
}
ans.push_back(
make_pair(make_pair(q[0].first, q[0].first + q[0].second - 1), 0));
for (int i = 1; i < a; ++i) {
sort(ans.begin(), ans.end());
flag = 0;
flag2 = 0;
if (ans.size() == 1) {
if (q[i].first > ans[0].first.second) {
ans.push_back(
make_pair(make_pair(q[i].first, q[i].first + q[i].second - 1), i));
continue;
}
if (q[i].second + q[i].first - 1 < ans[0].first.first) {
ans.push_back(
make_pair(make_pair(q[i].first, q[i].first + q[i].second - 1), i));
continue;
}
}
if (ans.size() > 1) {
if (q[i].first > ans[0].first.second &&
q[i].first + q[i].second < ans[1].first.first) {
ans.push_back(
make_pair(make_pair(q[i].first, q[i].first + q[i].second - 1), i));
continue;
}
if (q[i].second + q[i].first - 1 < ans[0].first.first) {
ans.push_back(
make_pair(make_pair(q[i].first, q[i].first + q[i].second - 1), i));
continue;
}
}
if (q[i].first > ans[ans.size() - 1].first.second) {
ans.push_back(
make_pair(make_pair(q[i].first, q[i].first + q[i].second - 1), i));
continue;
}
for (int j = 0; j < ans.size() - 1; ++j) {
if (q[i].first > ans[j].first.second &&
q[i].second + q[i].first - 1 < ans[j + 1].first.first) {
ans.push_back(
make_pair(make_pair(q[i].first, q[i].first + q[i].second - 1), i));
flag = 1;
break;
}
}
if (!flag) {
if (q[i].second < ans[0].first.first) {
ans.push_back(make_pair(make_pair(1, q[i].second), i));
continue;
}
for (int j = 0; j < ans.size() - 1; ++j) {
if (ans[j + 1].first.first - ans[j].first.second > q[i].second) {
ans.push_back(make_pair(make_pair(ans[j].first.second + 1,
ans[j].first.second + q[i].second),
i));
flag2 = 1;
break;
}
}
if (!flag2) {
ans.push_back(make_pair(
make_pair(ans[ans.size() - 1].first.second + 1,
ans[ans.size() - 1].first.second + 1 + q[i].second - 1),
i));
}
}
}
for (int i = 0; i < ans.size(); ++i) {
swap(ans[i].first.first, ans[i].second);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].second << " " << ans[i].first.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<long long int, long long int> > clients, answer, true_answer;
int main() {
cin >> n;
clients.resize(n);
for (int i = 0; i < n; i++) {
cin >> clients[i].first >> clients[i].second;
}
answer.push_back(make_pair(0, 0));
for (int i = 0; i < n; i++) {
bool found = false;
if (clients[i].first > answer.back().second) {
found = true;
answer.push_back(make_pair(clients[i].first,
clients[i].first + clients[i].second - 1));
true_answer.push_back(answer.back());
}
for (int j = 1; j < answer.size(); j++) {
if ((answer.size() == 1 ||
(answer[j].first > clients[i].first + clients[i].second - 1 &&
answer[j - 1].second < clients[i].first)) &&
!found) {
answer.push_back(make_pair(clients[i].first,
clients[i].first + clients[i].second - 1));
true_answer.push_back(answer.back());
found = true;
}
}
for (int j = 0; j < answer.size() - 1; j++) {
if (answer[j + 1].first - answer[j].second - 1 >= clients[i].second &&
!found) {
answer.push_back(make_pair(answer[j].second + 1,
answer[j].second + clients[i].second));
true_answer.push_back(answer.back());
found = true;
}
}
if (!found) {
answer.push_back(make_pair(answer.back().second + 1,
answer.back().second + clients[i].second));
true_answer.push_back(answer.back());
}
sort(answer.begin(), answer.end());
}
for (auto p : true_answer) {
cout << p.first << ' ' << p.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
set<long long> a, b;
b.insert(-1), a.insert(0), b.insert(0), a.insert((long long)10000000000);
long long n, x, y, cnt = 0;
scanf("%lld", &n);
while (n--) {
scanf("%lld %lld", &x, &y);
long long num = x + y - 1, flag = 0;
auto px = a.begin();
auto py = b.begin();
while (px != a.end()) {
int xx = *px;
int yy = *py;
px++;
py++;
if (yy < x && xx > num) {
a.insert(x);
b.insert(num);
flag = 1;
printf("%lld %lld\n", x, num);
break;
}
}
if (!flag) {
auto px = a.begin();
auto py = b.begin();
while (px != a.end()) {
long long xx = *px;
long long yy = *py;
px++;
py++;
if (xx - yy - 1 >= y) {
a.insert(yy + 1);
b.insert(yy + y);
printf("%lld %lld\n", yy + 1, yy + y);
break;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
struct node {
long long l, r;
} a[N];
bool cmp(const node& u, const node& v) { return u.l < v.l; }
int main() {
int n, cnt = 0;
long long l, r, d;
a[++cnt] = (node){0, 0};
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &l, &d);
r = l + d - 1;
int flag = 1;
for (int j = 1; j <= cnt; j++)
if ((a[j].l <= l && a[j].r >= l) || (a[j].l <= r && a[j].r >= r) ||
(a[j].l >= l && a[j].r <= r))
flag = 0;
if (flag == 1) {
printf("%lld %lld\n", l, r);
a[++cnt] = (node){l, r};
} else {
for (int j = 2; j <= cnt; j++)
if (a[j].l - a[j - 1].r - 1 >= d) {
flag = 1;
l = a[j - 1].r + 1, r = l + d - 1;
break;
}
if (flag == 0) l = a[cnt].r + 1, r = l + d - 1;
printf("%lld %lld\n", l, r);
a[++cnt] = (node){l, r};
}
sort(a + 1, a + cnt + 1, cmp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
int l[210], r[210];
int l_tmp[210], r_tmp[210];
int cnt = 0, tmp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
l[i] = a;
r[i] = a + b - 1;
}
cout << l[0] << " " << r[0] << endl;
int x = 1;
if (x >= l[0] && x <= r[0]) x = r[0] + 1;
for (int i = 1; i < n; i++) {
x = 1;
bool f = false;
for (int j = 0; j < i; j++)
if (l[i] > r[j] || r[i] < l[j]) {
} else {
f = true;
break;
}
if (f) {
back:
for (int j = 0; j < i; j++) {
if (x > r[j] || x + r[i] - l[i] < l[j]) {
} else {
x = r[j] + 1;
goto back;
}
}
r[i] = x + r[i] - l[i];
l[i] = x;
}
cout << l[i] << " " << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int INF = std::numeric_limits<int>::max() / 2;
const long long INFLL = std::numeric_limits<long long>::max() / 2;
int n;
std::vector<int> vec;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
vec.push_back(1);
vec.push_back(INF);
std::cin >> n;
while (n--) {
int s, d;
std::cin >> s >> d;
int i = std::upper_bound(vec.begin(), vec.end(), s) - vec.begin();
if ((i & 1) && vec[i] - s >= d) {
vec.insert(vec.begin() + i, s + d);
vec.insert(vec.begin() + i, s);
std::cout << s << ' ' << s + d - 1 << '\n';
} else
for (int i = 0; i != vec.size(); i += 2)
if (vec[i + 1] - vec[i] >= d) {
vec.insert(vec.begin() + i + 1, vec[i] + d);
vec.insert(vec.begin() + i + 1, vec[i]);
std::cout << vec[i] << ' ' << vec[i] + d - 1 << '\n';
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, long long> > interval;
int main() {
int n;
cin >> n;
interval.insert(pair<long long, long long>(0, -1));
interval.insert(pair<long long, long long>(1, 100000000000000000LL));
while (n--) {
long long a, b;
cin >> a >> b;
pair<long long, long long> k;
for (set<pair<long long, long long> >::reverse_iterator it =
interval.rbegin();
it != interval.rend(); it++) {
if (it->first <= a) {
k = *it;
break;
}
}
if (k.second >= a + b - 1) {
interval.erase(k);
cout << a << ' ' << a + b - 1 << endl;
if (k.first != a)
interval.insert(pair<long long, long long>(k.first, a - 1));
if (k.second != a + b - 1)
interval.insert(pair<long long, long long>(a + b, k.second));
} else {
for (set<pair<long long, long long> >::iterator it = interval.begin();
it != interval.end(); it++) {
if (it->second - it->first >= b - 1) {
k = *it;
break;
}
}
interval.erase(k);
a = k.first, b = k.first + b - 1;
cout << a << ' ' << b << endl;
if (k.first != a)
interval.insert(pair<long long, long long>(k.first, a - 1));
if (k.second != b)
interval.insert(pair<long long, long long>(b + 1, k.second));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long l, r;
bool operator<(const edge& rhs) const { return l < rhs.l; }
} ans[205];
int n;
long long s, d;
multiset<edge> es;
multiset<edge>::iterator ita, itb, it;
int main() {
scanf("%d", &n);
bool ok;
for (int i = 1; i <= n; ++i) {
ok = true;
cin >> s >> d;
d = s + d - 1;
es.insert((edge){s, d});
it = es.find((edge){s, d});
ita = itb = it;
if (ita != es.begin()) {
--ita;
if (ita->r >= s) ok = false;
}
++itb;
if (itb != es.end()) {
if (itb->l <= d) ok = false;
}
if (ok) {
ans[i].l = s;
ans[i].r = d;
continue;
}
es.erase(it);
itb = ita = es.begin();
++itb;
if (ita->l - 1 >= d - s + 1) {
es.insert((edge){1, d - s + 1});
ans[i].l = 1;
ans[i].r = d - s + 1;
continue;
}
for (; itb != es.end(); ++ita, ++itb) {
if (itb->l - ita->r - 1 >= d - s + 1) {
es.insert((edge){ita->r + 1, ita->r + d - s + 1});
ans[i].l = ita->r + 1;
ans[i].r = ita->r + d - s + 1;
break;
}
}
if (ans[i].l != 0) continue;
es.insert((edge){ita->r + 1, ita->r + d - s + 1});
ans[i].l = ita->r + 1;
ans[i].r = ita->r + d - s + 1;
}
for (int i = 1; i <= n; ++i) cout << ans[i].l << " " << ans[i].r << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 207;
const long long inf = 1LL << 55;
long long x[maxn], y[maxn];
struct node {
long long ls, rs;
};
vector<node> p[maxn];
int Find(long long ls, long long rs, int s) {
for (int i = 0; i < p[s].size(); i++) {
node tmp = p[s][i];
if (tmp.ls <= ls && rs <= tmp.rs) return i;
}
for (int i = 0; i < p[s].size(); i++) {
node tmp = p[s][i];
if (tmp.rs - tmp.ls >= rs - ls) return i;
}
return -1;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
p[0].push_back(node{1, inf});
for (int i = 1; i <= n; i++) {
int pos = Find(x[i], y[i] + x[i] - 1, i - 1);
for (int j = 0; j < p[i - 1].size(); j++) {
node tmp = p[i - 1][j];
if (pos != j)
p[i].push_back(tmp);
else {
if (tmp.ls <= x[i] && x[i] + y[i] - 1 <= tmp.rs) {
cout << x[i] << " " << x[i] + y[i] - 1 << endl;
if (tmp.ls <= x[i] - 1) p[i].push_back(node{tmp.ls, x[i] - 1});
if (x[i] + y[i] <= tmp.rs) p[i].push_back(node{x[i] + y[i], tmp.rs});
} else {
cout << tmp.ls << " " << tmp.ls + y[i] - 1 << endl;
tmp.ls += y[i];
if (tmp.ls <= tmp.rs) p[i].push_back(tmp);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, t1, t2;
scanf("%d", &n);
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push(pair<int, int>(1, 2000000000));
for (int i = 0; i < n; i++) {
scanf("%d%d", &t1, &t2);
deque<pair<int, int> > deq;
bool done = false;
while (!pq.empty()) {
pair<int, int> p = pq.top();
pq.pop();
if (p.first > t1 || p.second < t2 + t1 - 1) {
deq.push_back(p);
if (p.first >= t1) break;
continue;
}
if (p.first < t1) {
deq.push_back(pair<int, int>(p.first, t1 - 1));
}
if (p.second > t1 + t2 - 1) {
deq.push_back(pair<int, int>(t1 + t2, p.second));
}
done = true;
printf("%d %d\n", t1, t1 + t2 - 1);
break;
}
while (!deq.empty()) {
pq.push(deq.front());
deq.pop_front();
}
if (!done) {
while (!pq.empty()) {
pair<int, int> p = pq.top();
pq.pop();
if (p.second - p.first < t2 - 1) {
deq.push_back(p);
continue;
}
if (p.second > p.first + t2 - 1) {
deq.push_back(pair<int, int>(p.first + t2, p.second));
}
done = true;
printf("%d %d\n", p.first, p.first + t2 - 1);
break;
}
}
while (!deq.empty()) {
pq.push(deq.front());
deq.pop_front();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool can(long long& s, long long d, vector<pair<long long, long long> >& v) {
for (long long l = 0; l < v.size(); ++l) {
if (((s >= v[l].first && s <= v[l].second) ||
(s + d - 1 >= v[l].first && s + d - 1 <= v[l].second) ||
(s <= v[l].first && s + d - 1 >= v[l].second))) {
s = v[l].second + 1;
return false;
}
}
return true;
}
int main() {
long long s, n, d;
vector<pair<long long, long long> > v;
cin >> n;
cin >> s >> d;
cout << s << ' ' << s + d - 1 << endl;
v.push_back(make_pair(s, s + d - 1));
for (long long i = 1; i < n; ++i) {
cin >> s >> d;
if (can(s, d, v)) {
cout << s << ' ' << s + d - 1 << endl;
v.push_back(make_pair(s, s + d - 1));
sort(v.begin(), v.end());
} else {
long long x = 1;
while (!can(x, d, v)) {
}
cout << x << ' ' << x + d - 1 << endl;
v.push_back(make_pair(x, x + d - 1));
sort(v.begin(), v.end());
}
}
return 0;
}
|
#include <bits/stdc++.h>
int l[200], r[200];
int n;
int check(int L, int R, int n) {
for (int i = 0; i < n; i++)
if ((l[i] <= L && L <= r[i]) || (l[i] <= R && R <= r[i]) ||
(L <= l[i] && l[i] <= R) || (L <= r[i] && r[i] <= R))
return i + 1;
return 0;
}
int main() {
int x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", l + i, r + i);
if (check(l[i], l[i] + r[i] - 1, i) != 0) {
l[i] = 1;
while ((x = check(l[i], l[i] + r[i] - 1, i)) != 0) l[i] = r[x - 1] + 1;
}
r[i] = l[i] + r[i] - 1;
printf("%d %d\n", l[i], r[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char board[4][4];
bool Valid(int x, int y) { return (x >= 0 && x < 4 && y >= 0 && y < 4); }
int main() {
std::ios::sync_with_stdio(false);
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
cin >> board[i][j];
}
}
bool valid = false;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
if (board[i][j] == 'x') {
if (Valid(i - 1, j) && board[i - 1][j] == 'x' && Valid(i - 2, j) &&
board[i - 2][j] == '.' ||
Valid(i - 1, j) && board[i - 1][j] == '.' && Valid(i - 2, j) &&
board[i - 2][j] == 'x') {
valid = true;
break;
} else if (Valid(i + 1, j) && board[i + 1][j] == 'x' &&
Valid(i + 2, j) && board[i + 2][j] == '.' ||
Valid(i + 1, j) && board[i + 1][j] == '.' &&
Valid(i + 2, j) && board[i + 2][j] == 'x') {
valid = true;
break;
} else if (Valid(i, j - 1) && board[i][j - 1] == 'x' &&
Valid(i, j - 2) && board[i][j - 2] == '.' ||
Valid(i, j - 1) && board[i][j - 1] == '.' &&
Valid(i, j - 2) && board[i][j - 2] == 'x') {
valid = true;
break;
} else if (Valid(i, j + 1) && board[i][j + 1] == 'x' &&
Valid(i, j + 2) && board[i][j + 2] == '.' ||
Valid(i, j + 1) && board[i][j + 1] == '.' &&
Valid(i, j + 2) && board[i][j + 2] == 'x') {
valid = true;
break;
} else if (Valid(i + 1, j + 1) && board[i + 1][j + 1] == 'x' &&
Valid(i + 2, j + 2) && board[i + 2][j + 2] == '.' ||
Valid(i + 1, j + 1) && board[i + 1][j + 1] == '.' &&
Valid(i + 2, j + 2) && board[i + 2][j + 2] == 'x') {
valid = true;
break;
} else if (Valid(i - 1, j - 1) && board[i - 1][j - 1] == 'x' &&
Valid(i - 2, j - 2) && board[i - 2][j - 2] == '.' ||
Valid(i - 1, j - 1) && board[i - 1][j - 1] == '.' &&
Valid(i - 2, j - 2) && board[i - 2][j - 2] == 'x') {
valid = true;
break;
} else if (Valid(i - 1, j + 1) && board[i - 1][j + 1] == 'x' &&
Valid(i - 2, j + 2) && board[i - 2][j + 2] == '.' ||
Valid(i - 1, j + 1) && board[i - 1][j + 1] == '.' &&
Valid(i - 2, j + 2) && board[i - 2][j + 2] == 'x') {
valid = true;
break;
} else if (Valid(i + 1, j - 1) && board[i + 1][j - 1] == 'x' &&
Valid(i + 2, j - 2) && board[i + 2][j - 2] == '.' ||
Valid(i + 1, j - 1) && board[i + 1][j - 1] == '.' &&
Valid(i + 2, j - 2) && board[i + 2][j - 2] == 'x') {
valid = true;
break;
}
}
}
}
(valid) ? cout << "YES\n" : cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(int x, int y, vector<vector<char>> &v) {
if (y <= 1) {
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < 3; i++) {
if (v[x][y + i] == 'x') {
cnt0++;
} else if (v[x][y + i] == 'o') {
cnt1++;
}
}
if (cnt0 == 2 && cnt1 == 0) {
return true;
}
}
if (x <= 1) {
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < 3; i++) {
if (v[x + i][y] == 'x') {
cnt0++;
} else if (v[x + i][y] == 'o') {
cnt1++;
}
}
if (cnt0 == 2 && cnt1 == 0) {
return true;
}
}
if (x <= 1 && y <= 1) {
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < 3; i++) {
if (v[x + i][y + i] == 'x') {
cnt0++;
} else if (v[x + i][y + i] == 'o') {
cnt1++;
}
}
if (cnt0 == 2 && cnt1 == 0) {
return true;
}
}
if (x <= 1 && y >= 2) {
int cnt0 = 0, cnt1 = 0;
for (int i = 0; i < 3; i++) {
if (v[x + i][y - i] == 'x') {
cnt0++;
} else if (v[x + i][y - i] == 'o') {
cnt1++;
}
}
if (cnt0 == 2 && cnt1 == 0) {
return true;
}
}
return false;
}
int main() {
vector<vector<char>> v(4, vector<char>(4));
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
cin >> v[i][j];
}
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (check(i, j, v)) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int me = 100025;
string s[5];
int good(int x, int y) { return x > 0 && y > 0 && x < 5 && y < 5; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i <= 4; i++) {
cin >> s[i];
s[i] = "$" + s[i];
}
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++) {
if (s[i][j] == 'x' || s[i][j] == 'o') continue;
s[i][j] = 'x';
for (int k = 1; k <= 4; k++)
for (int q = 1; q <= 4; q++) {
if (s[k][q] != 'x') continue;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++) {
if (dx * dx + dy * dy == 0) continue;
if (!good(k + dx, q + dy) || s[k + dx][q + dy] != 'x') continue;
if (!good(k + dx + dx, q + dy + dy) ||
s[k + dx + dx][q + dy + dy] != 'x')
continue;
cout << "YES" << endl;
return 0;
}
}
s[i][j] = '.';
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string W[7];
int cs(int a, int b) {
if (a >= 4 || a < 0 || b >= 4 || b < 0) return 100;
if (W[a][b] == 'x') return 1;
if (W[a][b] == '.') return 10;
if (W[a][b] == 'o') return 100;
}
int checkr(int i, int j) {
if (j > 1)
return 0;
else {
if (cs(i, j) + cs(i, j + 1) + cs(i, j + 2) == 12)
return 1;
else
return 0;
}
}
int checkl(int i, int j) {
if (i > 1)
return 0;
else {
if (cs(i, j) + cs(i + 1, j) + cs(i + 2, j) == 12)
return 1;
else
return 0;
}
}
int checks(int i, int j) {
if (cs(i, j) + cs(i + 1, j + 1) + cs(i + 2, j + 2) == 12)
return 1;
else
return 0;
}
int checkx(int i, int j) {
if (cs(i, j) + cs(i + 1, j - 1) + cs(i + 2, j - 2) == 12)
return 1;
else
return 0;
}
int main() {
for (int i = 0; i < 4; i++) {
cin >> W[i];
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
int w = 0;
w = w + checkr(i, j);
w = w + checkl(i, j);
w = w + checks(i, j);
w = w + checkx(i, j);
if (w > 0) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[4][4], x, t = 0;
for (int i = 0; i < 4; i++) {
cin >> arr[i];
}
int count1 = 0, count2 = 0;
for (int i = 0; i < 4; i++) {
count1 = 0, count2 = 0;
for (int j = 0; j < 4; j++) {
if (arr[i][j] == '.') count2++;
if (arr[i][j] == 'x')
count1++;
else if (arr[i][j] == 'o') {
count1 = 0;
count2 = 0;
}
if (count1 == 2 && count2 >= 1) {
if (count2 == 2) {
if (arr[i][1] == '.' && arr[i][2] == '.') continue;
}
cout << "YES" << endl;
return 0;
}
}
}
for (int i = 0; i < 4; i++) {
count1 = 0, count2 = 0;
for (int j = 0; j < 4; j++) {
if (arr[j][i] == '.') count2++;
if (arr[j][i] == 'x')
count1++;
else if (arr[j][i] == 'o') {
count1 = 0;
count2 = 0;
}
if (count1 == 2 && count2 >= 1) {
if (count2 == 2) {
if (arr[1][i] == '.' && arr[2][i] == '.') continue;
}
cout << "YES" << endl;
return 0;
}
}
}
if (arr[0][0] == 'x' && arr[1][1] == 'x' && arr[2][2] == '.') {
cout << "YES" << endl;
} else if (arr[0][0] == '.' && arr[1][1] == 'x' && arr[2][2] == 'x') {
cout << "YES" << endl;
} else if (arr[0][0] == 'x' && arr[1][1] == '.' && arr[2][2] == 'x') {
cout << "YES" << endl;
} else if (arr[3][3] == '.' && arr[1][1] == 'x' && arr[2][2] == 'x') {
cout << "YES" << endl;
} else if (arr[1][1] == '.' && arr[3][3] == 'x' && arr[2][2] == 'x') {
cout << "YES" << endl;
} else if (arr[1][1] == 'x' && arr[3][3] == 'x' && arr[2][2] == '.') {
cout << "YES" << endl;
} else if (arr[0][3] == 'x' && arr[1][2] == 'x' && arr[2][1] == '.') {
cout << "YES" << endl;
} else if (arr[0][3] == '.' && arr[1][2] == 'x' && arr[2][1] == 'x') {
cout << "YES" << endl;
} else if (arr[0][3] == 'x' && arr[1][2] == '.' && arr[2][1] == 'x') {
cout << "YES" << endl;
} else if (arr[3][0] == '.' && arr[1][2] == 'x' && arr[2][1] == 'x') {
cout << "YES" << endl;
} else if (arr[3][0] == 'x' && arr[1][2] == '.' && arr[2][1] == 'x') {
cout << "YES" << endl;
} else if (arr[3][0] == 'x' && arr[1][2] == 'x' && arr[2][1] == '.') {
cout << "YES" << endl;
} else if ((arr[0][1] == 'x' && arr[1][2] == 'x' && arr[2][3] == '.') ||
(arr[0][1] == 'x' && arr[1][2] == '.' && arr[2][3] == 'x') ||
(arr[0][1] == '.' && arr[1][2] == 'x' && arr[2][3] == 'x')) {
cout << "YES" << endl;
} else if ((arr[1][0] == 'x' && arr[2][1] == 'x' && arr[3][2] == '.') ||
(arr[1][0] == 'x' && arr[2][1] == '.' && arr[3][2] == 'x') ||
(arr[1][0] == '.' && arr[2][1] == 'x' && arr[3][2] == 'x')) {
cout << "YES" << endl;
} else if ((arr[1][3] == 'x' && arr[2][2] == 'x' && arr[3][1] == '.') ||
(arr[1][3] == '.' && arr[2][2] == 'x' && arr[3][1] == 'x') ||
(arr[1][3] == 'x' && arr[2][2] == '.' && arr[3][1] == 'x')) {
cout << "YES" << endl;
} else if ((arr[0][2] == 'x' && arr[1][1] == 'x' && arr[2][0] == '.') ||
(arr[0][2] == 'x' && arr[1][1] == '.' && arr[2][0] == 'x') ||
(arr[0][2] == '.' && arr[1][1] == 'x' && arr[2][0] == 'x')) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("lol.in");
ofstream fout("lol.out");
char c;
int m[10][10], ok;
int main() {
ios::sync_with_stdio(false);
for (int i = 1; i <= 6; ++i) {
m[1][i] = m[6][i] = 100;
m[i][1] = m[i][6] = 100;
}
for (int i = 2; i <= 5; ++i) {
for (int j = 2; j <= 5; ++j) {
cin >> c;
if (c == 'x') m[i][j] = 1;
if (c == 'o') m[i][j] = 100;
}
}
for (int i = 2; i <= 5; ++i) {
for (int j = 2; j <= 5; ++j) {
if (m[i][j] + m[i + 1][j] + m[i + 2][j] == 2) ok = 1;
if (m[i][j] + m[i + 1][j + 1] + m[i + 2][j + 2] == 2) ok = 1;
if (m[i][j] + m[i + 1][j - 1] + m[i + 2][j - 2] == 2) ok = 1;
if (m[i][j] + m[i][j + 1] + m[i][j + 2] == 2) ok = 1;
if (ok == 1) {
cout << "YES";
return 0;
}
}
}
if (ok == 1) {
cout << "YES";
return 0;
} else
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[10][10];
bool flag;
int main() {
for (int i = 0; i < 4; i++) scanf("%s", a[i]);
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
if (a[i][j] == 'x') {
if (a[i][j + 1] == 'x' || a[i][j + 2] == 'x') {
if (a[i][j + 1] == '.' || a[i][j + 2] == '.') flag = 1;
}
if (a[i][j - 1] == 'x' || a[i][j - 2] == 'x') {
if (a[i][j - 1] == '.' || a[i][j - 2] == '.') flag = 1;
}
if (a[i + 1][j] == 'x' || a[i + 2][j] == 'x') {
if (a[i + 1][j] == '.' || a[i + 2][j] == '.') flag = 1;
}
if (a[i - 1][j] == 'x' || a[i - 2][j] == 'x') {
if (a[i - 1][j] == '.' || a[i - 2][j] == '.') flag = 1;
}
if (a[i + 1][j + 1] == 'x' || a[i + 2][j + 2] == 'x') {
if (a[i + 1][j + 1] == '.' || a[i + 2][j + 2] == '.') flag = 1;
}
if (a[i - 1][j - 1] == 'x' || a[i - 2][j - 2] == 'x') {
if (a[i - 1][j - 1] == '.' || a[i - 2][j - 2] == '.') flag = 1;
}
if (a[i + 1][j - 1] == 'x' || a[i + 2][j - 2] == 'x') {
if (a[i + 1][j - 1] == '.' || a[i + 2][j - 2] == '.') flag = 1;
}
if (a[i - 1][j + 1] == 'x' || a[i - 2][j + 2] == 'x') {
if (a[i - 1][j + 1] == '.' || a[i - 2][j + 2] == '.') flag = 1;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1000000007;
const int N = 200000 + 7;
char arr[10][10];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 2; i < 6; i++) {
string t;
cin >> t;
for (int j = 0; j < 4; j++) {
arr[i][j + 2] = t[j];
}
}
for (int i = 2; i < 6; i++) {
for (int j = 2; j < 6; j++) {
if (arr[i][j] != '.') continue;
bool f = false;
if (arr[i - 1][j - 1] == 'x' && arr[i + 1][j + 1] == 'x')
f = true;
else if (arr[i][j - 1] == 'x' && arr[i][j + 1] == 'x')
f = true;
else if (arr[i + 1][j - 1] == 'x' && arr[i - 1][j + 1] == 'x')
f = true;
else if (arr[i - 1][j] == 'x' && arr[i + 1][j] == 'x')
f = true;
else if (arr[i - 1][j - 1] == 'x' && arr[i - 2][j - 2] == 'x')
f = true;
else if (arr[i][j - 1] == 'x' && arr[i][j - 2] == 'x')
f = true;
else if (arr[i + 1][j - 1] == 'x' && arr[i + 2][j - 2] == 'x')
f = true;
else if (arr[i + 1][j] == 'x' && arr[i + 2][j] == 'x')
f = true;
else if (arr[i + 1][j + 1] == 'x' && arr[i + 2][j + 2] == 'x')
f = true;
else if (arr[i][j + 1] == 'x' && arr[i][j + 2] == 'x')
f = true;
else if (arr[i - 1][j + 1] == 'x' && arr[i - 2][j + 2] == 'x')
f = true;
else if (arr[i - 1][j] == 'x' && arr[i - 2][j] == 'x')
f = true;
if (f) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[10][10];
int dx[8] = {1, 1, 1, 0, -1, -1, -1, 0};
int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
bool check(int x, int y) {
for (int i = 0; i < 4; i++) {
if (a[x + dx[i]][y + dy[i]] == 'x' && a[x - dx[i]][y - dy[i]] == 'x')
return true;
}
for (int i = 0; i < 8; i++) {
if (a[x + dx[i]][y + dy[i]] == 'x' &&
a[x + 2 * dx[i]][y + 2 * dy[i]] == 'x')
return true;
}
return false;
}
int main() {
for (int i = 0; i < 4; i++) {
scanf("%s", a[i + 2] + 2);
}
for (int i = 2; i < 6; i++)
for (int j = 2; j < 6; j++) {
if (a[i][j] == '.') {
if (check(i, j) == true) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char mat[10][10];
bool inside(int i, int j) { return i >= 1 and j >= 1 and i <= 4 and j <= 4; }
int main() {
ios ::sync_with_stdio(false);
int n;
n = 4;
int cate = 0;
for (int i = 1; i <= n; ++i) {
cin >> (mat[i] + 1);
for (int j = 1; j <= n; ++j) {
if (mat[i][j] != '.') {
++cate;
}
}
}
if (cate & 1) {
label:
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (mat[i][j] == '.') {
int cate1 = 0;
cate = 0;
int ii = i + 1;
while (inside(ii, j) and mat[ii][j] == 'o') {
++cate;
++ii;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
cate1 = cate;
cate = 0;
ii = i - 1;
while (inside(ii, j) and mat[ii][j] == 'o') {
++cate;
--ii;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
if (cate1 + cate == 2) {
cout << "YES\n";
return 0;
}
int jj = j + 1;
cate = 0;
cate1 = 0;
while (inside(i, jj) and mat[i][jj] == 'o') {
++cate;
++jj;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
cate1 = cate;
jj = j - 1;
cate = 0;
while (inside(i, jj) and mat[i][jj] == 'o') {
++cate;
--jj;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
if (cate1 + cate == 2) {
cout << "YES\n";
return 0;
}
ii = i + 1;
jj = j + 1;
cate = 0;
cate1 = 0;
while (inside(ii, jj) and mat[ii][jj] == 'o') {
++ii;
++jj;
cate += 1;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
cate1 = cate;
ii = i - 1;
jj = j - 1;
cate = 0;
while (inside(ii, jj) and mat[ii][jj] == 'o') {
--ii;
--jj;
cate += 1;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
if (cate1 + cate == 2) {
cout << "YES\n";
return 0;
}
ii = i - 1;
jj = j + 1;
cate = 0;
cate1 = 0;
while (inside(ii, jj) and mat[ii][jj] == 'o') {
--ii;
++jj;
cate += 1;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
cate1 = cate;
ii = i + 1;
jj = j - 1;
cate = 0;
while (inside(ii, jj) and mat[ii][jj] == 'o') {
++ii;
--jj;
cate += 1;
}
if (cate == 2) {
cout << "YES\n";
return 0;
}
if (cate1 + cate == 2) {
cout << "YES\n";
return 0;
}
}
}
}
} else {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (mat[i][j] == 'x') {
mat[i][j] = 'o';
} else if (mat[i][j] == 'o') {
mat[i][j] = 'x';
}
}
}
goto label;
for (int i = 1; i <= n; ++i) {
cout << (mat[i] + 1) << endl;
}
return 0;
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, ok = 0;
string board[8] = {"........", "........", "........", "........",
"........", "........", "........", "........"};
for (i = 2; i <= 5; i++)
for (j = 2; j <= 5; j++) cin >> board[i][j];
for (i = 2; i <= 5; i++)
for (j = 2; j <= 5; j++)
if (board[i][j] == '.') {
if (board[i - 1][j] == 'x' && board[i - 2][j] == 'x') ok = 1;
if (board[i + 1][j] == 'x' && board[i + 2][j] == 'x') ok = 1;
if (board[i - 1][j - 1] == 'x' && board[i - 2][j - 2] == 'x') ok = 1;
if (board[i + 1][j - 1] == 'x' && board[i + 2][j - 2] == 'x') ok = 1;
if (board[i][j + 1] == 'x' && board[i][j + 2] == 'x') ok = 1;
if (board[i][j - 1] == 'x' && board[i][j - 2] == 'x') ok = 1;
if (board[i - 1][j + 1] == 'x' && board[i - 2][j + 2] == 'x') ok = 1;
if (board[i + 1][j + 1] == 'x' && board[i + 2][j + 2] == 'x') ok = 1;
if (board[i - 1][j] == 'x' && board[i + 1][j] == 'x') ok = 1;
if (board[i][j - 1] == 'x' && board[i][j + 1] == 'x') ok = 1;
if (board[i - 1][j - 1] == 'x' && board[i + 1][j + 1] == 'x') ok = 1;
if (board[i + 1][j - 1] == 'x' && board[i - 1][j + 1] == 'x') ok = 1;
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[4][4];
int i, j;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++) cin >> a[i][j];
int flag = 0;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (a[i][j] == 'x') {
if (i + 1 < 4 && i + 2 < 4 && a[i + 1][j] != a[i + 2][j] &&
((a[i + 1][j] == 'x' && a[i + 2][j] == '.') ||
(a[i + 1][j] == '.' && a[i + 2][j] == 'x'))) {
flag = 1;
break;
}
if (j + 1 < 4 && j + 2 < 4 && a[i][j + 1] != a[i][j + 2] &&
((a[i][j + 1] == 'x' && a[i][j + 2] == '.') ||
(a[i][j + 1] == '.' && a[i][j + 2] == 'x'))) {
flag = 1;
break;
}
if (i + 1 < 4 && i + 2 < 4 && j + 1 < 4 && j + 2 < 4 &&
a[i + 1][j + 1] != a[i + 2][j + 2] &&
((a[i + 1][j + 1] == 'x' && a[i + 2][j + 2] == '.') ||
(a[i + 1][j + 1] == '.' && a[i + 2][j + 2] == 'x'))) {
flag = 1;
break;
}
if (i + 1 < 4 && i + 2 < 4 && j - 2 >= 0 &&
a[i + 1][j - 1] != a[i + 2][j - 2] &&
((a[i + 1][j - 1] == 'x' && a[i + 2][j - 2] == '.') ||
(a[i + 1][j - 1] == '.' && a[i + 2][j - 2] == 'x'))) {
flag = 1;
break;
}
}
if (a[i][j] == '.') {
if (i + 1 < 4 && i + 2 < 4 && a[i + 1][j] == a[i + 2][j] &&
a[i + 1][j] == 'x') {
flag = 1;
break;
}
if (j + 1 < 4 && j + 2 < 4 && a[i][j + 1] == a[i][j + 2] &&
a[i][j + 1] == 'x') {
flag = 1;
break;
}
if (i + 1 < 4 && i + 2 < 4 && j + 1 < 4 && j + 2 < 4 &&
a[i + 1][j + 1] == a[i + 2][j + 2] && a[i + 1][j + 1] == 'x') {
flag = 1;
break;
}
if (i + 1 < 4 && i + 2 < 4 && j - 2 >= 0 &&
a[i + 1][j - 1] == a[i + 2][j - 2] && a[i + 1][j - 1] == 'x') {
flag = 1;
break;
}
}
}
if (flag) break;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[5];
for (long long int i = 0; i < 4; i++) cin >> s[i];
long long int f = 0;
for (long long int i = 0; i <= 3; i++) {
for (long long int j = 0; j <= 3; j++) {
if (j <= 1) {
if (s[i][j] == 'x' and s[i][j + 1] == 'x' and s[i][j + 2] == '.') {
f = 1;
break;
}
if (s[i][j] == '.' and s[i][j + 1] == 'x' and s[i][j + 2] == 'x') {
f = 1;
break;
}
if (s[i][j] == 'x' and s[i][j + 1] == '.' and s[i][j + 2] == 'x') {
f = 1;
break;
}
}
if (i <= 1) {
if (s[i][j] == 'x' and s[i + 1][j] == 'x' and s[i + 2][j] == '.') {
f = 1;
break;
}
if (s[i][j] == 'x' and s[i + 1][j] == '.' and s[i + 2][j] == 'x') {
f = 1;
break;
}
if (s[i][j] == '.' and s[i + 1][j] == 'x' and s[i + 2][j] == 'x') {
f = 1;
break;
}
}
if (i <= 1 and j <= 1) {
if (s[i][j] == 'x' and s[i + 1][j + 1] == 'x' and
s[i + 2][j + 2] == '.') {
f = 1;
break;
}
if (s[i][j] == '.' and s[i + 1][j + 1] == 'x' and
s[i + 2][j + 2] == 'x') {
f = 1;
break;
}
if (s[i][j] == 'x' and s[i + 1][j + 1] == '.' and
s[i + 2][j + 2] == 'x') {
f = 1;
break;
}
}
if (i >= 2 and j <= 1) {
if (s[i][j] == 'x' and s[i - 1][j + 1] == 'x' and
s[i - 2][j + 2] == '.') {
f = 1;
break;
}
if (s[i][j] == '.' and s[i - 1][j + 1] == 'x' and
s[i - 2][j + 2] == 'x') {
f = 1;
break;
}
if (s[i][j] == 'x' and s[i - 1][j + 1] == '.' and
s[i - 2][j + 2] == 'x') {
f = 1;
break;
}
}
}
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char G[10][10];
int dx[8] = {1, -1, 0, 0, 1, -1, -1, 1};
int dy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
int L(int x, int y) {
return x < 4 and x >= 0 and y < 4 and y >= 0 and G[x][y] == 'x';
}
int func(int x, int y) {
for (int i = 0; i < 8; i += 2) {
if (L(x + dx[i], y + dy[i]) and L(x + dx[i + 1], y + dy[i + 1])) return 1;
if (L(x + dx[i], y + dy[i]) and L(x + 2 * dx[i], y + 2 * dy[i])) return 1;
if (L(x - dx[i], y - dy[i]) and L(x - 2 * dx[i], y - 2 * dy[i])) return 1;
}
return 0;
}
int main() {
for (int i = 0; i < 4; i++) scanf("%s", G[i]);
int flag = 1;
for (int i = 0; flag and i < 4; i++)
for (int j = 0; flag and j < 4; j++)
if (G[i][j] == '.' and func(i, j)) flag = 0;
printf("%s\n", flag ? "NO" : "YES");
}
|
#include <bits/stdc++.h>
using namespace std;
char a[10][10], s[555];
int main() {
s['x'] = 2, s['.'] = 1;
const clock_t begin_time = clock();
if (0) freopen("b.in", "r", stdin);
memset(a, 'x', sizeof a);
for (int i = 3; i < 7; i++) scanf("%s", a[i] + 3);
bool found = false;
for (int i = 2; i < 8; i++) {
for (int j = 2; j < 8; j++) {
if (i >= 3 && i <= 6 && j >= 3 && j + 2 <= 6 &&
s[a[i][j]] + s[a[i][j + 1]] + s[a[i][j + 2]] == 5)
found = true;
if (i >= 3 && i + 2 <= 6 && j >= 3 && j <= 6 &&
s[a[i][j]] + s[a[i + 1][j]] + s[a[i + 2][j]] == 5)
found = true;
if (i >= 3 && i + 2 <= 6 && j >= 3 && j + 2 <= 6 &&
s[a[i][j]] + s[a[i + 1][j + 1]] + s[a[i + 2][j + 2]] == 5)
found = true;
if (i - 2 >= 3 && i <= 6 && j >= 3 && j + 2 <= 6 &&
s[a[i][j]] + s[a[i - 1][j + 1]] + s[a[i - 2][j + 2]] == 5)
found = true;
}
}
printf("%s\n", found ? "YES" : "NO");
if (0)
printf("\nTime used: %.6lfs\n",
double(clock() - begin_time) / CLOCKS_PER_SEC);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
char c[5][5];
int x = 0, o = 0;
char s;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) {
cin >> c[i][j];
if (c[i][j] == 'x') x++;
if (c[i][j] == 'o') o++;
}
if (x == o)
s = 'x';
else
s = 'o';
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) {
if (c[i][j] == s) {
if (c[i][j + 1] == s && c[i][j + 2] == '.') {
cout << "YES";
return 0;
}
if (c[i][j + 1] == '.' && c[i][j + 2] == s) {
cout << "YES";
return 0;
}
if (c[i][j - 1] == s && c[i][j - 2] == '.') {
cout << "YES";
return 0;
}
if (c[i][j - 1] == '.' && c[i][j - 2] == s) {
cout << "YES";
return 0;
}
if (c[i + 1][j] == s && c[i + 2][j] == '.') {
cout << "YES";
return 0;
}
if (c[i + 1][j] == '.' && c[i + 2][j] == s) {
cout << "YES";
return 0;
}
if (c[i - 1][j] == s && c[i - 2][j] == '.') {
cout << "YES";
return 0;
}
if (c[i - 1][j] == '.' && c[i - 2][j] == s) {
cout << "YES";
return 0;
}
if (c[i + 1][j + 1] == s && c[i + 2][j + 2] == '.') {
cout << "YES";
return 0;
}
if (c[i + 1][j + 1] == '.' && c[i + 2][j + 2] == s) {
cout << "YES";
return 0;
}
if (c[i - 1][j - 1] == s && c[i - 2][j - 2] == '.') {
cout << "YES";
return 0;
}
if (c[i - 1][j - 1] == '.' && c[i - 2][j - 2] == s) {
cout << "YES";
return 0;
}
if (c[i + 1][j - 1] == s && c[i + 2][j - 2] == '.') {
cout << "YES";
return 0;
}
if (c[i + 1][j - 1] == '.' && c[i + 2][j - 2] == s) {
cout << "YES";
return 0;
}
if (c[i - 1][j + 1] == s && c[i - 2][j + 2] == '.') {
cout << "YES";
return 0;
}
if (c[i - 1][j + 1] == '.' && c[i - 2][j + 2] == s) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, i, j, k, l, m, n;
string s1[4];
for (i = 0; i < 4; i++) cin >> s1[i];
d = 0;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (s1[i][j] == '.') {
if (j < 2) {
if (s1[i][j + 1] == 'x' && s1[i][j + 2] == 'x') d = 1;
}
if (j > 1) {
if (s1[i][j - 1] == 'x' && s1[i][j - 2] == 'x') d = 1;
}
if (i < 2) {
if (s1[i + 1][j] == 'x' && s1[i + 2][j] == 'x') d = 1;
}
if (i > 1) {
if (s1[i - 1][j] == 'x' && s1[i - 2][j] == 'x') d = 1;
}
if (j > 0 && j < 3) {
if (s1[i][j - 1] == 'x' && s1[i][j + 1] == 'x') d = 1;
}
if (i > 0 && i < 3) {
if (s1[i - 1][j] == 'x' && s1[i + 1][j] == 'x') d = 1;
}
if (j < 2 && i < 2) {
if (s1[i + 1][j + 1] == 'x' && s1[i + 2][j + 2] == 'x') d = 1;
}
if (j > 1 && i > 1) {
if (s1[i - 1][j - 1] == 'x' && s1[i - 2][j - 2] == 'x') d = 1;
}
if (i < 2 && j > 1) {
if (s1[i + 1][j - 1] == 'x' && s1[i + 2][j - 2] == 'x') d = 1;
}
if (i > 1 && j < 2) {
if (s1[i - 1][j + 1] == 'x' && s1[i - 2][j + 2] == 'x') d = 1;
}
if (i > 0 && i < 3 && j > 0 && j < 3) {
if (s1[i - 1][j - 1] == 'x' && s1[i + 1][j + 1] == 'x') d = 1;
if (s1[i + 1][j - 1] == 'x' && s1[i - 1][j + 1] == 'x') d = 1;
}
}
if (d == 1) break;
}
if (d == 1) break;
}
if (d == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.