text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int n, l[110], r[110];
bool checkl(int a, int b) {
if (l[b] == 0) {
return true;
}
if (l[b] == a) {
return false;
}
return checkl(a, l[b]);
}
bool checkr(int a, int b) {
if (r[b] == 0) {
return true;
}
if (r[b] == a) {
return false;
}
return checkr(a, r[b]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) {
cnt++;
}
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0 && cnt > 1) {
for (int j = 1; j <= n; j++) {
if (r[j] == 0 && j != i && checkl(i, j)) {
l[i] = j, r[j] = i, cnt--;
break;
}
}
}
if (r[i] == 0 && cnt > 1) {
for (int j = 1; j <= n; j++) {
if (l[j] == 0 && i != j && checkr(i, j)) {
r[i] = j, l[j] = i, cnt--;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
set<int> a, b;
vector<pair<int, int> > ans(n);
for (int i = 0; i < n; ++i) {
cin >> ans[i].first >> ans[i].second;
--ans[i].first;
--ans[i].second;
if (ans[i].first == -1) a.insert(i);
if (ans[i].second == -1) b.insert(i);
}
while (a.size() > 1) {
int node = *a.begin();
a.erase(a.begin());
int last = node;
while (ans[last].second != -1) last = ans[last].second;
auto nxt = b.begin();
if (*nxt == last) ++nxt;
ans[*nxt].second = node;
ans[node].first = *nxt;
b.erase(nxt);
}
for (int i = 0; i < n; ++i)
cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const double eps = 1e-4;
const int mod = 1e9 + 7;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 7;
const int maxm = 1e6 + 7;
const double pi = acos(-1.0);
int a[110], l[110], r[110];
int par[110];
int ra[110];
void init(int n) {
for (int i = 1; i <= n; i++) {
par[i] = i;
ra[i] = 0;
}
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (ra[x] < ra[y])
par[x] = y;
else {
par[y] = x;
if (ra[x] == ra[y]) ra[x]++;
}
}
bool same(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return true;
else
return false;
}
void debug() {
cout << "this is a debug ~ " << endl;
for (int i = 1; i <= 7; i++) cout << l[i] << " " << r[i] << endl;
;
cout << "debug end ~ " << endl;
}
int main() {
int n;
while (cin >> n) {
init(n);
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i]) unite(l[i], i);
if (r[i]) unite(r[i], i);
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0 && r[i] == 0) {
for (int j = 1; j <= n; j++) {
if (j != i && r[j] == 0) {
l[i] = j;
r[j] = i;
unite(i, j);
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
for (int j = 1; j <= n; j++) {
if (r[j] == 0 && !same(i, j)) {
r[j] = i;
l[i] = j;
unite(i, j);
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int l;
int r;
int list;
int number;
Node(int l, int r, int number) {
this->l = l;
this->r = r;
this->number = number;
this->list = -1;
}
};
int main() {
int Nn;
scanf("%d", &Nn);
vector<Node*> v;
v.push_back((new Node(-1, -1, 0)));
vector<Node*> noRight;
vector<Node*> noLeft;
for (int i = 1; i <= Nn; i++) {
int r, l;
scanf("%d %d", &l, &r);
Node* node = new Node(l, r, i);
v.push_back(node);
}
int last_list = -1;
for (Node* N : v) {
if (N->r == -1)
continue;
else {
if (N->list == -1) {
last_list++;
N->list = last_list;
Node* flow = N;
if (flow->r == 0) noRight.push_back(flow);
if (flow->l == 0) {
noLeft.insert(noLeft.begin(), flow);
}
while (flow->r != 0 && v[flow->r]->list == -1) {
flow = v[flow->r];
flow->list = last_list;
if (flow->r == 0) noRight.push_back(flow);
}
flow = N;
while (flow->l != 0 && v[flow->l]->list == -1) {
flow = v[flow->l];
flow->list = last_list;
if (flow->l == 0) noLeft.push_back(flow);
}
}
}
}
while (noRight.size() > 1 || noLeft.size() > 1) {
int right = 0, left = 0;
while (noRight[right]->list == noLeft[left]->list) {
right++;
}
if (right >= noRight.size()) right = noRight.size() - 1;
while (noRight[right]->list == noLeft[left]->list) {
left++;
}
if (left >= noLeft.size()) left = noLeft.size() - 1;
noRight[right]->r = noLeft[left]->number;
noLeft[left]->l = noRight[right]->number;
int corrlist = noRight[right]->list;
for (auto tyty : v) {
if (tyty->list == corrlist) tyty->list = noLeft[left]->list;
}
noRight.erase(noRight.begin() + right);
noLeft.erase(noLeft.begin() + left);
}
v.erase(v.begin());
for (auto nodes : v) {
printf("%d %d\n", nodes->l, nodes->r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, x, y;
vector<pair<int, int> > v;
map<int, int> l;
map<int, int> r;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
l[i] = x;
r[i] = y;
}
for (int i = 0; i <= n; i++)
if (l[i] == 0) {
int c = i;
while (r[c]) {
c = r[c];
}
v.push_back({i, c});
}
for (int i = 0; i < v.size() - 1; i++) {
r[v[i].second] = v[i + 1].first;
l[v[i + 1].first] = v[i].second;
}
cout << "\n";
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int L[N], R[N], n, l, r, RR[N];
vector<vector<int> > v;
vector<int> start, tmp;
void DFS(int u) {
tmp.push_back(u);
if (RR[u]) DFS(RR[u]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &l, &r);
L[i] = l, R[i] = r;
if (l) RR[l] = i;
if (r) RR[i] = r;
if (!l) start.push_back(i);
}
for (int st : start) {
tmp.clear();
DFS(st);
v.push_back(tmp);
}
for (int i = 0; i < (int)v.size() - 1; i++) {
R[v[i].back()] = v[i + 1][0];
L[v[i + 1][0]] = v[i].back();
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", L[i], R[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[105];
map<int, int> lefts;
map<int, int> rights;
bool vis[105];
bool found = false;
int bfs(int s) {
bool isvisited[105];
memset(isvisited, false, sizeof isvisited);
isvisited[s] = true;
queue<int> q;
q.push(s);
int res;
while (!q.empty()) {
int u = q.front();
if (rights[u] == 0) {
res = u;
break;
}
q.pop();
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!isvisited[v]) {
isvisited[v] = true;
q.push(v);
}
}
}
return res;
}
int main() {
int n;
cin >> n;
vector<int> roots;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
lefts[i] = l;
rights[i] = r;
if (r != 0) {
g[i].push_back(r);
}
if (l == 0) {
roots.push_back(i);
}
}
vector<pair<int, int>> newarr;
for (int i = 0; i < roots.size(); i++) {
int u = roots[i];
found = false;
int ends = bfs(u);
newarr.push_back(make_pair(u, ends));
}
for (int i = 0; i < newarr.size() - 1; i++) {
int start = newarr[i].first;
int fin = newarr[i].second;
int ns = newarr[i + 1].first;
int nf = newarr[i + 1].second;
rights[fin] = ns;
lefts[ns] = fin;
}
for (int i = 1; i <= n; i++) {
cout << lefts[i] << " " << rights[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[10010];
pair<int, int> P[200];
int main() {
int n;
scanf("%d", &n);
int begin = -1;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &P[i].first, &P[i].second);
if (P[i].first == 0 && begin == -1) begin = i, vis[i] = true;
}
int ka = begin;
int pre = begin;
while (true) {
pre = begin;
while (begin != 0) {
pre = begin;
begin = P[begin].second;
}
bool K = 0;
for (int i = 1; i <= n; i++) {
if (P[i].first == 0 && !vis[i]) {
begin = i, vis[i] = true;
K = 1;
break;
}
}
if (!K) break;
P[begin].first = pre;
P[pre].second = begin;
}
for (int i = 1; i <= n; i++) printf("%d %d\n", P[i].first, P[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, num = 0;
cin >> n;
int l[n], r[n];
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
vector<vector<int> > li;
for (int i = 0; i < n; i++) {
if (l[i] == 0) {
vector<int> ar;
li.push_back(ar);
li[num].push_back(i + 1);
num++;
}
}
int j, k;
for (int i = 0; i < num; i++) {
j = li[i][0] - 1;
if (i > 0) {
l[j] = k + 1;
}
k = j;
while (j != -1) {
k = j;
j = r[j] - 1;
}
if (num - 1 != i) {
r[k] = li[i + 1][0];
}
}
for (int i = 0; i < n; i++) {
cout << l[i] << " " << r[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, l[102], r[102], a[102], first[102], last[102], m;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> l[i] >> r[i];
m = 0;
memset(a, 0, sizeof(a));
memset(first, 0, sizeof(first));
memset(last, 0, sizeof(last));
for (int i = 1; i <= n; ++i)
if (a[i] == 0) {
a[i] = ++m;
int j = i;
while (r[j]) {
j = r[j];
a[j] = m;
}
last[m] = j;
j = i;
while (l[j]) {
j = l[j];
a[j] = m;
}
first[m] = j;
}
for (int i = 2; i <= m; ++i) {
l[first[i]] = last[i - 1];
r[last[i - 1]] = first[i];
}
r[last[1]] = first[2];
for (int i = 1; i <= n; ++i) cout << l[i] << ' ' << r[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
int a[maxn][3], n;
int f[maxn];
int get(int x) {
if (f[x] == x) return x;
f[x] = get(f[x]);
return f[x];
}
void join(int x, int y) {
if (!y) return;
int fx = get(x), fy = get(y);
if (fx != fy) f[fx] = fy;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
cin >> a[i][1] >> a[i][2];
join(i, a[i][1]);
join(i, a[i][2]);
}
for (int i = 1; i <= n; i++) {
if (a[i][1] == 0) {
for (int j = 1; j <= n; j++)
if (get(i) != get(j)) {
if (a[j][2] == 0) {
a[i][1] = j;
a[j][2] = i;
join(i, j);
break;
}
}
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", a[i][1], a[i][2]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int x, y;
vector<int> l(n + 1, 0);
vector<int> r(n + 1, 0);
vector<int> c(n + 1, -1);
for (int i = 1; i <= n; i++) {
cin >> x >> y;
l[i] = x;
r[i] = y;
}
int a = -1;
int b = -1;
int front;
int end;
for (int i = 1; i <= n; i++) {
if (c[i] != -1)
continue;
else {
if (l[i] != 0)
front = l[i];
else
front = i;
while (front != 0) {
c[front] = 0;
if (l[front] == 0) break;
front = l[front];
}
if (r[i] != 0)
end = r[i];
else
end = i;
while (end != 0) {
c[end] = 0;
if (r[end] == 0) break;
end = r[end];
}
if (a == -1) a = front;
if (b == -1)
b = end;
else {
l[front] = b;
r[b] = front;
b = end;
}
}
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
struct node {
int l, r;
};
int main() {
int n;
scanf("%d", &n);
node link[n + 10];
int if_he[n + 10];
int ct[n + 10];
for (int i = 1; i <= n; i++) {
ct[i] = 0;
scanf("%d%d", &link[i].l, &link[i].r);
if (!link[i].l)
if_he[i] = 1;
else
if_he[i] = 0;
}
int now = 1;
while (!if_he[now]) now++;
for (int i = 0; i < n; i++) {
ct[now]++;
if (link[now].r)
now = link[now].r;
else
for (int i = 1; i <= n; i++)
if (!ct[i] && if_he[i]) {
link[now].r = i;
link[i].l = now;
now = i;
break;
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", link[i].l, link[i].r);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
vector<int> l, r;
int us[109];
void dfs(int v) {
us[v] = 1;
if (r[v] != -1 && us[r[v]] == 0) {
g.back().push_back(r[v]);
dfs(r[v]);
}
}
int main() {
#pragma warning(disable : 4996)
int n;
cin >> n;
l.resize(n);
r.resize(n);
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
l[i]--;
r[i]--;
}
for (int i = 0; i < n; i++) {
if (l[i] == -1) {
g.push_back(vector<int>());
g.back().push_back(i);
dfs(i);
}
}
for (int i = 0; i < g.size() - 1; i++) {
r[g[i].back()] = g[i + 1][0];
l[g[i + 1][0]] = g[i].back();
}
for (int i = 0; i < n; i++) {
cout << l[i] + 1 << " " << r[i] + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, ind;
};
struct coll {
int start, end;
};
int find_start(struct node input, struct node arr[103]);
int find_end(struct node input, struct node arr[103]);
int main() {
int i, n, j, size;
cin >> n;
struct node arr[103];
vector<coll> brr;
vector<coll>::iterator bt, et, nt;
coll temp, flag, car;
for (i = 1; i <= n; i++) {
cin >> arr[i].l >> arr[i].r;
arr[i].ind = i;
}
for (i = 1; i <= n; i++) {
if (arr[i].l != 0 && arr[i].r == 0) {
temp.end = i;
temp.start = find_start(arr[i], arr);
} else if (arr[i].l == 0 && arr[i].r != 0) {
temp.start = i;
temp.end = find_end(arr[i], arr);
brr.push_back(temp);
} else if (arr[i].l == 0 && arr[i].r == 0) {
temp.start = i;
temp.end = i;
brr.push_back(temp);
}
}
size = brr.size();
for (j = 0; j < size - 1; j++) {
arr[brr[j].end].r = brr[j + 1].start;
arr[brr[j + 1].start].l = brr[j].end;
}
for (i = 1; i <= n; i++) {
cout << arr[i].l << " " << arr[i].r << endl;
}
}
int find_start(struct node input, struct node arr[103]) {
while (input.l != 0) {
return find_start(arr[input.l], arr);
}
return input.ind;
}
int find_end(struct node input, struct node arr[103]) {
while (input.r != 0) {
return find_end(arr[input.r], arr);
}
return input.ind;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dsu;
int get(int v) {
if (dsu[v] == v) {
return v;
}
return dsu[v] = get(dsu[v]);
}
void unite(int a, int b) {
int x = get(a);
int y = get(b);
if (x != y) {
if (rand() & 1) {
dsu[x] = y;
} else {
dsu[y] = x;
}
}
}
int main() {
int n;
cin >> n;
dsu.assign(n, 0);
for (int i = 0; i < n; i++) {
dsu[i] = i;
}
vector<pair<int, int>> q(n);
vector<int> fl;
vector<int> fr;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a == 0) {
fl.push_back(i);
} else {
unite(a - 1, i);
}
if (b == 0) {
fr.push_back(i);
} else {
unite(b - 1, i);
}
q[i] = make_pair(a - 1, b - 1);
}
while (fl.size() > 1) {
for (int j = 0; j < fr.size(); j++) {
if (get(fl[0]) != get(fr[j])) {
unite(fl[0], fr[j]);
q[fl[0]].first = fr[j];
q[fr[j]].second = fl[0];
fl.erase(fl.begin());
fr.erase(fr.begin() + j);
}
}
}
for (int i = 0; i < n; i++) {
cout << q[i].first + 1 << " " << q[i].second + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[105], r[105], vis[105];
int dfs(int node, int val) {
vis[node] = val;
if (r[node] == 0) return node;
return dfs(r[node], val);
}
int main() {
int n, i, j, f, val, temp;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
memset(vis, -1, sizeof(vis));
f = 0;
val = 0;
temp = 0;
for (i = 1; i <= n; i++) {
if (l[i] == 0 && f == 0 && vis[i] == -1) {
f = 1;
temp = dfs(i, val);
val++;
} else if (f == 1 && l[i] == 0 && vis[i] == -1) {
l[i] = temp;
r[temp] = i;
temp = dfs(i, val);
val++;
}
}
for (i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy8[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dxH[] = {2, 2, -2, -2, 1, 1, -1, -1};
int dyH[] = {1, -1, 1, -1, 2, -2, 2, -2};
int nlmon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int lmon[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const double GRS = (1 + sqrt(5)) / 2;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch<'0' | ch> '9') break;
}
return (ng ? -n : n);
}
template <typename T>
T power(T X, T P) {
T ans = (T)1;
for (T i = 1; i <= P; i++) {
ans = ans * X;
}
return ans;
}
template <typename T>
T ABS(T A, T B) {
T ret = A - B;
if (ret < 0) return -ret;
return ret;
}
const long long MOD = 1000000007;
const long long BIGMAX = power(2, 63) - 1;
template <typename T>
T ADD(T X, T Y, T M) {
if (X + Y < 0)
return (X - M) + Y;
else if (X + Y >= M)
return X + Y - M;
else
return X + Y;
}
template <typename T>
T prod(T a, T b, T c) {
T x = 0, y = a % c;
while (b > 0) {
if (b % 2 == 1) {
x = ADD(x, y, c);
}
y = (y * 2) % c;
b /= 2;
}
return x % c;
}
template <typename T>
T bigmod(T a, T b, T c) {
T x = (T)1, y = a % c;
while (b > 0) {
if (b % (T)2 == (T)1) {
x = (x * y) % c;
}
y = (y * y) % c;
b /= (T)2;
}
return x;
}
template <typename T>
T MODINVERSE(T a) {
return bigmod(a, (T)(MOD - 2), (T)MOD);
}
template <typename T>
T GCD(T x, T y) {
while (y != 0) {
T z = x % y;
x = y;
y = z;
}
return x;
}
bool isvowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U')
return true;
return false;
}
template <typename T>
T isleap(T year) {
if (year % (T)400 == (T)0 || (year % (T)100 != (T)0 && year % (T)4 == (T)0))
return true;
return false;
}
vector<int> graph[10005];
int L[1005], R[1005];
bool visited[10005];
int pre;
void DFS(int u) {
pre = u;
visited[u] = true;
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (!visited[v]) {
DFS(v);
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d %d", &l, &r);
L[i] = l, R[i] = r;
if (l) graph[l].push_back(i), graph[i].push_back(l);
if (r) graph[i].push_back(r), graph[r].push_back(i);
}
bool flag = false;
int cnt = 0;
int nod;
for (int i = 1; i <= n; i++) {
if (!L[i]) {
if (cnt) {
R[pre] = i, L[i] = pre;
}
DFS(i);
cnt++;
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", L[i], R[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int sb[110][5];
int t1[110], t2[110];
int vis[110];
queue<int> q, q2;
void dfs(int x) {
if (vis[x]) return;
if (t1[x] == 0 && t2[x] == 0) {
q.push(x);
q.push(x);
} else if (t1[x] == 0) {
q.push(x);
vis[x] = 1;
dfs(t2[x]);
} else if (t2[x] == 0) {
q.push(x);
vis[x] = 1;
dfs(t1[x]);
} else {
vis[x] = 1;
dfs(t1[x]);
dfs(t2[x]);
}
}
int main() {
int n, f, id, flag = 0, sum = 0, xx = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &sb[i][0], &sb[i][1]);
}
for (int i = 1; i <= n; i++) {
t1[sb[i][0]] = i;
t1[i] = sb[i][1];
t2[i] = sb[i][0];
t2[sb[i][1]] = i;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
while (!q.empty()) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
if (t1[x] == 0) {
q2.push(x);
q2.push(y);
} else {
q2.push(y);
q2.push(x);
}
}
q2.pop();
while (q2.size() > 1) {
int x = q2.front();
q2.pop();
int y = q2.front();
q2.pop();
t1[y] = x;
t2[x] = y;
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", t2[i], t1[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
struct linked {
int head, tail;
} arr[200];
int n, x, i;
vector<int> st;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> arr[i].head >> arr[i].tail;
if (arr[i].head == 0) st.push_back(i);
}
i = 0;
while (i + 1 < st.size()) {
x = st[i];
while (arr[x].tail) x = arr[x].tail;
arr[x].tail = st[i + 1];
arr[st[++i]].head = x;
}
for (i = 1; i <= n; i++) {
cout << arr[i].head << ' ' << arr[i].tail << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using pii = pair<int, int>;
int l[110], r[110];
vector<int> heads;
int main() {
int i, n, v, u;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> l[i] >> r[i];
if (l[i] == 0) heads.push_back(i);
}
for (v = heads.back(), heads.pop_back(); !heads.empty(); heads.pop_back()) {
while (r[v] != 0) v = r[v];
u = heads.back();
r[v] = u;
l[u] = v;
}
for (i = 1; i <= n; ++i) cout << l[i] << ' ' << r[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int NIL = 500005;
const double EPS = 1e-9;
const int INF = 1e9;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long mod = 1000000007;
long long mod2 = 1000000009;
long long power(long long base, int p) {
if (!p) return 1;
long long ret = power(base, p / 2);
ret *= ret;
ret %= mod;
if (p & 1) ret *= base, ret %= mod;
return ret;
}
long long modInverse(int a) { return power(a, mod - 2); }
int l[102], r[102];
int main() {
int n;
cin >> n;
vector<int> second;
vector<int> sol;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
if (l[i] == 0) {
second.push_back(i);
}
}
for (int i = 0; i < ((int)((second).size())); i++) {
while (second[i] != 0) {
sol.push_back(second[i]);
second[i] = r[second[i]];
}
}
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
for (int i = 0; i < sol.size(); i++) {
if (i + 1 < sol.size()) r[sol[i]] = sol[i + 1];
if (i) l[sol[i]] = sol[i - 1];
}
for (int i = 1; i <= n; i++) cout << l[i] << ' ' << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[10100];
int r[10100];
int per[100100];
int pr(int x) {
if (x == per[x]) return x;
return per[x] = pr(per[x]);
}
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int t = 0;
for (int i = 1; i <= n; i++) {
per[i] = i;
cin >> l[i];
cin >> r[i];
t += l[i] == 0;
}
for (int i = 1; i <= n; i++) {
if (l[i]) {
r[l[i]] = i;
per[pr(i)] = pr(l[i]);
}
if (r[i]) {
l[r[i]] = i;
per[pr(i)] = pr(r[i]);
}
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
if (t == 1) continue;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (pr(i) == pr(j)) continue;
if (r[j] == 0) {
r[j] = i;
l[i] = j;
per[pr(i)] = pr(j);
break;
}
}
t--;
}
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[101], r[101];
int n;
bool check() {
int tou = 0;
for (int i = 1; i <= n; i++)
if (l[i] == 0) tou++;
int wei = 0;
for (int i = 1; i <= n; i++)
if (r[i] == 0) wei++;
if (tou == 1 && wei == 1) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
while (!check()) {
int wei;
for (int i = 1; i <= n; i++)
if (r[i] == 0) {
wei = i;
break;
}
int tou;
for (int i = 1; i <= n; i++)
if (l[i] == 0) {
int j = i;
while (r[j] != 0) j = r[j];
if (j != wei) {
tou = i;
break;
}
}
r[wei] = tou;
l[tou] = wei;
}
for (int i = 1; i <= n; i++) cout << l[i] << ' ' << r[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ab;
vector<int> g[105];
int ara[105], le;
void dfs(int u, int par) {
if (u == 0) {
le = par;
return;
}
dfs(g[u][0], u);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, ans, temp, t, j, i, a, mx, d, k, l, c, h, m, b;
scanf("%d", &n);
ab.push_back({0, 0});
for (i = 1; i <= n; i++) {
scanf("%d%d", &a, &b);
ab.push_back({a, b});
g[i].push_back(b);
g[a].push_back(i);
}
le = -1;
for (i = 0; i < g[0].size(); i++) {
if (le != -1) {
ab[le].second = g[0][i];
ab[g[0][i]].first = le;
}
dfs(g[0][i], 0);
}
for (i = 1; i <= n; i++) {
printf("%d %d\n", ab[i].first, ab[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxn = 105;
struct Node {
int pre, next;
};
Node lis[105];
int n;
int getfir() {
for (int i = 1; i <= n; i++) {
if (lis[i].pre == 0) {
return i;
}
}
return -1;
}
int getlast() {
for (int i = 1; i <= n; i++) {
if (lis[i].next == 0) return i;
}
return -1;
}
int main() {
scanf("%d", &n);
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &lis[i].pre, &lis[i].next);
if (lis[i].pre == 0) cnt++;
if (lis[i].next == 0) cnt++;
}
if (cnt == 2) {
for (int i = 1; i <= n; i++) {
printf("%d %d\n", lis[i].pre, lis[i].next);
}
} else {
int flag = 0, cur;
for (int i = 1; i <= n + 1; i++) {
int id = getfir();
if (id == -1) {
for (int i = 1; i <= n; i++) {
if (lis[i].pre == -1) lis[i].pre = 0;
printf("%d %d\n", lis[i].pre, lis[i].next);
}
return 0;
} else {
if (!flag) {
lis[id].pre = -1;
flag = 1;
while (lis[id].next != 0) {
id = lis[id].next;
}
cur = id;
} else {
lis[id].pre = cur;
lis[cur].next = id;
while (lis[id].next != 0) {
id = lis[id].next;
}
cur = id;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<bool> trust;
vector<int> massive(int** mas, int num) {
vector<int> mase;
int nume = num;
int nume1;
while (nume != 0) {
nume1 = nume;
nume = mas[nume - 1][0];
}
mase.push_back(0);
while (nume1 != 0) {
mase.push_back(nume1);
trust[nume1 - 1] = true;
nume1 = mas[nume1 - 1][1];
}
mase.push_back(0);
return mase;
}
int main() {
int n;
cin >> n;
int** mas = new int*[n];
for (int i = 0; i < n; i++) {
mas[i] = new int[2];
trust.push_back(false);
cin >> mas[i][0] >> mas[i][1];
}
vector<vector<int>> comp;
for (int i = 0; i < n; i++) {
vector<int> vect2;
if (!trust[i]) {
vect2 = massive(mas, i + 1);
comp.push_back(vect2);
}
}
vector<int> ansver;
ansver.push_back(0);
for (auto i : comp) {
for (auto j : i) {
if (j != 0) {
ansver.push_back(j);
}
}
}
ansver.push_back(0);
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < ansver.size(); j++) {
if (i == ansver[j]) {
cout << ansver[j - 1] << " " << ansver[j + 1];
}
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> next(n + 1);
vector<int> prev(n + 1);
vector<int> ans;
ans.push_back(0);
int a, b;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
next[i] = b;
prev[i] = a;
}
for (int i = 1; i <= n; i++)
if (prev[i] == 0) {
int it = i;
while (it != 0) {
ans.push_back(it);
it = next[it];
}
}
ans.push_back(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i == ans[j]) cout << ans[j - 1] << " " << ans[j + 1] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long parent[100005], x[100005], y[100005], i, n, j;
long long find(long long a) {
return a == parent[a] ? a : parent[a] = find(parent[a]);
}
void join(long long a, long long b) { parent[find(b)] = find(a); }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (i = 1; i <= n; i++) parent[i] = i;
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
if (x[i] != 0) join(i, x[i]);
if (y[i] != 0) join(i, y[i]);
}
long long left, right, k;
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
if (find(i) != find(j)) {
left = find(i);
right = find(j);
for (k = 1; k <= n; k++) {
if (find(k) == right && y[k] == 0) right = k;
}
for (k = 1; k <= n; k++) {
if (find(k) == left && x[k] == 0) left = k;
}
x[left] = right;
y[right] = left;
join(i, j);
}
}
}
for (i = 1; i <= n; i++) cout << x[i] << " " << y[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100 + 5;
const int INF = 0x7F7F7F7F;
int N;
int L[MaxN], R[MaxN];
int Pre[MaxN], Nxt[MaxN];
bool used[MaxN];
void init() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d %d", &L[i], &R[i]);
}
inline int Find_head() {
for (int i = 1; i <= N; ++i)
if (used[i] == false && L[i] == 0) return i;
return -1;
}
void solve() {
int pre = 0;
while (Find_head() != -1) {
int x = Find_head();
used[x] = true;
Nxt[pre] = x, Pre[x] = pre, Nxt[x] = R[x];
pre = x;
for (int i = R[x]; i != 0; i = R[i]) {
Nxt[i] = R[i], Pre[i] = L[i];
used[i] = true;
pre = i;
}
}
for (int i = 1; i <= N; ++i) printf("%d %d\n", Pre[i], Nxt[i]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int lef[105];
int r[105];
vector<pair<int, int> > fin(105);
int main() {
int n, i, j, l, rt, beg;
vector<int> ans, v;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> l >> rt;
if (l == 0) v.push_back(i);
r[i] = rt;
}
for (i = 0; i < v.size(); i++) {
beg = v[i];
while (r[beg] != 0) {
ans.push_back(beg);
beg = r[beg];
}
ans.push_back(beg);
}
for (i = 0; i < ans.size(); i++) {
if (ans.size() > 1) {
if (i == 0)
fin[ans[i]] = {0, ans[i + 1]};
else if (i == ans.size() - 1)
fin[ans[i]] = {ans[i - 1], 0};
else
fin[ans[i]] = {ans[i - 1], ans[i + 1]};
} else {
fin[ans[i]] = {0, 0};
}
}
for (i = 1; i <= n; i++) printf("%d %d\n", fin[i].first, fin[i].second);
}
|
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int data;
node *prev, *next;
node(int i) {
data = i;
prev = nullptr;
next = nullptr;
}
};
unordered_map<int, node*> mm;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int a, b;
for (int i = 1; i <= n; i++) mm[i] = new node(i);
for (int i = 1; i <= n; i++) {
cin >> a >> b;
if (b) mm[i]->next = mm[b];
if (a) mm[i]->prev = mm[a];
}
unordered_set<int> s;
for (int i = 1; i <= n; i++) {
if (mm[i]->prev == nullptr) s.insert(i);
}
node* head = mm[*s.begin()];
s.erase(s.begin());
auto it = head;
while (!s.empty()) {
while (it->next) it = it->next;
it->next = mm[*s.begin()];
mm[*s.begin()]->prev = it;
s.erase(s.begin());
}
it = head;
map<int, pair<int, int>> sol;
while (it) {
if (it->prev == nullptr)
sol[it->data].first = 0;
else
sol[it->data].first = it->prev->data;
if (it->next == nullptr)
sol[it->data].second = 0;
else
sol[it->data].second = it->next->data;
it = it->next;
}
for (auto& it : (sol))
cout << it.second.first << " " << it.second.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int l[maxn], r[maxn];
std::vector<int> nl;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int sz = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) nl.push_back(i), sz++;
}
int last = 0, pp = 1;
while (sz > 1) {
if (last == 0) {
int p = nl[0];
while (r[p]) p = r[p];
last = p;
}
r[last] = nl[pp];
l[nl[pp]] = last;
pp++, sz--;
while (r[last]) last = r[last];
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long _a, long long _b) {
long long _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
long long add(long long a, long long b, long long m = 1000000007) {
long long x = a + b;
while (x >= m) x -= m;
return x;
}
long long sub(long long a, long long b, long long m = 1000000007) {
long long x = a - b;
while (x < 0) x += m;
return x;
}
long long mul(long long a, long long b, long long m = 1000000007) {
long long x = a * b;
x %= m;
return x;
}
long long gcd(long long a, long long b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
long long lcm(long long a, long long b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
long long returnright(long long x, long long lr[], long long rr[],
long long n) {
long long i, o = x;
while (1) {
if (rr[o] == 0) break;
o = rr[o];
if (rr[o] == 0) break;
}
return o;
}
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
long long lr[n + 1], rr[n + 1], i, j;
for (i = 1; i <= n; i++) cin >> lr[i] >> rr[i];
vector<long long> le, ri;
bool ef[n + 1], right[n + 1];
memset(ef, false, sizeof(ef));
for (i = 1; i <= n; i++) {
if (lr[i] == 0) {
le.push_back(i);
}
if (rr[i] == 0) {
ri.push_back(i);
}
}
for (i = 0; i < le.size() - 1; i++) {
long long x = returnright(le[i], lr, rr, n);
rr[x] = le[i + 1];
lr[le[i + 1]] = x;
}
for (i = 1; i <= n; i++) cout << lr[i] << " " << rr[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l[105], r[105], sava, savb, a, b, v[105], nr, uz[105], sav;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
a = 1;
while (true) {
while (a <= n && (l[a] || uz[a])) {
a++;
}
if (a > n) break;
sav = a;
do {
uz[a] = 1;
v[++nr] = a;
a = r[a];
} while (a != 0);
a = sav + 1;
}
for (int i = 1; i <= n; i++) {
l[v[i]] = v[i - 1];
r[v[i]] = v[i + 1];
}
for (int i = 1; i <= n; i++) cout << l[i] << ' ' << r[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int par[105], nex[105];
vector<int> prev_less;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, l, r;
cin >> n;
int head = 0, x;
for (int i = 1; i <= n; i++) {
cin >> l;
cin >> r;
if (l == 0 && head == 0) {
head = i;
} else if (l == 0) {
prev_less.push_back(i);
}
if (l != 0) {
par[i] = l;
}
if (r != 0) {
nex[i] = r;
}
}
x = head;
while (nex[x] != 0) {
x = nex[x];
}
int y;
for (int i = 0; i < prev_less.size(); i++) {
y = prev_less[i];
if (y == head) {
continue;
}
par[y] = x;
nex[x] = y;
while (nex[y] != 0) {
y = nex[y];
}
x = y;
}
for (int i = 1; i <= n; i++) {
cout << par[i] << " " << nex[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > a(n + 5, {0, 0});
set<long long> l, r;
for (long long i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
if (a[i].first == 0) l.insert(i);
if (a[i].second == 0) r.insert(i);
}
for (long long i = 1; i <= n; i++) {
if (l.size() == 1 and r.size() == 1) break;
long long left = *l.begin(), right;
long long right_end = left;
while (a[right_end].second) right_end = a[right_end].second;
for (auto it : r) {
if (it == left or it == right_end) continue;
right = it;
break;
}
l.erase(left);
r.erase(right);
a[left].first = right;
a[right].second = left;
}
for (long long i = 1; i <= n; i++)
cout << a[i].first << " " << a[i].second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
bool vis[100001] = {false};
vector<long long> temp[100001];
long long cnt = 0, root;
void dfs(long long s, long long sub) {
vis[s] = true;
temp[sub].push_back(s);
for (long long i = 0; i < v[s].size(); ++i) {
if (!vis[v[s][i]]) dfs(v[s][i], sub);
}
}
int main() {
long long n, a, b;
cin >> n;
pair<long long, long long> p[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> a >> b;
p[i].first = a;
p[i].second = b;
if (a) {
v[a].push_back(i);
v[i].push_back(a);
}
if (b) {
v[i].push_back(b);
v[b].push_back(i);
}
}
long long sub = 1;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, sub);
sub++;
}
}
pair<long long, long long> rec[sub];
for (long long i = 1; i < sub; i++) {
for (long long j = 0; j < temp[i].size(); j++) {
if (p[temp[i][j]].first == 0) rec[i].first = temp[i][j];
if (p[temp[i][j]].second == 0) rec[i].second = temp[i][j];
}
}
for (long long i = 1; i < sub - 1; i++) {
p[rec[i].second].second = rec[i + 1].first;
p[rec[i + 1].first].first = rec[i].second;
}
for (long long i = 1; i <= n; i++)
cout << p[i].first << " " << p[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a < b; }
int main() {
int k = 0, n = 0, s = 0, b, c[150][3], a, l = 0, pos = 101, nac;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c[i][1] >> c[i][2];
}
while (k < n) {
l = 0;
while (c[l][1] != 0 || l == pos || l == nac) {
l++;
}
c[pos][2] = l + 1;
k++;
if (k == 1) {
nac = l;
}
if (pos != 101) {
c[l][1] = pos + 1;
}
while (c[l][2] != 0) {
k++;
l = c[l][2] - 1;
}
pos = l;
}
for (int i = 0; i < n; i++) {
cout << c[i][1] << " " << c[i][2] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vll = vector<vl>;
using pll = pair<ll, ll>;
using vb = vector<bool>;
const ll oo = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;
ll n;
vb visited;
void solve(vl &l, vl &r, ll i) {
visited[i] = true;
if (r[i] != -1) {
solve(l, r, r[i]);
} else {
for (ll j = (0); j < (n); j++) {
if (!visited[j] && l[j] == -1) {
r[i] = j;
l[j] = i;
solve(l, r, r[i]);
break;
}
}
}
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
vl l(n), r(n);
for (ll i = (0); i < (n); i++) {
cin >> l[i] >> r[i];
l[i]--;
r[i]--;
}
visited = vb(n);
for (ll i = (0); i < (n); i++) {
if (l[i] == -1) {
solve(l, r, i);
}
}
for (ll i = (0); i < (n); i++) cout << l[i] + 1 << ' ' << r[i] + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const auto INF = 0x3f3f3f3f;
const int N = 1e2 + 5;
struct node {
int l, r;
} head[N];
int pre[N];
int find(int x) {
int i, r;
r = x;
while (pre[r] != r) r = pre[r];
int j;
i = x;
while (pre[i] != r) {
j = pre[i];
pre[i] = r;
i = j;
}
return r;
}
bool mx(int a, int b) {
int fx = find(a);
int fy = find(b);
if (fx != fy) {
pre[fx] = fy;
return false;
}
return true;
}
vector<int> L, R;
bool visit[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
pre[i] = i;
head[i].l = head[i].r = 0;
}
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b);
if (a) {
head[i].l = a;
mx(i, a);
} else
L.push_back(i);
if (b) {
head[i].r = b;
mx(i, b);
} else
R.push_back(i);
if (a && b) {
mx(a, b);
}
}
for (int i = 1; i < (int)(L.size()); i++) {
int x = L[i];
for (int j = 0; j < (int)(R.size()); j++) {
if (visit[j]) continue;
int y = R[j];
if (mx(x, y)) continue;
head[x].l = y;
head[y].r = x;
visit[j] = true;
mx(x, y);
break;
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", head[i].l, head[i].r);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int l[110], r[110], st, en;
vector<pair<int, int> > a;
void DFS(int v) {
if (r[v] == 0) {
en = v;
return;
}
DFS(r[v]);
return;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
st = i;
DFS(i);
a.push_back(make_pair(st, en));
}
}
for (int i = 1; i < a.size(); i++) {
l[a[i].first] = a[i - 1].second;
r[a[i - 1].second] = a[i].first;
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
int r[N], l[N], used[N];
void dfs(int v) {
used[v] = 1;
if (r[v] == 0) {
for (int i = 1; i <= n; i++) {
if (l[i] == 0 && !used[i]) {
l[i] = v;
r[v] = i;
dfs(v);
break;
}
}
} else {
dfs(r[v]);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0) {
dfs(i);
break;
}
}
for (int i = 1; i <= n; i++) {
cout << l[i] << ' ' << r[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int l[104], r[105];
stack<int> st;
int main() {
int n, i, j, beg = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) {
if (beg == 0)
beg = i;
else
st.push(i);
}
}
while (!st.empty()) {
while (r[beg]) beg = r[beg];
if (!st.empty()) {
r[beg] = st.top();
l[st.top()] = beg;
st.pop();
}
}
for (i = 1; i <= n; i++) cout << l[i] << " " << r[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> vec(n + 1);
vector<int> noL;
for (int i = 1; i < n + 1; i++) {
cin >> vec[i].first >> vec[i].second;
if (!vec[i].first) {
noL.push_back(i);
}
}
deque<int> res;
res.push_back(noL.back());
noL.pop_back();
while (res.size() != n) {
int curr = res.back();
if (int next = vec[curr].second) {
res.push_back(next);
} else {
next = noL.back();
noL.pop_back();
vec[curr].second = next;
vec[next].first = curr;
res.push_back(next);
}
}
for (int i = 1; i < n + 1; i++) {
cout << vec[i].first << " " << vec[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
int uf[N];
int root(int x) {
int r = x;
while (uf[r] >= 0) r = uf[r];
int t;
while (uf[x] >= 0) {
t = uf[x];
uf[x] = r;
x = t;
}
return r;
}
void join(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return;
if (uf[x] < uf[y]) {
uf[x] += uf[y];
uf[y] = x;
} else {
uf[y] += uf[x];
uf[x] = y;
}
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(uf, -1, sizeof(uf));
int n;
cin >> n;
vector<int> l(n + 1), r(n + 1), free_left, free_right;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i]) join(i, l[i]);
if (r[i]) join(i, r[i]);
if (l[i] == 0) free_right.push_back(i);
if (r[i] == 0) free_left.push_back(i);
}
while ((int)free_left.size() > 1) {
int y = free_right.back();
free_right.pop_back();
int x = free_left.back();
free_left.pop_back();
if (root(x) == root(y)) {
int t = x;
x = free_left.back();
free_left.pop_back();
free_left.push_back(t);
assert(root(x) != root(y));
}
r[x] = y;
l[y] = x;
join(x, y);
}
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<vector<int>>> connections;
vector<vector<int>> input = {{-1, -1}};
void connect(int r, int listIndex) {
if (!r) return;
connections[listIndex].push_back({input[r][0], r, input[r][1]});
connect(input[r][1], listIndex);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
input.push_back({l, r});
}
int currentList = 0;
for (int i = 1; i <= n; i++) {
if (!input[i][0]) {
connections.push_back({{input[i][0], i, input[i][1]}});
connect(input[i][1], currentList);
currentList++;
}
}
for (int i = 0; i < connections.size() - 1; i++) {
connections[i][connections[i].size() - 1][2] = connections[i + 1][0][1];
connections[i + 1][0][0] = connections[i][connections[i].size() - 1][1];
}
for (int z = 1; z <= n; z++) {
bool flag = false;
for (int i = 0; i < connections.size() && !flag; i++) {
for (int j = 0; j < connections[i].size() && !flag; j++) {
if (connections[i][j][1] == z) {
cout << connections[i][j][0] << " " << connections[i][j][2] << endl;
flag = true;
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > a(n + 5, {0, 0});
set<long long> l, r;
for (long long i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
if (a[i].first == 0) l.insert(i);
if (a[i].second == 0) r.insert(i);
}
for (long long i = 1; i <= n; i++) {
if (l.size() == 1 and r.size() == 1) break;
auto it = l.begin();
long long left = *it, right;
l.erase(left);
for (auto it1 = r.begin(); it1 != r.end(); it1++) {
if (*it1 == left) continue;
bool chosen = true;
right = *it1;
for (long long k = left;;) {
k = a[k].second;
if (!k) break;
if (k == right) {
chosen = false;
break;
}
}
if (chosen) {
break;
}
}
r.erase(right);
a[left].first = right;
a[right].second = left;
}
for (long long i = 1; i <= n; i++) {
cout << a[i].first << " " << a[i].second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> count(16);
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < k; j++) {
int x;
cin >> x;
sum = sum * 2 + x;
}
count[sum] += 1;
}
int ans = 0;
if (count[0] > 0)
ans = 1;
else {
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if (count[i] == 0 || count[j] == 0) continue;
if (i == j and count[j] < 2) continue;
if (i & j) continue;
ans = 1;
}
}
}
ans == 1 ? cout << "YES\n" : cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> ok[N];
int d[5];
int t[7];
map<pair<int, int>, int> a = {{{1, 2}, 1}, {{1, 3}, 2}, {{1, 4}, 3},
{{2, 3}, 4}, {{2, 4}, 5}, {{3, 4}, 6}};
void add(int i) {
if (ok[i][1] < ok[i][0]) swap(ok[i][1], ok[i][0]);
t[a[make_pair(ok[i][0], ok[i][1])]]++;
}
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
int mx = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
int x;
cin >> x;
if (x == 0) {
ok[i].push_back(j);
mx = max(mx, int(ok[i].size()));
d[j]++;
}
}
for (int i = 1; i <= k; i++)
if (!d[i]) {
cout << "NO";
return 0;
}
if (mx == k) {
cout << "YES";
return 0;
}
if (k == 2) cout << "YES";
if (k == 3) {
if (mx == 2)
cout << "YES";
else
cout << "NO";
}
if (k == 4) {
if (mx == 3) cout << "YES";
if (mx == 2) {
for (int i = 1; i <= n; i++)
if (ok[i].size() == 2) add(i);
if ((t[1] && t[6]) || (t[2] && t[5]) || (t[3] && t[4]))
cout << "YES";
else
cout << "NO";
}
if (mx == 1) cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int lowbit(int x) { return x & (-x); }
long long quickmod(long long x, long long y, long long mod) {
x = x % mod;
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
y >>= 1;
x = x * x % mod;
}
return ans;
}
const int INF = 0x3f3f3f3f;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const int MOD = 1e9 + 7;
int n, k;
struct NUM {
int v[4];
} num[100005];
int used[100];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
int temp = 0;
for (int j = 1; j <= k; j++) {
scanf("%d", &num[i].v[j]);
if (num[i].v[j]) temp = temp | (1 << (j - 1));
}
used[temp]++;
}
int cnt = (1 << k);
int flag = 0;
for (int i = 0; i < cnt; i++) {
for (int j = 0; j < cnt; j++) {
if (used[i] && used[j] && (i & j) == 0) flag = 1;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int a[5];
int f[20];
int main() {
int n, k, x;
while (~scanf("%d%d", &n, &k)) {
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &x);
cnt = cnt * 2 + x;
}
f[cnt]++;
}
if (f[0]) {
printf("YES\n");
continue;
}
int flag = 0;
for (int i = 0; i <= 16; i++) {
for (int j = 0; j <= 16; j++) {
if (f[i] && f[j] && i != j) {
memset(a, 0, sizeof(a));
int xx = i, yy = j;
int pos = 0;
while (xx) {
a[pos++] += xx % 2;
xx >>= 1;
}
pos = 0;
while (yy) {
a[pos++] += yy % 2;
yy >>= 1;
}
int count = 0;
for (int o = 0; o < 4; o++) {
if (a[o] <= 1) count++;
}
if (count == 4) {
flag = 1;
break;
}
}
}
if (flag) break;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, a[16] = {0}, q[5] = {0};
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
cin >> q[j];
}
a[q[1] + q[2] * 2 + q[3] * 4 + q[4] * 8] = 1;
}
if (a[0]) {
cout << "YES" << endl;
return 0;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if (((i & j) == 0) && a[i] && a[j]) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sign[17];
int main() {
int n, m, x;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int f = 0;
for (int j = 0; j < m; j++) {
scanf("%d", &x);
if (x) f |= (1 << j);
}
sign[f] = 1;
}
for (int i = 0; i < 16; i++) {
for (int j = i; j < 16; j++) {
if (!(i & j) && sign[i] && sign[j]) {
printf("YES\n");
return 0;
}
}
}
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, i, j, x;
cin >> n >> k;
vector<int> a(k);
set<int> s;
for (i = 0; i < n; i++) {
x = 0;
for (j = 0; j < k; j++) {
cin >> a[j];
if (a[j]) x += 1 << j;
}
s.insert(x);
}
bool solved = false;
if (s.find(0) != s.end())
solved = true;
else {
for (auto p : s) {
for (auto q : s) {
if ((p & q) == 0) solved = true;
}
}
}
if (solved)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
long n, k;
scanf("%ld %ld", &n, &k);
std::set<long> s;
for (long p = 0; p < n; p++) {
long x(0);
for (long q = 0; q < k; q++) {
long b;
scanf("%ld", &b);
x = 2 * x + b;
}
s.insert(x);
}
std::vector<long> v;
for (std::set<long>::iterator it = s.begin(); it != s.end(); it++) {
v.push_back(*it);
}
bool possible(*s.begin() == 0);
for (long p = 0; p < v.size(); p++) {
if (possible) {
break;
}
for (long q = p + 1; q < v.size(); q++) {
if ((v[p] & v[q]) == 0) {
possible = true;
break;
}
}
}
puts(possible ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 0x3f3f3f3f3f3f3f3f;
int n, k;
int cnt[64];
bool valid(int x) {
int CNT[6], sum = 0;
memset(CNT, 0, sizeof(CNT));
for (int i = 0; i < (1 << k); i++) {
if (((1 << i) & x) != 0 && cnt[i]) {
sum++;
for (int j = 0; j < k; j++) {
if ((1 << j) & i) {
CNT[j]++;
}
}
}
}
if (sum == 0) return false;
for (int i = 0; i < k; i++) {
if ((CNT[i] * 2) > sum) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &k);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) {
int code = 0;
for (int j = 0; j < k; j++) {
int tmp;
scanf("%d", &tmp);
if (tmp) code |= (1 << j);
}
cnt[code]++;
}
bool flag = false;
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
}
}
int limit = (1 << k);
limit = (1 << limit);
for (int i = 1; i < limit; i++) {
if (valid(i)) {
flag = true;
break;
}
}
puts(flag ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100007][5], s[100007][5], d[5], cnt = 1, ss[100007], t, se[5];
bool kt, kt2;
void chay(int j, int tg) {
if (j == k + 1) {
if (tg == 2) {
for (int i = 0; i <= k; ++i) ss[i] = 0;
for (int i = 1; i <= n; ++i) {
int t = 0;
for (int j = 1; j <= k; ++j) t += (a[i][j] == d[j]);
ss[t] = 1;
}
if (ss[k] && ss[0]) kt2 = 1;
}
return;
}
for (int i = 0; i < 2; ++i) {
if (tg == 2 && i == 1) continue;
d[j] = i;
chay(j + 1, tg + i);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
cin >> a[i][j], s[i][j] = s[i][j - 1] + a[i][j];
if (!a[i][j]) se[j] = 1;
}
if (s[i][k] == 0) {
cout << "YES";
return 0;
}
if (s[i][k] == 1) kt = 1;
}
chay(1, 0);
if (kt2)
cout << "YES";
else {
if (kt) {
int c = 0;
for (int i = 1; i <= k; ++i)
if (se[i]) ++c;
if (c == k)
cout << "YES";
else
cout << "NO";
return 0;
} else
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool problem[16];
bool test(int msk) {
vector<int> know(k, 0);
int q = 0;
for (int i = 0; i < 16; i++) {
if (msk & (1 << i)) {
for (int j = 0; j < 4; j++)
if (i & (1 << j)) know[j]++;
if (problem[i])
++q;
else
return false;
}
}
if (*max_element(know.begin(), know.end()) > (q / 2)) return false;
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
int msk = 0;
for (int b, j = k - 1; j >= 0; j--) {
cin >> b;
if (b) msk |= (1 << j);
}
problem[msk] = true;
}
for (int i = 1; i < (1 << 16); i++) {
if (test(i)) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
map<long long, bool> mp;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long sum = 0, mask = 0;
for (long long j = 0; j < m; j++) {
long long x;
cin >> x;
mask |= (1 << j) * x;
sum += x;
}
mp[mask] = true;
if (!sum) return cout << "YES\n", 0;
}
for (long long i = 0; i < (1 << m); i++) {
for (long long j = 0; j < (1 << m); j++) {
if (mp[i] && mp[j] && (i + j) == (i ^ j)) return cout << "YES\n", 0;
}
}
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int a[N], cnt[20];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
int x;
scanf("%d", &x);
a[i] |= x << j;
}
++cnt[a[i]];
}
for (int i = 0; i < 1 << k; i++) {
for (int j = 0; j < 1 << k; j++) {
if (cnt[j] && cnt[i] && (i & j) == 0) {
printf("YES");
return 0;
}
}
}
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXBUF = 10000;
char buf[MAXBUF], *ps = buf, *pe = buf + 1;
inline void rnext() {
if (++ps == pe)
pe = (ps = buf) +
fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool rin(T &res) {
res = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do {
res = (res << 1) + (res << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
res *= f;
return true;
}
int a[20];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, flag = 0, ss;
rin(n);
rin(k);
for (int i = 0; i < n; i++) {
int t, tsum = 0;
ss = 0;
for (int j = 1; j <= k; j++) {
rin(t);
ss += t << (k - j);
tsum += t;
}
if (!tsum) flag++;
a[ss]++;
}
if (flag) {
cout << "YES" << endl;
return 0;
}
for (int i = 0; i < 15; i++) {
if (!a[i]) continue;
for (int j = i; j < 16; j++) {
if (!a[j]) continue;
if (!(i & j)) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, C[16], K;
int main() {
int i, j, a;
scanf("%d%d", &n, &K);
for (i = 0; i < n; i++) {
int s = 0;
for (j = 0; j < K; j++) {
scanf("%d", &a);
s += (a << j);
}
if (s == 0) {
puts("YES");
return 0;
}
C[s]++;
}
for (int i = 0; i < (1 << K); i++) {
for (int j = 0; j < (1 << K); j++) {
if (i & j) continue;
if (C[i] != 0 && C[j] != 0) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a[20];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, flag = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t, tsum = 0;
int ss = 0;
for (int j = 0; j < k; j++) {
cin >> t;
ss += t << (k - j - 1);
tsum += t;
}
if (!tsum) flag++;
a[ss]++;
}
for (int i = 0; i < 15; i++) {
if (!a[i]) continue;
for (int j = i; j < 16; j++) {
if (!a[j]) continue;
if (!(i & j)) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, sum[100];
vector<int> v;
bool Judge(int S) {
int cnt[6];
memset(cnt, 0, sizeof(cnt));
for (int t = 0; t < 16; t++) {
if (S & (1 << t)) {
int now = t;
for (int i = 1; i <= 4; i++) {
if (now & 1)
cnt[i]++;
else
cnt[i]--;
now >>= 1;
}
}
}
for (int i = 1; i <= 4; i++)
if (cnt[i] > 0) return false;
return true;
}
void Prepare() {
v.clear();
for (int S = 1; S < (1 << 16); S++)
if (Judge(S)) v.push_back(S);
}
void Init() {
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= n; i++) {
int now = 0;
for (int j = 1; j <= K; j++) {
int t;
scanf("%d", &t);
now = (now << 1) + t;
}
sum[now]++;
}
}
void Solve() {
int tot = v.size();
bool flag = false;
for (int i = 0; i < tot; i++) {
int S = v[i];
flag = true;
for (int t = 0; t < 16; t++)
if (S & (1 << t)) {
if (sum[t] == 0) flag = false;
}
if (flag) {
break;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
int main() {
Prepare();
while (~scanf("%d%d", &n, &K)) {
Init();
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long 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;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
inline int STRLEN(char *s) {
int p = 0;
while (s[p]) p++;
return p;
}
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
const long long inf = 2147383647LL;
const long long mod = 1e9 + 7;
const int Size = 200005;
int N, K;
int A[Size];
map<int, int> Map;
vector<int> List;
int teamcnt[5];
bool isok(int mask) {
int total = 0;
memset(teamcnt, 0, sizeof(teamcnt));
for (int p = 0; p < List.size(); p++) {
if ((!((mask & (1LL << p)) == 0))) {
total++;
int tmask = List[p];
for (int team = 0; team < K; team++) {
if ((!((tmask & (1LL << team)) == 0))) {
teamcnt[team]++;
}
}
}
}
for (int team = 0; team < K; team++) {
int tcnt = teamcnt[team];
if (tcnt * 2 > total) return false;
}
return true;
}
bool solve() {
int Len = List.size();
for (int mask = 1; mask < (1 << Len); mask++) {
if (isok(mask)) return true;
}
return false;
}
int main() {
scanf("%d %d", &N, &K);
for (int i = 0; i < N; i++) {
int mask = 0;
for (int t = 0; t < K; t++) {
int s;
scanf("%d", &s);
if (s == 1) mask = (mask | (1LL << t));
}
if (Map[mask] == 0) List.push_back(mask);
Map[mask] = 1;
}
if (solve())
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long min(long long a, long long b) { return (a < b) ? a : b; }
long long gcd(long long a, long long b) {
while (1) {
if (a == 0) return b;
b %= a;
if (b == 0) return a;
a %= b;
}
}
int main() {
long long n, m, i, j, t, k;
t = 1;
for (long long ii = 0; ii < t; ii++) {
cin >> n >> k;
vector<long long> p(20);
long long s = 0, q = 0;
for (i = 0; i < n; i++) {
s = 0;
for (j = 0; j < k; j++) {
cin >> m;
s += m * pow(2, k - j - 1);
}
p[s]++;
m = pow(2, k) - 1 - s;
if (p[m] != 0 || s == 0) {
q = 1;
}
}
if (q == 1) {
cout << "YES" << endl;
return 0;
}
for (i = 1; i <= 15; i++) {
if (p[i] == 0) continue;
for (j = i + 1; j <= 15; j++) {
if (p[j] != 0 && (j & i) == 0) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec[200000];
int main() {
long long sum1 = 0, i, flag = 0, j, k, n, num, maxi = 1000000, index,
cnt[4] = {0};
long long taken = 0, endflag = 0;
long long tp = 0;
scanf("%lld %lld", &n, &k);
for (i = 0; i < n; i++) {
sum1 = 0;
for (j = 0; j < k; j++) {
scanf("%lld", &num);
vec[i].push_back(num);
sum1 = sum1 + num;
}
if (sum1 <= maxi) {
maxi = sum1;
index = i;
}
}
for (j = 0; j < k; j++) cnt[j] = cnt[j] + vec[index][j];
taken = 1;
for (j = 0; j < k; j++) {
if (cnt[j] == 0) tp++;
}
if (tp == k) {
printf("YES\n");
return 0;
}
for (i = 0; i < n; i++) {
if (i == index) continue;
flag = 0;
endflag = 0;
for (j = 0; j < k; j++) {
if (cnt[j] + vec[i][j] > (taken + 1) / 2) {
flag = 1;
break;
}
}
if (flag == 0) {
for (j = 0; j < k; j++) cnt[j] += vec[i][j];
taken++;
for (j = 0; j < k; j++) {
if (cnt[j] > taken / 2) {
endflag = 1;
printf("dsdsf\n");
break;
}
}
}
if (flag == 0 && endflag == 0) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 1000000;
const long long mod = 1e9 + 7;
using namespace std;
vector<int> a;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < k; j++) {
sum *= 2;
int t;
cin >> t;
sum += t;
}
a.push_back(sum);
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
if (a[0] == 0) {
cout << "YES"
<< "\n";
return 0;
}
for (int i = 0; i < a.size() - 1; i++) {
for (int j = i + 1; j < a.size(); j++) {
int t = a[i] & a[j];
if (!t) {
cout << "YES"
<< "\n";
return 0;
}
}
}
cout << "NO"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<string> st;
int n, k;
bool solve(set<string>::iterator it, vector<int> v, int problemas) {
if (it == st.end()) return 0;
vector<int> tomar = v;
string problema = *it;
bool da = true;
for (int i = 0; i < k; ++i) {
if (problema[i] == '1') {
tomar[i]++;
}
if (tomar[i] * 2 > problemas + 1) {
da = false;
}
}
if (da)
return 1;
else {
it++;
return max(solve(it, v, problemas), solve(it, tomar, problemas + 1));
}
}
int main() {
cin >> n >> k;
string s;
char c;
for (int i = 0; i < n; ++i) {
s = "";
for (int j = 0; j < k; ++j) {
cin >> c;
s += c;
}
st.insert(s);
}
if (solve(st.begin(), vector<int>(k, 0), 0))
cout << "YES\n";
else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int VM = 16;
bitset<VM> c;
int p[VM];
int main() {
int n, e;
cin >> n >> e;
for (int i = 0; i < n; i++) {
int cod = 0;
for (int j = 0; j < e; j++) {
int x;
cin >> x;
if (x == 1) {
cod += (1 << j);
}
}
c[cod] = 1;
}
int np = 0;
for (int i = 0; i < VM; i++) {
if (c[i]) {
p[np++] = i;
}
}
bool exista = false;
int nr[e];
for (int i = 1; i < (1 << np); i++) {
int nrprob = 0;
for (int k = 0; k < e; k++) {
nr[k] = 0;
}
for (int j = 0; j < np; j++) {
if (i & (1 << j)) {
nrprob++;
for (int k = 0; k < e; k++) {
if (p[j] & (1 << k)) {
nr[k]++;
}
}
}
}
bool probleme_ok = true;
for (int k = 0; k < e; k++) {
if (nr[k] > nrprob / 2) {
probleme_ok = false;
}
}
if (probleme_ok) {
exista = true;
}
}
if (exista) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
int g[100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
int cur = 0;
for (int j = 0; j < k; ++j) {
int a;
cin >> a;
a = 1 - a;
cur |= (a << j);
}
if (cur == (1 << k) - 1) {
cout << "YES";
return 0;
}
for (int j = 0; j < (1 << k); ++j) {
if (!g[j]) continue;
if ((j | cur) == (1 << k) - 1) {
cout << "YES";
return 0;
}
}
g[cur] = 1;
}
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool f[100], flag;
int n, k, a[100005][30];
int get(int o) {
int x = 1, s = 0;
for (int i = 1; i <= k; ++i) s += x * a[o][i], x <<= 1;
return s;
}
void insert(int x, int t = 1, int s = 0, int q = 1) {
if (t > k) {
f[s] = 1;
return;
}
for (int i = 0; i <= 1 - a[x][t]; ++i) insert(x, t + 1, s + i * q, q * 2);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
flag = 0;
for (int j = 1; j <= k; ++j) {
scanf("%d", &a[i][j]);
if (a[i][j] == 1) flag = 1;
}
if (!flag) return puts("YES"), 0;
if (f[get(i)]) return puts("YES"), 0;
insert(i);
}
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct data {
int id, cnt;
int can[5];
bool friend operator<(data x, data y) { return x.cnt < y.cnt; }
} p[N];
int can[N], cnt[50], n, k;
void solve() {
int i;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= k; ++j) {
if (p[i].can[j]) can[i] |= (1 << j);
if (p[i].cnt == 0) {
puts("YES");
return;
}
}
for (int i = 1; i <= n; ++i) cnt[can[i]]++;
int t = (1 << 5);
for (int i = 1; i < t - 1; ++i)
for (int j = i + 1; j < t - 1; ++j)
if (cnt[i] && cnt[j]) {
if ((i & j) == 0) {
puts("YES");
return;
}
}
puts("NO");
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j)
scanf("%d", &p[i].can[j]), p[i].cnt += p[i].can[j];
p[i].id = i;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000009;
double PI = 4 * atan(1);
int n, k;
int C[16];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
int s = 0;
for (int j = 0; j < k; j++) {
int a;
cin >> a;
s += (a << j);
}
if (s == 0) {
cout << "YES";
return 0;
}
C[s]++;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if (i & j) continue;
if (C[i] && C[j]) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 100005;
int n, m;
vector<int> a[16];
bool ok() {
int x, st = 1 << m;
for (int i = 0; i < (st); i++)
for (int j = 0; j < (st); j++) {
if (i & j) continue;
if (!a[i].empty() && !a[j].empty()) return 1;
}
return 0;
}
int main() {
int d, x;
while (~scanf("%d %d", &n, &m)) {
for (int i = 0; i < ((1 << m)); i++) a[i].clear();
for (int i = 0; i < (n); i++) {
d = 0;
for (int j = 0; j < (m); j++) {
scanf("%d", &x);
if (x) d |= 1 << j;
}
a[d].push_back(i);
}
puts(ok() ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int f[101];
memset(f, 0, sizeof(f));
int n, k, flag;
int i, j, x;
cin >> n >> k;
for (i = 1; i <= n; i++) {
int cnt = 0;
for (j = 1; j <= k; j++) {
cin >> x;
cnt += (1 << j - 1) * x;
}
f[cnt] = 1;
}
flag = 0;
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
if (!(i & j) && f[i] && f[j]) {
flag = 1;
}
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[27];
int main() {
int n, k;
int t, mi, z;
while (~scanf("%d %d", &n, &k)) {
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
t = 0, mi = 1 << (k - 1);
for (int j = 0; j < k; j++) {
scanf("%d", &z);
t += z * mi;
mi /= 2;
}
a[t]++;
}
bool flag = false;
for (int i = 0; i < (1 << k); i++) {
if (a[i] != 0) {
for (int j = 0; j < (1 << k); j++) {
if (a[j] != 0 && ((i & j) == 0)) {
flag = true;
printf("YES\n");
break;
}
}
}
if (flag) break;
}
if (!flag) printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool dp[1009];
void test_case() {
long long n, k;
cin >> n >> k;
long long arr[n][k];
for (long long i = 0; i < (long long)(n); i++) {
long long mask = 0;
for (long long j = 0; j < (long long)(k); j++) {
cin >> arr[i][j];
if (arr[i][j]) {
mask |= (1 << j);
}
}
dp[mask] = true;
if (mask == 0) {
cout << "YES"
<< "\n";
;
return;
}
}
for (long long i = 0; i < (1 << k); i++) {
for (long long j = 0; j < (1 << k); j++) {
if (dp[i] && dp[j] && (i & j) == 0) {
cout << "YES"
<< "\n";
;
return;
}
}
}
cout << "NO"
<< "\n";
;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
long long t = 1;
while (t--) {
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool chk[16];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int s = 0, x;
for (int j = 0; j < k; j++) {
scanf("%d", &x);
s = s * 2 + x;
}
if (s == 0) return 0 & puts("YES");
chk[s] = true;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if (i & j) continue;
if (chk[i] && chk[j]) return 0 & puts("YES");
}
}
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, t[16];
string init(string data) {
for (auto i = data.size(); i < 4; ++i) data.push_back('0');
return data;
}
int getNum(string data) {
int num = 0;
for (int i = 0; i < data.size(); i++) {
num += (data[i] - '0') * pow(2, 4 - i);
}
return num / 2;
}
void end() {
cout << "YES" << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
string data;
char c;
for (int i = 0; i < k; i++) {
cin >> c;
data.push_back(c);
}
++t[getNum(init(data))];
}
if (t[0]) end();
if (t[1])
if (t[2] || t[4] || t[6] || t[8] || t[10] || t[12] || t[14]) end();
if (t[2])
if (t[4] || t[5] || t[8] || t[9] || t[12] || t[13]) end();
if (t[4])
if (t[3] || t[8] || t[9] || t[10] || t[11]) end();
if (t[8])
if (t[3] || t[5] || t[6] || t[7]) end();
if (t[3] && t[12]) end();
if (t[5] && t[10]) end();
if (t[6] && t[9]) end();
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
bool mp[maxn][5];
int kkk[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++) cin >> mp[i][j];
bool flag = false;
for (int i = 0; i < n; i++) {
int num = 0;
for (int j = 0; j < k; j++)
if (mp[i][j]) num |= 1 << j;
kkk[num]++;
}
for (int i = 0; i < 1 << k; i++)
for (int j = 0; j < 1 << k; j++)
if ((i & j) == 0 && (kkk[i] && kkk[j])) flag = true;
cout << (flag ? "YES" : "NO") << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 1000000;
const long long mod = 1e9 + 7;
using namespace std;
int a[20];
vector<int> b;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < k; j++) {
sum *= 2;
int t;
cin >> t;
sum += t;
}
a[sum]++;
}
for (int i = 0; i <= (1 << k); i++)
if (a[i]) b.push_back(i);
if (b[0] == 0) {
cout << "YES"
<< "\n";
return 0;
}
for (int i = 0; i < b.size() - 1; i++) {
for (int j = i + 1; j < b.size(); j++) {
int t = b[i] & b[j];
if (!t) {
cout << "YES"
<< "\n";
return 0;
}
}
}
cout << "NO"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-12;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
const int maxn = 1e5 + 5;
int n, k;
int a[maxn];
int cnt[100];
void solve() {
cin >> n >> k;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (k); j++) {
int x;
cin >> x;
a[i] = a[i] * 2 + x;
}
cnt[a[i]]++;
}
if (!k) {
for (int i = (0); i < (n); i++)
if (!a[i]) {
cout << "YES\n";
return;
}
}
for (int i = (0); i < (n); i++)
for (int msk = (0); msk < (1 << k); msk++)
if ((msk & a[i]) == a[i]) {
int t = a[i] ^ msk;
if (cnt[t]) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
int JUDGE_ONLINE = 1;
if (fopen("in.txt", "r")) {
JUDGE_ONLINE = 0;
assert(freopen("in.txt", "r", stdin));
} else {
ios_base::sync_with_stdio(0), cin.tie(0);
}
solve();
if (!JUDGE_ONLINE) {
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[16];
int main() {
int n, k;
int t, mi, z;
while (~scanf("%d %d", &n, &k)) {
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
t = 0, mi = 1 << (k - 1);
for (int j = 0; j < k; j++) {
scanf("%d", &z);
t += z * mi;
mi /= 2;
}
a[t]++;
}
bool flag = false;
for (int i = 0; i < (1 << k); i++) {
if (a[i] != 0) {
for (int j = 0; j < (1 << k); j++) {
if (a[j] != 0 && ((i & j) == 0)) {
flag = true;
printf("YES\n");
break;
}
}
}
if (flag) break;
}
if (!flag) printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(1e5) + 10;
const int MOD = int(1e9) + 7;
const int oo = INT_MAX;
int n, k;
bool check(const vector<int>& all, int mask) {
int t = __builtin_popcount(mask);
for (int i = 0; i < k; ++i) {
int cnt = 0;
for (int j = 0; j < int((all).size()); ++j) {
if ((mask >> j) & 1) {
cnt += ((all[j] >> i) & 1);
}
}
if (cnt * 2 > t) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
while (cin >> n >> k) {
vector<int> all;
for (int i = 0; i < n; ++i) {
int mask = 0;
for (int j = 0; j < k; ++j) {
int x;
cin >> x;
mask |= (x << j);
}
all.push_back(mask);
}
sort((all).begin(), (all).end());
all.resize(unique((all).begin(), (all).end()) - all.begin());
bool can = false;
int sz = int((all).size());
for (int i = 1; i < (1 << sz); ++i) {
can |= check(all, i);
}
cout << (can ? "YES" : "NO") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[100100][5];
int ct[5];
int ctt[5][5];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) cin >> val[i][j], ct[j] += val[i][j];
}
for (int i = 1; i <= k; i++) {
if (ct[i] == n) {
cout << "NO" << endl;
return 0;
}
}
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= k; j++) {
cnt += val[i][j];
}
if (cnt <= 1) {
cout << "YES" << endl;
return 0;
}
}
if (k < 4) {
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= 4; j++) {
cnt += val[i][j];
}
if (cnt != 2) continue;
int id1 = 0, id2;
for (int j = 1; j <= 4; j++) {
if (val[i][j]) {
id2 = j;
if (id1 == 0) id1 = id2;
}
}
ctt[id1][id2]++;
}
if (ctt[1][2] && ctt[3][4]) {
cout << "YES" << endl;
return 0;
}
if (ctt[1][3] && ctt[2][4]) {
cout << "YES" << endl;
return 0;
}
if (ctt[1][4] && ctt[2][3]) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int m = 1000000007;
int main() {
long long int t = 1;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int a;
long long int g = 0;
long long int flag = 0;
long long int arr[17] = {};
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
cin >> a;
if (a == 1) {
g += (1 << (k - j - 1));
}
}
arr[g]++;
g = 0;
}
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++)
if (!(i & j) && arr[i] && arr[j]) flag = -1;
if (flag == -1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, k, a[N], b[20];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1, x; i <= n; i++) {
for (int j = 1; j <= k; j++) scanf("%d", &x), a[i] = a[i] * 2 + x;
b[a[i]]++;
}
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++)
if (!(i & j) && b[i] && b[j]) return puts("YES"), 0;
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const long long INF = 1e18;
int main() {
int n, k;
bool appear[20];
memset(appear, false, sizeof(appear));
cin >> n >> k;
for (int i = 0; i < n; i++) {
int m = 0;
for (int j = 0; j < k; j++) {
int x;
scanf("%d", &x);
m = (m << 1) + x;
}
appear[m] = true;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if ((i & j) == 0 && appear[i] && appear[j]) {
puts("YES");
return 0;
}
}
}
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> arr;
map<vector<int>, int> check;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
vector<int> v;
for (int j = 0; j < k; j++) {
int val;
cin >> val;
v.push_back(val);
}
if (check[v] == 0) {
check[v]++;
arr.push_back(v);
}
}
for (int i = 0; i < arr.size(); i++) {
for (int j = 0; j < arr.size(); j++) {
int cnt = 0;
for (int q = 0; q < k; q++)
if (arr[i][q] == 1 && arr[j][q] == 1)
break;
else
cnt++;
if (cnt == k) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5;
int num[maxn];
int dp[20];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &num[j]);
ans = ans * 2 + num[j];
}
dp[ans] = 1;
}
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++) {
if (dp[i] && dp[j] && !(i & j)) {
printf("YES");
return 0;
}
}
printf("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, f[4], mask, z[1 << 4], ok = 0;
int main() {
cin >> n >> k;
for (int i = 0; i < k; ++i) mask |= (1 << i);
for (int i = 0; i < n; ++i) {
int s = 0;
for (int j = 0; j < k; ++j) {
int v;
scanf("%d", &v);
if (v) s |= (1 << j);
}
z[s]++;
if (s == 0) ok = 1;
}
for (int i = 1; i < (1 << k); ++i) {
int g = mask ^ i;
if (!z[i]) continue;
for (int j = 1; j < (1 << k); ++j) {
bool sub = 1;
if (!z[j]) continue;
for (int jj = 0; jj < k; ++jj) {
if (((j >> jj) & 1) && (((g >> jj) & 1) == 0)) sub = 0;
}
if (sub) {
ok = 1;
}
}
}
puts(ok ? "yes" : "no");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, probs[16];
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) {
int c = 0;
for (int j = 0; j < K; j++) {
int c_i;
cin >> c_i;
c += c_i ? (1 << j) : 0;
}
probs[c]++;
}
for (int i = 0; i < (1 << K); i++) {
if (probs[i] == 0) {
continue;
}
for (int j = 0; j < (1 << K); j++) {
if (probs[j] == 0) {
continue;
}
if ((i & j) == 0) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100005][10], type[20];
vector<int> tot;
map<int, int> Hash;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
cin >> a[i][j];
}
}
if (k == 1) {
tot.push_back(3);
tot.push_back(2);
} else if (k == 2) {
tot.push_back(33);
tot.push_back(32);
tot.push_back(23);
tot.push_back(22);
} else if (k == 3) {
tot.push_back(333);
tot.push_back(332);
tot.push_back(323);
tot.push_back(233);
tot.push_back(223);
tot.push_back(232);
tot.push_back(322);
tot.push_back(222);
} else if (k == 4) {
tot.push_back(2222);
tot.push_back(2223);
tot.push_back(2232);
tot.push_back(2322);
tot.push_back(3222);
tot.push_back(2233);
tot.push_back(2332);
tot.push_back(3322);
tot.push_back(2323);
tot.push_back(3232);
tot.push_back(3223);
tot.push_back(3332);
tot.push_back(3323);
tot.push_back(3233);
tot.push_back(2333);
tot.push_back(3333);
}
for (int i = 1; i <= n; ++i) {
int num = 0;
for (int j = 1; j <= k; ++j) {
num = num * 10;
num += a[i][j] + 1;
}
Hash[num]++;
}
for (int i = 1; i <= n; ++i) {
int num = 0;
for (int j = 1; j <= k; ++j) {
num = num * 10;
num += a[i][j] + 1;
}
for (int j = 0; j < tot.size(); ++j) {
if (Hash[tot[j] - num]) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
set<int> st;
set<int>::iterator it;
int n, k;
int q[MAX];
void get(int x) {
int M = pow(2, k) - 1;
for (int i = 0; i < M; ++i) {
if ((i & x) == 0) st.insert(i);
}
}
bool solve() {
if (n == 1 && q[1] == 0) return true;
for (int i = 1; i <= n; ++i) {
it = st.find(q[i]);
if (it == st.end()) {
get(q[i]);
} else
return true;
}
return false;
}
int main(void) {
int x;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
int res = 0;
for (int j = 1; j <= k; ++j) {
scanf("%d", &x);
res = res * 2 + x;
}
q[i] = res;
}
if (solve())
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[5];
int main() {
while (~scanf("%d %d", &n, &k)) {
vector<int> vec;
int vis[1005];
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; ++i) {
int temp = 0;
for (int j = 0; j < k; ++j) {
scanf("%d", &a[j]);
int z = a[j] * (1 << (k - 1 - j));
temp += z;
}
if (vis[temp] == 0) {
vec.push_back(temp);
vis[temp]++;
}
}
int flag = 0;
for (int i = 0; i < vec.size(); ++i) {
for (int j = 0; j < vec.size(); ++j) {
if ((vec[i] & vec[j]) == 0) flag = 1;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
int a;
int arr[16];
for (int i = 0; i < 16; i++) arr[i] = 0;
for (int i = 0; i < n; i++) {
int s = 0;
for (int j = 0; j < k; j++) {
cin >> a;
s += (a << j);
}
if (s == 0) {
cout << "YES";
return 0;
break;
}
arr[s]++;
}
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
if (i & j != 0) continue;
if (arr[i] && arr[j] && ((i & j) == 0)) {
cout << "YES";
return 0;
break;
}
}
}
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const int MAX = 4e5 + 10;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline void read(T& num) {
bool start = false, neg = false;
char c;
num = 0;
while ((c = getchar()) != EOF) {
if (c == '-')
start = neg = true;
else if (c >= '0' && c <= '9') {
start = true;
num = num * 10 + c - '0';
} else if (start)
break;
}
if (neg) num = -num;
}
inline long long powMM(long long a, long long b, long long M) {
long long ret = 1;
a %= M;
while (b) {
if (b & 1) ret = ret * a % M;
b >>= 1;
a = a * a % M;
}
return ret;
}
void open() { freopen("out.txt", "w", stdout); }
int n, k;
int a[5], b[5], c[5];
int id(int e[]) {
int re = 0;
for (int i = 1; i <= k; i++) {
re = (re * 2 + a[i]);
}
return re;
}
void trace(int num, int f[]) {
for (int i = k; i >= 1; i--) {
f[i] = num % 2;
num /= 2;
}
}
vector<int> x;
int cnt[500];
int re[500][30], ge;
bool an;
bool check(int i, int j) {
for (int s = 1; s <= k; s++) {
if (re[i][s] + re[j][s] > 1) return false;
}
return true;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) scanf("%d", &a[j]);
int tem = id(a);
if (!cnt[tem]) {
cnt[tem] = 1;
x.push_back(tem);
++ge;
for (int j = 1; j <= k; j++) re[ge][j] = a[j];
} else
++cnt[tem];
}
if (cnt[0])
return 0 * printf("YES\n");
else {
for (int i = 1; i <= ge && !an; i++) {
for (int j = 1; j <= ge && !an; j++) {
if (check(i, j)) an = true;
}
}
}
if (an)
printf("YES\n");
else
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (scanf("%d%d", &n, &k) == 2) {
if (k == 1) {
int dp[2] = {0};
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
dp[x]++;
}
if (dp[0])
puts("yes");
else
puts("no");
} else if (k == 2) {
int dp[2][2];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
int x1, x2;
scanf("%d%d", &x1, &x2);
dp[x1][x2]++;
}
if (dp[0][0])
puts("yes");
else if (dp[0][1] && dp[1][0])
puts("yes");
else
puts("no");
} else if (k == 3) {
int dp[2][2][2];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
int x1, x2, x3;
scanf("%d%d%d", &x1, &x2, &x3);
dp[x1][x2][x3]++;
}
if (dp[0][0][0]) {
puts("yes");
continue;
}
if (dp[1][0][0]) {
if (dp[0][1][0] || dp[0][0][1] || dp[0][1][1]) {
puts("yes");
continue;
}
}
if (dp[0][1][0]) {
if (dp[0][0][1] || dp[1][0][1]) {
puts("yes");
continue;
}
}
if (dp[0][0][1] && dp[1][1][0]) {
puts("yes");
continue;
}
puts("no");
} else {
int dp[2][2][2][2];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
int x1, x2, x3, x4;
scanf("%d%d%d%d", &x1, &x2, &x3, &x4);
dp[x1][x2][x3][x4]++;
}
if (dp[0][0][0][0]) {
puts("yes");
continue;
}
if (dp[1][0][0][0]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int z = 0; z < 2; z++)
if (dp[0][i][j][z]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[0][1][0][0]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int z = 0; z < 2; z++)
if (dp[i][0][j][z]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[0][0][1][0]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int z = 0; z < 2; z++)
if (dp[i][j][0][z]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[0][0][0][1]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int z = 0; z < 2; z++)
if (dp[i][j][z][0]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[1][1][0][0]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (dp[0][0][i][j]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[1][0][1][0]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (dp[0][i][0][j]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[1][0][0][1]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (dp[0][i][j][0]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[0][1][1][0]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (dp[i][0][0][j]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[0][1][0][1]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (dp[i][0][j][0]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
if (dp[0][0][1][1]) {
int c = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (dp[i][j][0][0]) {
c = 1;
break;
}
}
}
if (c) {
puts("yes");
continue;
}
}
puts("no");
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.