text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int ans[N];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, mx = 0;
scanf("%d", &n);
vector<pair<int, int> > vec, arr(n);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
vec.push_back({l, 0});
vec.push_back({r, 1});
arr[i] = {l, r};
}
sort((vec).begin(), (vec).end());
int s = 0, cnt = 0, sta = 0, end = 0;
for (int i = 0; i < int((vec).size()); i++) {
if (vec[i].second == 0) {
s++;
if (!sta) sta = vec[i].first;
} else {
s--;
if (s == 0) {
cnt++;
if (!end) end = vec[i].first;
}
}
}
if (cnt < 2) {
printf("-1\n");
continue;
}
for (int i = 0; i < n; i++) {
if (arr[i].first >= sta && arr[i].second <= end)
printf("1 ");
else
printf("2 ");
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vpii = vector<pii>;
template <class T>
inline bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const char nl = '\n';
const int mxN = 2e5 + 10;
const int MOD = 1e9 + 7;
const ll infLL = 1e18;
const ld eps = 1e-6;
struct node {
int l, r, i;
bool operator<(const node& other) const { return r < other.r; }
};
void solve() {
int n;
cin >> n;
vector<array<int, 3>> v;
for (int i = (0); i < (n); i++) {
int l, r;
cin >> l >> r;
v.push_back({l, r, i});
}
sort(v.begin(), v.end());
vi ans(n);
set<node> second[2];
second[0].insert({-MOD, -MOD, -MOD});
second[1].insert({-MOD, -MOD, -MOD});
int mx = v[0][1];
bool g = 0;
for (int i = (1); i < (n); i++) {
if (v[i][0] > mx) {
for (int j = (0); j < (i); j++) ans[v[j][2]] = 1;
for (int j = (i); j < (n); j++) ans[v[j][2]] = 2;
g = 1;
break;
}
ckmax(mx, v[i][1]);
}
if (!g) {
cout << "-1\n";
return;
}
for (int i = (0); i < (n); i++) cout << ans[i] << ' ';
cout << nl;
}
int32_t main() {
cin.tie(0)->sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
struct gg {
int a, b, c;
} g[120000];
int cmp(gg x, gg y) {
if (x.a != y.a)
return x.a < y.a;
else
return x.b < y.b;
}
int p[120000];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> g[i].a >> g[i].b;
g[i].c = i;
}
sort(g, g + n, cmp);
int x, pp = g[0].b, falg = 0;
for (int i = 1; i < n; i++) {
if (g[i].a > pp) {
x = i;
falg = 1;
break;
}
pp = max(pp, g[i].b);
}
if (!falg)
cout << "-1" << endl;
else {
for (int i = 0; i < x; i++) {
p[g[i].c] = 1;
}
for (int i = x; i < n; i++) {
p[g[i].c] = 2;
}
for (int i = 0; i < n; i++) {
cout << p[i];
if (i == n - 1)
cout << endl;
else
cout << " ";
}
}
}
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 2e6 + 5;
struct event {
int t, x, idx;
bool operator<(const event& rhs) const {
return t < rhs.t || (t == rhs.t && x < rhs.x);
}
};
int T, n;
int ans[MAXN];
event ev[MAXN];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) {
int l, r;
scanf("%d %d", &l, &r);
ev[i] = {l, 0, i / 2};
ev[i + 1] = {r, 1, i / 2};
i++;
}
sort(ev, ev + (2 * n));
set<int> s;
int a = 1;
for (int i = 0; i < 2 * n; i++) {
int x = ev[i].x, idx = ev[i].idx;
if (x) {
s.erase(idx);
if (s.empty() && a == 1) a++;
} else {
s.insert(idx);
ans[idx] = a;
}
}
a = 0;
for (int i = 0; i < n; i++) a += (ans[i] == 2);
if (a) {
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
} else {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int mini1 = INT_MAX;
int visi[n];
vector<pair<int, int>> v1, v2;
int ind;
for (int i = 0; i < n; i++) {
visi[i] = 1;
int a1, b1;
cin >> a1 >> b1;
v1.push_back({a1, b1});
v2.push_back({a1, b1});
}
sort(v2.begin(), v2.end());
int g1 = v2[0].second;
int cnt = 0;
int cnti = 0;
for (int i = 0; i < n; i++) {
if ((v2[i].first <= g1)) {
cnti++;
if (v2[i].second > g1) {
g1 = v2[i].second;
}
}
}
cnt = 0;
if (cnti == n) {
cout << "-1\n";
return;
}
for (int i = 0; i < n; i++) {
if ((v1[i].second <= g1) && (v2[0].first <= v1[i].first)) {
cout << "2 ";
} else
cout << "1 ";
}
cout << "\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
pair<pair<long long, long long>, long long> seg[n];
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
cin >> seg[i].first.first >> seg[i].first.second;
seg[i].second = i;
}
sort(seg, seg + n);
long long l = seg[0].first.first, r = seg[0].first.second, res[n], tot = 0;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
if (seg[i].first.first <= r) {
r = max(seg[i].first.second, r);
res[seg[i].second] = 1;
} else {
res[seg[i].second] = 2;
tot++;
}
}
if (tot) {
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
cout << res[i] << " ";
}
} else {
cout << "-1";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323;
const double EPS = 1e-12;
const int N = 1e6 + 5;
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t, n;
cin >> t;
while (t--) {
cin >> n;
vector<pair<long long, long long> > v(n);
long long a[n], b[n];
map<pair<long long, long long>, long long> mp;
long long l, r;
for (int i = 0; i < n; i++) {
cin >> l >> r;
a[i] = l, b[i] = r;
v[i] = {l, r};
}
sort(v.begin(), v.end());
long long maxm = v[0].second, ans = 0;
mp[{v[0].first, v[0].second}] = 1;
for (int i = 1; i < n; i++) {
if (v[i].first > maxm) {
ans = 1;
break;
} else
mp[{v[i].first, v[i].second}] = 1;
maxm = max(v[i].second, maxm);
}
if (ans) {
for (int i = 0; i < n; i++) {
if (mp[{a[i], b[i]}])
cout << 1 << " ";
else
cout << 2 << " ";
}
}
if (!ans) cout << -1;
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
vector<pair<int, int> > segs, segs2;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
pair<int, int> p;
cin >> p.first >> p.second;
segs.push_back(p);
segs2.push_back(p);
}
int val = -1;
sort(segs.begin(), segs.end());
int mx = 0;
for (int i = 0; i < n - 1; i++) {
if (segs[i].second < segs[i + 1].first && segs[i + 1].first > mx) {
val = segs[i + 1].first;
}
mx = max(mx, segs[i].second);
}
if (val == -1)
cout << "-1\n";
else {
for (int i = 0; i < segs2.size(); i++) {
if (segs2[i].first < val && segs2[i].second < val)
cout << "1 ";
else
cout << "2 ";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 314;
const int INF = 1e9;
const double PI = acos(-1);
const int MOD = 1e9 + 7;
const double eps = 1e-9;
int d[N];
pair<int, int> p[N];
int ans[N];
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return 1;
if (b.first < a.first) return 0;
return a.second > b.second;
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) ans[i] = 0;
vector<pair<int, int> > v;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
p[i] = {x, y};
v.push_back({x, 1});
v.push_back({y, -1});
}
sort((v).begin(), (v).end(), cmp);
int b = 0, l = -1, r = -1;
for (int i = 0; i < v.size(); ++i) {
if (b == 0) l = v[i].first;
b += v[i].second;
if (b == 0) {
r = v[i].first;
break;
}
}
int cnt1 = 0;
for (int i = 0; i < n; ++i) {
if (l <= p[i].first && p[i].second <= r) {
cnt1++;
ans[i] = 1;
}
}
if (cnt1 == n) {
cout << "-1\n";
return;
}
for (int i = 0; i < n; ++i) {
if (ans[i] == 0) {
ans[i] = 2;
}
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
long long bit[N];
void upd(int x) {
x++;
for (int i = x; i < N; i += (i & (-i))) {
bit[i]++;
}
}
int get(int x) {
int res = 0;
x++;
for (int i = x; i > 0; i -= (i & (-i))) {
res += bit[i];
}
return res;
}
long long mod = 1e9 + 7;
long long myPow(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res *= x;
res %= mod;
x = x * x;
x %= mod;
k /= 2;
}
return res;
}
int freq[300];
string word = "012";
char findNext(char c, int exp) {
int index = c - '0';
int act = 0;
while (act == index || freq[word[act]] >= exp) act++;
return word[act];
}
int id[N];
int main() {
int t;
cin >> t;
while (t--) {
vector<tuple<int, int, int> > vec;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d%d", &l, &r);
vec.emplace_back(l, -1, i);
vec.emplace_back(r, +1, i);
}
sort(vec.begin(), vec.end());
int c = 0;
bool can = false;
for (int i = 0; i < vec.size() - 1; i++) {
int x, y, z;
tie(x, y, z) = vec[i];
c += y;
id[z] = 1;
if (c == 0) {
can = true;
break;
}
}
if (!can) {
cout << -1;
} else {
for (int i = 0; i < n; i++) {
if (id[i] == 0) {
printf("2 ");
} else {
printf("1 ");
}
}
}
cout << endl;
for (int i = 0; i < n; i++) {
id[i] = 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using llu = long long unsigned;
using ld = long double;
const ld EPS = 1e-9;
inline int cmp(ld first, ld second = 0, ld tol = EPS) {
return (first <= second + tol) ? (first + tol < second) ? -1 : 0 : 1;
}
const int MOD = 1;
inline int mod(ll first, int m = MOD) { return (int)(((first % m) + m) % m); }
const int MAXN = 1e5 + 10;
int t;
int ans[MAXN];
int main() {
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
vector<pair<pii, int>> vec;
int l, r;
for (int i = 0; i < n; i++) {
scanf("%d %d", &l, &r);
vec.push_back({{l, r}, i});
}
sort(vec.begin(), vec.end());
pii g1;
g1 = vec[0].first;
ans[vec[0].second] = 1;
bool ok = false;
for (int i = 1; i < ((int)(vec).size()); i++) {
auto p = vec[i];
if (p.first.first <= g1.second) {
ans[p.second] = 1;
g1.second = max(g1.second, p.first.second);
} else {
ok = true;
ans[p.second] = 2;
}
}
if (!ok)
printf("-1\n");
else {
for (int i = 0; i < n; i++) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
putchar('\n');
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
tuple<int, int, int> a[100010];
int id[100010];
void sol() {
int n;
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
get<2>(a[i]) = i;
scanf("%d%d", &get<0>(a[i]), &get<1>(a[i]));
}
sort(a + 1, a + n + 1);
int r = get<1>(a[1]);
for (int i = (1); i <= (n); ++i) id[get<2>(a[i])] = i;
for (int i = (2); i <= (n); ++i) {
if (get<0>(a[i]) > r) {
for (int j = (1); j <= (n); ++j) printf("%d ", 1 + (id[j] >= i));
printf("\n");
return;
}
r = max(r, get<1>(a[i]));
}
printf("-1\n");
}
int main() {
int T;
for (scanf("%d", &T); T--;) sol();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, mx = 0;
scanf("%d", &n);
vector<pair<int, int> > vec, arr(n);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
vec.push_back({l, 0});
vec.push_back({r, 1});
arr[i] = {l, r};
}
sort((vec).begin(), (vec).end());
int s = 0, cnt = 0, sta = 0, end = 0;
for (int i = 0; i < int((vec).size()); i++) {
if (vec[i].second == 0) {
s++;
if (!sta) sta = vec[i].first;
} else {
s--;
if (s == 0) {
cnt++;
if (!end) end = vec[i].first;
}
}
}
if (cnt < 2) {
printf("-1\n");
continue;
}
for (int i = 0; i < n; i++) {
if (arr[i].first >= sta && arr[i].second <= end)
printf("1 ");
else
printf("2 ");
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int maxn = 1002;
void solve() {
long long n;
cin >> n;
long long ans[n];
pair<long long, long long> p[n];
long long a[n], b[n];
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
p[i] = make_pair(a[i], i);
}
sort(p, p + n);
int val = 1;
long long right = b[p[0].second];
for (int i = 0; i < n; ++i) {
if (p[i].first <= right) {
ans[p[i].second] = val;
right = max(right, b[p[i].second]);
} else {
if (val == 1) {
val++;
ans[p[i].second] = val;
} else {
ans[p[i].second] = val;
}
right = max(right, b[p[i].second]);
}
}
if (val == 2) {
for (int i = 0; i < n; ++i) {
cout << ans[i] << ' ';
}
} else {
cout << -1 << ' ';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) {
solve();
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int>& p1, pair<int, int>& p2) {
if (p1.first < p2.first) {
return true;
} else if (p1.first == p2.first) {
return p1.second < p2.second;
} else
return false;
}
int main() {
int T;
vector<pair<int, int> > v1;
vector<pair<int, int> > v2;
cin >> T;
while (T--) {
v1.clear();
v2.clear();
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
v1.push_back({l, r});
}
v2 = v1;
sort(v1.begin(), v1.end());
int sep = -1;
int maxr = v1[0].second;
for (int i = 1; i < v1.size(); i++) {
if (v1[i].first > maxr) {
sep = v1[i].first;
break;
}
maxr = max(maxr, v1[i].second);
}
if (sep == -1) {
cout << -1 << '\n';
continue;
}
for (int i = 0; i < v2.size(); i++) {
if (v2[i].second < sep)
cout << 1 << ' ';
else
cout << 2 << ' ';
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
vector<pair<pair<int, int>, int> > vc;
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
vc.push_back({{l, r}, i});
}
sort(vc.begin(), vc.end());
int mn = vc[0].first.first, mx = vc[0].first.second, pos = vc[0].second;
int ans[100005];
ans[pos] = 1;
bool f = 0;
for (int i = 1; i < vc.size(); i++) {
if (vc[i].first.first > mx) {
for (int j = i; j < vc.size(); j++) {
pos = vc[j].second;
ans[pos] = 2;
}
f = 1;
break;
} else {
mn = min(vc[i].first.first, mn);
mx = max(vc[i].first.second, mx);
pos = vc[i].second;
ans[pos] = 1;
}
}
if (!f) {
cout << "-1\n";
} else {
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, l, r;
cin >> n;
map<pair<int, int>, int> m;
vector<pair<int, int> > V(n);
for (int i = 0; i < n; i++) cin >> V[i].first >> V[i].second;
bool possible = true;
vector<pair<int, int> > B(V);
sort(B.begin(), B.end());
m[B[0]] = 1;
int right_bound = B[0].second;
for (int i = 1; i < n; i++) {
if (B[i].first <= right_bound) {
if (i == n - 1) {
possible = false;
cout << -1;
}
right_bound = max(right_bound, B[i].second);
m[B[i]] = 1;
} else {
while (i < n) m[B[i++]] = 2;
}
}
if (possible)
for (auto x : V) cout << m[x] << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool compare(int a, int b) { return a > b; }
bool compare1(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
bool compare2(pair<int, int> a, pair<int, int> b) {
return a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int idx = 0; idx < t; idx++) {
int n;
cin >> n;
vector<pair<int, int> > vp(n);
int mini = INT_MAX;
int maxi = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> vp[i].first >> vp[i].second;
mini = min(mini, vp[i].first);
maxi = max(maxi, vp[i].second);
}
vector<pair<int, int> > vp1 = vp;
sort(vp.begin(), vp.end(), compare1);
int idx1 = 0;
for (int i = 0; i < n; i++) {
if (idx1 != 0 && vp[idx1 - 1].first <= vp[i].second) {
while (idx1 != 0 && vp[idx1 - 1].first <= vp[i].second) {
vp[idx1 - 1].second = max(vp[idx1 - 1].second, vp[i].second);
vp[idx1 - 1].first = min(vp[idx1 - 1].first, vp[i].first);
idx1--;
}
} else
vp[idx1] = vp[i];
idx1++;
}
if (idx1 > 1) {
int idx2 = vp[0].first;
int idx3 = vp[0].second;
for (int i = 0; i < n; i++) {
if (vp1[i].first >= idx2 && idx3 >= vp1[i].second) {
cout << 1;
} else {
cout << 2;
}
cout << " ";
}
} else {
cout << -1;
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, res = -1, i, t1, t2, tt;
vector<pair<int, int> > vp, vp2;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t1 >> t2;
vp.push_back(make_pair(t1, t2));
vp2.push_back(make_pair(t1, t2));
}
sort(vp2.begin(), vp2.end());
tt = vp2[0].second;
for (i = 1; i < n; i++) {
tt = max(tt, vp2[i - 1].second);
if (vp2[i].first > tt) res = vp2[i].first;
}
if (res == -1)
cout << -1 << endl;
else
for (i = 0; i < n; i++) {
if (vp[i].second < res) {
if (i < (n - 1))
cout << 1 << " ";
else
cout << 1 << endl;
} else {
if (i < (n - 1))
cout << 2 << " ";
else
cout << 2 << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1e18;
const int MX = 100001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<pair<int, int>, int>> v(n);
vector<int> st(n, 2);
int l, r;
for (int i = 0; i <= (n - 1); i++) {
cin >> l >> r;
v[i] = make_pair(make_pair(l, r), i);
}
sort(v.begin(), v.end());
int end = v[0].first.second;
st[v[0].second] = 1;
int i = 1;
while (end >= v[i].first.first && i < n) {
end = max(end, v[i].first.second);
st[v[i].second] = 1;
i++;
}
if (i == n) {
cout << "-1\n";
continue;
}
for (int j = 0; j <= (n - 1); j++) cout << st[j] << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
const int N = 2e5 + 10;
vector<pair<pair<int, int>, int> > seg;
int mini[N];
int fin[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
seg.clear();
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
seg.push_back(make_pair(make_pair(r, l), i));
}
mini[n] = N;
sort(seg.begin(), seg.end());
for (int i = n - 1; i >= 0; i--)
mini[i] = min(mini[i + 1], seg[i].first.second);
int ans = -1;
for (int i = 0; i < n - 1; i++) {
if (seg[i].first.first < mini[i + 1]) {
ans = i;
break;
}
}
if (ans == -1)
cout << -1 << endl;
else {
for (int i = 0; i <= ans; i++) fin[seg[i].second] = 1;
for (int i = ans + 1; i < n; i++) fin[seg[i].second] = 2;
for (int i = 1; i <= n; i++) cout << fin[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, id;
} s[100010];
int cmp(node a, node b) {
if (a.l == b.l)
return a.r < b.r;
else
return a.l < b.l;
}
int ans[100010];
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
memset(ans, 0, sizeof(ans));
int l, r;
for (int i = 1; i <= n; i++) {
cin >> l >> r;
s[i] = (node){l, r, i};
}
sort(s + 1, s + n + 1, cmp);
int x = s[1].r;
ans[s[1].id] = 1;
int flag = 0;
for (int i = 2; i <= n; i++)
if (s[i].l <= x) {
x = max(x, s[i].r);
ans[s[i].id] = 1;
} else
flag = 1;
if (!flag)
puts("-1");
else {
for (int i = 1; i <= n; i++) printf("%d ", ans[i] + 1);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
struct tacka {
int val;
int ind;
int t;
};
vector<tacka> v;
bool cmp(tacka a, tacka b) {
if (a.val == b.val) {
return a.t < b.t;
} else {
return a.val < b.val;
}
}
int sta[100005];
void solve() {
cin >> n;
v.clear();
for (int(i) = (1); (i) <= (n); ++(i)) {
int a, b;
cin >> a >> b;
v.push_back({a, i, 0});
v.push_back({b, i, 1});
}
sort(v.begin(), v.end(), cmp);
int otvoreni = 0;
int m = v.size() - 1;
bool moze = 0;
int koji = 0;
for (int(i) = (0); (i) <= (m - 1); ++(i)) {
if (v[i].t == 0)
otvoreni++;
else
otvoreni--;
if (!moze)
sta[v[i].ind] = 1;
else
sta[v[i].ind] = 2;
if (otvoreni == 0) {
moze = 1;
koji = v[i].ind;
}
}
if (moze) {
for (int(i) = (1); (i) <= (n); ++(i)) {
cout << sta[i] << " ";
}
cout << endl;
} else {
cout << -1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int num, tc, k;
scanf("%lld", &tc);
while (tc--) {
scanf("%lld", &num);
vector<pair<pair<long long int, long long int>, long long int> > vcp(num);
vector<long long int> ans(num);
for (long long int i = 0; i < num; i++) {
cin >> vcp[i].first.first >> vcp[i].first.second;
vcp[i].second = i;
}
bool check = false;
sort(vcp.begin(), vcp.end());
long long int mx1 = 0;
for (long long int i = 0; i < num; i++) {
if (i != 0 && mx1 < vcp[i].first.first) {
for (long long int j = 0; j < i; j++) ans[vcp[j].second] = 1;
for (long long int j = i; j < num; j++) ans[vcp[j].second] = 2;
check = true;
break;
}
mx1 = max(mx1, vcp[i].first.second);
}
if (check == false)
cout << "-1" << endl;
else {
for (long long int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long n = 0;
const long long mod = 1e9 + 7;
long long tt = 0;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long m) {
if (y == 0) return 1;
if (y == 1) return x;
long long cur = power(x, y / 2, m);
cur = (cur % m * cur % m);
if ((y & 1)) cur = (cur % m * x % m) % m;
return cur;
}
long long modinv(long long x, long long m) { return power(x, m - 2, m) % m; }
void pre_solve() {}
void sol(long long tc) {
cin >> n;
vector<vector<long long> > arr(n, vector<long long>(3));
for (long long i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
arr[i][2] = i;
}
sort(arr.begin(), arr.end());
long long y = arr[0][1], idx = 0;
for (idx = 1; idx < n; idx++) {
if (arr[idx][0] > y)
break;
else {
y = max(arr[idx][1], y);
}
}
if (idx == n)
cout << -1 << endl;
else {
long long ans[n];
for (long long i = 0; i < idx; i++) {
ans[arr[i][2]] = 1;
}
for (long long i = idx; i < n; i++) ans[arr[i][2]] = 2;
for (long long i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long tc = 1;
cin >> tc;
while (tc--) {
tt++;
sol(tc);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct range {
int a;
int b;
};
range arr[400000];
int mark[400000];
int main() {
int t;
scanf("%d", &t);
for (int y = 0; y < t; y++) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &arr[i].a, &arr[i].b);
mark[i] = 0;
}
int l = arr[0].a;
int r = arr[0].b;
for (int k = 0; k < 3400; k++) {
for (int i = 0; i < n; i++) {
if (arr[i].a >= l and arr[i].a <= r) {
l = min(l, arr[i].a);
r = max(r, arr[i].b);
mark[i] = 1;
} else if (arr[i].b >= l and arr[i].b <= r) {
l = min(l, arr[i].a);
r = max(r, arr[i].b);
mark[i] = 1;
} else if (l >= arr[i].a and l <= arr[i].b) {
l = min(l, arr[i].a);
r = max(r, arr[i].b);
mark[i] = 1;
} else if (r >= arr[i].a and r <= arr[i].b) {
l = min(l, arr[i].a);
r = max(r, arr[i].b);
mark[i] = 1;
}
}
}
bool flag = false;
for (int i = 0; i < n; i++) {
if (mark[i] == 0) {
flag = true;
}
}
if (!flag) {
printf("-1\n");
} else {
for (int i = 0; i < n; i++) {
if (mark[i] == 1) {
printf("1 ");
} else {
printf("2 ");
}
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int t;
cin >> t;
while (t--) {
vector<pair<int, pair<int, int>>> v;
int n, x, y;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
v.push_back({x, {y, i}});
}
sort(v.begin(), v.end());
int m1 = 0, m2 = -1, flag = 1;
int ans[n + 3];
ans[v[0].second.second] = 1;
m1 = v[0].second.first;
for (int i = 1; i <= n - 1; i++) {
if (v[i].first <= m1) {
ans[v[i].second.second] = 1;
m1 = max(m1, v[i].second.first);
} else
m2 = i, ans[v[i].second.second] = 2;
}
if (m2 == -1) {
cout << -1 << '\n';
continue;
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int N = 1e5 + 5;
int n;
tuple<int, int, int> v[N];
int ans[N];
bool go(int i, int j, int k) {
int Li, Lj, Lk, Ri, Rj, Rk;
tie(Li, Ri, ignore) = v[i];
tie(Lj, Rj, ignore) = v[j];
tie(Lk, Rk, ignore) = v[k];
int l = max(Li, max(Lj, Lk));
int r = max(Ri, max(Rj, Rk));
return (l <= r);
}
void go() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d %d", &l, &r);
v[i] = make_tuple(l, r, i);
}
sort(v, v + n);
int r, id;
tie(ignore, r, id) = v[0];
ans[id] = 1;
int at = 0;
for (int i = 1; i < n; i++) {
int L, R, id;
tie(L, R, id) = v[i];
if (L > r) at = 1;
ans[id] = at + 1;
r = max(r, R);
}
bool f = false;
for (int i = 0; i < n; i++)
if (ans[i] == 2) f = true;
if (!f) {
printf("-1\n");
return;
}
for (int i = 0; i < n; i++) printf("%d%c", ans[i], " \n"[i == n - 1]);
}
int main(void) {
int T;
scanf("%d", &T);
while (T--) go();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
struct Node {
int fi, se, idx;
} arr[100005];
int res[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t, n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i].fi >> arr[i].se;
arr[i].idx = i;
}
sort(arr, arr + n, [](Node a, Node b) {
if (a.fi == b.fi) {
return a.se < b.se;
}
return a.fi < b.fi;
});
bool switched = false;
int lastgr = 1, span;
for (int i = 0; i < n; i++) {
if (i == 0) {
span = arr[i].se;
res[arr[i].idx] = lastgr;
continue;
}
if (arr[i].fi <= span) {
res[arr[i].idx] = lastgr;
span = max(arr[i].se, span);
} else {
lastgr = (lastgr == 1 ? 2 : 1);
switched = true;
res[arr[i].idx] = lastgr;
span = arr[i].se;
}
}
if (switched) {
for (int i = 0; i < n; i++) {
cout << res[i] << ' ';
}
cout << '\n';
} else {
cout << -1 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void dbg_vector(const T& v) {
for (size_t i = 0; i < v.size(); ++i) cout << v[i] << " ";
cout << endl;
}
void dbg() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg(Head H, Tail... T) {
cerr << H << ' ';
dbg(T...);
}
struct pair_hash {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto h1 = std::hash<T1>{}(p.first);
auto h2 = std::hash<T2>{}(p.second);
return h1 ^ h2;
}
};
inline long long lmin(long long a, long long b) {
if (a < b) return a;
return b;
}
inline long long lmax(long long a, long long b) {
if (a > b) return a;
return b;
}
inline long long labs(long long a) {
if (a < 0) return -a;
return a;
}
const long long INF = 1e18;
const long long P_HASH = 31;
const long long MOD = 1e9 + 7;
const long double EPS = 1e-8;
const long double PI = atan(1) * 4;
struct e {
int f, s, t;
e(){};
e(int f, int s, int t) : f(f), s(s), t(t){};
};
bool cmp(const e& a, const e& b) {
if (a.f < b.f) return true;
if (a.f > b.f) return false;
if (a.s < b.s) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<e> ev;
for (int i = 0; i <= n - 1; ++i) {
int l, r;
cin >> l >> r;
ev.push_back(e(l, 1, i));
ev.push_back(e(r, 2, i));
}
sort(ev.begin(), ev.end(), cmp);
int g = 1;
int cur = 0;
vector<int> group(n);
for (int i = 0; i <= 2 * n - 1; ++i) {
if (ev[i].s == 1) {
if (cur == 0) {
g = 1 - g;
}
group[ev[i].t] = g;
cur++;
} else {
cur--;
}
}
bool was_0 = false, was_1 = false;
for (int i = 0; i <= n - 1; ++i)
if (group[i] == 0) {
was_0 = true;
} else
was_1 = true;
if (!was_0 || !was_1) {
cout << -1 << endl;
continue;
}
for (int i = 0; i <= n - 1; ++i) cout << (group[i] + 1) << ' ';
cout << '\n';
}
}
|
#include <bits/stdc++.h>
int main() {
long int i, j, n, w, x, t, y, a, b, count, v;
long int g1[4];
long int s[100001][2];
scanf("%ld", &t);
for (y = 0; y < t; y++) {
count = 0;
scanf("%ld", &n);
for (i = 0; i < n; i++) {
scanf("%ld %ld", &s[i][0], &s[i][1]);
}
g1[0] = s[0][0];
g1[1] = s[0][1];
for (x = 0; x < (n / 50) + 100; x++) {
for (a = 0; a < n; a++) {
if ((g1[0] <= s[a][0]) && (g1[1] >= s[a][0])) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else if (g1[0] <= s[a][1] && g1[1] >= s[a][1]) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else if (g1[0] >= s[a][0] && g1[0] <= s[a][1]) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else if (g1[1] >= s[a][0] && g1[1] <= s[a][1]) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else
;
}
a = n;
while (a) {
a -= 1;
if ((g1[0] <= s[a][0]) && (g1[1] >= s[a][0])) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else if (g1[0] <= s[a][1] && g1[1] >= s[a][1]) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else if (g1[0] >= s[a][0] && g1[0] <= s[a][1]) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else if (g1[1] >= s[a][0] && g1[1] <= s[a][1]) {
if (g1[0] > s[a][0]) {
g1[0] = s[a][0];
}
if (g1[1] < s[a][1]) {
g1[1] = s[a][1];
}
} else
;
}
}
for (x = 0; x < n; x++) {
if (g1[0] <= s[x][0] && g1[1] >= s[x][0]) {
count += 1;
}
}
if (count == n) {
printf("-1");
goto end;
} else {
for (x = 0; x < n; x++) {
if (g1[0] <= s[x][0] && g1[1] >= s[x][0]) {
printf("1 ");
} else {
printf("2 ");
}
}
}
end:
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAX = 1e7;
int arr[MAX];
bool cmp(pair<int, pair<int, int> > &l, pair<int, pair<int, int> > &r) {
if (l.first < r.first) return 1;
if (l.first > r.first) return 0;
if (l.second.first < r.second.first) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, l, r;
cin >> n;
vector<int> v;
vector<pair<int, pair<int, int> > > p;
for (int i = 0; i < n; i++) {
cin >> l >> r;
p.push_back({r, {l, i}});
}
sort(p.begin(), p.end(), cmp);
int color = 1, x = p[n - 1].second.first, pos = n - 2;
arr[p[n - 1].second.second] = 1;
for (int i = n - 2; i >= 0; i--) {
if (p[i].first >= x) {
arr[p[i].second.second] = 1;
x = min(x, p[i].second.first);
} else {
pos = i;
color = 2;
break;
}
}
for (int i = pos; i >= 0; i--) arr[p[i].second.second] = 2;
if (color == 1)
cout << "-1" << endl;
else {
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int Q;
scanf("%d", &Q);
for (int q = 0; q < Q; ++q) {
int N;
scanf("%d", &N);
vector<pair<int, int>> segs(N);
for (auto& seg : segs) {
scanf("%d %d", &seg.first, &seg.second);
}
vector<int> idx(N);
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(),
[&](int a, int b) { return segs[a] < segs[b]; });
vector<int> ans(N);
int g = 1, l = segs[idx[0]].second;
bool judge = false;
for (int i : idx) {
if (segs[i].first > l) {
judge = true;
g = 3 - g;
}
ans[i] = g;
l = max(l, segs[i].second);
}
if (!judge) {
printf("-1");
} else {
for (int g : ans) {
printf("%d ", g);
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int tt;
cin >> tt;
for (int t = 0; t < tt; t++) {
int n;
cin >> n;
vector<pair<int, int>> otr(n);
vector<pair<pair<int, int>, int>> for_sort;
vector<int> ans(n, 2);
for (int i = 0; i < n; i++) {
cin >> otr[i].first >> otr[i].second;
for_sort.push_back({otr[i], i});
}
sort(for_sort.begin(), for_sort.end());
int fn = for_sort[0].first.second;
bool flag = true;
for (int i = 0; i < n; i++) {
if (fn >= for_sort[i].first.first) {
fn = max(fn, for_sort[i].first.second);
continue;
}
for (int j = i - 1; j >= 0; j--) {
ans[for_sort[j].second] = 1;
}
flag = false;
break;
}
if (flag) {
cout << -1 << '\n';
continue;
}
for (auto x : ans) cout << x << " ";
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct pii {
int l, r, p, v;
} s[maxn];
int ans[maxn];
bool cmp(pii a, pii b) { return a.l < b.l; }
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int a, b;
cin >> a >> b;
s[i] = {a, b, i, 0};
}
sort(s + 1, s + 1 + n, cmp);
s[0] = {0, 0, 0, 0};
s[n + 1] = {210000, 210000, n + 1, 0};
int flag = 0;
int rr = s[1].r;
for (int i = 2; i <= n; ++i) {
if (s[i].l > rr) {
s[i].v = s[i - 1].v ^ 1;
flag = 1;
} else {
s[i].v = s[i - 1].v;
}
rr = max(rr, s[i].r);
}
if (!flag) {
cout << -1 << endl;
return;
}
for (int i = 1; i <= n; ++i) ans[s[i].p] = s[i].v;
for (int i = 1; i <= n; ++i) cout << ans[i] + 1 << " ";
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
int T;
cin >> T;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
map<int, int> ma;
priority_queue<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int>>,
greater<pair<pair<int, int>, int>>>
pq;
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
pq.push({{l, r}, i});
}
int currcol = 1;
int prevrMax = -99;
int cnt2 = 0;
while (!pq.empty()) {
pair<pair<int, int>, int> to = pq.top();
pq.pop();
int tl = to.first.first;
int tr = to.first.second;
int ind = to.second;
if (currcol == 2) {
ma.insert({ind, 2});
} else if (currcol == 1) {
if (prevrMax == -99) {
ma.insert({ind, 1});
prevrMax = tr;
} else if (tl > prevrMax) {
currcol == 2;
ma.insert({ind, 2});
cnt2++;
} else {
ma.insert({ind, 1});
prevrMax = max(prevrMax, tr);
}
}
}
if (cnt2 == 0) {
cout << -1 << endl;
continue;
} else {
for (auto it = ma.begin(); it != ma.end(); it++) {
cout << it->second << " ";
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
unsigned long long t;
cin >> t;
while (t--) {
int n;
cin >> n;
map<int, vector<int>> mp;
vector<pair<int, pair<int, int>>> vv;
vector<int> ans(n, 0);
for (unsigned long long i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
vv.push_back({l, {r, i}});
}
sort(vv.begin(), vv.end());
for (unsigned long long i = 0; i < n; i++) {
int l = vv[i].first, r = vv[i].second.first;
int idx = vv[i].second.second;
mp[l].push_back(idx);
mp[r + 1].push_back(-1);
}
int cn = 0;
int change = 1;
int once = 0;
for (auto i : mp) {
for (auto j : i.second) {
if (j == -1)
cn--;
else
ans[j] = change, once = 1, cn++;
if (once == 1 && cn == 0) change = 2;
}
}
int theek = 0;
for (unsigned long long i = 0; i < n; i++) {
if (ans[i] == 2) theek++;
}
if (theek == 0) {
cout << -1 << endl;
} else {
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<vector<int> > a;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
vector<int> v{l, r, i};
a.push_back(v);
}
sort(a.begin(), a.end());
int res[n], flag = 2, lim = 0, check = 0;
for (int i = 0; i < n; i++) {
if (lim < a[i][0]) {
flag = (flag == 1) ? 2 : 1;
if (i) check = 1;
}
lim = max(lim, a[i][1]);
res[a[i][2]] = flag;
}
if (check) {
for (int i = 0; i < n; i++) cout << res[i] << " ";
cout << endl;
} else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k[100000], a = 0, l = -15, r = 0, x, y, s;
pair<int, int> c[100000];
cin >> s;
for (int h = 0; h < s; h++) {
cin >> n;
for (int q = 0; q < n; q++) {
cin >> x >> y;
k[q] = x;
c[q] = make_pair(x, y);
}
sort(c, c + n);
r = c[0].second;
for (int j = 1; j < n; j++) {
r = max(r, c[j - 1].second);
if (r < c[j].first) {
a = c[j].first;
l = 14;
break;
}
}
if (l < 0) {
cout << -1;
} else {
for (int w = 0; w < n; w++) {
if (k[w] < a) {
cout << 1 << " ";
}
if (k[w] >= a) {
cout << 2 << " ";
}
}
}
l = -15;
a = 0;
r = 0;
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<pair<int, int>, int> > segs;
inline bool read() {
if (!(cin >> n)) return false;
segs.resize(n);
for (int i = 0; i < n; i++) {
cin >> segs[i].first.first >> segs[i].first.second;
segs[i].second = i;
}
return true;
}
bool cmp(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
if (a.first.second != b.first.second) return a.first.second < b.first.second;
if (a.first.first != b.first.first) return a.first.first < b.first.first;
return a.second < b.second;
}
inline void solve() {
sort(segs.begin(), segs.end(), cmp);
int mn = segs[n - 1].first.first;
for (int i = n - 2; i >= 0; i--) {
if (segs[i].first.second < mn) {
vector<int> ts(n, 2);
for (int id = 0; id <= i; id++) ts[segs[id].second] = 1;
for (int t : ts) cout << t << ' ';
cerr << "haha";
cout << '\n';
return;
}
mn = min(mn, segs[i].first.first);
}
cout << -1 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int tc;
cin >> tc;
while (tc--) {
assert(read());
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long qpow(long long x, long long y) {
long long s = 1;
while (y) {
if (y & 1) s = s * x % mod;
x = x * x % mod;
y >>= 1;
}
return s;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
long long inve(long long x) {
return x == 1 ? 1 : (mod - mod / x) * inve(mod % x) % mod;
}
const int maxn = 2e5 + 5;
struct node {
int l, r, id;
};
vector<node> v;
bool cmp(node a, node b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
int ans[maxn];
int main() {
int n, t;
scanf("%d", &t);
while (t--) {
v.clear();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
v.push_back((node){l, r, i});
}
sort(v.begin(), v.end(), cmp);
int st = v[0].l, ed = v[0].r;
int flag = 0;
ans[v[0].id] = 1;
for (int i = 1; i < n; i++) {
node tmp = v[i];
if (tmp.l <= st && tmp.r >= ed) {
st = tmp.l;
ed = tmp.r;
ans[v[i].id] = 1;
} else if (tmp.l <= ed && tmp.r <= ed) {
ans[v[i].id] = 1;
} else if (tmp.l <= ed && tmp.r > ed) {
ed = tmp.r;
ans[v[i].id] = 1;
} else if (tmp.l > ed) {
flag = 1;
ans[v[i].id] = 2;
}
}
if (flag) {
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int t, n, l, r, mn[N];
vector<pair<pair<int, int>, int> > v;
vector<pair<int, int> > ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
v.clear();
ans.clear();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l >> r;
v.push_back({{l, r}, i});
}
for (int i = 0; i < n; i++) mn[i] = 1e9;
sort(v.begin(), v.end(),
[&](pair<pair<int, int>, int> p1, pair<pair<int, int>, int> p2) {
if (p1.first.second != p2.first.second)
return p1.first.second < p2.first.second;
return p1.first.first < p2.first.first;
});
mn[n - 1] = v.back().first.first;
for (int i = n - 2; i >= 0; i--) mn[i] = min(mn[i + 1], v[i].first.first);
int last = -1;
for (int i = 0; i < n - 1; i++) {
if (v[i].first.second < mn[i + 1]) {
last = i;
break;
}
}
if (last == -1) {
cout << -1 << '\n';
continue;
}
for (int i = 0; i <= last; i++) ans.push_back({v[i].second, 1});
for (int i = last + 1; i < n; i++) ans.push_back({v[i].second, 2});
sort(ans.begin(), ans.end());
for (pair<int, int> p : ans) cout << p.second << " ";
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ifstream fin("input.txt", ios::in);
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cout << setprecision(10);
cout << fixed;
int t;
cin >> t;
int in1[200010];
int in2[200010];
while (t--) {
int n;
cin >> n;
set<pair<int, int> > d, ans;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
in1[i] = a;
in2[i] = b;
d.insert({a, b});
}
int l = d.begin()->second;
int i = 1;
int f = 0;
for (set<pair<int, int> >::iterator it = d.begin(); it != d.end(); it++) {
if (it == d.begin()) continue;
if (it->first <= l) {
l = max(l, it->second);
i++;
} else {
f = 1;
break;
}
}
if (f == 0)
cout << -1 << endl;
else {
for (set<pair<int, int> >::iterator it = d.begin(); it != d.end(); it++) {
if (i == 0) break;
ans.insert({it->first, it->second});
i--;
}
for (int i = 0; i < n; i++) {
if (ans.find({in1[i], in2[i]}) == ans.end())
cout << 1 << " ";
else
cout << 2 << " ";
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, ta, tb, has, t, X[202020], Y[202020], a[202020], b[202020],
x[202020];
pair<pair<long long, long long>, long long> A[202020], B[202020];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i <= n; i++) {
x[i] = 2;
cin >> a[i] >> b[i];
A[i] = make_pair(make_pair(a[i], b[i]), i);
}
has = -1;
long long ma = -1e18;
sort(A + 1, A + 1 + n);
for (i = 1; i <= n; i++) {
x[A[i].second] = 1;
ma = max(ma, A[i].first.second);
if (i < n && A[i + 1].first.first > ma) {
has = 1;
break;
}
}
if (has == -1)
cout << -1 << "\n";
else {
for (i = 1; i <= n; i++)
if (i < n)
cout << x[i] << " ";
else
cout << x[i] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, i, j, x, y;
scanf("%d", &n);
pair<pair<int, int>, int> p[n];
for (i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
p[i].first.first = x;
p[i].first.second = y;
p[i].second = i;
}
sort(p, p + n);
int l = p[0].first.first;
int r = p[0].first.second;
set<int> ans;
ans.insert(p[0].second);
int f = 0;
for (i = 1; i < n; i++) {
if (p[i].first.first <= r) {
ans.insert(p[i].second);
r = max(r, p[i].first.second);
} else {
f = 1;
break;
}
}
if (f) {
for (i = 0; i < n; i++) {
if (ans.find(i) != ans.end()) {
printf("1 ");
} else {
printf("2 ");
}
}
} else {
printf("-1");
}
printf("\n");
return;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 7;
const int mod = 998244353;
const long long INFLL = 0x3f3f3f3f3f3f3fLL;
const int INF = 0x3f3f3f3f;
using namespace std;
int t, n, vis[maxn];
struct node {
int l, r, id;
} qu[maxn];
int cmp(node a, node b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &qu[i].l, &qu[i].r);
qu[i].id = i;
}
sort(qu + 1, qu + 1 + n, cmp);
int maxx = qu[1].r, flag = 0;
;
for (int i = 1; i <= n; i++) {
if (qu[i].l > maxx) {
flag = 1;
for (int j = i; j <= n; j++) vis[qu[j].id] = 2;
break;
} else {
vis[qu[i].id] = 1;
maxx = max(maxx, qu[i].r);
}
}
if (!flag)
printf("-1\n");
else {
for (int i = 1; i <= n; i++) printf("%d ", vis[i]);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
struct data {
int lx, ry, index;
};
bool compare(data a, data b) { return a.lx < b.lx; }
int main() {
int t;
cin >> t;
while (t--) {
long n;
cin >> n;
struct data d[n];
long r, l;
map<int, int> mi;
for (int i = 1; i <= n; i++) {
cin >> l >> r;
d[i - 1].lx = l;
d[i - 1].ry = r;
d[i - 1].index = i;
}
sort(d, d + n, compare);
int start, end;
start = d[0].lx;
end = d[0].ry;
mi[d[0].index] = 1;
int flag = 0;
for (int i = 1; i < n; i++) {
if (d[i].lx >= start && d[i].lx <= end) {
if (d[i].ry > end) end = d[i].ry;
mi[d[i].index] = 1;
} else {
mi[d[i].index] = 2;
flag = 1;
}
}
if (flag == 0)
cout << -1 << endl;
else {
for (int i = 1; i <= n; i++) cout << mi[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[100005][3], idx[100005];
vector<pair<int, int> > seg;
bool cmp(pair<int, int> &x, pair<int, int> &y) {
if (x.first != y.first) return x.first < y.first;
return x.second > y.second;
}
int main() {
int l, r, i, j, t, n, ga, gb, cnt = 0, fl = 0;
cin >> t;
while (t--) {
cin >> n;
ga = 0;
gb = 0;
cnt = 0;
fl = 0;
seg.clear();
seg.push_back(make_pair(-1, 0));
for (i = 1; i <= n; i++) {
cin >> arr[i][1] >> arr[i][2];
seg.push_back(make_pair(arr[i][1], i));
seg.push_back(make_pair(arr[i][2], -i));
}
sort(seg.begin(), seg.end(), cmp);
for (i = 1; i <= 2 * n; i++) {
if (cnt == 0) {
fl = abs(fl - 1);
idx[seg[i].second] = fl + 1;
cnt++;
} else if (seg[i].second > 0) {
idx[seg[i].second] = fl + 1;
cnt++;
} else if (seg[i].second < 0)
cnt--;
if (fl == 0)
ga++;
else
gb++;
}
if (ga == 0 || gb == 0)
cout << "-1" << endl;
else {
for (i = 1; i <= n; i++) cout << idx[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct dm {
int first, second, vitri;
};
dm a[100000];
void QS(long l, long r) {
long i = l, j = r, x = a[(l + r) / 2].first, y = a[(l + r) / 2].second;
while (i <= j) {
while (a[i].first < x || (a[i].first == x && a[i].second < y)) i++;
while (a[j].first > x || (a[j].first == x && a[j].second > y)) j--;
if (i <= j) {
swap(a[i], a[j]);
i++;
j--;
}
}
if (l < j) QS(l, j);
if (i < r) QS(i, r);
}
int main() {
int n, t, flag = 0, vt[100000], danhso, maxk = 0;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
a[i].vitri = i;
}
QS(0, n - 1);
flag = 0;
maxk = 0;
for (int i = 0; i < n; i++) {
if (flag == 0 || flag == 2)
danhso = 1;
else
danhso = 2;
maxk = max(maxk, a[i].second);
if (maxk < a[i + 1].first && flag == 0) {
flag = 1;
maxk = 0;
}
vt[a[i].vitri] = danhso;
}
if (flag == 0)
cout << -1;
else
for (int i = 0; i < n; i++) cout << vt[i] << " ";
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct t {
int x;
int y;
int poz;
} v[100001];
t ras[100001];
bool f[100001];
short int tont[100001];
bool comp(t a, t b) { return (a.x < b.x || a.x == b.x && a.y < b.y); }
int main() {
int q, n, i, el, j, f1x, f1y, nr1, nr2;
cin >> q;
int k = 0;
for (i = 1; i <= q; ++i) {
cin >> n;
for (j = 1; j <= n; ++j) {
cin >> v[j].x >> v[j].y;
v[j].poz = j;
}
sort(v + 1, v + n + 1, comp);
f1x = v[1].x;
f1y = v[1].y;
tont[v[1].poz] = 1;
nr1 = 1;
nr2 = 0;
for (j = 2; j <= n; ++j) {
if (v[j].x > f1y) {
nr2++;
tont[v[j].poz] = 2;
} else {
f1y = max(f1y, v[j].y);
tont[v[j].poz] = 1;
nr1++;
}
}
if (nr1 == 0 || nr2 == 0) f[i] = 1;
for (j = 1; j <= n; ++j) {
ras[++k].x = i;
ras[k].y = tont[j];
}
}
for (i = 1; i <= k; ++i) {
if (f[ras[i].x] == 0) {
el = ras[i].x;
while (ras[i].x == el) {
cout << ras[i].y << " ";
i++;
}
cout << "\n";
i--;
} else {
el = ras[i].x;
while (ras[i].x == el) i++;
cout << "-1\n";
i--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool primeCheck(long long n) {
if (n % 2 == 0) return false;
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) return false;
}
return true;
}
string twostringdigitsum(string a, string b) {
string s = "";
while (a.size() < b.size()) {
a = '0' + a;
}
while (a.size() > b.size()) {
b = '0' + b;
}
long long c = 0;
for (long long i = a.size() - 1; i >= 0; i--) {
c += (a[i] - '0') + (b[i] - '0');
s = char((c % 10) + '0') + s;
c /= 10;
}
while (c > 0) {
s = char((c % 10) + '0') + s;
c /= 10;
}
return s;
}
long long stringdigitsum(string digits) {
long long num, total = 0;
for (int i = 0; i < digits.length(); i++) {
num = digits.at(i) - '0';
assert(0 <= num && num <= 9);
total += num;
}
return total;
}
long long integerdigitsum(long long n) {
long long sum = 0;
while (1) {
if (n < 10) {
sum += n;
break;
} else {
sum += n % 10;
n /= 10;
}
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, i, x, y;
string str;
cin >> t;
while (t--) {
vector<pair<pair<long long, long long>, long long>> p;
cin >> n;
long long ans[n + 10];
for (i = 0; i < n; i++) {
cin >> x >> y;
p.push_back(make_pair(make_pair(x, y), i));
}
sort(p.begin(), p.end());
long long mx, ck = 0;
mx = p[0].first.second;
for (i = 0; i < n; i++) {
if (p[i].first.first <= mx) {
mx = max(mx, p[i].first.second);
ans[p[i].second] = 1;
} else {
ans[p[i].second] = 2;
ck = 1;
}
}
if (!ck)
cout << "-1" << endl;
else {
for (i = 0; i < n; i++) cout << ans[i] << ' ';
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e6 + 5;
const long long inf = 2e9 + 5;
const long long MOD = 1e9 + 7;
const long long N = 2e5;
const double PI = 3.14159265358979323846;
vector<pair<long long, long long> > v, r;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
v.clear();
r.clear();
long long q;
cin >> q;
long long ma = 0;
for (long long u = 1; u <= q; u++) {
long long a, b;
cin >> a >> b;
v.push_back(make_pair(a, b));
r.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
long long i = 0;
for (i = 0; i < v.size(); i++) {
long long a, b;
a = v[i].first;
b = v[i].second;
if (i == 0)
ma = b;
else {
if (a > ma)
break;
else
ma = max(ma, b);
}
}
if (i == v.size()) {
cout << "-1\n";
continue;
}
for (long long j = 1; j <= q; j++) {
long long a, b;
a = r[j - 1].first;
b = r[j - 1].second;
if (a > ma)
cout << "2 ";
else
cout << "1 ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int ans[maxn];
struct node {
int l, r, v;
} a[maxn];
bool cmp(node a, node b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].v = i;
}
sort(a, a + n, cmp);
int flag = -1, pos = a[0].r;
for (int i = 1; i < n; i++) {
if (pos < a[i].l) {
for (int j = 0; j < i; j++) ans[a[j].v] = 1;
for (int j = i; j < n; j++) ans[a[j].v] = 2;
flag = 0;
break;
}
pos = max(pos, a[i].r);
}
if (flag == -1)
puts("-1");
else {
for (int i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powr(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b % 2) res = (a * res) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
void extentded_eucledian(long long int a, long long int b, long long int &ex,
long long int &ey) {
if (b == 0) {
ex = 1;
ey = 0;
return;
}
extentded_eucledian(b, a % b, ex, ey);
swap(ex, ey);
ey -= (a / b) * ex;
}
bool cmp(pair<pair<long long int, long long int>, long long int> &a,
pair<pair<long long int, long long int>, long long int> &b) {
if (a.first.first != b.first.first) return (a.first.first < b.first.first);
return (a.first.second < b.first.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int tc = 1;
cin >> tc;
while (tc--) {
long long int n;
cin >> n;
vector<pair<pair<long long int, long long int>, long long int>> vec;
vector<long long int> ans(n);
for (long long int i = 0; i < n; ++i) {
long long int x, y;
cin >> x >> y;
vec.push_back(make_pair(make_pair(x, y), i));
}
sort(vec.begin(), vec.end(), cmp);
long long int maxr[2] = {-1, -1}, isOK = 1, sz[2] = {0, 0};
for (long long int i = 0; i < n; ++i) {
long long int chose = (sz[1] < sz[0]);
if (maxr[1 - chose] < vec[i].first.first) {
ans[vec[i].second] = chose + 1;
maxr[chose] = max(maxr[chose], vec[i].first.second);
++sz[chose];
continue;
} else if (maxr[chose] < vec[i].first.first) {
chose = 1 - chose;
ans[vec[i].second] = chose + 1;
maxr[chose] = max(maxr[chose], vec[i].first.second);
++sz[chose];
continue;
}
isOK = 0;
break;
}
if (min(sz[0], sz[1]) == 0) isOK = 0;
if (isOK) {
for (auto lstelem : ans) cout << lstelem << " ";
cout << " \n";
} else
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, id, c;
} a[100005];
bool cmp1(node p, node q) {
if (p.l != q.l) return p.l < q.l;
return p.r < q.r;
}
bool cmp2(node p, node q) { return p.id < q.id; }
int main() {
int t, n, i, j, p, fg, mx;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d%d", &a[i].l, &a[i].r), a[i].id = i;
sort(a, a + n, cmp1);
p = 2;
for (fg = i = 0; i < n; i++) {
a[i].c = 3 - p;
mx = a[i].r;
for (j = i + 1; j < n; j++) {
if (a[j].l <= mx)
a[j].c = a[i].c;
else
break;
mx = max(mx, a[j].r);
}
if (i == 0 && j == n) {
fg = 1;
break;
}
i = j - 1;
p = 3 - p;
}
if (fg) {
puts("-1");
continue;
}
sort(a, a + n, cmp2);
for (i = 0; i < n; i++) printf("%d%c", a[i].c, i == n - 1 ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
template <typename A, size_t NNN, typename T>
void Fill(A (&array)[NNN], const T &val) {
fill((T *)array, (T *)(array + NNN), val);
}
long long MOD = 1e9 + 7;
long long n, m;
long long p;
long long a[505050];
int dp[505050][10];
int ans[505050];
int main() {
int q = in();
for (int iii = 0; iii < q; iii++) {
n = in();
vector<pair<pair<int, int>, int>> v;
for (int i = 0; i < n; i++) {
v.push_back({{in(), in()}, i});
}
sort((v).begin(), (v).end());
bool flag = true;
int mem = -1;
int temp = -1;
for (int i = 0; i < n - 1; i++) {
temp = max(temp, v[i].first.second);
if (temp < v[i + 1].first.first) {
mem = i;
}
}
if (mem == -1) {
cout << -1 << "\n";
} else {
for (int i = 0; i < mem + 1; i++) ans[v[i].second] = 1;
for (long long j = mem + 1; j <= n - 1; ++j) {
ans[v[j].second] = 2;
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
long long int cnt = 0;
long long int n;
cin >> n;
long long int arr[n];
long long int brr[n];
long long int min1, min2, max1, max2;
vector<pair<long long int, long long int> > vect;
vector<int> v;
for (auto i = 0; i < n; i++) {
long long int a, b;
cin >> a;
vect.push_back(make_pair(a, i));
cin >> arr[i];
}
sort(vect.begin(), vect.end());
long long int x = vect[0].first;
long long int y = arr[vect[0].second];
brr[vect[0].second] = 1;
for (auto i = 1; i < n; i++) {
if ((vect[i].first >= x and vect[i].first <= y) or
(arr[vect[i].second] >= x and arr[vect[i].second] <= y) or
(vect[i].first < x and arr[vect[i].second] > y)) {
brr[vect[i].second] = 1;
if (x > vect[i].first) x = vect[i].first;
if (y < arr[vect[i].second]) y = arr[vect[i].second];
} else {
cnt++;
brr[vect[i].second] = 2;
}
}
if (cnt == n or cnt == 0)
cout << "-1\n";
else {
for (auto i = 0; i < n; i++) cout << brr[i] << " ";
cout << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
int ans[MAXN];
vector<pair<pair<int, int>, int> > p;
int main() {
int t;
scanf("%d", &t);
while (t--) {
p.clear();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d %d", &l, &r);
p.push_back({{l, r}, i});
}
sort(p.begin(), p.end());
int r = p[0].first.second, k = -1;
for (int i = 1; i < n; i++) {
if (p[i].first.first > r) {
k = i;
break;
}
r = max(r, p[i].first.second);
}
if (k == -1) {
printf("-1\n");
continue;
}
for (int i = 0; i < k; i++) {
ans[p[i].second] = 1;
}
for (int i = k; i < n; i++) {
ans[p[i].second] = 2;
}
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
int n;
for (int t = 0; t < T; t++) {
cin >> n;
vector<pair<pair<int, int>, int>> v;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
v.push_back({{l, r}, i});
}
sort(v.begin(), v.end());
vector<int> r;
r.resize(n);
r[v[0].second] = 1;
bool us2 = false;
bool NON_VA_BENE = false;
int maxl = 0;
for (int i = 1; i < v.size(); i++) {
int g = -1;
if (v[maxl].first.second >= v[i].first.first) {
if (g == -1 or g == r[v[maxl].second])
g = (r[v[maxl].second] == 1) ? 1 : 2;
else {
NON_VA_BENE = true;
break;
}
}
if (g == -1)
r[v[i].second] = (r[v[i - 1].second] == 2) ? 1 : 2;
else {
r[v[i].second] = g;
}
if (r[v[i].second] == 2) us2 = true;
if (v[maxl].first.second < v[i].first.second) maxl = i;
}
if (!us2 or NON_VA_BENE) {
cout << -1 << endl;
;
continue;
}
for (auto ris : r) cout << ris << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
vector<pair<pair<long long int, long long int>, long long int>> v;
long long int i, j, q, r, t;
long long int n;
i = 0;
cin >> n;
long long int m = n;
long long int a[n + 5];
while (m--) {
cin >> q >> r;
v.push_back(make_pair(make_pair(q, r), i));
i++;
}
sort(v.begin(), v.end());
long long int p = 1, mx = 0;
for (i = 0; i < n; i++) {
a[v[i].second] = p;
mx = max(mx, v[i].first.second);
if (mx < v[i + 1].first.first && p == 1 && i < n - 1) {
p++;
}
}
if (p == 1) {
cout << -1 << endl;
continue;
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long mod = 1e9 + 7;
void sout() { cout << "\n"; }
template <typename T, typename... Types>
void sout(T var1, Types... var2) {
cout << var1 << " ";
sout(var2...);
}
long long n, m;
long long temp;
long long cnt;
long long ans;
long long ind;
bool static cmp(const pair<pair<long long, long long>, long long> &a,
const pair<pair<long long, long long>, long long> &b) {
if (a.first.second != b.first.second) return a.first.second < b.first.second;
if (a.first.first != b.first.first) return a.first.first < b.first.first;
return a.second < b.second;
}
void test_case() {
long long n;
vector<pair<pair<long long, long long>, long long> > segs;
cin >> n;
segs.resize(n);
for (long long i = 0; i < n; i++) {
cin >> segs[i].first.first >> segs[i].first.second;
segs[i].second = i;
}
sort(segs.begin(), segs.end(), cmp);
long long mn = segs[n - 1].first.first;
for (long long i = n - 2; i >= 0; i--) {
if (segs[i].first.second < mn) {
vector<long long> ts(n, 2);
for (long long id = 0; id <= i; id++) ts[segs[id].second] = 1;
for (long long t : ts) cout << t << ' ';
cout << '\n';
return;
}
mn = min(mn, segs[i].first.first);
}
cout << -1 << '\n';
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
long long t = 1;
cin >> t;
while (t--) {
test_case();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
for (int p = 0; p < t; p++) {
int n;
vector<pair<int, int> > s;
vector<pair<int, int> > v;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
s.push_back(make_pair(l, r));
v.push_back(make_pair(l, r));
}
sort(v.begin(), v.end());
int maxR = v[0].second;
for (int i = 1; i < n; i++) {
if (v[i].first <= maxR)
maxR = max(maxR, v[i].second);
else
break;
}
if (maxR >= v[n - 1].first)
cout << "-1\n";
else {
for (int i = 0; i < n; i++) {
if (s[i].first <= maxR)
cout << "1 ";
else
cout << "2 ";
}
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int q, n, l, r;
cin >> q;
while (q--) {
cin >> n;
vector<tuple<int, int, int> > segs;
for (int i = 0; i < int(n); i++) {
cin >> l >> r;
segs.push_back(tuple<int, int, int>(l, 0, i));
segs.push_back(tuple<int, int, int>(r, 1, i));
}
sort(segs.begin(), segs.end());
vector<int> grp(n, 0);
int cur = 0;
bool ok = false;
for (int i = 0; i < int(((int)(segs).size())); i++) {
auto p = segs[i];
if (ok) {
grp[get<2>(p)] = 2;
continue;
}
if (get<1>(p) == 0)
cur++;
else
cur--;
grp[get<2>(p)] = 1;
if (cur == 0 && i < ((int)(segs).size()) - 1) ok = true;
}
if (!ok)
cout << -1;
else
for (int i : grp) cout << i << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int t, i, j, k, n, temp, flag;
int main() {
fast();
cin >> t;
while (t--) {
cin >> n;
map<pair<int, int>, int> ans;
vector<pair<int, int> > v(n), u(n);
int c[3] = {0};
for (i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
u[i].first = v[i].first;
u[i].second = v[i].second;
}
sort(v.begin(), v.end());
ans[v[0]] = 1;
int r = v[0].second;
int ca = 1;
c[ca]++;
for (i = 1; i < n;) {
if (v[i].first <= r) {
while (v[i].first <= r && i < n) {
ans[v[i]] = ca;
r = max(r, v[i].second);
c[ca]++;
i++;
}
} else {
if (c[1] == 0) {
ca = 1;
ans[v[i]] = ca;
c[ca]++;
} else {
ca = 2;
ans[v[i]] = ca;
c[ca]++;
}
i++;
r = v[i].second;
}
}
if (c[1] == 0 || c[2] == 0) {
cout << -1 << '\n';
} else {
for (i = 0; i < n; i++) {
cout << ans[u[i]] << ' ';
}
cout << '\n';
;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 2, oo = 1e9, M = 1e6;
long long const OO = 1e18;
double const eps = 1e-6, PI = acos(-1);
int mod = oo + 7;
int n, an[N];
pair<pair<int, int>, int> seg[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> seg[i].first.first >> seg[i].first.second;
seg[i].second = i;
an[i] = 0;
}
sort(seg, seg + n);
int r = seg[0].first.second;
int i = 1;
for (; i < n; i++)
if (seg[i].first.first > r)
break;
else
r = max(r, seg[i].first.second);
if (i == n) {
cout << -1 << '\n';
continue;
}
for (int j = 0; j < i; j++) an[seg[j].second] = 1;
for (int j = i; j < n; j++) an[seg[j].second] = 2;
bool y = 0;
for (int i = 0; i < n - 1; i++)
if (an[i] != an[i + 1]) y = 1;
if (y)
for (int i = 0; i < n; i++) cout << an[i] << ' ';
else
cout << -1;
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, x = -1, c, i, y, n, k, j, idx, res, flag;
vector<long long> v1, v2;
string s;
vector<pair<long long, long long> > vp, vp1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
cin >> n;
for (i = 0; i < n; i++)
cin >> x >> y, vp.push_back(make_pair(x, y)),
vp1.push_back(make_pair(x, y));
sort(vp.begin(), vp.end());
x = vp[0].second;
for (i = 1; i < vp.size(); i++) {
if (x >= vp[i].first && vp[i].second >= x) {
idx = i, x = vp[i].second;
}
}
if (idx + 1 == vp.size())
flag = 1;
else {
for (i = 0; i < vp1.size(); i++) {
if (x >= vp1[i].second)
res++, v2.push_back(1);
else
v2.push_back(2);
}
}
if (v2.size() == res || flag)
cout << -1 << "\n";
else {
for (i = 0; i < v2.size(); i++) cout << v2[i] << " ";
cout << "\n";
}
vp.clear();
vp1.clear();
v2.clear();
idx = 0;
flag = 0;
res = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100005;
using namespace std;
struct node {
int l, r, id;
bool friend operator<(const node u, const node v) {
if (u.l == v.l) return u.r < v.r;
return u.l < v.l;
}
} p[maxn];
int vis[maxn];
int main() {
int t, n;
cin >> t;
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &p[i].l, &p[i].r);
p[i].id = i;
vis[i] = 2;
}
sort(p + 1, p + 1 + n);
int R = p[1].r;
vis[p[1].id] = 1;
bool fg = 0;
for (int i = 2; i <= n; i++) {
if (p[i].l <= R) {
R = max(R, p[i].r);
vis[p[i].id] = 1;
} else {
fg = 1;
break;
}
}
if (fg) {
for (int i = 1; i <= n; i++) {
printf("%d ", vis[i]);
}
} else {
printf("-1");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long i, a[n];
pair<pair<long long, long long>, long long> p[n];
for (i = 0; i < n; i++) {
cin >> p[i].first.first >> p[i].first.second;
p[i].second = i;
}
long long l1, r1, l2 = LONG_MAX, r2 = LONG_MIN, ind = LONG_MAX;
sort(p, p + n);
l1 = p[0].first.first;
r1 = p[0].first.second;
a[p[0].second] = 1;
for (i = 1; i < n; i++) {
if (p[i].first.first > r1) {
l2 = p[i].first.first;
r2 = p[i].first.second;
a[p[i].second] = 2;
ind = i;
break;
} else {
r1 = max(r1, p[i].first.second);
a[p[i].second] = 1;
}
}
for (i = ind; i < n; i++) a[p[i].second] = 2;
if ((l2 != LONG_MAX && r2 != LONG_MIN)) {
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
} else
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
struct Data {
int l, r, id;
Data(int l = 0, int r = 0, int id = 0) : l(l), r(r), id(id) {}
} A[100010], B[100010];
bool cmp_r(Data &a, Data &b) {
if (a.r != b.r) return a.r < b.r;
return a.l < b.l;
}
bool cmp_l(Data &a, Data &b) {
if (a.l != b.l) return a.l < b.l;
return a.r < b.r;
}
int N, Q;
bool mk[100010], ok;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
for (cin >> Q; Q-- > 0;) {
cin >> N;
for (int i = 1; i <= N; ++i) mk[i] = false;
ok = false;
for (int i = 1; i <= N; ++i)
cin >> A[i].l >> A[i].r, A[i].id = i, B[i] = A[i];
sort(A + 1, A + 1 + N, &cmp_l);
sort(B + 1, B + 1 + N, &cmp_r);
for (int i = 1, j = 1, ri = 0; !ok && i <= N && j <= N; ++i) {
if (mk[B[i].id] == true) continue;
ri = max(ri, B[i].r);
while (j <= N && (ri >= A[j].l || mk[A[j].id] == true)) {
mk[A[j].id] = true;
ri = max(ri, A[j].r);
++j;
}
if (i <= N && j <= N) ok = true;
}
if (!ok)
cout << -1 << '\n';
else {
for (int i = 1; i <= N; ++i) cout << mk[i] + 1 << ' ';
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> x, pair<long long, long long> y) {
if (x.first != y.first) return x.first < y.first;
return x.second < y.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n, i, j, k, x, y;
cin >> n;
pair<pair<long long, long long>, long long> f[n];
for (i = 0; i < n; i++) {
cin >> x >> y;
f[i].first.first = x;
f[i].first.second = y;
f[i].second = i;
}
sort(f, f + n);
pair<long long, long long> xz, res;
long long idx = 0;
long long my = f[0].first.second;
int found = 0;
for (i = 1; i < n; i++) {
xz = f[i].first;
if (xz.first > my) {
idx = i;
found = 1;
res = xz;
break;
}
my = max(my, xz.second);
}
if (found == 1) {
int c[n];
for (i = 0; i < n; i++) {
if (i < idx)
c[f[i].second] = 1;
else
c[f[i].second] = 2;
}
for (i = 0; i < n; i++) cout << c[i] << ' ';
cout << '\n';
} else {
cout << "-1\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 200;
int T, n, ans[N];
struct node {
int x, y, id;
bool operator<(const node rhs) const {
if (x != rhs.x)
return x < rhs.x;
else
return y < rhs.y;
}
} G[N];
int main() {
for (scanf("%d", &T); T--;) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &G[i].x, &G[i].y), G[i].id = i;
sort(G + 1, G + n + 1);
int l = G[1].x, r = G[1].y, x = 2147483647, y = 0;
ans[G[1].id] = 1;
for (int i = 2; i <= n; i++)
if (G[i].x <= r)
r = max(r, G[i].y), ans[G[i].id] = 1;
else {
x = min(G[i].x, x);
y = max(y, G[i].y);
ans[G[i].id] = 2;
}
if (x <= r and x >= l or y <= r and y >= l or y == 0)
printf("-1\n");
else {
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const int INF = 2e9;
const int MX = 200005;
const int MOD = 1000000007;
const double PI = acos(-1.0);
struct ele {
int l, r;
ele(){};
ele(int l, int r) : l(l), r(r){};
bool operator<(const ele &e) const {
if (l == e.l) return r > e.r;
return l < e.l;
}
};
int main() {
int tc = ({
int a;
read(a);
a;
});
while (tc--) {
int n = ({
int a;
read(a);
a;
});
vector<ele> res;
for (int i = 0; i < n; i++) {
int l = ({
int a;
read(a);
a;
}),
r = ({
int a;
read(a);
a;
});
res.push_back(ele(l, r));
}
vector<ele> v;
v.assign(res.begin(), res.end());
sort(v.begin(), v.end());
int pos = -1;
int mxright = v[0].r;
for (int i = 0; i < n; i++) {
if (v[i].l > mxright) {
pos = v[i].l;
break;
}
mxright = max(mxright, v[i].r);
}
if (pos == -1)
printf("-1\n");
else {
for (int i = 0; i < n; i++) {
if (res[i].l < pos)
printf("1 ");
else
printf("2 ");
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 9;
const long long int inf = 1e14;
const long long int MOD = 1e9 + 7;
const long long int mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int powm(long long int a, long long int b) {
a = a % mod;
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
int main() {
long long int t = 1;
cin >> t;
while (t--) {
long long int n;
cin >> n;
std::vector<pair<long long int, long long int> > v;
set<long long int> b;
for (int i = 0; i < n; i++) {
pair<long long int, long long int> a;
cin >> a.first >> a.second;
b.insert(a.first);
b.insert(a.second);
v.push_back(a);
}
map<long long int, long long int> comp;
long long int ct = 0;
for (auto i : b) {
comp[i] = ct++;
}
long long int here[ct];
memset(here, 0, sizeof(here));
for (auto i : v) {
here[comp[i.first]]++;
here[comp[i.second]]--;
}
long long int ans = -1, curr_sum = 0;
for (int i = 0; i < ct - 1; i++) {
curr_sum += here[i];
if (curr_sum == 0) {
ans = i;
break;
}
}
if (ans == -1) {
cout << ans << '\n';
} else {
for (auto i : v) {
if (comp[i.second] <= ans) {
cout << 1 << " ";
} else {
cout << 2 << " ";
}
}
cout << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2e5 + 17;
const int INF = (int)(1e9);
const long long mod = 998244353;
const double eps = 1e-9;
int n;
pair<int, pair<int, int> > a[MaxN];
int ans[MaxN];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first >> a[i].second.first;
a[i].second.second = i;
ans[i] = 0;
}
sort(a + 1, a + n + 1);
int R = a[1].second.first;
bool b = 0;
ans[a[1].second.second] = 1;
for (int i = 2; i <= n; ++i) {
int l = a[i].first;
int r = a[i].second.first;
int x = a[i].second.second;
if (b == 1) {
ans[x] = 2;
continue;
}
if (l > R) {
b = 1;
ans[x] = 2;
} else
ans[x] = 1, R = max(R, r);
}
if (b == 0) {
cout << -1 << "\n";
} else {
for (int i = 1; i <= n; ++i) {
cout << ans[i] << ' ';
}
cout << "\n";
}
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct section {
int index;
int start;
int end;
};
bool compare_start(section a, section b) { return a.start < b.start; }
int main() {
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int n;
cin >> n;
section sect[100000];
for (int j = 0; j < n; j++) {
sect[j].index = j;
cin >> sect[j].start >> sect[j].end;
}
sort(sect, sect + n, compare_start);
int solve[100000] = {0};
bool flag = false;
solve[sect[0].index] = 1;
int max_end = sect[0].end;
for (int j = 1; j < n; j++) {
if (sect[j].start > max_end) {
solve[sect[j].index] = solve[sect[j - 1].index] + 1;
max_end = sect[j].end;
flag = true;
} else {
solve[sect[j].index] = solve[sect[j - 1].index];
if (sect[j].end > max_end) max_end = sect[j].end;
}
}
if (flag) {
for (int j = 0; j < n; j++) cout << 2 - (solve[j] == 1) << " ";
cout << endl;
} else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, ans[N], a, b, mx;
pair<int, pair<int, int> > arr[N];
bool can;
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
ans[i] = 1;
scanf("%d%d", &arr[i].first, &arr[i].second.first);
arr[i].second.second = i;
}
sort(arr, arr + n);
can = false;
mx = -1;
for (int i = 0; i < n; i++) {
if (can) {
ans[arr[i].second.second] = 2;
continue;
}
if (arr[i].first > mx && mx != -1) {
ans[arr[i].second.second] = 2;
can = true;
continue;
}
mx = max(mx, arr[i].second.first);
}
if (!can) {
puts("-1");
continue;
}
for (int i = 0; i < n; i++) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using Point = int64_t;
using Segment = std::pair<Point, Point>;
using Segments = std::vector<Segment>;
auto divide(const Segments &segments_) -> std::vector<bool> {
auto segments = segments_;
std::sort(segments.begin(), segments.end());
auto build_mask = [&segments_](Point divider) {
std::vector<bool> results(segments_.size());
std::transform(
segments_.begin(), segments_.end(), results.begin(),
[divider](const Segment &segment) { return segment.first < divider; });
return results;
};
Point last = segments.front().second;
for (auto segment : segments) {
if (segment.first >= last) {
return build_mask(last);
}
last = std::max(segment.second, last);
}
return {};
}
auto main() -> int {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
size_t tests;
std::cin >> tests;
for (size_t test = 0; test < tests; ++test) {
size_t count;
std::cin >> count;
auto segments = Segments(count);
for (auto &[left, right] : segments) {
std::cin >> left >> right;
++right;
}
auto results = divide(segments);
if (results.empty()) {
std::cout << "-1\n";
}
for (auto result : results) {
std::cout << (result ? 1 : 2) << ' ';
}
std::cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200001;
pair<int, int> T[maxN * 2];
int a[maxN], b[maxN];
void solve() {
int n, s = 0;
scanf("%d", &n);
for (int i = (1); (i) < (n + 1); (i)++) {
scanf("%d%d", a + i, b + i);
T[s++] = {a[i], -1};
T[s++] = {b[i], 1};
}
sort(T, T + s);
int bord = -1, st = 0;
for (int i = (0); (i) < (s); (i)++) {
st -= T[i].second;
if (st == 0 and i != s - 1 and bord == -1) bord = T[i].first;
}
if (bord == -1) {
printf("-1\n");
return;
}
for (int i = (1); (i) < (n + 1); (i)++) printf("%d ", b[i] <= bord ? 1 : 2);
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int gcd(long long int a, long long int b) {
if (a == 0 || b == 0) return (a + b);
if (a < b) swap(a, b);
return gcd(b, a % b);
}
bool cmp(pair<int, pair<int, int> > p1, pair<int, pair<int, int> > p2) {
if (p1.first < p2.first) return true;
if (p1.first > p2.first) return false;
if (p1.second.first < p2.second.first) return true;
return false;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
pair<int, pair<int, int> > p[n];
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second.first;
p[i].second.second = i;
}
sort(p, p + n, cmp);
int ans[n], one = 0, two = 0;
bool check = true;
for (int i = 0; i < n; i++) {
if ((one == 0 || p[i].first <= one) && p[i].first > two) {
ans[p[i].second.second] = 1;
one = max(one, p[i].second.first);
} else if ((two == 0 || p[i].first <= two) && p[i].first > one) {
ans[p[i].second.second] = 2;
two = max(p[i].second.first, two);
} else if (p[i].first > one && p[i].first > two) {
ans[p[i].second.second] = 1;
one = max(one, p[i].second.first);
} else
check = false;
}
if (two == 0) {
check = false;
}
if (check) {
for (int i = 0; i < n; i++) cout << ans[i] << " ";
} else
cout << "-1";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct L {
int l, r, i, b;
} ls[200000];
bool cmp(L a, L b) { return a.l < b.l; }
bool cmp1(L a, L b) { return a.i < b.i; }
void solve() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &ls[i].l, &ls[i].r);
ls[i].i = i;
ls[i].b = 2;
}
sort(ls, ls + n, cmp);
bool f = true;
int rr = ls[0].r;
ls[0].b = 1;
for (int j = 1; f && j < n; j++) {
if (ls[j].l > rr) {
f = false;
} else {
ls[j].b = 1;
rr = max(rr, ls[j].r);
}
}
if (!f) {
sort(ls, ls + n, cmp1);
for (int i = 0; i < n; i++) {
printf("%d%c", ls[i].b, i == n - 1 ? '\n' : ' ');
}
} else {
printf("-1\n");
}
}
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vector<pair<pair<int, int>, int>> vec(n);
vector<int> f, s;
for (auto i = 0; i < (long long)(n); i++) {
int a, b;
cin >> a >> b;
vec[i] = {{a, b}, i};
}
sort(((vec).begin()), ((vec).end()));
int e = -1;
auto x = vec[0];
e = x.first.second;
vector<int> res(n + 1);
res[x.second] = 1;
int cnt = 1;
for (auto i = 1; i < (long long)(n); i++) {
auto y = vec[i];
if (y.first.first <= e) {
e = max(e, y.first.second), res[y.second] = 1;
} else
res[y.second] = 2, cnt |= 2;
}
if (cnt == 3) {
for (auto i = 0; i < (long long)(n); i++) cout << res[i] << " ";
cout << '\n';
} else
cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
int first;
int second;
int idx;
};
bool comp(const st &s, const st &x) { return s.first < x.first; }
void f(int testCase) {
int n;
cin >> n;
vector<st> seg(n);
for (int i = 0; i < n; i++) {
cin >> seg[i].first >> seg[i].second;
seg[i].idx = i;
}
sort(seg.begin(), seg.end(), comp);
vector<vector<int> > un(1);
int right = seg[0].second;
int left = seg[0].first;
int j = 0;
un[0].push_back(0);
for (int i = 1; i < n; i++) {
if (seg[i].first > right) {
left = seg[i].first;
right = seg[i].second;
j++;
un.push_back(vector<int>());
un[j].push_back(i);
} else {
un[j].push_back(i);
right = max(right, seg[i].second);
}
}
if (un.size() < 2) {
cout << "-1\n";
return;
}
vector<bool> ans(n, false);
auto v = un[0];
for (auto i : v) ans[seg[i].idx] = true;
for (int i = 0; i < n; i++) {
if (ans[i])
cout << 1 << ' ';
else
cout << 2 << ' ';
}
cout << endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) f(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 200005;
vector<long long> vis(N);
vector<vector<long long>> adj(N);
void dfs(long long v) {
vis[v] = 1;
for (auto i : adj[v]) {
if (!vis[i]) {
dfs(i);
}
}
return;
}
bool isPrime(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long factorial(long long n) {
return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
long long max(long long a, long long b) {
long long ans = a > b ? a : b;
return ans;
}
long long min(long long a, long long b) {
long long ans = a < b ? a : b;
return ans;
}
long long root(long long a[], long long i) {
while (a[i] != i) {
a[i] = a[a[i]];
i = a[i];
}
return i;
}
void unionn(long long a[], long long i, long long j) {
long long root_i = root(a, i);
long long root_j = root(a, j);
a[root_i] = root_j;
return;
}
void fun() {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
fun();
long long tt = 1;
cin >> tt;
while (tt--) {
long long c1 = 0, c2 = 0;
long long n;
cin >> n;
map<long long, pair<long long, long long>> m;
map<pair<long long, long long>, long long> m1;
long long maxx = 0;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
m[i] = a[i];
}
sort(a.begin(), a.end());
for (long long i = 0; i < n; i++) {
if (!c1) {
m1[a[i]] = 1;
c1 = 1;
maxx = max(maxx, a[i].second);
} else {
if (a[i].first > maxx) {
if (m1[a[i - 1]] == 1) {
m1[a[i]] = 2;
c2 = 1;
} else {
m1[a[i]] = 1;
}
maxx = max(maxx, a[i].second);
} else {
m1[a[i]] = m1[a[i - 1]];
maxx = max(maxx, a[i].second);
}
}
}
if (!c2) {
cout << "-1"
<< "\n";
continue;
}
for (long long i = 0; i < n; i++) cout << m1[m[i]] << " ";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
int i, j;
for (i = 0; i < T; i++) {
int N;
cin >> N;
map<int, int> Map;
vector<int> Result(N);
unordered_map<int, vector<int> > Map1;
for (j = 0; j < N; j++) {
int L, R;
cin >> L >> R;
Map[L]++;
Map[R]--;
Map1[L].push_back(j);
}
int Sum = 0;
int C = 0;
for (auto it : Map) {
for (auto it1 : Map1[it.first]) {
Result[it1] = 1;
Sum++;
}
C += it.second;
if (C == 0) {
break;
}
}
if (Sum == N) {
cout << -1 << endl;
} else {
for (j = 0; j < N; j++) {
cout << (Result[j] + 1) << " ";
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> tree;
vector<long long> lazy;
void update_lazy(vector<long long> &tree, vector<long long> &lazy, int node,
int start, int end) {
if (lazy[node] != 0) {
tree[node] += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
}
void update_range(vector<long long> &tree, vector<long long> &lazy, int node,
int start, int end, int left, int right, long long diff) {
update_lazy(tree, lazy, node, start, end);
if (left > end || right < start) {
return;
}
if (left <= start && end <= right) {
tree[node] += (end - start + 1) * diff;
if (start != end) {
lazy[node * 2] += diff;
lazy[node * 2 + 1] += diff;
}
return;
}
update_range(tree, lazy, node * 2, start, (start + end) / 2, left, right,
diff);
update_range(tree, lazy, node * 2 + 1, (start + end) / 2 + 1, end, left,
right, diff);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
long long sum(vector<long long> &tree, vector<long long> &lazy, int node,
int start, int end, int left, int right) {
update_lazy(tree, lazy, node, start, end);
if (left > end || right < start) {
return 0;
}
if (left <= start && end <= right) {
return tree[node];
}
return sum(tree, lazy, node * 2, start, (start + end) / 2, left, right) +
sum(tree, lazy, node * 2 + 1, (start + end) / 2 + 1, end, left, right);
}
int L[100005], R[100005];
vector<int> X;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T;
cin >> T;
while (T--) {
int N;
cin >> N;
X.resize(2 * N);
tree.resize(16 * N);
lazy.resize(16 * N);
for (int i = 0; i < 16 * N; i++) {
tree[i] = 0;
lazy[i] = 0;
}
for (int i = 0; i < N; i++) {
cin >> L[i] >> R[i];
X[2 * i] = L[i];
X[2 * i + 1] = R[i];
}
sort(X.begin(), X.end());
X.resize(unique(X.begin(), X.end()) - X.begin());
for (int i = 0; i < N; i++) {
L[i] = lower_bound(X.begin(), X.end(), L[i]) - X.begin();
R[i] = lower_bound(X.begin(), X.end(), R[i]) - X.begin();
update_range(tree, lazy, 1, 0, 4 * N - 1, 2 * L[i], 2 * R[i], 1LL);
}
int k = -1;
for (int i = 1; i < 4 * N; i += 2) {
if (sum(tree, lazy, 1, 0, 4 * N - 1, i, i) == 0LL) {
k = i;
break;
}
}
int f = -1;
for (int i = 0; i < N; i++) {
if (2 * R[i] > k) {
f = 1;
break;
}
}
if (f == -1) {
cout << -1 << '\n';
continue;
}
for (int i = 0; i < N; i++) {
cout << (2 * R[i] < k ? 1 : 2) << ' ';
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
pair<int, int> a[N], b[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n, i, r = 0, cut = 0;
cin >> n;
for (i = 0; i < n; ++i) cin >> a[i].first >> a[i].second, b[i] = a[i];
sort(b, b + n);
for (i = 1; i < n; ++i) {
r = max(r, b[i - 1].second);
if (b[i].first > r) cut = r;
}
if (cut)
for (i = 0; i < n; ++i) cout << (a[i].first > cut) + 1 << ' ';
else
cout << -1;
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e9 + 7;
long long mod = 1e9 + 7;
using namespace std;
bool comp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
if (a.first.first != b.first.first) return a.first.first < b.first.first;
return a.first.second < b.first.second;
}
bool isOverlap(pair<long long, long long> a, pair<long long, long long> b) {
if (a.second < b.first or a.first > b.second) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T, N, i, j, k, L, l, r, m, n;
long long K, P;
long long M;
cin >> T;
while (T--) {
deque<pair<pair<long long, long long>, long long> > v;
cin >> N;
vector<long long> ret(N, 0);
for (i = 0; i < N; i++) {
cin >> l >> r;
v.push_back(make_pair(make_pair(l, r), i));
}
sort(v.begin(), v.end(), comp);
vector<long long> ans;
while (!v.empty()) {
pair<long long, long long> inv = v.front().first;
ans.push_back(v.front().second);
v.pop_front();
while (!v.empty() and isOverlap(inv, v.front().first)) {
ans.push_back(v.front().second);
inv.first =
(((inv.first) < (v.front().first.first)) ? (inv.first)
: (v.front().first.first));
inv.second = (((inv.second) > (v.front().first.second))
? (inv.second)
: (v.front().first.second));
v.pop_front();
}
break;
}
if (v.empty())
cout << -1 << endl;
else {
for (i = 0; i < ans.size(); i++) ret[ans[i]] = 1;
while (!v.empty()) {
ret[v.front().second] = 2;
v.pop_front();
}
for (i = 0; i < N; i++) cout << ret[i] << " ";
cout << endl;
}
ret.clear();
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool common(vector<int> &a, vector<int> &b) {
if (a.size() == 0 or b.size() == 0) return 0;
int x1 = a[0], y1 = a[1], x2 = b[0], y2 = b[1];
if ((x2 <= x1 and y2 >= x1) or (x2 >= x1 and x2 <= y1)) return 1;
return 0;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<vector<int>> c;
unordered_map<int, unordered_map<int, vector<int>>> m1;
unordered_map<int, unordered_map<int, int>> m2;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
c.push_back({x, y});
m1[x][y].push_back(i);
}
sort(c.begin(), c.end());
vector<int> answer(n, 1);
vector<int> s1 = c[0];
vector<int> s2;
int flag = 0;
for (int i = 1; i < n; i++) {
if ((common(s1, c[i]) or common(c[i], s1)) and
(common(s2, c[i]) or common(c[i], s2))) {
flag = 0;
break;
} else if (common(s1, c[i]) or common(c[i], s1)) {
if (c[i][1] >= s1[1]) s1 = c[i];
} else if (common(s2, c[i]) or common(c[i], s2)) {
if (!s2.size() or (c[i][1] >= s2[1])) s2 = c[i];
int index = m2[c[i][0]][c[i][1]];
answer[m1[c[i][0]][c[i][1]][index]] = 2;
m2[c[i][0]][c[i][1]]++;
flag = 1;
} else {
int index = m2[c[i][0]][c[i][1]];
answer[m1[c[i][0]][c[i][1]][index]] = 2;
m2[c[i][0]][c[i][1]]++;
s2 = c[i], flag = 1;
}
}
if (flag == 0)
cout << -1 << "\n";
else {
for (auto &z : answer) cout << z << " ";
cout << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 30;
bool cmp(const pair<int, pair<int, int> > &a,
const pair<int, pair<int, int> > &b) {
if (a.second.first == b.second.first)
return a.second.second > b.second.second;
return a.second.first < b.second.first;
}
void solve() {
int i, t;
cin >> t;
int ans[t];
vector<pair<int, pair<int, int> > > v(t);
for (i = 0; i < t; i++) {
cin >> v[i].second.first >> v[i].second.second;
v[i].first = i;
}
sort(v.begin(), v.end(), cmp);
int g1_max = 0, g2_max = 0;
int choice = 2;
bool ok1 = 0, ok2 = 0;
for (i = 0; i < t; i++) {
int se = v[i].first;
int l = v[i].second.first;
int r = v[i].second.second;
if (choice == 1) {
if (g1_max < l) {
choice = 2;
g2_max = max(g2_max, r);
ans[se] = choice;
} else {
g1_max = max(g1_max, r);
ans[se] = choice;
}
} else {
if (g2_max < l) {
choice = 1;
g1_max = max(g1_max, r);
ans[se] = choice;
} else {
g2_max = max(g2_max, r);
ans[se] = choice;
}
}
if (ans[se] == 1)
ok1 = 1;
else
ok2 = 1;
}
if (ok1 && ok2) {
for (i = 0; i < t; i++) cout << ans[i] << " ";
cout << "\n";
} else
cout << -1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int test;
cin >> test;
while (test--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
if (a.first.first != b.first.first) return a.first.first < b.first.first;
return a.first.second < b.first.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(), cout.tie();
long long t, n;
cin >> t;
while (t--) {
cin >> n;
long long ans[n];
vector<pair<pair<long long, long long>, long long> > v;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v.push_back({{x, y}, i});
}
sort(v.begin(), v.end(), cmp);
long long d = -1, mx = v[0].first.second;
for (int i = 0; i < n - 1; i++) {
mx = max(mx, v[i].first.second);
if (mx < v[i + 1].first.first) {
d = i;
break;
}
}
if (d == -1)
cout << -1 << endl;
else {
for (int i = 0; i <= d; i++) ans[v[i].second] = 1;
for (int i = d + 1; i < n; i++) ans[v[i].second] = 2;
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[100010], r[100010], n, t;
struct edge {
int l, r;
} e[100010];
bool cmp(edge a, edge b) {
if (a.l != b.l) return a.l < b.l;
return a.r < b.r;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
e[i].l = l[i], e[i].r = r[i];
}
sort(e + 1, e + n + 1, cmp);
int rr = -1;
bool flag = 0;
for (int i = 1; i <= n; i++) {
if (i == 1) {
rr = e[i].r;
continue;
}
if (e[i].l > rr) {
flag = 1;
break;
} else
rr = max(rr, e[i].r);
}
if (!flag) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i++)
if (r[i] <= rr)
printf("1 ");
else
printf("2 ");
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c<'0' | c> '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
template <class T>
inline long long gcd(T a, T b) {
a = abs(a);
b = abs(b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
template <class T>
inline long long ext_gcd(T A, T B, T *X, T *Y) {
T x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
template <class T>
inline long long modInv(T a, T m) {
T x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
template <class T>
inline long long power(T a, T p) {
T res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
template <class T>
inline long long bigmod(T a, T p, T m) {
T res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
struct node {
int x, y, pos, group;
node(int _x, int _y, int _pos, int _group) {
x = _x;
y = _y;
pos = _pos;
group = _group;
}
};
vector<int> ans;
vector<node> v;
bool cmp(node a, node b) {
if (a.y == b.y) return a.x < b.x;
return a.x < b.x;
}
bool cmp2(node a, node b) { return a.pos < b.pos; }
int main() {
int tc;
cin >> tc;
while (tc--) {
v.clear();
int n;
cin >> n;
int l, r;
for (int i = 1; i <= n; i++) {
cin >> l >> r;
v.push_back(node(l, r, i, -1));
}
sort(v.begin(), v.end(), cmp);
int firstGroupMax = v[0].y, secondGroupMax = -1;
v[0].group = 1;
bool Two = 0;
for (int i = 1; i < n; i++) {
int current = v[i].x;
if (current > firstGroupMax && Two == 0) {
v[i].group = 2;
Two = 1;
secondGroupMax = v[i].y;
} else if (current <= firstGroupMax) {
v[i].group = 1;
firstGroupMax = max(v[i].y, firstGroupMax);
} else if (current <= secondGroupMax) {
v[i].group = 2;
secondGroupMax = max(v[i].y, secondGroupMax);
} else {
v[i].group = 1;
firstGroupMax = max(v[i].y, firstGroupMax);
}
}
sort(v.begin(), v.end(), cmp2);
if (!Two) {
puts("-1");
continue;
}
bool isAvailable = 0, isMinus = 0;
for (int i = 0; i < n; i++) {
if (v[i].group == -1) {
isMinus = 1;
break;
}
}
if (isMinus) {
puts("-1");
} else {
for (int i = 0; i < n; i++) {
printf("%d ", v[i].group);
}
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A>
void pr(A a) {
cout << a;
cout << '\n';
}
template <class A, class B>
void pr(A a, B b) {
cout << a << ' ';
pr(b);
}
template <class A, class B, class C>
void pr(A a, B b, C c) {
cout << a << ' ';
pr(b, c);
}
template <class A, class B, class C, class D>
void pr(A a, B b, C c, D d) {
cout << a << ' ';
pr(b, c, d);
}
template <class A>
void PR(A a, long long n) {
for (long long i = (long long)(0); i < (long long)(n); i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n';
}
long long check(long long n, long long m, long long x, long long y) {
return x >= 0 && x < n && y >= 0 && y < m;
}
const long long MAX = 1e9 + 7, MAXL = 1LL << 61, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
int p[300001], r[300001];
void init(int n) {
for (long long i = (long long)(0); i < (long long)(n); i++)
p[i] = i, r[i] = 0;
}
int find(int x) { return (p[x] == x) ? x : (p[x] = find(p[x])); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (r[x] < r[y])
p[x] = y;
else {
p[y] = x;
if (r[x] == r[y]) r[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
void Main() {
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
pair<int, int> a[n];
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> a[i].first >> a[i].second;
a[i].first--;
a[i].second--;
}
set<long long> s;
for (long long i = (long long)(0); i < (long long)(n); i++) {
s.insert(a[i].first);
s.insert(a[i].second);
}
map<long long, long long> ma;
long long e = 0;
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); it++) {
ma[*it] = e;
e++;
}
init(e);
for (long long i = (long long)(0); i < (long long)(n); i++) {
long long l = ma[a[i].first], r = ma[a[i].second];
while (!same(l, r)) {
unite(l, l + 1);
unite(r - 1, r);
l++, r--;
}
}
map<long long, long long> m;
for (long long i = (long long)(0); i < (long long)(e); i++) {
if (find(i) == i) {
int k = m.size() + 1;
m[i] = min(k, 2);
}
}
if (m.size() == 1)
pr(-1);
else {
long long b[n];
for (long long i = (long long)(0); i < (long long)(n); i++)
b[i] = m[find(ma[a[i].first])];
PR(b, n);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void init_code() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
init_code();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<int, int>> v;
vector<pair<int, int>> v1;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v1.push_back({x, y});
v.push_back({x, y});
}
sort(v.begin(), v.end());
int st = v[0].first;
int ed = v[0].second;
int cnt = 1;
unordered_map<int, int> mp;
mp[st] = 1;
for (int i = 1; i < n; i++) {
if (v[i].first <= ed) {
mp[v[i].first] = cnt;
ed = max(ed, v[i].second);
} else {
st = v[i].first;
ed = v[i].second;
if (cnt == 1) {
cnt++;
}
mp[v[i].first] = cnt;
}
}
if (cnt < 2) {
cout << "-1" << endl;
} else {
for (int i = 0; i < v1.size(); i++) {
cout << mp[v1[i].first] << " ";
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("O3")
#pragma GCC optimize("O4")
#pragma GCC optimize("O5")
#pragma GCC optimize("O6")
#pragma GCC optimize("O2")
#pragma GCC optimize("O7")
#pragma GCC optimize("O8")
#pragma GCC optimize("O9")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
struct ios {
inline char read() {
static const long long IN_LEN = 1 << 18 | 1;
static char buf[IN_LEN], *s, *t;
return (s == t) && (t = (s = buf) + fread(buf, 1, IN_LEN, stdin)),
s == t ? -1 : *s++;
}
template <typename _Tp>
inline ios& operator>>(_Tp& x) {
static char c11, boo;
for (c11 = read(), boo = 0; !isdigit(c11); c11 = read()) {
if (c11 == -1) return *this;
boo |= c11 == '-';
}
for (x = 0; isdigit(c11); c11 = read()) x = x * 10 + (c11 ^ '0');
boo && (x = -x);
return *this;
}
} io;
template <typename T>
void printe(const T x) {
if (x >= 10) printe(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void print(const T x) {
if (x < 0)
putchar('-'), printe(-x);
else
printe(x);
}
long long T, n;
struct node {
long long l, r;
long long id;
bool operator<(const node& rhs) const {
return (l == rhs.l) ? r < rhs.r : l < rhs.l;
}
} s[100010];
long long belong[100010];
signed main() {
io >> T;
while (T--) {
io >> n;
for (long long i = 1; i <= n; ++i) io >> s[i].l >> s[i].r, s[i].id = i;
long long l = 0;
sort(s + 1, s + n + 1);
long long maxr = s[1].r;
for (long long i = 2; i <= n; ++i)
if (s[i].l > maxr) {
l = i;
break;
} else
maxr = max(maxr, s[i].r);
if (l == 0) {
cout << -1 << endl;
continue;
}
for (long long i = 1; i < l; ++i) belong[s[i].id] = 1;
for (long long i = l; i <= n; ++i) belong[s[i].id] = 2;
for (long long i = 1; i <= n; ++i, cout << ' ') cout << belong[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
struct node {
long long l, r, i;
};
bool cmp(node &a, node &b) { return a.l < b.l; }
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long x, y;
bool flag = 0;
vector<long long> ans(n);
vector<node> a;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
a.push_back({x, y, i});
}
sort((a).begin(), (a).end(), cmp);
long long p = -1;
x = a[0].r;
for (long long i = 1; i < n; i++) {
if (x < a[i].l) {
p = i;
break;
}
x = max(x, a[i].r);
}
if (p == -1)
cout << -1 << '\n';
else {
for (long long i = 0; i < p; i++) ans[a[i].i] = 1;
for (long long i = p; i < n; i++) ans[a[i].i] = 2;
for (auto i : ans) cout << i << " ";
cout << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N_max = 1e5;
long long rightmost[N_max + 5];
long long solution[N_max + 5];
void run_case() {
long long n, i, l, r, idx;
cin >> n;
vector<pair<pair<long long, long long>, long long>> V;
for (i = 0; i < n; i++) {
cin >> l >> r;
V.push_back({{l, r}, i});
}
sort(V.begin(), V.end());
rightmost[0] = V[0].first.second;
for (i = 1; i < n; i++) {
rightmost[i] = max(rightmost[i - 1], V[i].first.second);
}
bool found = false;
for (i = 1; i < n; i++) {
if (V[i].first.first > rightmost[i - 1]) {
found = true;
idx = i;
break;
}
}
if (!found) {
cout << "-1\n";
} else {
for (i = 0; i < idx; i++) solution[V[i].second] = 1;
for (i = idx; i < n; i++) solution[V[i].second] = 2;
for (i = 0; i < n; i++) {
cout << solution[i] << " ";
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
cin >> T;
while (T--) run_case();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int L, R, id;
} segment[100005];
int ans[100005];
int n;
bool comp(node xx, node yy) {
if (xx.L < yy.L) return true;
if (xx.L > yy.L) return false;
return xx.R < yy.R;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
segment[i].id = i;
scanf("%d%d", &segment[i].L, &segment[i].R);
}
sort(segment + 1, segment + n + 1, comp);
int flag = -1, mx = segment[1].R;
for (int i = 2; i <= n; ++i) {
if (segment[i].L > mx) {
flag = i;
break;
}
mx = max(mx, segment[i].R);
}
if (flag == -1) {
printf("-1\n");
continue;
}
for (int i = 1; i < flag; ++i) ans[segment[i].id] = 1;
for (int i = flag; i <= n; ++i) ans[segment[i].id] = 2;
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool mycomp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first == b.first.first) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
void solve() {
int n;
cin >> n;
vector<pair<pair<int, int>, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first.first >> a[i].first.second;
a[i].second = i;
}
sort(a.begin(), a.end(), mycomp);
int ptr = a[0].first.second, id = -1;
for (int i = 1; i < n; i++) {
if (ptr < a[i].first.first) {
id = i - 1;
break;
} else
ptr = max(a[i].first.second, ptr);
}
if (id == -1)
cout << -1 << endl;
else {
vector<int> ans(n);
for (int i = 0; i < n; i++) {
if (i <= id)
ans[a[i].second] = 1;
else
ans[a[i].second] = 2;
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)2e5 + 7;
const int infint = (long long)1e9;
const long long inf = (long long)1e18;
int T, n, ans[MAXN], can = 0;
pair<int, pair<int, int> > P[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
can = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> P[i].first >> P[i].second.first;
P[i].second.second = i;
}
sort(P, P + n);
int mx_1 = -1;
for (int i = 0; i < n; i++) {
if (mx_1 < P[i].first) can = i;
mx_1 = max(mx_1, P[i].second.first);
}
if (can == 0)
cout << "-1\n";
else {
for (int i = 0; i < can; i++) ans[P[i].second.second] = 1;
for (int i = can; i < n; i++) ans[P[i].second.second] = 2;
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.