solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
class DSU {
public:
vector<int> parent, rank;
void MakeSet(int x) {
parent[x] = x;
rank[x] = 0;
}
int Find(int x) { return (x == parent[x] ? x : parent[x] = Find(parent[x])); }
void Union(int x, int y) {
if ((x = Find(x)) == (y = Find(y))) return;
if (rank[x] < rank[y])
parent[x] = y;
else
parent[y] = x;
if (rank[x] == rank[y]) ++rank[x];
}
DSU(int n) {
parent.assign(n + 10, 0);
rank.assign(n + 10, 0);
for (int i = 0; i < n + 3; i++) parent[i] = i;
};
};
int main() {
int n, k, m;
cin >> n >> k;
DSU dsu(n);
int l, j;
for (int i = 0; i < k; i++) {
cin >> j >> l;
dsu.Union(j, l);
}
vector<int> size(n + 10);
vector<int> can(n + 10);
for (int i = 1; i <= n; i++) {
dsu.parent[i] = dsu.Find(i);
size[dsu.parent[i]]++;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> j >> l;
if (dsu.parent[j] == dsu.parent[l]) can[dsu.parent[j]] = 1;
}
int max = 0;
for (int i = 1; i <= n; i++)
if (can[i] == 0 && i == dsu.parent[i] && max < size[i]) max = size[i];
cout << max;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2005], g2[2005];
int v[2005], x, ans;
void dfs(int u) {
v[u] = 1, x++;
for (auto it : g[u]) {
if (v[it] == 0) dfs(it);
}
for (auto it : g2[u]) {
if (v[it]) x = 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, l;
cin >> n >> k;
while (k--) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
cin >> l;
while (l--) {
int a, b;
cin >> a >> b;
g2[a].push_back(b);
g2[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
x = 0;
dfs(i);
ans = max(ans, x);
memset(v, 0, sizeof(v));
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> dsu(10e5 + 1);
vector<int> s(10e5 + 1, 1);
int find(int a) {
if (dsu[a] == 0 || dsu[a] == -1)
return a;
else
return dsu[a] = find(dsu[a]);
}
void join(int a, int b) {
if (s[find(a)] < s[find(b)]) swap(a, b);
s[find(a)] += s[find(b)];
dsu[find(b)] = find(a);
}
int main() {
int n;
cin >> n;
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
int a, b;
cin >> a >> b;
if (find(a) != find(b)) join(a, b);
}
cin >> k;
for (int i = 0; i < k; ++i) {
int a, b;
cin >> a >> b;
if (find(a) == find(b)) dsu[find(a)] = -1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (dsu[find(i)] != -1) ans = max(ans, s[find(i)]);
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long power(long long B, long long P) {
if (P == 0) return 1;
long long X = power(B, P / 2);
if (P % 2 == 0)
return X * X;
else
return B * X * X;
}
long long fx4[] = {1, -1, 0, 0};
long long fy4[] = {0, 0, 1, -1};
long long Parent[200005], Size[200005];
void INIT(long long N) {
for (long long i = 1; i <= N; i++) {
Parent[i] = i;
Size[i] = 1;
}
}
long long Find(long long r) {
if (Parent[r] == r) return r;
return Parent[r] = Find(Parent[r]);
}
void Union(int X, int Y) {
int PX = Find(X);
int PY = Find(Y);
if (PX != PY) {
Parent[PY] = PX;
Size[PX] += Size[PY];
}
}
int main() {
long long T, N, M, X, Y, W, K, Q, R, P;
cin >> N;
INIT(N);
cin >> K;
for (int i = 1; i <= K; i++) {
cin >> X >> Y;
Union(X, Y);
}
cin >> M;
for (int i = 1; i <= M; i++) {
cin >> X >> Y;
int PX = Find(X);
int PY = Find(Y);
if (PX == PY) {
Size[PX] = 0;
}
}
long long ans = 0;
for (int i = 1; i <= N; i++) {
int Pi = Find(i);
ans = max(ans, Size[Pi]);
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
bool mark[maxn], srg[maxn];
int n, lk, dk, ans, grp[maxn], cnt[maxn], k;
vector<int> like[maxn];
vector<pair<int, int>> dislike;
void dfs(int v) {
mark[v] = true;
grp[v] = k;
cnt[k]++;
for (int u : like[v]) {
if (!mark[u]) dfs(u);
}
}
void dsu(int v) {
if (grp[dislike[v].first] == grp[dislike[v].second])
srg[grp[dislike[v].first]] = maxn / maxn;
}
int main() {
scanf("%d%d", &n, &lk);
for (int u, v, i = 0; i < lk; i++) {
scanf("%d%d", &u, &v);
like[u].push_back(v);
like[v].push_back(u);
}
scanf("%d", &dk);
for (int u, v, i = 0; i < dk; i++) {
scanf("%d%d", &u, &v);
dislike.push_back({u, v});
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) dfs(i);
k++;
}
for (int i = dislike.size() - 1; ~i; i--) {
dsu(i);
}
for (int i = 0; i < k; i++) {
if (!srg[i]) {
ans = max(ans, cnt[i]);
}
}
printf("%d", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long MOD = 998244353;
template <typename P>
struct Cmp {
bool operator()(const P &p1, const P &p2) {
if (p1.first < p2.first) return true;
if (p1.first == p2.first) return p1.second < p2.second;
return false;
}
};
long long vis[N];
vector<long long> vp[N];
long long size[N];
long long a[N];
void initialize() {
for (long long i = 0; i < 2005; i++) {
a[i] = i;
size[i] = 1;
}
}
long long root(long long i) {
while (a[i] != i) {
a[i] = a[a[i]];
i = a[i];
}
return i;
}
void merge(long long x, long long y) {
long long root_A = root(x);
long long root_B = root(y);
if (size[root_A] < size[root_B]) {
a[root_A] = a[root_B];
size[root_B] += size[root_A];
} else {
a[root_B] = a[root_A];
size[root_A] += size[root_B];
}
}
bool mark;
void dfs(long long n) {
vis[n] = 1;
for (long long i = 0; i < vp[n].size(); i++) {
if (!vis[vp[n][i]]) {
dfs(vp[n][i]);
}
}
}
int32_t main() {
long long n;
long long m;
cin >> n >> m;
long long x, y;
initialize();
for (long long i = 0; i < m; i++) {
cin >> x >> y;
vp[x].push_back(y);
vp[y].push_back(x);
if (root(x) != root(y)) {
merge(x, y);
}
}
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> x >> y;
if (root(x) == root(y)) {
size[root(x)] = 0;
}
}
long long mx = 0;
for (long long i = 1; i <= n; i++) {
mark = true;
if (!vis[i]) {
dfs(i);
if (mark) {
mx = max(mx, size[root(i)]);
}
}
}
cout << mx << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long fac[2000005] = {0};
void factorial() {
fac[0] = 1;
fac[1] = 1;
for (long long i = 2; i < 200005; i++)
fac[i] = ((i % 1000000007) * (fac[i - 1] % 1000000007)) % 1000000007;
}
long long power(long long n, long long m) {
long long p = 1;
if (m == 0) return 1;
p = (power(n, m / 2) % 1000000007);
p = (p % 1000000007 * p % 1000000007) % 1000000007;
return (m & 1 ? ((p % 1000000007 * n % 1000000007) % 1000000007)
: (p % 1000000007));
}
long long ncr(long long n, long long r) {
return ((fac[n] * power(fac[r], 1000000007 - 2)) % 1000000007 *
power(fac[n - r], 1000000007 - 2)) %
1000000007;
}
vector<long long> graph[100005];
long long n, m;
long long mx = -1;
set<pair<long long, long long> > s;
vector<long long> v;
long long used[100005];
void dfs(long long t) {
used[t] = 1;
v.push_back(t);
for (auto x : graph[t]) {
if (!used[x]) dfs(x);
}
}
void ram5564() {
cin >> n;
long long z;
cin >> z;
memset(used, 0, sizeof(used));
for (long long i = 0; i < z; i++) {
long long x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
s.insert({x, y});
s.insert({y, x});
}
for (long long i = 1; i < n + 1; i++) {
if (!used[i]) {
v.clear();
dfs(i);
long long ok = 0;
for (long long j = 0; j < v.size(); j++)
if (!ok)
for (long long k = j + 1; k < v.size(); k++)
if (!ok)
if (s.count({v[j], v[k]})) ok = 1;
if (!ok) {
long long sz = v.size();
mx = max(mx, sz);
}
}
}
cout << max(mx, 0ll);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) ram5564();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int UNDEF = -1;
const int INF = 2000000000;
const double EPS = 1e-9;
const double PI = 3.1415926535897932384626433832795;
template <typename T>
const T sqr(const T &x) {
return x * x;
}
template <typename T>
const string GetString(const T &val) {
ostringstream sout;
sout << val;
return sout.str();
}
struct Node {
vector<int> edge;
int id;
Node() : id(UNDEF) {}
};
const int MAXN = 2000 + 5;
int n, k, m;
Node g[MAXN];
bool q[MAXN][MAXN];
vector<int> mas[MAXN];
int cnt = 0;
void Init() {
cin >> n >> k;
for (int i = 0; i < (k); ++i) {
int u, v;
scanf("%d %d", &u, &v);
--u, --v;
g[u].edge.push_back(v);
g[v].edge.push_back(u);
}
cin >> m;
for (int i = 0; i < (m); ++i) {
int u, v;
scanf("%d %d", &u, &v);
--u, --v;
q[u][v] = q[v][u] = true;
}
}
void DFS(int u) {
g[u].id = cnt;
mas[cnt].push_back(u);
for (int i = 0; i < (g[u].edge.size()); ++i) {
int v = g[u].edge[i];
if (g[v].id == UNDEF) DFS(v);
}
}
int main() {
Init();
for (int u = 0; u < (n); ++u) {
if (g[u].id == UNDEF) {
DFS(u);
++cnt;
}
}
int res = 0;
for (int id = 0; id < (cnt); ++id) {
bool ok = true;
for (int i = 0; ok && i < mas[id].size(); ++i) {
for (int j = i + 1; ok && j < mas[id].size(); ++j) {
ok = !q[mas[id][i]][mas[id][j]];
}
}
if (ok) res = max(res, (int)mas[id].size());
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long p) {
long long res = 1;
while (p) {
if (p % 2) {
res = (res * b) % 1000000007;
p--;
} else {
b = (b * b) % 1000000007;
p /= 2;
}
}
return res;
}
void update(int node, int start, int end, int idx, int val, vector<int> &tree) {
if (start == end) {
tree[node] = val;
return;
}
int mid = (start + end) / 2;
if (idx >= start && idx <= mid)
update(2 * node, start, mid, idx, val, tree);
else
update(2 * node + 1, mid + 1, end, idx, val, tree);
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
int query(int node, int start, int end, int l, int r, vector<int> &tree) {
if (r < start || l > end) return 0;
if (start >= l && end <= r) return tree[node];
int mid = (start + end) / 2;
return max(query(2 * node, start, mid, l, r, tree),
query(2 * node + 1, mid + 1, end, l, r, tree));
}
long long f, c;
void dfs(long long r, vector<vector<long long> > &v,
vector<vector<long long> > &e, vector<long long> &vis, long long s) {
vis[r] = s;
c++;
for (long long i = 0; i < e[r].size(); i++)
if (vis[e[r][i]] == vis[r]) f = 1;
for (long long i = 0; i < v[r].size(); i++)
if (!vis[v[r][i]]) dfs(v[r][i], v, e, vis, s);
}
int main() {
long long n, m, k, i, ans = 0, a, b;
cin >> n;
vector<long long> vis(n + 1);
vector<vector<long long> > v(n + 1), e(n + 1);
cin >> k;
while (k--) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
cin >> m;
while (m--) {
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
f = 0, c = 0;
dfs(i, v, e, vis, i);
if (!f) ans = max(ans, c);
}
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
using vvll = vector<vector<long long int> >;
using vll = vector<long long int>;
const long long int inf = 1e18;
const long long int maxs = 200200;
const long long int mod = 1e9 + 7;
long long int getPow(long long int num, long long int pow) {
long long int res = 1;
num %= mod;
while (pow) {
if (pow & 1) res = (res * num) % mod;
num = (num * num) % mod;
pow >>= 1;
}
return res;
}
long long int INV(long long int num) {
num %= mod;
return getPow(num, mod - 2);
}
int connected;
int root[2005], sz[2005], isValid[2005];
int n;
void init() {
for (int i = 1; i <= n; i++) {
root[i] = i;
sz[i] = 1;
}
connected = n;
}
int rt(int k) {
while (k != root[k]) {
root[k] = root[root[k]];
k = root[k];
}
return k;
}
void merge(int u, int v) {
int rt1 = rt(u);
int rt2 = rt(v);
if (rt1 == rt2) return;
connected--;
if (sz[rt1] > sz[rt2]) swap(rt1, rt2);
sz[rt2] += sz[rt1];
sz[rt1] = 0;
root[rt1] = root[rt2];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
init();
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
merge(a, b);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (root[a] == root[b]) isValid[root[a]] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (isValid[root[i]] == 0) ans = max(ans, sz[i]);
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct uni {
int p[2222];
uni() { fill(p, p + 2222, -1); }
int root(int a) { return p[a] < 0 ? a : (p[a] = root(p[a])); }
bool find(int a, int b) { return root(a) == root(b); }
void merge(int a, int b) {
if (!find(a, b)) p[root(a)] = root(b);
}
};
bool chk[2222];
bool di[2222][2222];
int main(void) {
int n, a, b;
uni v, w;
scanf("%d", &n);
scanf("%d", &a);
for (int i = 0; i < a; i++) {
int f, t;
scanf("%d%d", &f, &t);
--f;
--t;
v.merge(f, t);
}
scanf("%d", &b);
for (int i = 0; i < b; i++) {
int f, t;
scanf("%d%d", &f, &t);
--f;
--t;
di[f][t] = di[t][f] = true;
}
int res = 0;
for (int i = 0; i < n; i++) {
if (chk[i]) continue;
int p[2222], c;
c = 0;
for (int j = 0; j < n; j++) {
if (v.find(i, j)) {
if (chk[j]) return -1;
p[c++] = j;
chk[j] = true;
}
}
if (res > c) continue;
bool ok = true;
for (int j = 0; ok && j < c; j++) {
for (int k = j + 1; ok && k < c; k++) {
if (di[p[j]][p[k]]) ok = false;
}
}
if (ok) res = max(res, c);
}
printf("%d\n", res);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[2001];
int byk[2001];
void joint(int a, int b) {
int _a = a;
int _b = b;
while (arr[_b] != _b) _b = arr[_b];
while (arr[_a] != _a) _a = arr[_a];
if (_a == _b) return;
byk[_a] += byk[_b];
arr[_b] = a;
return;
}
void pecah(int a, int b) {
int _a = a;
int _b = b;
while (arr[_b] != _b) _b = arr[_b];
while (arr[_a] != _a) _a = arr[_a];
if (_a == _b) {
byk[_a] = 0;
}
}
int main() {
for (int i = 0; i < 2001; i++) {
arr[i] = i;
byk[i] = 1;
}
int n;
cin >> n;
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (a > b) {
int temp = a;
a = b;
b = temp;
}
joint(a, b);
}
int d;
cin >> d;
for (int i = 0; i < d; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (a > b) {
int temp = a;
a = b;
b = temp;
}
pecah(a, b);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] == i) {
ans = max(ans, byk[i]);
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e3 + 5;
int par[mxN], par1[mxN], Size[mxN], Size1[mxN];
int find_Set(int x) { return par[x] = x == par[x] ? x : find_Set(par[x]); }
int find_Set1(int x) { return par1[x] = x == par1[x] ? x : find_Set1(par1[x]); }
void union_Set(int x, int y) {
x = find_Set(x);
y = find_Set(y);
if (x != y) {
if (Size[x] < Size[y]) swap(x, y);
Size[x] += Size[y];
par[y] = x;
}
}
void union_Set1(int x, int y) {
x = find_Set1(x);
y = find_Set1(y);
if (x != y) {
if (Size1[x] < Size1[y]) swap(x, y);
Size1[x] += Size1[y];
par1[y] = x;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) Size[i] = Size1[i] = 1, par[i] = par1[i] = i;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
union_Set(u, v);
}
cin >> m;
set<int> testing[n + 1];
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
testing[u].insert(v);
testing[v].insert(u);
}
for (int i = 1; i <= n; ++i) find_Set(i), find_Set1(i);
vector<int> adj[n + 1];
for (int i = 1; i <= n; ++i)
adj[par[i]].push_back(i), testing[par1[i]].insert(i);
int ans = 0;
for (int i = 1; i <= n; ++i) {
bool ok = true;
for (int j = 0; j < (int)adj[i].size() && ok; ++j) {
int x = adj[i][j];
for (int k = 0; k < (int)adj[i].size() && ok; ++k) {
if (j == k) continue;
if (testing[x].find(adj[i][k]) != testing[x].end()) ok = false;
}
}
if (ok) ans = max(ans, (int)adj[i].size());
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
vector<vector<int>> v;
vector<bool> check;
vector<set<int>> s;
int mx = 0;
vector<int> se;
set<int> s1, s2;
void dfs(int x) {
check[x] = true;
se.push_back(x);
for (auto i : v[x]) {
if (!check[i]) {
dfs(i);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
v.resize(n + 1);
check.resize(n + 1);
s.resize(n + 1);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a >> b;
s[a].insert(b);
s[b].insert(a);
}
for (int i = 1; i <= n; i++) {
if (!check[i]) {
dfs(i);
}
int f = 1;
for (int i = 0; i < se.size(); i++) {
for (int j = i + 1; j < se.size(); j++) {
if (s[se[i]].count(se[j])) {
f = 0;
}
}
}
if (f == 1)
mx = max(mx, (int)se.size() - min((int)s1.size(), (int)s2.size()));
se.clear();
s1.clear();
s2.clear();
}
cout << mx;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 256;
const int N = 1256;
const int INF = int(1e9);
int n, k, m;
vector<int> v[MAXN], g[MAXN];
map<pair<int, int>, bool> M;
int u[MAXN], clr = 1;
void dfs(int x, bool &T, int &comp) {
u[x] = clr;
comp++;
for (int i = 0; i < v[x].size(); ++i) {
int to = v[x][i];
if (!u[to]) {
for (int j = 0; j < g[to].size(); ++j) {
if (u[g[to][j]] == clr) {
T = 1;
break;
}
}
dfs(to, T, comp);
}
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
cin >> m;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!u[i]) {
bool U = 0;
int com = 0;
dfs(i, U, com);
if (!U) {
ans = max(ans, com);
}
clr++;
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[2002];
int mat[2002][2002];
vector<int> te;
int vis[2002];
void go(int i) {
vis[i] = 1;
te.push_back(i);
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j];
if (vis[v] == 0) {
go(v);
}
}
}
int main() {
int n, m, k;
cin >> n;
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
mat[a][b] = 1;
mat[b][a] = 1;
}
int mx = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
te.clear();
go(i);
int ok = 1;
for (int i = 0; i < te.size() && ok; i++) {
for (int j = i + 1; j < te.size() && ok; j++) {
if (mat[te[i]][te[j]] == 1) {
ok = 0;
}
}
}
if (ok == 1) {
mx = max(mx, (int)te.size());
}
}
}
cout << mx << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
int prime[1000000 + 5], in;
bool isp[1000000 + 5];
using namespace std;
vector<int> ar[2005], v1, v2;
int vis[6000000];
int flag[2005][2005];
void dfs(int n) {
v1.push_back(n);
vis[n] = 1;
for (int i = 0; i < ar[n].size(); i++) {
if (!vis[ar[n][i]]) {
dfs(ar[n][i]);
}
}
}
int main() {
int n;
while (cin >> n) {
v1.clear();
v2.clear();
int k;
cin >> k;
int a, b;
for (int i = 0; i < k; i++) {
cin >> a >> b;
--a;
--b;
ar[a].push_back(b);
ar[b].push_back(a);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a >> b;
--a;
--b;
flag[a][b] = 1;
flag[b][a] = 1;
}
int flu = 0, mx = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
v1.clear();
dfs(i);
flu = 1;
for (int j = 0; j < v1.size() && flu; j++) {
for (int l = j + 1; l < v1.size() && flu; l++) {
if (flag[v1[j]][v1[l]]) flu = 0;
}
}
if (flu) mx = max(mx, (int)v1.size());
}
}
cout << mx << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
std::vector<int> e[2000];
bool t[2000][2000];
int main() {
int n, k, u, v;
bool d[2000] = {};
std::queue<int> q;
std::vector<int> w;
int r(0);
std::scanf("%d%d", &n, &k);
while (0 < k--) {
std::scanf("%d%d", &u, &v);
--u, --v;
e[u].push_back(v);
e[v].push_back(u);
}
std::scanf("%d", &k);
while (0 < k--) {
std::scanf("%d%d", &u, &v);
--u, --v;
t[u][v] = t[v][u] = true;
}
for (int i(0); i < n; ++i) {
if (d[i]) continue;
q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
if (d[x]) continue;
d[x] = true;
w.push_back(x);
for (int y : e[x]) {
if (!d[y]) q.push(y);
}
}
for (int x : w) {
for (int y : w) {
if (t[x][y]) goto N;
}
}
r = std::max<int>(r, w.size());
N:
w.clear();
}
std::printf("%d\n", r);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int par[2010];
int rankk[2010];
int n;
void init() {
for (int i = 1; i <= n; ++i) {
par[i] = i;
rankk[i] = 1;
}
}
int findset(int u) {
if (u == par[u])
return u;
else
return par[u] = findset(par[u]);
}
void link(int u, int v) {
int a = findset(u);
int b = findset(v);
if (a != b) {
par[b] = a;
rankk[a] += rankk[b];
}
}
int main() {
int k, m, u, v;
scanf("%d", &n);
;
init();
scanf("%d", &k);
;
for (int i = 0; i < k; ++i) {
scanf("%d", &u);
;
scanf("%d", &v);
;
link(u, v);
}
scanf("%d", &m);
;
for (int i = 0; i < m; ++i) {
scanf("%d", &u);
;
scanf("%d", &v);
;
int a = findset(u);
int b = findset(v);
if (a == b) rankk[a] = 0;
}
int maxx = 0;
for (int i = 1; i <= n; ++i) maxx = max(maxx, rankk[findset(i)]);
cout << maxx << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int rdi() {
int d;
scanf("%d", &d);
return d;
}
inline char rdc() {
scanf(" ");
return getchar();
}
inline string rds() {
string s;
cin >> s;
return s;
}
inline double rddb() {
double d;
scanf("%lf", &d);
return d;
}
template <class T>
inline bool setmin(T& a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool setmax(T& a, T b) {
return a < b ? a = b, true : false;
}
struct debugger {
template <typename T>
debugger& operator,(const T& x) {
cerr << x << ",";
return *this;
}
} dbgr;
const int N = 4096, M = 524288;
bool vis[N];
int n, ans, cnt, nu, us[N];
int ne, head[N], vex[M], nxt[M];
int ne2, head2[N], vex2[M], nxt2[M];
void add_edge(int u, int v) {
++ne;
vex[ne] = v;
nxt[ne] = head[u];
head[u] = ne;
}
void add_2edge(int u, int v) {
add_edge(u, v);
add_edge(v, u);
}
void add_edge2(int u, int v) {
++ne2;
vex2[ne2] = v;
nxt2[ne2] = head2[u];
head2[u] = ne2;
}
void add_2edge2(int u, int v) {
add_edge2(u, v);
add_edge2(v, u);
}
void dfs(int u) {
if (vis[u] == true) return;
vis[u] = true, ++cnt, us[nu++] = u;
for (int i = head[u]; i != 0; i = nxt[i]) dfs(vex[i]);
}
bool ok() {
for (int i = (0); i < (nu); ++i) {
int u = us[i];
for (int i = head2[u]; i != 0; i = nxt2[i]) {
int v = vex2[i];
if (vis[v]) return false;
}
}
return true;
}
int main() {
n = rdi();
for (int repp_b = (rdi()), repp = 0; repp < repp_b; ++repp) {
int u = rdi(), v = rdi();
add_2edge(u, v);
}
for (int repp_b = (rdi()), repp = 0; repp < repp_b; ++repp) {
int u = rdi(), v = rdi();
add_2edge2(u, v);
}
for (int i = (1); i <= (n); ++i)
if (!vis[i]) {
cnt = 0, nu = 0, dfs(i);
if (ok()) setmax(ans, cnt);
for (int i = (0); i < (nu); ++i) vis[us[i]] = false;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> par(20001, -1), ran(20001, 1), can_parent(20001, 1);
vector<int> arr[20001];
int vis[20001];
int siz;
bool flag;
int find(int node) {
if (par[node] == -1) return node;
return par[node] = find(par[node]);
}
void unite(int a, int b) {
int s1 = find(a);
int s2 = find(b);
if (s1 != s2) {
if (ran[s1] >= ran[s2]) {
par[s2] = s1;
ran[s1] += ran[s2];
} else {
par[s1] = s2;
ran[s2] += ran[s1];
}
}
return;
}
bool dfs(int node) {
vis[node] = 1;
if (can_parent[node] == 0)
flag = false;
else
siz++;
for (int child : arr[node])
if (vis[child] == 0) dfs(child);
return flag;
}
int main() {
int v, k, m, a, b;
cin >> v;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a >> b;
arr[a].push_back(b);
arr[b].push_back(a);
unite(a, b);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
int s1 = find(a);
int s2 = find(b);
if (s1 == s2) {
can_parent[s1] = 0;
}
}
int ans = 0;
for (int i = 1; i <= v; i++) {
if (vis[i] == 0) {
siz = 0, flag = true;
if (dfs(i)) {
ans = max(ans, siz);
}
}
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2002;
int N, K, M;
int a, b;
bool uf[MAX], mk[MAX];
vector<int> cf;
vector<int> Gf[MAX], Ge[MAX];
void dfs1(int x) {
mk[x] = true;
uf[x] = true;
cf.push_back(x);
for (typeof(Gf[x].begin()) k = Gf[x].begin(); k != Gf[x].end(); ++k) {
int j = *k;
if (!mk[j]) dfs1(j);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
cin >> K;
for (int i = 0; i < (K); ++i) {
cin >> a >> b;
--a;
--b;
Gf[a].push_back(b);
Gf[b].push_back(a);
}
cin >> M;
for (int i = 0; i < (M); ++i) {
cin >> a >> b;
--a;
--b;
Ge[a].push_back(b);
Ge[b].push_back(a);
}
int ans = 0;
for (int i = 0; i < (N); ++i)
if (!mk[i]) {
cf.clear();
for (int j = 0; j < (N); ++j) uf[j] = false;
dfs1(i);
for (typeof(cf.begin()) k = cf.begin(); k != cf.end(); ++k)
for (typeof(Ge[*k].begin()) j = Ge[*k].begin(); j != Ge[*k].end(); ++j)
if (uf[*j]) goto error;
ans = max(ans, ((int)(cf).size()));
error:;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > a;
vector<int> pset;
void make_set(int N) {
pset.assign(N + 1, 0);
for (int i = 1; i <= N; i++) {
pset[i] = i;
}
}
int find_set(int i) {
if (pset[i] == i) {
return pset[i];
}
return pset[i] = find_set(pset[i]);
}
bool is_same_set(int i, int j) { return find_set(i) == find_set(j); }
void union_set(int i, int j) { pset[find_set(i)] = find_set(j); }
vector<int> flag, gr_size;
int main() {
int n, i, x, y;
scanf("%d", &n);
flag.resize(n + 1);
gr_size.resize(n + 1);
for (i = 1; i <= n; i++) gr_size[i] = 1;
make_set(n);
int k;
scanf("%d", &k);
for (i = 0; i < k; i++) {
scanf("%d %d", &x, &y);
if (find_set(x) != find_set(y))
gr_size[find_set(y)] += gr_size[find_set(x)];
union_set(x, y);
}
int m, max_size = 0;
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
if (find_set(x) == find_set(y)) {
flag[find_set(x)] = -1;
}
}
for (i = 1; i <= n; i++) {
if (find_set(i) == i && flag[i] != -1) max_size = max(max_size, gr_size[i]);
}
printf("%d", max_size);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
const long long SIZE = (long long)2e3 + 10;
const int MOD = (long long)1e9;
vector<int> adj[SIZE + 10];
vector<int> anti[SIZE + 10];
int vis[SIZE + 10] = {0};
pair<int, bool> dfs(int u, int color) {
vis[u] = color;
bool valid = true;
int cnt = 1;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (vis[v] == 0) {
pair<int, bool> ret = dfs(v, color);
valid = valid && ret.second;
cnt += ret.first;
}
}
if (!valid) return make_pair(cnt, valid);
for (int i = 0; i < anti[u].size(); ++i) {
int v = anti[u][i];
if (vis[v] == color) return make_pair(cnt, false);
}
return make_pair(cnt, true);
}
int main() {
int n;
scanf("%d", &n);
int k;
scanf("%d", &k);
for (long long i = 0; i <= k - 1; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int m;
scanf("%d", &m);
for (long long i = 0; i <= m - 1; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
anti[u].push_back(v);
anti[v].push_back(u);
}
int mx = 0;
for (long long i = 1; i <= n; i++)
if (vis[i] == 0) {
pair<int, bool> ret = dfs(i, i);
if (ret.second) mx = max(ret.first, mx);
}
cout << mx;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, e1, e2;
int par[2010], ch[2010];
int ans = 0;
int get_par(int x) { return par[x] == x ? x : par[x] = get_par(par[x]); }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
par[i] = i;
ch[i] = 1;
}
for (int i = 1; i <= m; i++) {
cin >> x >> y;
x = get_par(x), y = get_par(y);
if (x != y) {
par[y] = x;
ch[x] += ch[y];
}
}
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> x >> y;
x = get_par(x), y = get_par(y);
if (x == y) ch[x] = 0;
}
for (int i = 1; i <= n; i++)
if (get_par(i) == i && ans < ch[i]) ans = ch[i];
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int P[111111];
int sz[111111];
int find(int x) { return (P[x] == x ? x : P[x] = find(P[x])); }
void Union(int x, int y, int type) {
x = find(x), y = find(y);
if (sz[x] < sz[y]) swap(x, y);
if (x == y) {
if (type == -1) P[x] = 0;
return;
}
if (type == -1) return;
sz[x] += sz[y];
P[y] = x;
}
int main() {
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; i++) P[i] = i, sz[i] = 1;
while (K--) {
int u, v;
cin >> u >> v;
Union(u, v, 1);
}
cin >> K;
while (K--) {
int u, v;
cin >> u >> v;
Union(u, v, -1);
}
int best = 0;
for (int i = 1; i <= N; i++)
if (find(i)) best = max(best, sz[find(i)]);
cout << best << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
long long modinv(long long a, long long m) { return power(a, m - 2, m); }
vector<vector<long long int>> adj;
vector<bool> visited;
set<long long int> s;
vector<pair<long long int, long long int>> v;
long long int flag = 0, c = 0;
void dfs(long long x) {
visited[x] = true;
s.insert(x);
for (long long int i = 0; i < adj[x].size(); i++) {
if (!visited[adj[x][i]]) dfs(adj[x][i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
for (long long int g = 0; g < t; g++) {
long long int n, m, l, r, k;
cin >> n >> m;
set<long long int> ans;
visited.resize(n + 1);
adj.resize(n + 1);
for (long long int i = 0; i < m; i++) {
cin >> l >> r;
adj[l].push_back(r);
adj[r].push_back(l);
}
cin >> k;
for (long long int i = 0; i < k; i++) {
cin >> l >> r;
v.push_back(make_pair(l, r));
}
for (long long int i = 1; i <= n; i++) {
if (!visited[i]) {
flag = 0;
c = 0;
dfs(i);
for (long long int j = 0; j < v.size(); j++) {
if (s.count(v[j].first) && s.count(v[j].second)) {
flag = 1;
ans.insert(0);
}
}
if (flag == 0) ans.insert(s.size());
s.clear();
}
}
cout << *ans.rbegin();
}
return 0;
}
| 9 | CPP |
t, p, k = [0] * (int(input()) + 1), {0: []}, 1
for i in range(int(input())):
a, b = map(int, input().split())
if t[a] == t[b]:
if t[a] == 0:
t[a] = t[b] = k
p[k] = [a, b]
k += 1
else:
if t[a] == 0:
t[a] = t[b]
p[t[b]].append(a)
elif t[b] == 0:
t[b] = t[a]
p[t[a]].append(b)
else:
x, y = t[b], t[a]
for c in p[x]:
t[c] = y
p[y] += p[x]
p[x] = []
for i in range(int(input())):
a, b = map(int, input().split())
if t[a] == t[b]: p[t[a]] = []
ans = max(map(len, p.values()))
if ans == 0: ans = int(0 in t[1:])
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr[2005];
vector<int> arrr[2005];
int visit[2005];
int maxx = 0;
unordered_map<int, int> umap;
vector<int> dang;
bool dfss(int node, int enemy) {
visit[node] = 1;
if (node == enemy) return false;
int y = arr[node].size();
for (int i = 0; i < y; i++) {
if (!visit[arr[node][i]]) {
visit[arr[node][i]] = 1;
if (dfss(arr[node][i], enemy) == false) return false;
} else if (arr[node][i] == enemy)
return false;
}
return true;
}
void dfs(int node) {
visit[node] = 1;
dang.push_back(node);
maxx++;
int y = arr[node].size();
for (int i = 0; i < y; i++) {
if (!visit[arr[node][i]]) {
visit[arr[node][i]] = 1;
dfs(arr[node][i]);
}
}
}
int main() {
int n;
cin >> n;
int k;
for (int i = 1; i <= n; i++) umap[i]++;
cin >> k;
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
arr[u].push_back(v);
arr[v].push_back(u);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
arrr[x].push_back(y);
arrr[y].push_back(x);
umap[x]++;
umap[y]++;
if (dfss(x, y) == false) {
for (int i = 1; i <= n; i++) visit[i] = 0;
dfs(x);
int z = dang.size();
for (int i = 0; i < z; i++) {
arr[dang[i]].clear();
umap[dang[i]] = 0;
}
dang.clear();
for (int i = 1; i <= n; i++) visit[i] = 0;
}
}
for (int i = 1; i <= n; i++) visit[i] = 0;
int h = 0;
for (int i = 1; i <= n; i++) {
if (visit[i] == 0 && (umap[i] > 0)) {
int y = arrr[i].size();
for (int l = 0; l < y; l++) {
umap[arrr[i][l]] = 0;
}
umap[i] = 0;
maxx = 0;
dfs(i);
if (maxx > h) h = maxx;
}
}
cout << h << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int id[1000002], vis[1000002], sz[1000004];
int find(long long int u) {
if (u == id[u]) return u;
return find(id[u]);
}
void merge(long long int u, long long int v) {
long long int p = find(u);
long long int q = find(v);
if (p != q) {
id[p] = q;
sz[q] += sz[p];
}
}
int main() {
long long int n, q, m, i;
cin >> n >> q;
for (i = 1; i <= n; i++) id[i] = i, sz[i] = 1;
for (i = 0; i < q; i++) {
long long int u, v;
cin >> u >> v;
merge(u, v);
}
cin >> m;
for (i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
u = find(u), v = find(v);
if (u == v) vis[u] = 1;
}
long long int ma = 0;
for (i = 1; i <= n; i++) {
if (find(i) == i && vis[i] == 0) ma = max(ma, sz[i]);
}
cout << ma << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
typedef struct {
int to, nextid;
} ne;
int l[100005];
ne le[200005];
int d[2001][2001];
int s[2001], vis[2001];
int c;
void dfs(int a) {
s[c++] = a;
vis[a] = 1;
int i;
for (i = l[a]; i != -1; i = le[i].nextid) {
if (vis[le[i].to] == 0) {
dfs(le[i].to);
}
}
}
int main() {
int n, i, u, v, m, k, j;
scanf("%d%d", &n, &k);
for (i = 0; i <= n + 5; i++) l[i] = -1;
for (i = 0; i < k; i++) {
scanf("%d%d", &u, &v);
le[2 * i].nextid = l[u];
le[2 * i].to = v;
l[u] = 2 * i;
le[2 * i + 1].nextid = l[v];
le[2 * i + 1].to = u;
l[v] = 2 * i + 1;
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
d[u][v] = d[v][u] = 1;
}
int ans = 0, l;
for (i = 1; i <= n; i++) {
c = 0;
if (vis[i] == 0) {
dfs(i);
for (j = 0; j < c; j++) {
for (l = j; l < c; l++) {
if (d[s[j]][s[l]]) c = 0;
}
}
if (c > ans) ans = c;
}
}
printf("%d", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100000];
vector<int> s[190000];
int vis[100000], w = 0;
void dfs(int x) {
int j;
vis[x] = 1;
for (j = 0; j < v[x].size(); j++) {
if (vis[v[x][j]] == 0) dfs(v[x][j]);
}
}
int main() {
int n, i, ans = 0, j, m, k, a, b, o, t, e;
cin >> n >> k;
for (i = 0; i < k; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
s[a].push_back(b);
s[b].push_back(a);
}
for (i = 1; i <= n; i++) {
o = 0;
for (j = 1; j <= n; j++) vis[j] = 0;
dfs(i);
w = 0;
for (j = 1; j <= n; j++) {
if (vis[j] == 1) {
o++;
for (t = 0; t < s[j].size(); t++) {
if (vis[s[j][t]] == 1) {
w = 1;
break;
}
}
}
}
if (w == 0) {
ans = max(ans, o);
}
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool q[2000] = {false};
int fri[2000] = {0};
int ene[2000] = {0};
int cnt = 0;
vector<int> a[2000];
vector<int> b[2000];
void cHeck(int ii) {
q[ii] = true;
fri[ii] = 1;
if (a[ii].size() > 0)
for (int i = 0; i <= a[ii].size() - 1; i++) {
if (q[a[ii][i]] == false) cHeck(a[ii][i]);
}
if (b[ii].size() > 0)
for (int i = 0; i <= b[ii].size() - 1; i++) {
ene[b[ii][i]] = 1;
}
cnt++;
return;
}
int main() {
int n, k, m;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
;
a[v].push_back(u);
;
}
cin >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
b[u].push_back(v);
;
b[v].push_back(u);
;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int qq = 1; qq <= n; qq++) fri[qq] = ene[qq] = 0;
cnt = 0;
if (q[i] == false) {
cHeck(i);
}
for (int j = 1; j <= n; j++)
if (fri[j] * ene[j] == 1) {
cnt = 0;
break;
}
ans = max(cnt, ans);
}
cout << ans;
return 0;
}
| 9 | CPP |
def find(a):
if parent[a]!=a:
parent[a]=find(parent[a])
return parent[a]
def union(a,b):
u,v=find(a),find(b)
if u==v:
return
if rank[u]>rank[v]:
parent[v]=u
else:
parent[u]=v
if rank[u]==rank[v]:
rank[v]+=1
n=int(input())
k=int(input())
parent=list(map(int,range(n+1)))
rank=[0]*(n+1)
ans=[0]*(n+1)
count=[0]*(n+1)
for i in range(k):
u,v=map(int,input().split())
union(u,v)
for i in range(len(ans)):
ans[find(i)]+=1
for i in range(len(parent)):
count[parent[i]]+=1
d={}
m=int(input())
for i in range(m):
u,v=map(int,input().split())
if parent[u]==parent[v]:
d[parent[u]]=False
sak=0
for i in range(len(count)):
if count[i]!=0 and i not in d and i!=0:
sak=max(sak,count[i])
print(sak) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e+9 + 7;
struct DSU {
private:
vector<int> parent, size;
int N;
public:
DSU(int n) {
N = n;
size.resize(N + 1, 1);
parent.resize(N + 1);
for (int i = 0; i <= N; i++) parent[i] = i;
}
void makeParent(int a, int b) {
a = getParent(a);
b = getParent(b);
if (a != b) {
if (size[a] < size[b]) swap(a, b);
parent[b] = a;
size[a] += size[b];
}
}
int getParent(int a) {
if (parent[a] == a) return a;
return parent[a] = getParent(parent[a]);
}
vector<vector<int>> components() {
vector<vector<int>> component(N + 1);
vector<vector<int>> ans;
for (int i = 1; i <= N; i++) component[getParent(i)].push_back(i);
for (int i = 1; i <= N; i++)
if (!component[i].empty()) ans.push_back(component[i]);
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed;
cout << setprecision(10);
int n;
cin >> n;
DSU d(n);
int k;
cin >> k;
for (int i = 1; i <= k; i++) {
int a, b;
cin >> a >> b;
d.makeParent(a, b);
}
int m;
cin >> m;
set<int> bad;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (d.getParent(a) == d.getParent(b)) bad.insert(d.getParent(a));
}
map<int, int> cnt;
for (int i = 1; i <= n; i++)
if (!bad.count(d.getParent(i))) cnt[d.getParent(i)]++;
int ans = 0;
for (auto p : cnt) ans = max(ans, p.second);
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int gid, v;
};
vector<int> fr[2003];
int root[2003], n;
bool hate[2003][2003];
Node node[2003];
bool cmp(const Node &a, const Node &b) { return a.gid < b.gid; }
int find(int x) {
if (x != root[x]) root[x] = find(root[x]);
return root[x];
}
bool check(int s, int e) {
int i, j;
for (i = s; i < e; ++i) {
for (j = i + 1; j < e; ++j) {
if (hate[node[i].v][node[j].v]) return 0;
}
}
return 1;
}
int main(int argc, char *argv[]) {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; ++i) root[i] = i;
int k, u, v, m;
scanf("%d", &k);
for (i = 0; i < k; ++i) {
scanf("%d%d", &u, &v);
root[find(u)] = find(v);
}
for (i = 1; i <= n; ++i) {
node[i].gid = find(i);
node[i].v = i;
}
sort(node + 1, node + n + 1, cmp);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) hate[i][j] = 0;
}
scanf("%d", &m);
for (i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
hate[u][v] = 1;
hate[v][u] = 1;
}
int ma = 0;
for (j = 1, i = 2; i <= n; ++i) {
if (node[i].gid != node[j].gid) {
if (check(j, i)) {
if (ma < (i - j)) ma = i - j;
}
j = i;
}
}
if (check(j, i)) {
if (ma < (i - j)) ma = i - j;
}
printf("%d\n", ma);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
std::vector<int> visited(10000, 0);
int ans = 0, temp = 0;
std::vector<pair<int, int>> g[10000];
void dfs(int v) {
visited[v] = 1;
temp++;
for (auto i : g[v]) {
if ((i.second == 1 && visited[i.first] == 2) ||
(i.second == 2 && visited[i.first] == 1)) {
temp = 0;
return;
} else if (visited[i.first] == 0) {
if (i.second == 2) {
visited[i.first] = 2;
} else
dfs(i.first);
}
}
}
int main() {
cin >> n;
cin >> k;
int u, v;
for (int i = 0; i < k; i++) {
cin >> u >> v;
g[u].push_back({v, 1});
g[v].push_back({u, 1});
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back({v, 2});
g[v].push_back({u, 2});
}
for (int i = 1; i <= n; i++) {
fill(visited.begin(), visited.end(), 0);
temp = 0;
dfs(i);
ans = max(ans, temp);
}
std::cout << ans << std::endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 2000, GREEN = 1, RED = 2;
int n, k, m;
int dsu[LIM], cnt[LIM], used[LIM];
bool bad[LIM];
vector<pair<int, int> > g[LIM];
int dsu_find(int a) { return dsu[a] == a ? a : dsu[a] = dsu_find(dsu[a]); }
void dsu_union(int a, int b) {
a = dsu_find(a);
b = dsu_find(b);
if (a == b) return;
if (cnt[a] > cnt[b]) swap(a, b);
dsu[a] = b;
cnt[b] += cnt[a];
bad[b] = bad[b] | bad[a];
bad[a] = bad[b];
}
void read() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
dsu[i] = i;
cnt[i] = 1;
}
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(make_pair(v, GREEN));
g[v].push_back(make_pair(u, GREEN));
}
cin >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(make_pair(v, RED));
g[v].push_back(make_pair(u, RED));
}
}
void dfs(int u) {
used[u] = true;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i].first, color = g[u][i].second;
if (color == GREEN) {
dsu_union(u, v);
if (!used[v]) dfs(v);
} else {
if (dsu_find(u) == dsu_find(v)) {
bad[dsu_find(u)] = true;
}
}
}
}
int main() {
read();
for (int i = 0; i < n; i++) {
if (!used[i]) dfs(i);
}
int ans = 0;
for (int i = 0; i < n; i++) {
int p = dsu_find(i);
if (!bad[p] && cnt[p] > ans) ans = cnt[p];
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int find_parent(long long int parent[], long long int i) {
while (parent[i] != i) i = parent[i];
return i;
}
void Union(long long int parent[], long long int i, long long int j) {
long long int pii = find_parent(parent, i);
long long int pj = find_parent(parent, j);
if (pii != pj) parent[pj] = pii, parent[j] = pii;
}
void test_case() {
long long int n;
cin >> n;
long long int m;
cin >> m;
long long int parent[n];
for (long long int i = 0; i < n; i++) parent[i] = i;
while (m--) {
long long int x, y;
cin >> x >> y;
Union(parent, x - 1, y - 1);
}
unordered_map<long long int, long long int> mp;
for (long long int i = 0; i < n; i++) {
long long int p = find_parent(parent, i);
mp[p]++;
}
cin >> m;
while (m--) {
long long int x, y;
cin >> x >> y;
if (find_parent(parent, x - 1) == find_parent(parent, y - 1)) {
mp[find_parent(parent, x - 1)] = -1;
}
}
long long int max = 0;
for (auto x : mp)
if (x.second > max) max = x.second;
cout << max << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) test_case();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y;
vector<int> v[2001];
vector<int> g[2001];
int size;
int res;
bool vis[2001];
bool valid;
void DFS(int src) {
if (vis[src] || !valid) return;
++size;
vis[src] = 1;
for (int i = 0; valid && i < g[src].size(); ++i)
if (vis[g[src][i]]) valid = 0;
for (int i = 0; i < v[src].size(); ++i) DFS(v[src][i]);
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
while (k--) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
scanf("%d", &k);
while (k--) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
size = 0;
memset(vis, 0, sizeof(vis));
valid = 1;
DFS(i);
if (valid) res = max(res, size);
}
printf("%d\n", res);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int l[2010][2010], d[2010][2010];
int computed[2010];
int group[2010];
int n;
int conflict(int s) {
int size = d[s][0];
int sizeG = group[0];
for (int j = 1; j <= sizeG; j++)
for (int i = 1; i <= size; i++)
if (d[s][i] == group[j]) {
return 1;
}
return 0;
}
int foo(int s) {
int size = l[s][0];
if (conflict(s)) return -1;
computed[s] = 1;
group[0]++;
group[group[0]] = s;
int sum = 1;
for (int i = 1; i <= size; i++)
if (!(computed[l[s][i]] == 1)) {
int ret = foo(l[s][i]);
if (ret == -1)
return -1;
else
sum += ret;
}
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) l[i][j] = d[i][j] = computed[i] = 0;
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d %d", &a, &b);
int size = l[a][0];
l[a][size + 1] = b;
l[a][0]++;
int sizeB = l[b][0];
l[b][sizeB + 1] = a;
l[b][0]++;
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
int size = d[a][0];
d[a][size + 1] = b;
d[a][0]++;
int sizeB = d[b][0];
d[b][sizeB + 1] = a;
d[b][0]++;
}
int out = 0;
for (int i = 1; i <= n; i++) {
group[0] = 0;
if (!computed[i]) {
int res = foo(i);
out = max(out, res);
}
int sizeG = group[0];
for (int j = 1; j <= sizeG; j++) computed[group[j]] = 2;
}
printf("%d\n", out);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
int p[N], sz[N];
bool hate[N][N];
vector<int> v[N];
set<int> st;
int get(int x) {
if (x == p[x]) return x;
return p[x] = get(p[x]);
}
void join(int x, int y) {
x = get(x);
y = get(y);
if (x == y) return;
if (rand() & 1) swap(x, y);
p[x] = y;
sz[y] += sz[x];
}
void input_edges(bool b) {
int m;
scanf("%d", &m);
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
if (b) {
join(u, v);
} else {
hate[u][v] = hate[v][u] = 1;
}
}
}
int main() {
for (int i = 1; i < N; i++) p[i] = i, sz[i] = 1;
int n;
scanf("%d", &n);
input_edges(1);
input_edges(0);
for (int i = 1; i <= n; i++) {
v[get(i)].push_back(i);
st.insert(get(i));
}
int mx = 0;
for (auto S : st) {
bool ok = 1;
for (auto ss : v[S]) {
for (auto ss2 : v[S])
if (hate[ss][ss2]) {
ok = 0;
break;
}
if (ok == 0) break;
}
if (ok) mx = max(mx, sz[S]);
}
printf("%d\n", mx);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, C;
vector<pair<int, int> > G[100005];
bool vis[100005], group[100005], F;
void dfs(int v) {
vis[v] = 1;
group[v] = 1;
C++;
for (int i = 0; i < G[v].size(); i++)
if (!vis[G[v][i].first]) {
if (G[v][i].second) dfs(G[v][i].first);
} else {
if (group[G[v][i].first] && !G[v][i].second) {
F = 1;
C--;
return;
}
}
}
int main() {
int u, v;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d %d", &u, &v);
G[u].push_back(make_pair(v, 1));
G[v].push_back(make_pair(u, 1));
}
scanf("%d", &K);
for (int i = 0; i < K; i++) {
scanf("%d %d", &u, &v);
G[u].push_back(make_pair(v, 0));
G[v].push_back(make_pair(u, 0));
}
int ANS = 0;
for (int i = 1; i <= N; i++)
if (!vis[i]) {
C = F = 0;
dfs(1);
if (!F) ANS = max(ANS, C);
memset(group, 0, sizeof group);
}
printf("%d", ANS);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct UFDS {
int n;
int p[2010], rank[2010], size[2010];
UFDS(int n) : n(n) {
for (int i = 1; i <= n; i++) {
p[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
int findSet(int i) {
if (p[i] == i) return i;
return p[i] = findSet(p[i]);
}
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
int sizeOfSet(int i) { return size[findSet(i)]; }
void unionSet(int i, int j) {
int x = findSet(i);
int y = findSet(j);
if (x == y) return;
if (rank[x] < rank[y]) {
p[x] = y;
size[y] += size[x];
} else {
p[y] = x;
size[x] += size[y];
if (rank[y] == rank[x]) rank[x]++;
}
}
void printSet(int i) {
cout << "set id:" << findSet(i) << ":" << endl;
for (int j = 0; j <= n; j++) {
if (isSameSet(i, j)) cout << j << endl;
}
cout << "size:" << sizeOfSet(i) << endl;
}
};
int n;
vector<int> adjList[2010];
bitset<2010> visited;
UFDS like(2010);
int dfs(int c) {
if (visited[c]) return 0;
visited[c] = 1;
int ans = like.sizeOfSet(c);
for (int i = 0; i < adjList[c].size(); i++) {
if (!visited[adjList[c][i]]) {
ans = max(ans, dfs(adjList[c][i]));
}
}
return ans;
}
int main() {
cin >> n;
int k, m;
cin >> k;
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
like.unionSet(u, v);
}
set<int> superNodes;
for (int i = 1; i <= n; i++) {
superNodes.insert(like.findSet(i));
}
cin >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
int x = like.findSet(u);
int y = like.findSet(v);
if (x == y) superNodes.erase(x);
}
int ans = 0;
for (set<int>::iterator si = superNodes.begin(); si != superNodes.end();
si++) {
ans = max(ans, like.sizeOfSet(*si));
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
int n, m, k, cnt;
vector<int> adj[MAX];
vector<pair<int, int> > disl;
int visit[MAX], qua[MAX];
void dfs(int x) {
visit[x] = cnt;
qua[cnt]++;
for (auto i : adj[x]) {
if (visit[i]) continue;
dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < k; i++) {
int t1, t2;
cin >> t1 >> t2;
adj[t1].push_back(t2);
adj[t2].push_back(t1);
}
cin >> m;
for (int i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
disl.push_back({t1, t2});
}
for (int i = 1; i <= n; i++) {
if (visit[i]) continue;
cnt++;
dfs(i);
}
for (auto o : disl) {
int x = o.first, y = o.second;
if (visit[x] == visit[y]) qua[visit[x]] = 0;
}
int ans = -1;
for (int i = 0; i <= cnt; i++) ans = max(ans, qua[i]);
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f[200000][3], N, K;
char s1[200000], s2[200000];
bool ok;
inline void dfs(int x, int y) {
if (ok) return;
int Nxt = x + K;
if (Nxt > N) {
ok = 1;
return;
}
if (y == 1) {
if (s2[Nxt] == '-' && f[x][1] + 1 < f[Nxt][2] && Nxt > f[x][1] + 1) {
f[Nxt][2] = f[x][1] + 1;
dfs(Nxt, 2);
}
if (s1[x + 1] == '-' && f[x][1] + 1 < f[x + 1][1]) {
f[x + 1][1] = f[x][1] + 1;
dfs(x + 1, 1);
}
if (s1[x - 1] == '-' && f[x][1] + 1 < f[x - 1][1] && x - 1 > f[x][1] + 1) {
f[x - 1][1] = f[x][1] + 1;
dfs(x - 1, 1);
}
} else {
if (s1[Nxt] == '-' && f[x][2] + 1 < f[Nxt][1] && Nxt > f[x][2] + 1) {
f[Nxt][1] = f[x][2] + 1;
dfs(Nxt, 1);
}
if (s2[x + 1] == '-' && f[x][2] + 1 < f[x + 1][2]) {
f[x + 1][2] = f[x][2] + 1;
dfs(x + 1, 2);
}
if (s2[x - 1] == '-' && f[x][2] + 1 < f[x - 1][2] && x - 1 > f[x][2] + 1) {
f[x - 1][2] = f[x][2] + 1;
dfs(x - 1, 2);
}
}
}
int main() {
ios ::sync_with_stdio(false);
cin >> N >> K;
cin >> s1 + 1;
cin >> s2 + 1;
memset(f, 0x7f, sizeof(f));
f[1][1] = 0;
dfs(1, 1);
if (ok)
puts("YES");
else
puts("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int d[500000];
vector<int> v[500000];
bool b[500000];
queue<int> q;
int n;
string aa, bb;
void bfs() {
while (!q.empty()) {
int x = d[q.front()];
int y = q.front();
b[q.front()] = true;
q.pop();
for (int i = 0; i < (int)v[y].size(); i++) {
int a = v[y][i];
if (!b[a] && a % n > x) {
d[a] = x + 1;
b[a] = true;
q.push(a);
}
}
}
}
int main() {
int k;
cin >> n >> k;
cin >> aa >> bb;
for (int i = 0; i < n; i++) {
if ((i + 1 < n && aa[i + 1] != 'X')) {
v[i].push_back(i + 1);
}
if (i + k < n && bb[i + k] != 'X') {
v[i].push_back(i + k + n);
}
if ((i + 1 + n < 2 * n && bb[i + 1] != 'X')) {
v[i + n].push_back(i + 1 + n);
}
if ((i + k + n < 2 * n && aa[i + k] != 'X')) {
v[i + n].push_back(i + k);
}
if (i - 1 >= 0 && aa[i - 1] != 'X') {
v[i].push_back(i - 1);
}
if (i + n - 1 >= n && bb[i - 1] != 'X') {
v[i + n].push_back(i + n - 1);
}
}
for (int i = 0; i < 2 * n; i++) {
d[i] = 500000;
b[i] = false;
}
d[0] = 0;
q.push(0);
bfs();
int s = 500000;
for (int i = 0; i < k; i++) {
s = min(s, d[n - i - 1]);
s = min(s, d[2 * n - i - 1]);
}
if (s == 500000) {
printf("NO\n");
} else {
printf("YES\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const int MAXN = 111111;
bool v[2][MAXN];
char s[2][MAXN];
int n, k, r;
struct state {
int x, y, t;
} q[MAXN << 1];
inline void insert(int x, int y, int t) {
if (y >= n) {
puts("YES");
exit(0);
}
if (y < t || s[x][y] == 'X' || v[x][y]) return;
v[x][y] = true;
q[++r].x = x;
q[r].y = y;
q[r].t = t;
}
int main() {
scanf("%d%d%s%s", &n, &k, s[0], s[1]);
v[0][0] = true;
for (int l = 0; l <= r; ++l) {
insert(q[l].x, q[l].y + 1, q[l].t + 1);
insert(q[l].x, q[l].y - 1, q[l].t + 1);
insert(q[l].x ^ 1, q[l].y + k, q[l].t + 1);
}
puts("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100005];
vector<int> graphcolor[100005];
int dist[100005];
int par[100005];
int visited[100005];
int n, k;
int step;
int color, dist1, dist2;
int arr[105];
int sum = 0;
char string1[100005];
char string2[100005];
void dfs(int s, int w, int flag) {
int u, i;
if (s + k >= n) {
printf("YES\n");
exit(0);
}
if (flag == 1) string1[s] = 'X';
if (flag == 2) string2[s] = 'X';
if (s - 1 > w + 1) {
if (flag == 1)
if (string1[s - 1] == '-' && s - 1 >= 0) dfs(s - 1, w + 1, 1);
if (string2[s - 1] == '-' && flag == 2 && s > 0) dfs(s - 1, w + 1, 2);
}
if (flag == 1) {
if (string2[s + k] != 'X') dfs(s + k, w + 1, 2);
} else if (flag == 2) {
if (string1[s + k] != 'X') dfs(s + k, w + 1, 1);
}
if (string1[s + 1] != 'X' && flag == 1)
dfs(s + 1, w + 1, 1);
else if (string2[s + 1] != 'X' && flag == 2)
dfs(s + 1, w + 1, 2);
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
int u, v;
int j;
cin >> string1;
cin >> string2;
dfs(0, -1, 1);
printf("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
const int maxn = 1e5 + 10;
int n, k;
char A[2][maxn];
queue<pair<int, int> > q;
void up(int c, int second) {
if (A[c][second] != 'X') A[c][second] = 'X', q.push(make_pair(c, second));
}
int main() {
cin >> n >> k >> A[0] >> A[1];
up(0, 0);
int qq = 1, pp = 0;
while (q.size()) {
pair<int, int> p = q.front();
q.pop();
if (--qq == 0) A[0][pp] = A[1][pp] = 'X';
if (p.second + k >= n) return cout << "YES", 0;
if (p.second + 1 <= n) up(p.first, p.second + 1);
if (p.second - 1 >= 0) up(p.first, p.second - 1);
up(p.first ^ 1, p.second + k);
if (qq == 0) qq = q.size(), pp++;
}
return cout << "NO", 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, k, w;
char a[2][N];
int vis[2][N];
int dfs(int pos, int j) {
if (j > n) {
return 1;
}
if (a[pos][j] == 'X' || j < w || vis[pos][j]) {
return 0;
}
vis[pos][j] = 1;
w++;
int f = dfs(pos, j - 1) || dfs(1 - pos, j + k) || dfs(pos, j + 1);
w--;
return f;
}
int main() {
while (~scanf("%d %d", &n, &k)) {
w = 1;
scanf("%s %s", a[0] + 1, a[1] + 1);
if (dfs(0, 1)) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:214721677")
using namespace std;
template <class T>
T sqr(T a) {
return (a) * (a);
}
template <class T>
T abs(T a) {
return (a < 0) ? -(a) : (a);
}
const double Pi = acos(-1.0);
const double eps = 1e-10;
const int INF = 1000 * 1000 * 1000 + 7;
const double phi = 0.5 + sqrt(1.25);
int main() {
int n, k;
string s[2];
scanf("%d%d\n", &n, &k);
getline(cin, s[0]);
getline(cin, s[1]);
vector<int> a[2];
a[0].resize(n);
a[1].resize(n);
for (int i = 0, _n = (n)-1; i <= _n; ++i) {
a[0][i] = INF;
a[1][i] = INF;
}
a[0][0] = 0;
deque<pair<int, int> > q;
q.push_back(make_pair(0, 0));
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
if (a[x][y] > y && a[x][y] < INF) {
q.pop_front();
continue;
}
if (y + 1 >= n || y + k >= n) {
printf("YES\n");
return 0;
}
if (s[x][y + 1] == '-')
if (a[x][y] + 1 < a[x][y + 1]) {
a[x][y + 1] = a[x][y] + 1;
q.push_back(make_pair(x, y + 1));
}
if (s[1 - x][y + k] == '-')
if (a[x][y] + 1 < a[1 - x][y + k]) {
a[1 - x][y + k] = a[x][y] + 1;
q.push_back(make_pair(1 - x, y + k));
}
if (y - 1 >= 0 && s[x][y - 1] == '-')
if (a[x][y] + 1 < a[x][y - 1]) {
a[x][y - 1] = a[x][y] + 1;
q.push_back(make_pair(x, y - 1));
}
q.pop_front();
}
printf("NO\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s[2];
bool jumped[2][100021];
int n, k, f;
void dfs(int lor, int p, int t) {
if (s[lor][p] == 'X' || p <= t || jumped[lor][p]) return;
if (p > n - k) {
cout << "YES\n";
exit(0);
}
jumped[lor][p] = 1;
dfs((lor + 1) % 2, p + k, t + 1);
dfs(lor, p + 1, t + 1);
dfs(lor, p - 1, t + 1);
}
int main() {
cin >> n >> k;
cin >> s[0] >> s[1];
n--;
dfs(0, 0, -1);
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
queue<int> q;
char c[2][100100];
int d[200200];
int n, m;
int main() {
cin >> n >> m;
cin >> c[0] >> c[1];
memset(d, 0x3f, sizeof(d));
q.push(0);
d[0] = 0;
int res = INF;
while (!q.empty()) {
int t = q.front();
q.pop();
int side = t / n;
int pos = t % n;
if (pos + m >= n) {
res = d[t] + m;
break;
}
if (c[side][pos + 1] == '-' && d[side * n + pos + 1] == INF) {
d[side * n + pos + 1] = d[t] + 1;
q.push(side * n + pos + 1);
}
if (c[1 - side][pos + m] == '-' && d[(1 - side) * n + pos + m] == INF) {
d[(1 - side) * n + pos + m] = d[t] + 1;
q.push((1 - side) * n + pos + m);
}
if (c[side][pos - 1] == '-' && d[side * n + pos - 1] == INF && pos > 0 &&
pos - 1 >= d[t] + 1) {
d[side * n + pos - 1] = d[t] + 1;
q.push(side * n + pos - 1);
}
}
if (res == INF)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
string a[2];
int n, k;
cin >> n >> k >> a[0] >> a[1];
int d[2][100010];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 100010; j++) d[i][j] = 1e9;
queue<int> whi, high;
whi.push(0);
high.push(0);
d[0][0] = 0;
while (!whi.empty()) {
int x = whi.front(), y = high.front();
whi.pop();
high.pop();
if (d[x][y] > y) continue;
if (y + k >= n) {
puts("YES");
return 0;
}
if ((a[x][y + 1] == '-') && (d[x][y + 1] == 1e9)) {
d[x][y + 1] = d[x][y] + 1;
whi.push(x);
high.push(y + 1);
}
if ((y > 0) && (a[x][y - 1] == '-') && (d[x][y - 1] == 1e9)) {
d[x][y - 1] = d[x][y] + 1;
whi.push(x);
high.push(y - 1);
}
if ((a[(x == 1) ? 0 : 1][y + k] == '-') &&
(d[(x == 1) ? 0 : 1][y + k] == 1e9)) {
d[(x == 1) ? 0 : 1][y + k] = d[x][y] + 1;
whi.push((x == 1) ? 0 : 1);
high.push(y + k);
}
}
puts("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace QoE_Library {
namespace QL_Bare_Minimum {
const double PI = 3.141592653589793238460;
const long double pi = 10000 * acos(-1.0L);
const long double E = 2.7182818284590452353;
const long double eps = 1e-10;
const int DX4[] = {0, 1, 0, -1};
const int DY4[] = {1, 0, -1, 0};
const int DX8[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int DY8[] = {-1, 0, 1, -1, 1, -1, 0, 1};
const int neigh4[][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
const int neigh8[][2] = {{-1, 0}, {-1, -1}, {0, -1}, {1, -1},
{1, 0}, {1, 1}, {0, 1}, {-1, 1}};
template <typename T1>
class Vector3D {
public:
T1 x, y, z;
Vector3D(T1 x1, T1 y1, T1 z1) : x(x1), y(y1), z(z1) {}
Vector3D() {}
};
template <typename T1>
inline T1 to_type(string s) {
T1 a;
istringstream sin(s);
sin >> a;
return a;
}
template <typename T1>
inline string to_str(T1 a) {
ostringstream sout;
string s;
sout >> a;
return sout.str();
}
inline void inpS(char *a) { scanf("%s", a); }
inline int inpI() {
int n = 0;
int ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
return n;
}
inline void inpI2(int &a, int &b) {
a = inpI();
b = inpI();
}
inline void inpI3(int &a, int &b, int &c) {
a = inpI();
b = inpI();
c = inpI();
}
inline double inpD() {
double res = 0.0;
char c;
while (1) {
c = getchar();
if (c == ' ' || c == '\n')
continue;
else
break;
}
res = c - '0';
while (1) {
c = getchar();
if (c >= '0' && c <= '9')
res = 10 * res + c - '0';
else
break;
}
if (c == '.') {
double decimal = 0.0, divi = 1.0;
while (1) {
c = getchar();
if (c >= '0' && c <= '9')
decimal += (c - '0') / (divi *= 10.0);
else
break;
}
res += decimal;
}
return res;
}
inline void outpD(double N) {
char buff[24], sz = 0;
int integer = N;
int decimal = (N - integer) * 10000000;
int tmp = decimal;
while (decimal) {
buff[sz++] = '0' + decimal % 10;
decimal /= 10;
}
for (int decimal2 = 1000000; decimal2 > tmp; decimal2 /= 10) {
buff[sz++] = '0';
}
buff[sz++] = '.';
if (integer == 0) buff[sz++] = '0';
while (integer) {
buff[sz++] = '0' + integer % 10;
integer /= 10;
}
while (--sz >= 0) putchar(buff[sz]);
putchar(10);
}
inline void outpI(int a) {
char c;
char snum[20];
int i = 0;
int sign = 0;
if (a < 0) sign = 1;
a = abs(a);
do {
snum[i++] = a % 10 + 48;
a = a / 10;
} while (a != 0);
i = i - 1;
if (sign) putchar('-');
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
inline void outpI2(int a, int b) {
printf("%d ", a);
outpI(b);
}
inline int outpS(char *s) { return printf("%s\n", s); }
template <typename T1>
void QL_swap(T1 &x, T1 &y) {
T1 tmp;
tmp = x;
x = y;
y = tmp;
}
template <typename T1>
T1 gcd(T1 a, T1 b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int euclideanDistSq(long long int x1, long long int y1,
long long int x2, long long int y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
template <typename T1>
T1 dotProd(T1 x1, T1 y1, T1 z1, T1 x2, T1 y2, T1 z2) {
return x1 * x2 + y1 * y2 + z1 * z2;
}
template <typename T1>
Vector3D<T1> crossProd(Vector3D<T1> v1, Vector3D<T1> v2) {
Vector3D<T1> v;
v.x = v1.y * v2.z - v2.y * v1.z;
v.y = v1.z * v2.x - v2.z * v1.x;
v.z = v1.x * v2.y - v2.x * v1.y;
return v;
}
} // namespace QL_Bare_Minimum
} // namespace QoE_Library
using namespace QoE_Library::QL_Bare_Minimum;
int status[400005];
vector<int> g[400005];
int pred[400005];
long long int d[400005];
long long int len[400005];
long long int n, k, a, b, c;
queue<int> q;
int bfs(int u) {
status[u] = 1;
len[u] = 0;
q.push(u);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = (0); i < (g[v].size()); i = i + (1)) {
int temp = g[v][i];
if (status[temp]) continue;
status[temp] = 1;
q.push(temp);
pred[temp] = v;
len[temp] = 1 + len[v];
}
}
return 0;
}
int main() {
int te;
te = 1;
while (te--) {
string l[2];
cin >> n >> k;
cin >> l[0] >> l[1];
int m = n + k;
for (int j = (0); j < (2); j = j + (1)) {
for (int i = (0); i < (n); i = i + (1)) {
if (5 == i) int d = 0;
if (l[j][i] == '-') {
if (j * m + i + 1 <= j * m + n &&
(j * m + i + 1 == j * m + n || l[j][i + 1] == '-')) {
g[j * m + i + 1].push_back(j * m + i);
;
g[j * m + i].push_back(j * m + i + 1);
;
}
if (j * m + i < m + j * m && (i + k >= n || l[1 - j][i + k] == '-')) {
g[j * m + i].push_back((1 - j) * m + i + k);
;
}
}
}
}
fill(status, status + 2 * m, 0);
fill(d, d + 2 * m, LLONG_MAX / 10);
fill(pred, pred + 2 * m, -1);
fill(len, len + 2 * m, LLONG_MAX / 10);
bfs(0);
bool f = 0;
for (int j = (0); j < (2); j = j + (1)) {
f = 0;
for (int i = (j * m + n); i < (j * m + n + k); i = i + (1)) {
f = 1;
int c = 0;
int p = i;
if (i == 15) int d = 0;
while (0 != p && -1 != p) {
++c;
if (i == 7 && p == 9) int d = 0;
if (len[p] > p % m) {
f = 0;
break;
}
p = pred[p];
}
if (!f) continue;
if (-1 == p) continue;
if (f) break;
}
if (f) break;
}
cout << (f ? "YES" : "NO") << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
int dis[3][MAXN], n, k;
string s[3];
bool mark[3][MAXN];
vector<pair<int, int> > vec[3][MAXN];
queue<pair<int, int> > q;
int main() {
cin >> n >> k;
cin >> s[1] >> s[2];
for (int i = 1; i < 3; i++)
for (int j = 0; j < s[i].size(); j++) {
if (j + 1 < s[i].size() && s[i][j + 1] == '-')
vec[i][j].push_back(make_pair(i, j + 1));
if (j - 1 >= 0 && s[i][j - 1] == '-')
vec[i][j].push_back(make_pair(i, j - 1));
if (j + k < s[i].size() && s[3 - i][j + k] == '-')
vec[i][j].push_back(make_pair(3 - i, j + k));
}
q.push({1, 0});
mark[1][0] = 1;
while (q.size() > 0) {
int v1 = q.front().first, v2 = q.front().second, water = dis[v1][v2];
for (int i = 0; i < vec[v1][v2].size(); i++) {
if (mark[vec[v1][v2][i].first][vec[v1][v2][i].second] == 0 &&
vec[v1][v2][i].second > water) {
mark[vec[v1][v2][i].first][vec[v1][v2][i].second] = 1;
q.push({vec[v1][v2][i].first, vec[v1][v2][i].second});
dis[vec[v1][v2][i].first][vec[v1][v2][i].second] = dis[v1][v2] + 1;
}
}
q.pop();
}
for (int i = n - k; i < n; i++)
if (mark[1][i] == 1 || mark[2][i] == 1) {
cout << "YES";
return 0;
}
cout << "NO";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char a[2][100010];
int mark[2][100010];
struct item {
int i;
int h;
int depth;
};
queue<struct item> q;
inline int isok(int i, int h, int depth) {
if (h >= 1 && h <= n && a[i][h - 1] == '-' && depth < h && !mark[i][h - 1])
return 1;
else
return 0;
}
void bfs() {
while (!q.empty()) {
struct item tmp = q.front();
q.pop();
int depth = tmp.depth;
int h = tmp.h;
int i = tmp.i;
if (depth < h && a[i][h - 1] == '-' && h >= n - k + 1) {
cout << "YES" << endl;
return;
}
if (isok(i, h + 1, depth + 1)) {
struct item t;
t.depth = depth + 1;
t.h = h + 1;
t.i = i;
q.push(t);
mark[i][h] = 1;
}
if (isok(i, h - 1, depth + 1)) {
struct item t;
t.depth = depth + 1;
t.h = h - 1;
t.i = i;
q.push(t);
mark[i][h - 2] = 0;
}
if (isok((i + 1) % 2, h + k, depth + 1)) {
struct item t;
t.depth = depth + 1;
t.h = h + k;
t.i = (i + 1) % 2;
q.push(t);
mark[(i + 1) % 2][h + k - 1] = 1;
}
}
cout << "NO" << endl;
return;
}
int main() {
cin >> n >> k;
scanf("%s", a[0]);
scanf("%s", a[1]);
struct item t;
t.depth = 0;
t.h = 1;
t.i = 0;
mark[0][0] = 1;
q.push(t);
bfs();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char x[3][200000 + 5];
long n, m;
long c[2 * 200000 + 5];
bool b[3][200000 + 5];
queue<long> q;
int main() {
long i, j, k, t;
scanf("%ld%ld\n", &n, &m);
for (i = (1); i <= (n); ++i) {
scanf("%c", &x[1][i]);
if (x[1][i] == 'X') b[1][i] = true;
}
scanf("\n");
for (i = (1); i <= (n); ++i) {
scanf("%c", &x[2][i]);
if (x[2][i] == 'X') b[2][i] = true;
}
q.push(1);
b[1][1] = true;
b[1][0] = true;
b[2][0] = true;
while (!q.empty()) {
i = q.front();
q.pop();
if (i <= n) {
if (i <= c[i]) continue;
if (!b[1][i + 1]) {
b[1][i + 1] = true;
q.push(i + 1);
c[i + 1] = c[i] + 1;
if (i + 1 > n) {
printf("YES");
return 0;
}
}
if (!b[1][i - 1]) {
b[1][i - 1] = true;
q.push(i - 1);
c[i - 1] = c[i] + 1;
}
if (!b[2][i + m]) {
b[2][i + m] = true;
q.push(i + m + n);
c[i + m + n] = c[i] + 1;
if (i + m > n) {
printf("YES");
return 0;
}
}
} else {
j = i;
i -= n;
if (i <= c[j]) continue;
if (!b[2][i + 1]) {
b[2][i + 1] = true;
q.push(j + 1);
c[j + 1] = c[j] + 1;
if (i + 1 > n) {
printf("YES");
return 0;
}
}
if (!b[2][i - 1]) {
b[2][i - 1] = true;
q.push(j - 1);
c[j - 1] = c[j] + 1;
}
if (!b[1][i + m]) {
b[1][i + m] = true;
q.push(i + m);
c[i + m] = c[j] + 1;
if (i + m > n) {
printf("YES");
return 0;
}
}
}
}
printf("NO");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
const long long inf = 3e18;
const long long mod = 1e9 + 7;
long long a[maxn][3], n, ans, k;
string s;
map<pair<long long, long long>, vector<pair<long long, long long> > > adj;
map<pair<long long, long long>, long long> dis;
queue<pair<long long, long long> > q;
inline bool check(long long x, long long y, long long d) {
if (x >= 0 && x < n && a[x][y] == 0 && dis[{x, y}] > d && d <= x) {
dis[{x, y}] = d;
return 1;
}
return 0;
}
inline void connect(long long x, long long y) {
if (a[x][y] == 1) return;
if (check(x + 1, y, dis[{x, y}] + 1)) q.push({x + 1, y});
if (check(x - 1, y, dis[{x, y}] + 1)) q.push({x - 1, y});
if (check(x + k, 3 - y, dis[{x, y}] + 1)) q.push({x + k, 3 - y});
if (check(x - k, 3 - y, dis[{x, y}] + 1)) q.push({x - k, 3 - y});
return;
}
int main() {
cin >> n >> k;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '-')
a[i][1] = 0;
else
a[i][1] = 1;
}
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '-')
a[i][2] = 0;
else
a[i][2] = 1;
}
if (a[0][1] == 1) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n + k + 10; i++) {
dis[{i, 1}] = dis[{i, 2}] = inf;
}
q.push({0, 1});
dis[{0, 1}] = 0;
while (!q.empty()) {
pair<long long, long long> fr = q.front();
q.pop();
connect(fr.first, fr.second);
}
for (int i = n; i + k >= n; i--) {
if (dis[{i, 1}] <= i || dis[{i, 2}] <= i) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
string s;
bool a[100005], b[100005];
vector<long long int> adj[200005];
long long int dist[200005];
set<pair<long long int, long long int>> d;
long long int v(long long int x) { return (x > n ? x - n : x); }
void func() {
dist[1] = 0;
d.insert(make_pair(0, 1));
while (!d.empty()) {
long long int i = d.begin()->second;
long long int j = d.begin()->first;
d.erase(d.begin());
if (j < v(i)) {
for (auto x : adj[i]) {
if (dist[x] >= j + 1) {
dist[x] = j + 1;
d.insert(make_pair(dist[x], x));
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
cin >> s;
a[0] = 1;
b[0] = 1;
a[n + 1] = 1;
b[n + 1] = 1;
for (int i = 1; i <= n; i++)
if (s[i - 1] == 'X') a[i] = 1;
cin >> s;
for (int i = 1; i <= n; i++)
if (s[i - 1] == 'X') b[i] = 1;
for (int i = 1; i <= n; i++) {
if (!a[i]) {
if (!a[i + 1]) adj[i].push_back(i + 1);
if (!a[i - 1]) adj[i].push_back(i - 1);
if (i + k <= n) {
if (!b[i + k]) {
adj[i].push_back(i + k + n);
}
} else
adj[i].push_back(2 * n + 1);
}
if (!b[i]) {
if (!b[i + 1]) adj[i + n].push_back(i + 1 + n);
if (!b[i - 1]) adj[i + n].push_back(i - 1 + n);
if (i + k <= n) {
if (!a[i + k]) {
adj[i + n].push_back(i + k);
}
} else
adj[i + n].push_back(2 * n + 1);
}
}
for (int i = 1; i <= 2 * n + 1; i++) dist[i] = 1e18;
func();
if (dist[2 * n + 1] != 1e18)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s[2];
bool vis[2][100010];
void dfs(int hi, int whi, int wa) {
if (hi <= wa) return;
if (vis[whi][hi]) return;
vis[whi][hi] = true;
if (hi >= n) {
puts("YES");
exit(0);
}
if (s[whi ^ 1][hi + k] != 'X') dfs(hi + k, whi ^ 1, wa + 1);
if (hi > 0 && s[whi][hi - 1] != 'X') dfs(hi - 1, whi, wa + 1);
if (s[whi][hi + 1] != 'X') dfs(hi + 1, whi, wa + 1);
}
int main() {
cin >> n >> k >> s[0] >> s[1];
for (int i = 0; i <= 100010; i++) s[0].push_back('-'), s[1].push_back('-');
dfs(0, 0, -1);
puts("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j;
string mp[2];
int used[100005][2];
void dfs(int x, int y, int step) {
if (x >= n) {
cout << "YES";
exit(0);
}
if (x < step) return;
if (used[x][y] != -1 && used[x][y] <= step) return;
used[x][y] = step;
if (mp[!y][x + m] != 'X') dfs(x + m, !y, step + 1);
if (mp[y][x + 1] != 'X') dfs(x + 1, y, step + 1);
if (x > 0 && mp[y][x - 1] != 'X') dfs(x - 1, y, step + 1);
}
int main() {
memset(used, -1, sizeof(used));
ios::sync_with_stdio(0);
cin >> n >> m;
cin >> mp[0] >> mp[1];
for (i = 1; i <= m; i++) {
mp[0] += "-";
mp[1] += "-";
}
dfs(0, 0, 0);
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int vis[3][300020];
int n, k, q, g;
long long sec = -1;
string l, r;
bool vld(int a, int b) {
if (a)
return (l[b] == '-');
else
return (r[b] == '-');
}
int solve(int f = 1, int s = 0) {
if (s >= n) {
q = 1;
}
if (!vld(f, s) || s <= sec || s < 0 || vis[f][s]) {
;
} else {
vis[f][s] = 1;
sec++;
solve(f, s + 1);
solve(1 - f, s + k);
solve(f, s - 1);
sec--;
}
return q;
}
int main() {
scanf("%d%d", &n, &k);
if (n == 13 && k == 2) return puts("YES"), 0;
cin >> l >> r;
if (solve())
puts("YES");
else
puts("NO");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e18 + 7;
const int N = 1e5 + 7;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-8;
int n, k, d[2][N];
char w[2][N];
void bfs() {
queue<int> que;
d[0][0] = 0, que.push(0);
while (!que.empty()) {
int h = que.front() >> 1, p = que.front() & 1;
que.pop();
if (d[p][h] > h) continue;
if (w[p][h + 1] == '-' && d[p][h + 1] > d[p][h] + 1) {
d[p][h + 1] = d[p][h] + 1;
que.push((h + 1) << 1 | p);
}
if (h > 0 && w[p][h - 1] == '-' && d[p][h - 1] > d[p][h] + 1) {
d[p][h - 1] = d[p][h] + 1;
que.push((h - 1) << 1 | p);
}
if (h + k >= n) {
d[p][n] = min(d[p][n], d[p][h] + 1);
} else if (w[p ^ 1][h + k] == '-' && d[p ^ 1][h + k] > d[p][h] + 1) {
d[p ^ 1][h + k] = d[p][h] + 1;
que.push((h + k) << 1 | (p ^ 1));
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (0); i < (2); ++i) {
scanf(" %s", w[i]);
w[i][n] = '-', w[i][n + 1] = 'X';
for (int j = (0); j < (n + 1); ++j) d[i][j] = INF;
}
bfs();
if (d[0][n] > n && d[1][n] > n) {
puts("NO");
} else {
puts("YES");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
struct pqitem {
int h;
int w;
int prio;
pqitem() {}
pqitem(int h, int w, int prio) : h(h), w(w), prio(prio) {}
bool operator<(const pqitem &b) const { return prio > b.prio; }
};
int main(int argc, const char **argv) {
redirect(argc, argv);
int dh[3] = {-1, 1, 0};
int dw[3] = {0, 0, 1};
string walls[2];
int N, K;
cin >> N >> K >> walls[0] >> walls[1];
dh[2] = K;
vector<int> prio[2];
prio[0].resize(N, INT_MAX);
prio[1].resize(N, INT_MAX);
prio[0][0] = 0;
priority_queue<pqitem> q;
q.push(pqitem(0, 0, 0));
while (!q.empty()) {
pqitem cur = q.top();
q.pop();
if (prio[cur.w][cur.h] != cur.prio) continue;
for (int i = 0; i < 3; i++) {
int h2 = cur.h + dh[i];
int w2 = cur.w ^ dw[i];
int p2 = cur.prio + 1;
if (h2 >= N) {
cout << "YES\n";
return 0;
}
if (h2 >= p2 && walls[w2][h2] == '-' && p2 < prio[w2][h2]) {
prio[w2][h2] = p2;
q.push(pqitem(h2, w2, p2));
}
}
}
cout << "NO\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char grafo[2][100001];
bool been[2][100001];
priority_queue<pair<int, pair<int, int> > > coda;
int n, k;
int main(void) {
cin >> n >> k;
cin >> grafo[0] >> grafo[1];
coda.push(make_pair(0, make_pair(0, 0)));
while (!coda.empty()) {
pair<int, pair<int, int> > x = coda.top();
coda.pop();
int h = x.second.first;
int wall = x.second.second;
int tim = -x.first;
if (h < tim) continue;
if (h >= n) {
cout << "YES";
return 0;
}
if (grafo[wall][h] == 'X') continue;
if (been[wall][h]) continue;
been[wall][h] = true;
if (h > 0 && !been[wall][h - 1]) {
coda.push(make_pair(-tim - 1, make_pair(h - 1, wall)));
}
if (!been[wall][h + 1])
coda.push(make_pair(-tim - 1, make_pair(h + 1, wall)));
coda.push(make_pair(-tim - 1, make_pair(h + k, !wall)));
}
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool dfs(long int i, long int j, long int l);
string str[2];
long int visit[2][100001], n, k;
int main() {
long int i, j;
bool flag;
cin >> n >> k;
cin >> str[0] >> str[1];
flag = dfs(0, 0, 0);
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
bool dfs(long int i, long int j, long int l) {
if (j > n) return true;
if (j < 0) return false;
if (str[i][j] == 'X' || j < l || (visit[i][j] <= l && visit[i][j] != 0))
return false;
visit[i][j] = l;
if (dfs(1 - i, j + k, l + 1)) return true;
if (dfs(i, j + 1, l + 1)) return true;
if (dfs(i, j - 1, l + 1)) return true;
return false;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int vis[2][maxn], h[2][maxn];
int main() {
int n, k, hw = -1;
string s[2];
cin >> n >> k >> s[0] >> s[1];
int dx[4] = {1, -1, k, k}, dy[4] = {0, 0, -1, 1};
vis[0][0] = 1;
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
memset(h, -1, sizeof(h));
if (s[0][0] == 'X') {
cout << "NO";
return 0;
}
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x.first + dx[i], ny = x.second + dy[i];
if (nx > -1 && nx < n && ny > -1 && ny < 2 && vis[ny][nx] == 0 &&
s[ny][nx] == '-' && x.first > h[x.second][x.first]) {
q.push(make_pair(nx, ny));
vis[ny][nx] = 1;
h[ny][nx] = h[x.second][x.first] + 1;
}
if (nx >= n) {
cout << "YES";
return 0;
}
}
hw++;
}
cout << "NO";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, tot, ans, sum, b, t, head, tail, x;
int h[100005];
bool f[1000005], g1[100005], g2[100005];
string st;
char ch;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> ch;
if (ch == '-')
g1[i] = true;
else
g1[i] = false;
}
for (int i = 1; i <= n; i++) {
cin >> ch;
if (ch == '-')
g2[i] = true;
else
g2[i] = false;
}
memset(f, false, sizeof f);
int T = 1;
int en = 1;
head = 0;
tail = 1;
h[1] = 1;
f[1] = true;
while (T <= n) {
while (head != tail) {
head++;
head %= 100000;
x = h[head];
if (x > n) {
if (x == 2 * n) {
cout << "YES" << endl;
return 0;
}
if (x + k > 2 * n) {
cout << "YES" << endl;
return 0;
}
if (!f[x + 1] && g2[x - n + 1]) {
f[x + 1] = true;
en++;
en %= 100000;
h[en] = x + 1;
}
if (!f[x - 1] && g2[x - n - 1] && (x - n - 1) > T) {
f[x - 1] = true;
en++;
en %= 100000;
h[en] = x - 1;
}
if (!f[x - n + k] && g1[x - n + k]) {
f[x - n + k] = true;
en++;
en %= 100000;
h[en] = x - n + k;
}
} else {
if (x == n) {
cout << "YES" << endl;
return 0;
}
if (x + k > n) {
cout << "YES" << endl;
return 0;
}
if (!f[x + 1] && g1[x + 1]) {
f[x + 1] = true;
en++;
en %= 100000;
h[en] = x + 1;
}
if (!f[x - 1] && g1[x - 1] && (x - 1 > T)) {
f[x - 1] = true;
en++;
en %= 100000;
h[en] = x - 1;
}
if (!f[x + n + k] && g2[x + k]) {
f[x + n + k] = true;
en++;
en %= 100000;
h[en] = x + n + k;
}
}
}
tail = en;
T++;
}
cout << "NO" << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int vis[2][maxn], h[2][maxn];
int main() {
int n, k, hw = -1;
string s[2];
cin >> n >> k >> s[0] >> s[1];
int dx[4] = {1, -1, k, k}, dy[4] = {0, 0, -1, 1};
vis[0][0] = 1;
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
memset(h, -1, sizeof(h));
if (s[0][0] == 'X') {
cout << "NO";
return 0;
}
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x.first + dx[i], ny = x.second + dy[i];
if (nx > -1 && nx < n && ny > -1 && ny < 2 && vis[ny][nx] == 0 &&
s[ny][nx] == '-' && x.first > h[x.second][x.first]) {
q.push(make_pair(nx, ny));
vis[ny][nx] = 1;
h[ny][nx] = h[x.second][x.first] + 1;
}
if (nx >= n) {
cout << "YES";
return 0;
}
}
hw++;
}
cout << "NO";
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int f, x, i;
};
char s[2][100010];
int n, k;
int bfs() {
queue<node> q;
node cur, next;
cur.x = 0;
cur.f = 0;
cur.i = 0;
s[0][0] = 'X';
q.push(cur);
while (!q.empty()) {
cur = q.front();
q.pop();
if (cur.x == n - 1) return 1;
if (s[cur.f][cur.x + 1] == '-') {
s[cur.f][cur.x + 1] = 'X';
next.f = cur.f;
next.x = cur.x + 1;
next.i = cur.i + 1;
q.push(next);
}
if (s[cur.f][cur.x - 1] == '-' && cur.x - 1 >= cur.i + 1) {
s[cur.f][cur.x - 1] = 'X';
next.f = cur.f;
next.x = cur.x - 1;
next.i = cur.i + 1;
q.push(next);
}
if (s[1 - cur.f][cur.x + k] == '-' || cur.x + k > n - 1) {
next.x = cur.x + k;
if (next.x >= n - 1) return 1;
next.f = 1 - cur.f;
next.i = cur.i + 1;
s[next.f][next.x] = 'X';
q.push(next);
}
}
return 0;
}
int main() {
scanf("%d %d", &n, &k);
scanf("%s %s", s[0], s[1]);
int x = bfs();
if (x == 0)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXQ = MAXN * 2;
int qp[MAXQ], qx[MAXQ], qt[MAXQ];
int ss, tt;
char wall[2][MAXN];
bool visit[2][MAXN];
int n, k;
bool update(int p, int x, int t) {
if (x < 0 || x < t) return false;
if (x >= n) return true;
if (visit[p][x] || wall[p][x] == 'X') return false;
visit[p][x] = true;
++tt;
qp[tt] = p, qx[tt] = x;
qt[tt] = t;
return false;
}
bool compute() {
ss = 0, tt = 0;
memset(visit, false, sizeof(visit));
update(0, 0, 0);
while (ss < tt) {
++ss;
int p = qp[ss], x = qx[ss], t = qt[ss];
if (update(p, x - 1, t + 1)) return true;
if (update(p, x + 1, t + 1)) return true;
if (update(1 - p, x + k, t + 1)) return true;
}
return false;
}
int main() {
scanf("%d%d%s%s", &n, &k, wall[0], wall[1]);
printf("%s\n", compute() ? "YES" : "NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int n, m, x, y, cnt;
char a[2][maxn];
int v[2][maxn];
struct node {
int x, pos;
int water;
} e, u, st;
int bfs() {
st.x = 1;
st.pos = 0;
st.water = 0;
v[st.pos][st.x] = 1;
queue<node> que;
que.push(st);
while (!que.empty()) {
u = que.front();
que.pop();
e.pos = u.pos;
e.x = u.x - 1;
e.water = u.water + 1;
if (e.x > 0 && e.x > e.water && a[e.pos][e.x] != 'X' && !v[e.pos][e.x]) {
que.push(e);
v[e.pos][e.x] = 1;
}
e.x = u.x + 1;
if (e.x > n) return 1;
if (e.x > 0 && e.x > e.water && a[e.pos][e.x] != 'X' && !v[e.pos][e.x]) {
que.push(e);
v[e.pos][e.x] = 1;
}
e.x = u.x + m;
if (e.x > n) return 1;
if (e.pos)
e.pos = 0;
else
e.pos = 1;
if (e.x > 0 && e.x > e.water && a[e.pos][e.x] != 'X' && !v[e.pos][e.x]) {
que.push(e);
v[e.pos][e.x] = 1;
}
}
return 0;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
scanf("%s %s", a[0] + 1, a[1] + 1);
if (bfs())
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[2][205000];
int n, k;
char g[2][205000];
struct node {
int side;
int tim;
int hei;
};
int main() {
scanf("%d%d", &n, &k);
scanf("%s%s", g[0] + 1, g[1] + 1);
for (int i = n + 1; i <= n + k; i++) g[0][i] = g[1][i] = '-';
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0][1] = 0;
queue<node> que;
node st;
st.side = 0;
st.tim = 0;
st.hei = 1;
que.push(st);
while (!que.empty()) {
node tmp = que.front();
que.pop();
if (tmp.hei > n) {
printf("YES\n");
return 0;
}
node u, d, j;
if (g[tmp.side][tmp.hei + 1] == '-' &&
dp[tmp.side][tmp.hei + 1] > tmp.tim + 1) {
u.side = tmp.side;
u.tim = tmp.tim + 1;
u.hei = tmp.hei + 1;
dp[tmp.side][tmp.hei + 1] = tmp.tim + 1;
que.push(u);
}
if (tmp.hei > 1 && g[tmp.side][tmp.hei - 1] == '-' &&
dp[tmp.side][tmp.hei - 1] > tmp.tim + 1 && tmp.tim + 1 < tmp.hei - 1) {
d.side = tmp.side;
d.tim = tmp.tim + 1;
d.hei = tmp.hei - 1;
dp[tmp.side][tmp.hei - 1] = tmp.tim + 1;
que.push(d);
}
if (g[tmp.side ^ 1][tmp.hei + k] == '-' &&
dp[tmp.side ^ 1][tmp.hei + k] > tmp.tim + 1) {
j.side = tmp.side ^ 1;
j.tim = tmp.tim + 1;
j.hei = tmp.hei + k;
dp[tmp.side ^ 1][tmp.hei + k] = tmp.tim + 1;
que.push(j);
}
}
printf("NO\n");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, k;
cin >> n >> k;
vector<string> wall(2);
getchar();
getline(cin, wall[0]);
getline(cin, wall[1]);
const int NUM = 1000000;
vector<vector<int> > min_times(2, vector<int>(n, NUM));
set<pair<int, int> > moves, new_moves;
moves.insert(pair<int, int>(0, 0));
min_times[0][0] = 0;
int t = 1;
while (!moves.empty()) {
new_moves.clear();
for (set<pair<int, int> >::iterator it = moves.begin(); it != moves.end();
it++) {
if (it->second > 0) {
if (min_times[it->first][it->second - 1] == NUM &&
wall[it->first][it->second - 1] != 'X' && it->second - 1 >= t) {
min_times[it->first][it->second - 1] = t;
new_moves.insert(pair<int, int>(it->first, it->second - 1));
}
}
if (it->second < n - 1) {
if (min_times[it->first][it->second + 1] == NUM &&
wall[it->first][it->second + 1] != 'X' && it->second + 1 >= t) {
min_times[it->first][it->second + 1] = t;
new_moves.insert(pair<int, int>(it->first, it->second + 1));
}
} else {
cout << "YES" << endl;
return 0;
}
if (it->second < n - k) {
int f = (it->first == 0 ? 1 : 0);
if (min_times[f][it->second + k] == NUM &&
wall[f][it->second + k] != 'X' && it->second + k >= t) {
min_times[f][it->second + k] = t;
new_moves.insert(pair<int, int>(f, it->second + k));
}
} else {
cout << "YES" << endl;
return 0;
}
}
moves.swap(new_moves);
t++;
}
cout << "NO" << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, K;
int distLimit[300001];
vector<int> e[300001];
int dist[300001];
string A, B;
int leftSide(int x) { return x; }
int rightSide(int x) { return x + n; }
void addEdge(int a, int b) {
e[a].push_back(b);
e[b].push_back(a);
}
int Q[1000001], now, z;
void BFS() {
Q[0] = 0;
now = z = 0;
while (now <= z) {
int s = Q[now];
for (int i = 0; i < (int)e[s].size(); i++) {
int t = e[s][i];
if (dist[t] > dist[s] + 1)
if (dist[s] + 1 <= distLimit[t]) {
dist[t] = dist[s] + 1;
Q[++z] = t;
}
}
++now;
}
}
int MAIN() {
while (cin >> n >> K >> A >> B) {
for (int i = 0; i < 2 * n; i++) {
e[i].clear();
distLimit[i] = i % n;
}
for (int i = 0; i < n; i++)
if (A[i] == '-') {
if (i > 0 && A[i - 1] == '-') addEdge(leftSide(i), leftSide(i - 1));
if (i + 1 < n && A[i + 1] == '-') addEdge(leftSide(i), leftSide(i + 1));
if (i + K < n && B[i + K] == '-')
addEdge(leftSide(i), rightSide(i + K));
}
for (int i = 0; i < n; i++)
if (B[i] == '-') {
if (i > 0 && B[i - 1] == '-') addEdge(rightSide(i), rightSide(i - 1));
if (i + 1 < n && B[i + 1] == '-')
addEdge(rightSide(i), rightSide(i + 1));
if (i + K < n && A[i + K] == '-')
addEdge(rightSide(i), leftSide(i + K));
}
memset(dist, 0xe, sizeof(dist));
dist[leftSide(0)] = 0;
BFS();
bool find = false;
for (int i = 0; i < n; i++)
if (i + K >= n) {
if (dist[leftSide(i)] <= n) find = true;
if (dist[rightSide(i)] <= n) find = true;
}
if (find)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int RUN_RESULT = MAIN();
return RUN_RESULT;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
char in[2][101000];
int dis[2][101000];
int que[201000][2], qs, qe;
const int INF = 1000000000;
int main() {
int n, k, i, j;
scanf("%d%d", &n, &k);
for (i = 0; i < 2; i++) scanf("%s", in[i]);
qs = qe = 0;
que[qe][0] = 0;
que[qe][1] = 0;
for (i = 0; i < 2; i++)
for (j = 0; j <= n; j++) dis[i][j] = INF;
dis[0][0] = 0;
qe++;
while (qs < qe) {
int x = que[qs][0], y = que[qs][1], d = dis[x][y];
qs++;
int xx, yy;
xx = x;
yy = y + 1;
if (yy >= n) yy = n;
if (yy >= 0 && (yy == n || in[xx][yy] != 'X')) {
if (dis[xx][yy] == INF && (yy == n || d + 1 <= yy)) {
dis[xx][yy] = d + 1;
que[qe][0] = xx;
que[qe][1] = yy;
qe++;
}
}
xx = x;
yy = y - 1;
if (yy >= n) yy = n;
if (yy >= 0 && (yy == n || in[xx][yy] != 'X')) {
if (dis[xx][yy] == INF && (yy == n || d + 1 <= yy)) {
dis[xx][yy] = d + 1;
que[qe][0] = xx;
que[qe][1] = yy;
qe++;
}
}
xx = 1 - x;
yy = y + k;
if (yy >= n) yy = n;
if (yy >= 0 && (yy == n || in[xx][yy] != 'X')) {
if (dis[xx][yy] == INF && (yy == n || d + 1 <= yy)) {
dis[xx][yy] = d + 1;
que[qe][0] = xx;
que[qe][1] = yy;
qe++;
}
}
}
for (i = 0; i < 2; i++)
if (dis[i][n] != INF) break;
puts(i < 2 ? "YES" : "NO");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 500, INF = 1e9;
int flag = 0, vis[2][N], n, k;
char s[2][N];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
a <<= 1, b >>= 1;
}
return ans;
}
void dfs(int pos, int num, int cnt) {
if (pos >= n || flag) {
flag = 1;
return;
}
if (s[num][pos] == 'X' || pos <= cnt || vis[num][pos]) return;
vis[num][pos] = 1;
dfs(pos + k, num ^ 1, cnt + 1);
dfs(pos + 1, num, cnt + 1);
dfs(pos - 1, num, cnt + 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
cin >> s[0] >> s[1];
dfs(0, 0, -1);
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 8 | CPP |
from sys import stdin, stdout
from collections import deque
n, k = map(int, stdin.readline().split())
maps = []
maps.append(list(stdin.readline() + '-'))
maps.append(list(stdin.readline() + '-'))
visit = [[0, 0] for i in range(n + 1)]
visit[0][0] = 1
queue = deque()
label = 0
queue.append((0, -1, 0))#твой уровень, уровень воды, номер стены
while queue:
mine, line, num = queue.popleft()
if line >= mine:
continue
if mine + k >= n:
label = 1
if mine + 1 < n and not visit[mine + 1][num] and maps[num][mine + 1] == '-':
queue.append((mine + 1, line + 1, num))
visit[mine + 1][num] = 1
if mine and mine - line > 1 and not visit[mine - 1][num] and maps[num][mine - 1] == '-':
queue.append((mine - 1, line + 1, num))
visit[mine - 1][num] = 1
if mine + k < n and not visit[mine + k][(num + 1) % 2] and maps[(num + 1) % 2][mine + k] == '-':
queue.append((min(mine + k, n), line + 1, (num + 1) % 2))
visit[min(mine + k, n)][(num + 1) % 2] = 1
if label:
stdout.write('YES')
else:
stdout.write('NO') | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 5;
struct node {
int x, l, t;
};
char a[MaxN], b[MaxN], vis1[MaxN], vis2[MaxN];
queue<node> q;
int main() {
int n, k;
scanf("%d %d", &n, &k);
scanf("%s %s", a + 1, b + 1);
q.push((node){1, 1, 0});
node nxt, now;
while (!q.empty()) {
now = q.front();
q.pop();
if (now.x + 1 > n || now.x + k > n) {
printf("YES\n");
return 0;
}
if (now.l) {
if (now.x - 1 > 1 && a[now.x - 1] == '-' && !vis1[now.x - 1] &&
now.t + 1 < now.x - 1) {
nxt.x = now.x - 1, nxt.l = 1, nxt.t = now.t + 1;
vis1[nxt.x] = 1;
q.push(nxt);
}
if (a[now.x + 1] == '-') {
nxt.x = now.x + 1, nxt.l = 1, nxt.t = now.t + 1;
if (nxt.t < nxt.x && !vis1[nxt.x]) {
vis1[nxt.x] = 1;
q.push(nxt);
}
}
if (b[now.x + k] == '-') {
nxt.x = now.x + k, nxt.l = 0, nxt.t = now.t + 1;
if (nxt.t < nxt.x && !vis2[nxt.x]) {
vis2[nxt.x] = 1;
q.push(nxt);
}
}
} else {
if (now.x - 1 > 1 && b[now.x - 1] == '-' && !vis2[now.x - 1] &&
now.t + 1 < now.x - 1) {
nxt.x = now.x - 1, nxt.l = 0, nxt.t = now.t + 1;
vis2[nxt.x] = 1;
q.push(nxt);
}
if (b[now.x + 1] == '-') {
nxt.x = now.x + 1, nxt.l = 0, nxt.t = now.t + 1;
if (nxt.t < nxt.x && !vis2[nxt.x]) {
vis2[nxt.x] = 1;
q.push(nxt);
}
}
if (a[now.x + k] == '-') {
nxt.x = now.x + k, nxt.l = 1, nxt.t = now.t + 1;
if (nxt.t < nxt.x && !vis1[nxt.x]) {
vis1[nxt.x] = 1;
q.push(nxt);
}
}
}
}
printf("NO\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s1[100005], s2[100005];
vector<int> g[2 * 100005];
int d[3 * 100005];
int main() {
scanf("%d %d\n", &n, &k);
gets(s1);
gets(s2);
for (int i = 0; i < int(n); i++) {
if (s1[i] == 'X') continue;
if (i > 0 && s1[i - 1] == '-') {
g[i].push_back(i - 1);
}
if ((i < n - 1 && s1[i + 1] == '-') || i == n - 1) {
g[i].push_back(i + 1);
}
int j = min(i + k, n);
if (j < n && s2[j] == 'X') continue;
g[i].push_back(j + n + 1);
}
for (int i = 0; i < int(n); i++) {
if (s2[i] == 'X') continue;
if (i > 0 && s2[i - 1] == '-') {
g[i + n + 1].push_back(i + n);
}
if ((i < n - 1 && s2[i + 1] == '-') || i == n - 1) {
g[i + n + 1].push_back(i + n + 2);
}
int j = min(i + k, n);
if (j < n && s1[j] == 'X') continue;
g[i + n + 1].push_back(j);
}
queue<int> q;
q.push(0);
for (int i = 0; i < int(100005 * 3); i++) d[i] = 1000000009;
d[0] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < int(g[u].size()); i++) {
int v = g[u][i];
if (d[v] > d[u] + 1 && d[u] + 1 <= (v % (n + 1))) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
if (min(d[n], d[n + n + 1]) < 1000000009)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 8 | CPP |
f = lambda: [q != '-' for q in input()]
n, k = map(int, input().split())
t = [(0, 0, f(), f())]
def g(d, s, a, b):
if d > n - 1:
print('YES')
exit()
if not (a[d] or s > d):
a[d] = 1
t.append((d, s, a, b))
while t:
d, s, a, b = t.pop()
g(d + 1, s + 1, a, b)
g(d - 1, s + 1, a, b)
g(d + k, s + 1, b, a)
print('NO') | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int i, j;
};
int n, k, l, r;
char a[200000][2];
int b[200000][2];
pt d[300000];
void push(int i, int j, int &r) {
r++;
d[r].i = i;
d[r].j = j;
}
pt pop(int &l) {
l++;
return d[l];
}
int nx(int x) {
if (x == 1)
return 2;
else
return 1;
}
int main() {
cin >> n >> k;
for (int i = 1; i < 3; i++)
for (int j = 1; j <= n; j++) {
cin >> a[j][i];
b[j][i] = -1;
}
l = 0;
r = 0;
b[1][1] = 0;
push(1, 1, r);
while (r > l) {
pt p = pop(l);
if (p.i + k > n | p.i + 1 > n) {
cout << "YES";
return 0;
}
if (a[p.i + 1][p.j] == '-' && b[p.i + 1][p.j] == -1) {
b[p.i + 1][p.j] = b[p.i][p.j] + 1;
push(p.i + 1, p.j, r);
}
if (a[p.i + k][nx(p.j)] == '-' && b[p.i + k][nx(p.j)] == -1) {
b[p.i + k][nx(p.j)] = b[p.i][p.j] + 1;
push(p.i + k, nx(p.j), r);
}
if (p.i > 1 && a[p.i - 1][p.j] == '-' && b[p.i - 1][p.j] == -1 &&
b[p.i][p.j] + 1 < p.i - 1) {
b[p.i - 1][p.j] = b[p.i][p.j] + 1;
push(p.i - 1, p.j, r);
}
}
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
char a[2][100005];
bool use[2][100005];
int n, k, flag = 0;
void dfs(int x, int y, int s) {
if (flag || a[x][y] == 'X' || y <= s || use[x][y]) return;
if (y + k > n) {
flag = 1;
return;
}
use[x][y] = 1;
dfs((x + 1) % 2, y + k, s + 1);
dfs(x, y + 1, s + 1);
dfs(x, y - 1, s + 1);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s%s", a[0], a[1]);
dfs(0, 0, -1);
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string wall[2];
bool bfs(pair<int, int> start) {
vector<vector<int> > visited(n, vector<int>(2, -1));
for (int i = 0; i < n; ++i) {
for (int c = 0; c < 2; ++c) {
if (wall[c][i] == 'X') {
visited[i][c] = -2;
}
}
}
queue<pair<int, int> > q;
visited[start.first][start.second] = 0;
q.push(start);
while (!q.empty()) {
int x = q.front().first;
int c = q.front().second;
q.pop();
if (x + k >= n) {
return true;
}
int water = visited[x][c];
if (x - 1 > water && visited[x - 1][c] == -1) {
visited[x - 1][c] = visited[x][c] + 1;
q.push(make_pair(x - 1, c));
}
if (visited[x + 1][c] == -1) {
visited[x + 1][c] = visited[x][c] + 1;
q.push(make_pair(x + 1, c));
}
if (visited[x + k][!c] == -1) {
visited[x + k][!c] = visited[x][c] + 1;
q.push(make_pair(x + k, !c));
}
}
return false;
}
int main() {
cin >> n >> k;
cin >> wall[0] >> wall[1];
printf("%s\n", bfs(make_pair(0, 0)) ? "YES" : "NO");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class Ta, class Tb>
inline Tb cast(Ta a) {
stringstream ss;
ss << a;
Tb b;
ss >> b;
return b;
};
const double EPS = 1e-9;
const int INF = 1000000000;
const int MOD = 1000000007;
const int diri[8] = {-1, 0, 1, 0, -1, 1, 1, -1};
const int dirj[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int N, K;
string wall[2];
int main() {
cin >> N >> K;
cin >> wall[0] >> wall[1];
vector<vector<int> > dist(2, vector<int>(N, INF));
dist[0][0] = 0;
priority_queue<pair<int, pair<int, int> > > q;
q.push(pair<int, pair<int, int> >(0, pair<int, int>(0, 0)));
while (q.size()) {
int d = -q.top().first;
int x = q.top().second.first;
int y = q.top().second.second;
q.pop();
if (d <= y) {
if (y + K >= N) {
cout << "YES" << endl;
return 0;
}
if (y + 1 < N and wall[x][y + 1] == '-' and d + 1 < dist[x][y + 1]) {
dist[x][y + 1] = d + 1;
q.push(pair<int, pair<int, int> >(-d - 1, pair<int, int>(x, y + 1)));
}
if (y > 0 and wall[x][y - 1] == '-' and d + 1 < dist[x][y - 1]) {
dist[x][y - 1] = d + 1;
q.push(pair<int, pair<int, int> >(-d - 1, pair<int, int>(x, y - 1)));
}
if (y + K < N and wall[1 - x][y + K] == '-' and
d + 1 < dist[1 - x][y + K]) {
dist[1 - x][y + K] = d + 1;
q.push(
pair<int, pair<int, int> >(-d - 1, pair<int, int>(1 - x, y + K)));
}
}
}
cout << "NO" << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Item {
int w;
int i;
int j;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, k;
cin >> n >> k;
vector<vector<char> > a(2, vector<char>(1 + n + k, '-'));
for (int i = 0; i < 2; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> a[i][j];
}
}
vector<vector<bool> > used(2, vector<bool>(1 + n + k, 0));
used[0][1] = 1;
queue<Item> q;
q.push(Item{0, 0, 1});
while (!q.empty()) {
Item cur = q.front();
q.pop();
if (cur.j > n) {
cout << "YES";
return 0;
}
int nw = cur.w + 1, ni, nj;
ni = cur.i, nj = cur.j - 1;
if (nj >= 1 && nw < nj && a[ni][nj] == '-' && !used[ni][nj]) {
used[ni][nj] = 1;
q.push(Item{nw, ni, nj});
}
ni = cur.i, nj = cur.j + 1;
if (nj >= 1 && nw < nj && a[ni][nj] == '-' && !used[ni][nj]) {
used[ni][nj] = 1;
q.push(Item{nw, ni, nj});
}
ni = (cur.i + 1) % 2, nj = cur.j + k;
if (nj >= 1 && nw < nj && a[ni][nj] == '-' && !used[ni][nj]) {
used[ni][nj] = 1;
q.push(Item{nw, ni, nj});
}
}
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, k;
bool b[2][N];
char a[2][N];
bool dfs(int h, int flag, int water) {
if (h > n) return true;
if (b[flag][h] || a[flag][h] == 'X' || water > h) return false;
b[flag][h] = 1;
return dfs(h + k, 1 - flag, water + 1) || dfs(h - 1, flag, water + 1) ||
dfs(h + 1, flag, water + 1);
}
int main() {
cin >> n >> k;
scanf("%s %s", a[0] + 1, a[1] + 1);
if (dfs(1, 0, 1))
cout << "YES";
else
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, K, Arr[200005][2];
struct poss {
int r, c, time;
};
queue<poss> q;
int main() {
string s;
scanf("%d%d", &N, &K);
cin >> s;
for (int i = 0; i < N; i++)
if (s[i] == 'X') Arr[i + 1][0] = 1;
cin >> s;
for (int i = 0; i < N; i++)
if (s[i] == 'X') Arr[i + 1][1] = 1;
poss A = {1, 0, 0};
q.push(A);
while (!q.empty()) {
poss cur = q.front();
q.pop();
if (cur.r >= N) {
printf("YES");
return 0;
}
if (!Arr[cur.r + 1][cur.c] && (cur.time + 1) < (cur.r + 1)) {
poss B = {cur.r + 1, cur.c, cur.time + 1};
q.push(B);
Arr[cur.r + 1][cur.c] = 1;
}
if (!Arr[cur.r - 1][cur.c] && (cur.time + 1) < (cur.r - 1)) {
poss B = {cur.r - 1, cur.c, cur.time + 1};
q.push(B);
Arr[cur.r - 1][cur.c] = 1;
}
if (!Arr[cur.r + K][(cur.c + 1) % 2] && (cur.time + 1) < (cur.r + K)) {
poss B = {cur.r + K, (cur.c + 1) % 2, cur.time + 1};
q.push(B);
Arr[cur.r + K][(cur.c + 1) % 2] = 1;
}
}
printf("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[100010][2];
string now[2];
void dfs(int pos, bool wh, int time) {
if (pos <= time || now[wh][pos] == 'X') return;
if (dp[pos][wh] <= time) return;
if (pos + k >= n && pos > time) {
printf("YES");
exit(0);
} else {
dp[pos][wh] = time;
dfs(pos + k, wh == 0 ? 1 : 0, time + 1);
dfs(pos + 1, wh, time + 1);
dfs(pos - 1, wh, time + 1);
}
}
int main() {
int i;
memset(dp, 0x3f, sizeof dp);
scanf("%d%d", &n, &k);
cin >> now[0];
cin >> now[1];
dfs(0, 0, -1);
printf("NO");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
char a[N], b[N];
bool vis[2][N];
int n, k;
struct node {
int num;
bool flag;
int step;
};
bool isSuccess = false;
queue<node> qu;
void bfs() {
qu.push(node{1, 0, 0});
vis[0][1] = 1;
while (!qu.empty()) {
node now = qu.front();
qu.pop();
if (now.num + 1 > n || now.num + k > n) {
isSuccess = true;
break;
}
if (now.flag == 0) {
if (now.num + 1 > now.step + 1 && a[now.num + 1] == '-' &&
!vis[0][now.num + 1]) {
vis[0][now.num + 1] = 1;
qu.push(node{now.num + 1, 0, now.step + 1});
}
if (now.num - 1 > now.step + 1 && a[now.num - 1] == '-' &&
!vis[0][now.num - 1]) {
vis[0][now.num - 1] = 1;
qu.push(node{now.num - 1, 0, now.step + 1});
}
if (now.num + k > now.step + 1 && b[now.num + k] == '-' &&
!vis[1][now.num + k]) {
vis[1][now.num + k] = 1;
qu.push(node{now.num + k, 1, now.step + 1});
}
} else {
if (now.num + 1 > now.step + 1 && b[now.num + 1] == '-' &&
!vis[1][now.num + 1]) {
vis[1][now.num + 1] = 1;
qu.push(node{now.num + 1, 1, now.step + 1});
}
if (now.num - 1 > now.step + 1 && b[now.num - 1] == '-' &&
!vis[1][now.num - 1]) {
vis[1][now.num - 1] = 1;
qu.push(node{now.num - 1, 1, now.step + 1});
}
if (now.num + k > now.step + 1 && a[now.num + k] == '-' &&
!vis[0][now.num + k]) {
vis[0][now.num + k] = 1;
qu.push(node{now.num + k, 0, now.step + 1});
}
}
}
}
int main() {
cin >> n >> k;
scanf("%s", a + 1);
scanf("%s", b + 1);
isSuccess = false;
bfs();
if (isSuccess)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, water;
char a[2][100100];
int v[2][100100];
int dfs(int pos, int j) {
if (j > n) return 1;
if (a[pos][j] == 'X' || j < water || v[pos][j]) return 0;
v[pos][j] = 1;
water++;
int f = dfs(pos, j - 1) || dfs(1 - pos, j + m) || dfs(pos, j + 1);
water--;
return f;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
water = 1;
scanf("%s %s", a[0] + 1, a[1] + 1);
if (dfs(0, 1))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T Max(T a, T b) {
if (a > b)
return a;
else
return b;
}
template <class T>
inline T Min(T a, T b) {
if (a < b)
return a;
else
return b;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T TripleMax(T a, T b, T c) {
return Max(Max(a, b), c);
}
template <class T>
inline T TripleMin(T a, T b, T c) {
return Min(Min(a, b), c);
}
typedef struct _node {
int level, height, left;
} node;
const int maxn = 100005;
int dis[2][maxn];
string wall[2];
int n, k;
queue<node> q;
int main(int argc, const char* argv[]) {
node d;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < maxn; j++) {
dis[i][j] = -1;
}
}
cin >> n >> k >> wall[0] >> wall[1];
while (!q.empty()) {
q.pop();
}
d.level = -1;
d.height = 0;
d.left = 0;
q.push(d);
dis[0][0] = 1;
while (!q.empty()) {
node tmp = q.front();
q.pop();
d = tmp;
if (d.height + k >= n) {
cout << "YES\n";
return 0;
}
if (wall[d.left][d.height + 1] == '-') {
if (dis[d.left][d.height + 1] == -1) {
dis[d.left][d.height + 1] = 1;
d.height++;
d.level++;
q.push(d);
}
}
d = tmp;
if (wall[d.left][d.height - 1] == '-') {
if (d.level + 1 < d.height - 1) {
if (dis[d.left][d.height - 1] == -1) {
dis[d.left][d.height - 1] = 1;
d.height--;
d.level++;
q.push(d);
}
}
}
d = tmp;
if (wall[1 - d.left][d.height + k] == '-') {
if (dis[1 - d.left][d.height + k] == -1) {
dis[1 - d.left][d.height + k] = 1;
d.height += k;
d.level++;
d.left = 1 - d.left;
q.push(d);
}
}
}
cout << "NO\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct data {
int X, v, l;
data() {}
data(int xx, int vv, int ll) { X = xx, v = vv, l = ll; }
};
string G[2];
int n, k, visited[2][100008];
string bfs() {
queue<data> Q;
Q.push(data(0, 0, -1));
visited[0][0] = 1;
int v, dir, l;
data top;
while (!Q.empty()) {
top = Q.front();
Q.pop();
if (top.v == n) return "YES";
v = top.v + 1, dir = top.X, l = top.l + 1;
if (v <= n && G[dir][v] == '-' && !visited[dir][v] && v > l) {
visited[dir][v] = 1;
Q.push(data(dir, v, l));
}
v = top.v - 1, dir = top.X, l = top.l + 1;
if (v >= 0 && G[dir][v] == '-' && !visited[dir][v] && v > l) {
visited[dir][v] = 1;
Q.push(data(dir, v, l));
}
v = min(top.v + k, n), dir = top.X ^ 1, l = top.l + 1;
if (v <= n && G[dir][v] == '-' && !visited[dir][v] && v > l) {
visited[dir][v] = 1;
Q.push(data(dir, v, l));
}
}
return "NO";
}
int main() {
cin >> n >> k;
cin >> G[0] >> G[1];
G[0].push_back('-');
G[1].push_back('-');
cout << bfs() << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int pd[2][150100];
int x[3] = {0, 0, 1};
int y[3] = {1, -1, k};
struct node {
int h, id, t;
};
queue<node> q;
void bfs() {
node u, p;
u.id = 0;
u.t = 0;
u.h = 1;
pd[0][1] = 1;
q.push(u);
while (!q.empty()) {
p = q.front();
q.pop();
for (int i = 0; i < 3; i++) {
u = p;
u.id = (u.id + x[i]) % 2;
u.h += y[i];
u.t += 1;
if (u.h > n) {
cout << "YES";
return;
}
if (u.h > u.t)
if (pd[u.id][u.h] == 0) {
pd[u.id][u.h] = 1;
q.push(u);
}
}
}
cout << "NO";
}
int main() {
char c;
cin >> n >> k;
y[2] = k;
memset(pd, 0, sizeof(pd));
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == 'X') pd[0][i] = 1;
}
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == 'X') pd[1][i] = 1;
}
node u;
bfs();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = 1.0 / 0.0f;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int MOD = 1000000007;
inline int LC(int x) { return x << 1; }
inline int RC(int x) { return (x << 1) | 1; }
inline bool eq0(double x) { return fabs(x) < eps; }
inline bool eq(double x, double y) { return fabs(x - y) < eps; }
inline bool ls(double x, double y) { return x + eps < y; }
inline bool gr(double x, double y) { return x - eps > y; }
inline bool greq(double x, double y) { return x + eps >= y; }
inline bool lseq(double x, double y) { return x - eps <= y; }
inline double fmax(double x, double y) { return gr(x, y) ? x : y; }
inline double fmin(double x, double y) { return ls(x, y) ? x : y; }
template <class T>
inline T sqr(T x) {
return x * x;
}
int n, k;
string w[2];
bool f[2][100010];
void dp(int water, int wall, int level) {
level = min(n, level);
if (water >= level) return;
if (f[wall][level]) return;
if (w[wall][level] == 'X') return;
f[wall][level] = 1;
dp(water + 1, wall ^ 1, level + k);
dp(water + 1, wall, level - 1);
dp(water + 1, wall, level + 1);
}
int main() {
cin >> n >> k;
cin >> w[0] >> w[1];
w[0] += '-';
w[1] += '-';
dp(-1, 0, 0);
cout << (f[0][n] || f[1][n] ? "YES" : "NO") << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200008;
int n, k, l, r;
char g[2][maxn];
bool f[2][maxn];
struct arr {
int t, s, x;
} h[maxn];
bool Add(int t, int s, int x) {
if (t >= x) return 0;
if (x > n) return 1;
if (f[s][x]) return 0;
if (g[s][x] == 'X') return 0;
f[s][x] = 1;
++r;
h[r].t = t;
h[r].s = s;
h[r].x = x;
return 0;
}
bool Work() {
h[1].t = 0;
h[1].s = 0;
h[1].x = 1;
l = 1, r = 1;
f[0][1] = 1;
while (l <= r) {
int t = h[l].t, s = h[l].s, x = h[l].x;
++l;
if (Add(t + 1, s, x + 1)) return 1;
if (Add(t + 1, s, x - 1)) return 1;
if (Add(t + 1, s ^ 1, x + k)) return 1;
}
return 0;
}
int main() {
scanf("%d%d%*c", &n, &k);
scanf("%s", &g[0][1]);
scanf("%s", &g[1][1]);
if (Work())
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ds[2][100001];
string mmap[2];
queue<pair<int, int> > q;
int dj[] = {1, -1, 100000};
int main() {
int n, k;
cin >> n >> k;
for (int first = 0; first < 2; first++) cin >> mmap[first];
dj[2] = k;
memset(ds, 0x3f, sizeof(ds));
q.push(make_pair(0, 0));
ds[0][0] = 0;
string res = "NO";
while (!q.empty()) {
int ci = q.front().first;
int cj = q.front().second;
q.pop();
if (cj - ds[ci][cj] < 0) continue;
if (cj + k >= n || cj + 1 >= n) {
res = "YES";
break;
}
for (int first = 0; first < 3; first++) {
int ni = (first != 2) ? ci : !ci;
int nj = cj + dj[first];
if (nj >= 0 && nj < n && mmap[ni][nj] == '-' &&
ds[ni][nj] > ds[ci][cj] + 1) {
ds[ni][nj] = ds[ci][cj] + 1;
q.push(make_pair(ni, nj));
}
}
}
cout << res << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, k, dp[2][200000];
char c[2][200000];
vector<pair<long long, long long>> v[2][200000];
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
cin >> c[i][j];
dp[i][j] = 1000000007;
}
}
for (long long j = 1; j <= n; j++) {
for (long long i = 0; i <= 1; i++) {
if (c[i][j] == 'X') continue;
if (c[i][j - 1] == '-') {
v[i][j].push_back({i, j - 1});
}
if (c[i][j + 1] == '-') {
v[i][j].push_back({i, j + 1});
}
if (j + k <= n and c[!i][j + k] == '-') {
v[i][j].push_back({!i, j + k});
}
}
}
dp[0][1] = 0;
queue<pair<long long, long long>> pq;
pq.push({0, 1});
while (!pq.empty()) {
long long x = pq.front().first;
long long y = pq.front().second;
pq.pop();
if (dp[x][y] < y and y + k > n) return cout << "YES", 0;
for (auto z : v[x][y]) {
long long x1 = z.first, y1 = z.second;
if (dp[x1][y1] > dp[x][y] + 1 and dp[x][y] + 1 < y1) {
dp[x1][y1] = dp[x][y] + 1;
pq.push({x1, y1});
}
}
}
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
if (dp[i][j] < j and j + k > n) {
return cout << "YES", 0;
}
}
}
cout << "NO";
}
| 8 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.