solution
stringlengths
11
983k
difficulty
int64
0
21
language
stringclasses
2 values
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 5; int n, k; string wall[2]; bool mark[2][maxn]; bool bfs(int w = 0, int ind = 0) { queue<pair<pair<int, int>, int>> q; q.push({{w, ind}, 0}); mark[w][ind] = true; while (!q.empty()) { auto [tp, ut] = q.front(); auto [uw, uind] = tp; if (uind >= n) return true; q.pop(); if (ut > uind) continue; int dw[] = {0, 0, 1}; int di[] = {-1, 1, k}; for (int i = 0; i < 3; i++) { int nw = (uw + dw[i]) % 2, nind = uind + di[i]; if (nind >= 0 && (!mark[nw][nind]) && wall[nw][nind] == '-') { q.push({{nw, nind}, ut + 1}); mark[nw][nind] = true; } } } return false; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cout.precision(16); if (0) { freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout); } cin >> n >> k >> wall[0] >> wall[1]; for (int i = 0; i <= k; i++) { wall[0] += '-'; wall[1] += '-'; } cout << (bfs() ? "YES" : "NO") << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int best[100010][2]; int pode[100010][2]; char lef[100010], righ[100010]; int main() { int n, k; scanf("%d %d", &n, &k); scanf("%s", lef); scanf("%s", righ); memset(pode, 0, sizeof(pode)); for (int i = 0; i < n; i++) { pode[i][0] = (lef[i] == '-'); pode[i][1] = (righ[i] == '-'); } for (int i = 0; i < n; ++i) best[i][0] = (1 << 29), best[i][1] = (1 << 29); priority_queue<pair<int, pair<int, int> > > cola; cola.push(make_pair(0, make_pair(0, 0))); best[0][0] = 0; while (!cola.empty()) { int w = -cola.top().first; int wall = cola.top().second.first; int lado = cola.top().second.second; cola.pop(); if (best[wall][lado] < w) continue; if (wall > n) { cout << "YES\n"; return 0; } if (wall + 1 >= n || wall + k >= n) { cout << "YES\n"; return 0; } if (pode[wall + 1][lado] && w + 1 < best[wall + 1][lado]) { best[wall + 1][lado] = w + 1; cola.push(make_pair(-(w + 1), make_pair(wall + 1, lado))); } if (wall - 1 >= 0 && w + 1 <= wall - 1 && pode[wall - 1][lado] && w + 1 < best[wall - 1][lado]) { best[wall - 1][lado] = w + 1; cola.push(make_pair(-(w + 1), make_pair(wall - 1, lado))); } if (pode[wall + k][1 - lado] && w + 1 < best[wall + k][1 - lado]) { best[wall + k][1 - lado] = w + 1; cola.push(make_pair(-(w + 1), make_pair(wall + k, 1 - lado))); } } cout << "NO\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; char s[2][102012]; queue<int> Q1, Q2; int ans, n, k, i; int f[2][102012]; int main() { scanf("%d%d ", &n, &k); gets(s[0]); gets(s[1]); for (i = 0; i < n; ++i) f[1][i] = f[0][i] = 1000002012; Q1.push(0); Q2.push(0); f[0][0] = 0; while (Q1.size()) { int Now = Q1.front(), side = Q2.front(); Q1.pop(); Q2.pop(); if (Now + 1 >= n) { ans = f[side][Now] + 1; break; } else if (s[side][Now + 1] != 'X' && f[side][Now + 1] > f[side][Now] + 1) { f[side][Now + 1] = f[side][Now] + 1; Q1.push(Now + 1); Q2.push(side); } if (Now - 1 >= 0 && s[side][Now - 1] != 'X' && Now - 1 > f[side][Now] && f[side][Now - 1] > f[side][Now] + 1) { f[side][Now - 1] = f[side][Now] + 1; Q1.push(Now - 1); Q2.push(side); } if (Now + k >= n) { ans = f[side][Now] + 1; break; } else if (s[!side][Now + k] != 'X' && f[!side][Now + k] > f[side][Now] + 1) { f[!side][Now + k] = f[side][Now] + 1; Q1.push(Now + k); Q2.push(!side); } } if (ans == 0) printf("NO"); else printf("YES"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int INF = 1 << 29; const double PI = acos(-1); const double EPS = 1e-8; int t[2][100000]; int main() { int n, k; cin >> n >> k; string s[2]; cin >> s[0] >> s[1]; queue<pair<int, int> > Q; memset(t, -1, sizeof(t)); t[0][0] = 0; Q.push(pair<int, int>(0, 0)); int dx[] = {-1, 1, k}; while (!Q.empty()) { pair<int, int> p = Q.front(); Q.pop(); int lr = p.first; int pos = p.second; int tm = t[lr][pos]; for (int i = 0; i < (int)3; ++i) { int xx = pos + dx[i]; if (xx < 0) continue; if (xx >= n) { cout << "YES" << endl; return 0; } if (i == 2) lr = !lr; if (s[lr][xx] == 'X') continue; if (t[lr][xx] != -1) continue; if (xx <= tm) continue; t[lr][xx] = tm + 1; Q.push(pair<int, int>(lr, xx)); } } cout << "NO" << endl; }
8
CPP
#include <bits/stdc++.h> using namespace std; char s[2][210000]; int dp[2][210000], n, k; struct node { int a, b, t; node() {} node(int _a, int _b, int _t) : a(_a), b(_b), t(_t) {} }; void cmx(int &a, int b) { if (a == -1 || b < a) a = b; } int BFS() { queue<node> que; que.push(node(0, 1, 0)); int mi = 0xFFFFFFF; while (!que.empty()) { node tmp = que.front(); que.pop(); int ta = tmp.a, tb = tmp.b, tt = tmp.t; if (tb > n) { mi = min(mi, tt); continue; } if (s[ta][tb + 1] == '-' || tb + 1 > n) { if (dp[ta][tb + 1] == -1 || tt + 1 < dp[ta][tb + 1]) { dp[ta][tb + 1] = tt + 1; que.push(node(ta, tb + 1, tt + 1)); } } if (s[!ta][tb + k] == '-' || tb + k > n) { if (dp[!ta][tb + k] == -1 || tt + 1 < dp[!ta][tb + k]) { dp[!ta][tb + k] = tt + 1; que.push(node(!ta, tb + k, tt + 1)); } } if (tb > tt + 2) { if (s[ta][tb - 1] == '-') { if (dp[ta][tb - 1] == -1 || tt + 1 < dp[ta][tb - 1]) { dp[ta][tb - 1] = tt + 1; que.push(node(ta, tb - 1, tt + 1)); } } } } return mi; } int main() { while (~scanf("%d%d", &n, &k)) { scanf("%s", s[0] + 1); scanf("%s", s[1] + 1); memset(dp, -1, sizeof(dp)); int res = BFS(); if (res == 0xFFFFFFF) puts("NO"); else puts("YES"); } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; char s[2][100005]; int d[2][100005]; bool f[2][100005]; void work() { int i, j, x, y, ans = 0; scanf("%d%d", &n, &k); scanf("%s%s", s[0] + 1, s[1] + 1); queue<pair<int, int> > q; q.push(make_pair(0, 1)), f[0][1] = 1, d[0][1] = 1; while (!q.empty()) { x = q.front().first, y = q.front().second, q.pop(); if (y + k <= n && s[!x][y + k] != 'X' && !f[!x][y + k]) f[!x][y + k] = 1, q.push(make_pair(!x, y + k)), d[!x][y + k] = d[x][y] + 1; if (y + 1 <= n && s[x][y + 1] != 'X' && !f[x][y + 1]) f[x][y + 1] = 1, q.push(make_pair(x, y + 1)), d[x][y + 1] = d[x][y] + 1; if (y - 1 > 0 && y - 1 > d[x][y] && s[x][y - 1] != 'X' && !f[x][y - 1]) f[x][y - 1] = 1, q.push(make_pair(x, y - 1)), d[x][y - 1] = d[x][y] + 1; } for (i = n - k + 1; i <= n; ++i) ans |= f[0][i] | f[1][i]; puts(ans ? "YES" : "NO"); } int main() { work(); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long n, k; cin >> n >> k; string s1, s2; cin >> s1 >> s2; long long i, j; i = n - 1; long long c = 0LL; long long f = 0LL; char mat[2][n]; for (i = 0; i < 2; i++) { for (j = 0; j < n; j++) { if (i == 0) { mat[0][j] = s1[i]; } else { mat[1][j] = s2[j]; } } } char fin[2][n]; for (i = 0; i < 2; i++) { for (j = 0; j < n; j++) { fin[i][j] = 'F'; } } queue<pair<long long, pair<long long, long long>>> q; q.push({0, {0, 0}}); fin[0][0] = 'T'; while (q.size() > 0) { long long level; long long f1; level = q.front().first; f1 = q.front().second.first; i = q.front().second.second; q.pop(); level++; if (f1 == 0) { if (i - 1 >= 0 && i - 1 >= level && s1[i - 1] == '-' && fin[0][i - 1] == 'F') { q.push({level, {0, i - 1}}); fin[0][i - 1] = 'T'; } if (i + 1 >= n) { cout << "YES"; return 0; } if (i + 1 < n && i + 1 >= level && s1[i + 1] == '-' && fin[0][i + 1] == 'F') { q.push({level, {0, i + 1}}); fin[0][i + 1] = 'T'; } if (i + k >= n) { cout << "YES"; return 0; } if (i + k >= level && s2[i + k] == '-' && fin[1][i + k] == 'F') { q.push({level, {1, i + k}}); fin[1][i + k] = 'T'; } if (i - k >= 0 && i - k >= level && s2[i - k] == '-' && fin[1][i - k] == 'F') { q.push({level, {1, i - k}}); fin[1][i - k] = 'T'; } } else { if (i - 1 >= 0 && i - 1 >= level && s2[i - 1] == '-' && fin[1][i - 1] == 'F') { q.push({level, {1, i - 1}}); fin[1][i - 1] = 'T'; } if (i + 1 >= n) { cout << "YES"; return 0; } if (i + 1 < n && i + 1 >= level && s2[i + 1] == '-' && fin[1][i + 1] == 'F') { q.push({level, {1, i + 1}}); fin[1][i + 1] = 'T'; } if (i + k >= n) { cout << "YES"; return 0; } if (i + k >= level && s1[i + k] == '-' && fin[0][i + k] == 'F') { q.push({level, {0, i + k}}); fin[0][i + k] = 'T'; } if (i - k >= 0 && i - k >= level && s1[i - k] == '-' && fin[0][i - k] == 'F') { q.push({level, {1, i - k}}); fin[0][i - k] = 'T'; } } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 5; int n, k; string wall[2]; bool mark[2][maxn]; int t[2][maxn]; bool bfs() { mark[0][0] = 1; queue<pair<int, int>> q; q.push({0, 0}); while (!q.empty()) { int x = q.front().first; int y = q.front().second; q.pop(); if (t[x][y] > y) continue; int my[] = {1, -1, k}; int mx[] = {0, 0, 1}; for (int i = 0; i < 3; i++) { int newx = x + mx[i]; newx = newx % 2; int newy = y + my[i]; if (newy >= n) return 1; if (newy >= 0 && !mark[newx][newy] && wall[newx][newy] != 'X') { q.push({newx, newy}); mark[newx][newy] = 1; t[newx][newy] = t[x][y] + 1; } } } return 0; } int main() { cin >> n >> k >> wall[0] >> wall[1]; if (bfs()) cout << "YES" << endl; else cout << "NO" << endl; }
8
CPP
#include <bits/stdc++.h> using namespace std; char s[3][400005]; int n, k, dis[400005], q[400005]; bool can[400005]; int geth(int x) { if (x <= n) return x; else return x - n; } int main() { scanf("%d%d", &n, &k); for (int i = 1; i <= 2; ++i) scanf("%s", &s[i][1]); for (int i = 1; i <= 2; ++i) { for (int j = 1; j <= n; ++j) can[(i - 1) * n + j] = bool(s[i][j] == '-'); } int h, t; bool flag = 0; for (int i = 1; i <= 2 * n; ++i) dis[i] = 214748364; h = 0; q[t = 1] = 1; dis[1] = 0; while (h != t) { int x = q[++h]; if (geth(x) <= dis[x]) continue; if (x == n || x == 2 * n || geth(x) > n - k) { puts("YES"); flag = 1; break; } if (can[x + 1] && dis[x + 1] > dis[x] + 1) { dis[x + 1] = dis[x] + 1; q[++t] = x + 1; } if (x != 1 && x != n + 1 && can[x - 1] && dis[x - 1] > dis[x] + 1) { dis[x - 1] = dis[x] + 1; q[++t] = x - 1; } if (x <= n) { if (can[x + n + k] && dis[x + n + k] > dis[x] + 1) { dis[x + n + k] = dis[x] + 1; q[++t] = x + n + k; } } else { if (can[x - n + k] && dis[x - n + k] > dis[x] + 1) { dis[x - n + k] = dis[x] + 1; q[++t] = x - n + k; } } } if (!flag) puts("NO"); return 0; }
8
CPP
def bfs(n): visited=[False]*(2*n) queue=[] queue2=[] queue.append(0) queue2.append(0) visited[0]=True flag=True water=0 while queue and flag: s=queue.pop(0) water= queue2.pop(0) for i in graph[s]: if not visited[i]: a=0 #print(water,i) if i>=n: a=i-n else: a=i if a>water: if i==n-1 or i==2*n-1: flag=False else: queue.append(i) queue2.append(water+1) visited[i]=True return not flag n,k=map(int,input().split()) l=input() r=input() graph=[] for i in range(n): graph.append([]) if l[i]=='-': if i+1<n: if l[i+1]=='-': graph[i].append(i+1) if i-1>=0: if l[i-1]=='-': graph[i].append(i-1) if i+k<n: if r[i+k]=='-': graph[i].append(n+i+k) else: graph[i].append(2*n-1) for i in range(n): graph.append([]) if r[i]=='-': if i+1<n: if r[i+1]=='-': graph[n+i].append(n+i+1) if i-1>=0: if r[i-1]=='-': graph[n+i].append(n+i-1) if i+k<n: if l[i+k]=='-': graph[n+i].append(i+k) else: graph[n+i].append(n-1) #print(graph) if n==1: print("YES") elif bfs(n): print("YES") else: print("NO")
8
PYTHON3
#include <bits/stdc++.h> using namespace std; const int N = 200010, MOD = 1e9 + 7, sn = 500; int n, k, wl; bool vs[2][N]; char w[2][N]; void dfs(int wa, int bl) { if (bl >= n) { cout << "YES"; exit(0); } if (w[wa][bl] == 'X' || vs[wa][bl] || wl > bl) return; vs[wa][bl] = 1; wl++; dfs(wa ^ 1, bl + k); dfs(wa, bl + 1); dfs(wa, bl - 1); wl--; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> k; for (int i = 0; i < n; i++) cin >> w[0][i]; for (int i = 0; i < n; i++) cin >> w[1][i]; dfs(0, 0); cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; enum Side { LEFT, RIGHT }; int main(int argc, char *argv[]) { int height, jump; cin >> height >> jump; cin.ignore(); char left[height]; char right[height]; cin.getline(left, height + 1); cin.getline(right, height + 1); int curr_height = 0; queue<int> choices; queue<Side> sides; queue<int> water_level; vector<bool> left_visited(height); vector<bool> right_visited(height); Side side = LEFT; int water; choices.push(0); sides.push(LEFT); water_level.push(-1); left_visited[0] = true; while (!choices.empty()) { curr_height = choices.front(); if (curr_height + jump >= height) { cout << "YES" << endl; return 0; } choices.pop(); side = sides.front(); sides.pop(); water = water_level.front(); water_level.pop(); if (curr_height == water) { continue; } if (side == LEFT) { if (!right_visited[curr_height + jump] && right[curr_height + jump] != 'X') { choices.push(curr_height + jump); right_visited[curr_height + jump] = true; sides.push(RIGHT); water_level.push(water + 1); } if (!left_visited[curr_height + 1] && left[curr_height + 1] != 'X') { choices.push(curr_height + 1); left_visited[curr_height + 1] = true; sides.push(LEFT); water_level.push(water + 1); } if (water < curr_height - 1 && !left_visited[curr_height - 1] && left[curr_height - 1] != 'X') { choices.push(curr_height - 1); left_visited[curr_height - 1] = true; sides.push(LEFT); water_level.push(water + 1); } } else { if (!left_visited[curr_height + jump] && left[curr_height + jump] != 'X') { choices.push(curr_height + jump); left_visited[curr_height + jump] = true; sides.push(LEFT); water_level.push(water + 1); } if (!right_visited[curr_height + 1] && right[curr_height + 1] != 'X') { choices.push(curr_height + 1); right_visited[curr_height + 1] = true; sides.push(RIGHT); water_level.push(water + 1); } if (water < curr_height - 1 && !right_visited[curr_height - 1] && right[curr_height - 1] != 'X') { choices.push(curr_height - 1); right_visited[curr_height - 1] = true; sides.push(RIGHT); water_level.push(water + 1); } } } cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const long long inf = 1e18; const long long mod = 1e17 + 7; const long long N = 1e5 + 5; long long n, k, d[N][2], f = 0; string a[2]; queue<pair<long long, long long>> q; long long valid(long long x, long long y) { if (x < 0) return 0; if (a[y][x] == 'X') return 0; if (d[x][y] != 0) return 0; return 1; } void bfs() { while (!q.empty()) { pair<long long, long long> top = q.front(); q.pop(); long long x = top.first, y = top.second; if (valid(x + 1, y)) { d[x + 1][y] = d[x][y] + 1; q.push(make_pair(x + 1, y)); } if (valid(x - 1, y) && x + 1 > d[x][y] + 1) { d[x - 1][y] = d[x][y] + 1; q.push(make_pair(x - 1, y)); } if (x + k >= n) { f = 1; return; } else { if (valid(x + k, 1 - y)) { d[x + k][1 - y] = d[x][y] + 1; q.push(make_pair(x + k, 1 - y)); } } } } int main() { ios_base::sync_with_stdio(false); memset(d, 0, sizeof(d)); cin >> n >> k >> a[0] >> a[1]; d[0][0] = 1; q.push(make_pair(0, 0)); bfs(); if (f) cout << "YES"; else cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; struct pt { int in; int ti; int w; pt(int in = 0, int ti = 0, int w = 0) : in(in), ti(ti), w(w) {} }; int used[2][100013]; int ground[2][100013]; int flag = 0; int n, k; void dfs(pt u) { used[u.w][u.in] = 1; if (flag || u.in <= u.ti) return; if (u.in + k >= n || u.in + 1 >= n) { flag = 1; return; } if (!used[1 - u.w][u.in + k] && !ground[1 - u.w][u.in + k]) { dfs(pt(u.in + k, u.ti + 1, 1 - u.w)); } if (u.in >= 1 && !used[u.w][u.in - 1] && !ground[u.w][u.in - 1]) { dfs(pt(u.in - 1, u.ti + 1, u.w)); } if (!used[u.w][u.in + 1] && !ground[u.w][u.in + 1]) { dfs(pt(u.in + 1, u.ti + 1, u.w)); } } int main() { memset(used, 0, sizeof(used)); cin >> n >> k; string s1, s2; cin >> s1 >> s2; for (int i = 0; i < n; i++) { ground[0][i] = ((int)(s1[i] == 'X')); ground[1][i] = ((int)(s2[i] == 'X')); } dfs(pt(0, -1, 0)); if (flag) { cout << "YES"; } else { cout << "NO"; } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int N = 3e5 + 500; bool Grid[2][N]; int dist[2][N]; queue<pair<bool, int> > q; string L, R; int n, k; int main() { cin >> n >> k; cin >> L >> R; for (int i = 0; i <= n + k; i++) { if (i < n) { Grid[0][i] = (L[i] == 'X'); Grid[1][i] = (R[i] == 'X'); } dist[0][i] = dist[1][i] = 1e9; } dist[0][0] = 0; q.push({0, 0}); int water = 0; while (!q.empty()) { pair<bool, int> u = q.front(); q.pop(); water = dist[u.first][u.second] + 1; if (u.second - 1 >= 0 && u.second - 1 >= water) { if (!Grid[u.first][u.second - 1] && dist[u.first][u.second - 1] == 1e9) { dist[u.first][u.second - 1] = dist[u.first][u.second] + 1; q.push({u.first, u.second - 1}); } } if (u.second + 1 >= 0) { if (!Grid[u.first][u.second + 1] && dist[u.first][u.second + 1] == 1e9) { dist[u.first][u.second + 1] = dist[u.first][u.second] + 1; q.push({u.first, u.second + 1}); } } if (u.second + k >= 0) { if (u.second + k >= n) { cout << "YES" << endl; exit(0); } if (!Grid[!u.first][u.second + k] && dist[!u.first][u.second + k] == 1e9) { dist[!u.first][u.second + k] = dist[u.first][u.second] + 1; q.push({!u.first, u.second + k}); } } water++; if (u.second >= n) break; } bool flag = false; for (int i = n - 1; i <= n + k; i++) { if (dist[0][i] != 1e9 || dist[1][i] != 1e9) { flag = true; break; } } flag ? puts("YES") : puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int N = 1e6 + 10; vector<int> g[2][N]; deque<pair<int, int> > q; long long int dis[2][N]; int main() { ios::sync_with_stdio(0), cout.tie(0), cin.tie(0); memset(dis[0], 63, sizeof dis[0]); memset(dis[1], 63, sizeof dis[1]); int n, k; cin >> n >> k; string s, t; cin >> s >> t; for (int i = 0; i < n - 1; i++) { if (s[i] == '-' && s[i + 1] == '-') { g[0][i + 1].push_back(i + 2); g[0][i + 2].push_back(i + 1); } } for (int i = 0; i < n - 1; i++) { if (t[i] == '-' && t[i + 1] == '-') { g[1][i + 1].push_back(i + 2); g[1][i + 2].push_back(i + 1); } } q.push_back({0, 1}); dis[0][1] = 0; while (q.size()) { int v = q.front().second; int e = q.front().first; q.pop_front(); for (int i = 0; i < g[e][v].size(); i++) { if (g[e][v][i] > dis[e][v] + 1 && dis[e][v] + 1 < dis[e][g[e][v][i]]) { dis[e][g[e][v][i]] = dis[e][v] + 1; q.push_back({e, g[e][v][i]}); } } if (e == 0) { if (v + k > t.size()) { cout << "YES"; return 0; } if (t[v + k - 1] == '-' && dis[e][v] + 1 < dis[1 - e][v + k]) { dis[1 - e][v + k] = dis[e][v] + 1; q.push_back({1 - e, v + k}); } } else { if (v + k > s.size()) { cout << "YES"; return 0; } if (s[v + k - 1] == '-' && dis[e][v] + 1 < dis[1 - e][v + k]) { dis[1 - e][v + k] = dis[e][v] + 1; q.push_back({1 - e, v + k}); } } } for (int i = 0; i < 2; i++) { for (int j = max(0, n - k + 1); j < N; j++) { if (dis[i][j] < 10000000) { cout << "YES"; return 0; } } } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, x, y, fi, fr, f[2][100100], qx[200200], qy[200200]; char s[2][100100]; int main() { cin >> n >> k; cin >> s[0]; cin >> s[1]; f[0][0] = 1; for (fr = 1; fi < fr;) { x = qx[fi]; y = qy[fi++]; if (y >= n - k) { puts("YES"); return 0; } if (y > 0 && s[x][y - 1] == '-' && f[x][y - 1] == 0 && y > f[x][y]) { f[x][y - 1] = f[x][y] + 1; qx[fr] = x; qy[fr++] = y - 1; } if (s[x][y + 1] == '-' && f[x][y + 1] == 0) { f[x][y + 1] = f[x][y] + 1; qx[fr] = x; qy[fr++] = y + 1; } if (s[1 - x][y + k] == '-' && f[1 - x][y + k] == 0) { f[1 - x][y + k] = f[x][y] + 1; qx[fr] = 1 - x; qy[fr++] = y + k; } } puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; bool seen[200005]; struct data { int node, h, water; data(int a, int b, int c) : node(a), h(b), water(c) {} }; int main() { cin.tie(0); ios_base::sync_with_stdio(0); int n, k; cin >> n >> k; string left_wall, right_wall; cin >> left_wall >> right_wall; vector<vector<pair<int, int> > > G(2 * n + 1); int free = 2 * n; for (int i = 0; i < n; ++i) { int nb = i + k; if (left_wall[i] == '-') { if (nb < n && right_wall[nb] == '-') G[2 * i].push_back(make_pair(2 * nb + 1, k)); if (nb >= n) G[2 * i].push_back(make_pair(free, k)); if (i > 0 && left_wall[i - 1] == '-') { G[2 * i].push_back(make_pair(2 * i - 2, -1)); G[2 * i - 2].push_back(make_pair(2 * i, 1)); } } if (right_wall[i] == '-') { if (nb < n && left_wall[nb] == '-') G[2 * i + 1].push_back(make_pair(2 * nb, k)); if (nb >= n) G[2 * i + 1].push_back(make_pair(free, k)); if (i > 0 && right_wall[i - 1] == '-') { G[2 * i + 1].push_back(make_pair(2 * i - 1, -1)); G[2 * i - 1].push_back(make_pair(2 * i + 1, 1)); } } } if (left_wall[n - 1] == '-') G[2 * n - 2].push_back(make_pair(free, k)); if (right_wall[n - 1] == '-') G[2 * n - 1].push_back(make_pair(free, k)); memset(seen, 0, sizeof seen); seen[0] = 1; queue<data> q; q.push(data(0, 0, 0)); while (!q.empty()) { data u = q.front(); q.pop(); for (int i = 0; i < G[u.node].size(); ++i) { int v = G[u.node][i].first, w = G[u.node][i].second; if (!seen[v]) { seen[v] = true; if (u.h + w <= u.water) continue; if (u.h + w >= n) { cout << "YES"; return 0; } q.push(data(v, u.h + w, u.water + 1)); } } } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, m, i, j, used[100005][2], x, y, z; string st[2]; queue<int> qx, qy, step; int main() { cin >> n >> m >> st[0] >> st[1]; for (i = 1; i <= m; i++) { st[0] += "-"; st[1] += "-"; } qx.push(0); qy.push(0); step.push(0); while (!qx.empty()) { x = qx.front(); y = qy.front(); z = step.front(); qx.pop(); qy.pop(); step.pop(); if (st[y][x] == 'X') continue; if (x >= n - 1) { cout << "YES"; return 0; } if (used[x][y]) continue; if (z > x) continue; used[x][y] = 1; qx.push(x + 1); qy.push(y); step.push(z + 1); qx.push(x - 1); qy.push(y); step.push(z + 1); qx.push(x + m); qy.push(y ^ 1); step.push(z + 1); } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; char wall[2][100010]; int dp[100010][2]; int main(void) { for (int i = 0; i < 100010; ++i) dp[i][0] = dp[i][1] = 1000000000; dp[0][0] = 0; int n, k; scanf("%d %d ", &n, &k); gets(wall[0]); gets(wall[1]); queue<pair<int, int> > q; q.push(make_pair(0, 0)); while (!q.empty()) { pair<int, int> tmp = q.front(); int curr = tmp.first; int w = tmp.second; q.pop(); if (dp[curr][w] > curr || wall[w][curr] == 'X') continue; if (curr + k >= n) { cout << "YES\n"; return 0; } if (dp[curr + 1][w] > dp[curr][w] + 1) { dp[curr + 1][w] = dp[curr][w] + 1; q.push(make_pair(curr + 1, w)); } if (curr - 1 > -1 && dp[curr - 1][w] > dp[curr][w] + 1) { dp[curr - 1][w] = dp[curr][w] + 1; q.push(make_pair(curr - 1, w)); } if (dp[curr + k][(w + 1) & 1] > dp[curr][w] + 1) { dp[curr + k][(w + 1) & 1] = dp[curr][w] + 1; q.push(make_pair(curr + k, (w + 1) & 1)); } } cout << "NO\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, m; char s[2][200100]; bool vis[2][200100]; int main() { scanf("%d%d", &n, &m); scanf("%s", s[0]); scanf("%s", s[1]); queue<pair<int, pair<int, int> > > q; q.push(make_pair(0, make_pair(0, 0))); while (!q.empty()) { int x = q.front().second.first; int y = q.front().second.second; int d = q.front().first; q.pop(); if (y >= n) { puts("YES"); return 0; } if ((d < y + m) && !vis[!x][y + m] && (y + m >= n || s[!x][y + m] == '-')) { q.push(make_pair(d + 1, make_pair(!x, y + m))); vis[!x][y + m] = 1; } if ((d < y + 1) && !vis[x][y + 1] && (y + 1 >= n || s[x][y + 1] == '-')) { q.push(make_pair(d + 1, make_pair(x, y + 1))); vis[x][y + 1] = 1; } if ((d < y - 1) && y > 0 && !vis[x][y - 1] && s[x][y - 1] == '-') { q.push(make_pair(d + 1, make_pair(x, y - 1))); vis[x][y - 1] = 1; } } puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, q1, q2, x, y, l, f[2][111111], qx[333333], qy[333333], ql[333333]; char a[2][111111]; string ans = "NO"; void add(int x, int y, int l) { if (y >= n) ans = "YES"; if (y >= n || a[x][y] == 'X' || f[x][y] || l > y) return; f[x][y] = 1; qx[q1] = x; qy[q1] = y; ql[q1++] = l; } int main() { scanf("%d%d\n", &n, &k); gets(a[0]); gets(a[1]); add(0, 0, 0); while (q1 != q2) { x = qx[q2]; y = qy[q2]; l = ql[q2++]; add(x, y + 1, l + 1); add(x, y - 1, l + 1); add(x ^ 1, y + k, l + 1); } cout << (ans) << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const long long maxN = 1e6 + 100; const long long maxM = 1e3 + 100; const long long mod = 1e9 + 7; const long long hmod = 1e16 + 7; const long double PI = 3.141592653; const long double eps = 1e-8; const long long D = 1379; const long long INF = 1e18 + 20; const long long Inf = 1e9 + 140; void NO() { cout << "NO" << endl; exit(0); } void YES() { cout << "YES" << endl; exit(0); } long long n, k; bool mrk[2][maxN], mark[2][maxN]; void dfs(long long v, long long x = 0, long long W = 0) { if (v > n) YES(); if (v <= 0 || mrk[x][v] || mark[x][v] || v <= W) return; mark[x][v] = true; W++; dfs(v + k, x ^ 1, W); dfs(v + 1, x, W); dfs(v - 1, x, W); } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> k; for (long long i = 1; i <= n; i++) { char c; cin >> c; if (c == 'X') mrk[0][i] = true; } for (long long i = 1; i <= n; i++) { char c; cin >> c; if (c == 'X') mrk[1][i] = true; } dfs(1); NO(); }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; string wall[2]; bool visit[2][100050]; bool escape(int s, int h, int t) { if (h <= t || h < 0) return false; if (h >= n) return true; if (wall[s][h] != '-') return false; if (visit[s][h]) return false; visit[s][h] = true; return max(max(escape(s, h + 1, t + 1), escape(s, h - 1, t + 1)), escape(1 - s, h + k, t + 1)); } int main() { cin >> n >> k; cin >> wall[0]; cin >> wall[1]; if (escape(0, 0, -1)) cout << "YES" << endl; else cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int arrayLeft[100010] = {0}; int arrayRight[100010] = {0}; class Walls { public: int height; int pathLength; int pos; bool onLeft; Walls() { height = 1; pathLength = 1000000; pos = 1; onLeft = true; } }; int main() { int n, k; scanf("%d%d", &n, &k); Walls *wall = new Walls[2 * n]; char a[100010], b[100010]; a[0] = 'X'; b[0] = 'X'; scanf("%s%s", &a[1], &b[1]); int initialLimit = 0, finalLimit = 1; wall[0].pathLength = 0; arrayLeft[0] = 0; bool found = false; int count = 0; int waterHeight = 0; count = finalLimit; while (1) { for (int i = initialLimit; i < finalLimit; i++) { int pos = wall[i].pos; int pathLength = wall[i].pathLength; int height = wall[i].height; if ((height + 1 > n || height + k > n) && pathLength + 1 <= n) { found = true; break; } if (wall[i].onLeft) { if (arrayLeft[pos - 1] == 0 && a[pos - 1] == '-' && height - 1 > waterHeight + 1) { arrayLeft[pos - 1] = 1; wall[count].height = height - 1; wall[count].pathLength = pathLength + 1; wall[count].pos = pos - 1; count++; } if (arrayLeft[pos + 1] == 0 && a[pos + 1] == '-' && height > waterHeight) { arrayLeft[pos + 1] = 1; wall[count].height = height + 1; wall[count].pathLength = pathLength + 1; wall[count].pos = pos + 1; count++; } if (arrayRight[pos + k] == 0 && b[pos + k] == '-' && height + k > waterHeight + 1) { arrayRight[pos + k] = 1; wall[count].height = height + k; wall[count].pathLength = pathLength + 1; wall[count].pos = pos + k; wall[count].onLeft = false; count++; } } else { if (arrayRight[pos - 1] == 0 && b[pos - 1] == '-' && height - 1 > waterHeight + 1) { arrayRight[pos - 1] = 1; wall[count].height = height - 1; wall[count].pathLength = pathLength + 1; wall[count].pos = pos - 1; wall[count].onLeft = false; count++; } if (arrayRight[pos + 1] == 0 && b[pos + 1] == '-' && height > waterHeight) { arrayRight[pos + 1] = 1; wall[count].height = height + 1; wall[count].pathLength = pathLength + 1; wall[count].pos = pos + 1; wall[count].onLeft = false; count++; } if (arrayLeft[pos + k] == 0 && a[pos + k] == '-' && height + k > waterHeight + 1) { arrayLeft[pos + k] = 1; wall[count].height = height + k; wall[count].pathLength = pathLength + 1; wall[count].pos = pos + k; count++; } } } if (finalLimit == count) break; if (found) break; initialLimit = finalLimit; finalLimit = count; waterHeight++; } if (found) printf("YES\n"); if (!found) printf("NO\n"); }
8
CPP
#include <bits/stdc++.h> const int MAXN = 500000; using namespace std; int n, k; char s[2][MAXN]; int q[MAXN], d[MAXN]; void out(string verdict) { cout << verdict << endl; exit(0); } int main() { scanf("%d%d", &n, &k); scanf("%s%s", s[0], s[1]); q[0] = 0; memset(d, -1, sizeof(d)); d[0] = 0; for (int l = 0, r = 1; l < r; l++) { int u = q[l] >> 1, v = q[l] & 1; if (d[q[l]] > u) continue; if (u + k >= n) out("YES"); if (d[(u + 1) * 2 + v] == -1 && s[v][u + 1] != 'X') { d[(u + 1) * 2 + v] = d[q[l]] + 1; q[r++] = (u + 1) * 2 + v; } if (u && d[(u - 1) * 2 + v] == -1 && s[v][u - 1] != 'X') { d[(u - 1) * 2 + v] = d[q[l]] + 1; q[r++] = (u - 1) * 2 + v; } if (d[(u + k) * 2 + (v ^ 1)] == -1 && s[v ^ 1][u + k] != 'X') { d[(u + k) * 2 + (v ^ 1)] = d[q[l]] + 1; q[r++] = (u + k) * 2 + (v ^ 1); } } out("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int N = int(1e5) + 100; int n; int k; vector<int> g[2 * N]; bool doz[2 * N]; string s; bool pos[2 * N]; priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; int d[2 * N]; int p[2 * N]; bool NO; void dijkstra() { for (int i = 1; i <= 2 * n + 1; i++) { d[i] = -1; p[i] = -1; } d[1] = 1; p[1] = 0; pq.push(pair<int, int>(0, 1)); for (int i = 1; i <= 2 * n + 1; i++) { int v = -1; while (!pq.empty()) { int u = pq.top().second; pq.pop(); if (!pos[u]) { v = u; pos[v] = true; break; } } if (v == -1) break; pos[v] = true; for (int k = 0; k < g[v].size(); k++) { if (!pos[g[v][k]]) if (d[g[v][k]] == -1 || d[g[v][k]] > d[v] + 1) { d[g[v][k]] = d[v] + 1; p[g[v][k]] = v; pq.push(pair<int, int>(d[g[v][k]], g[v][k])); } } } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n >> k; cin >> s; for (int i = 1; i <= n; i++) if (s[i - 1] == '-') doz[i] = true; cin >> s; for (int i = 1; i <= n; i++) if (s[i - 1] == '-') doz[n + i] = true; doz[2 * n + 1] = true; for (int i = 1; i < n; i++) { if (!doz[i]) continue; if (doz[i + 1]) g[i].push_back(i + 1); if (doz[i - 1]) g[i].push_back(i - 1); if (i > n - k) g[i].push_back(2 * n + 1); else if (doz[i + k + n]) g[i].push_back(i + k + n); } g[n].push_back(2 * n + 1); for (int i = n + 1; i < 2 * n; i++) { if (!doz[i]) continue; if (i > n + 1) if (doz[i - 1]) g[i].push_back(i - 1); if (doz[i + 1]) g[i].push_back(i + 1); if (i > 2 * n - k) g[i].push_back(2 * n + 1); else if (doz[i + k - n]) g[i].push_back(i + k - n); } g[2 * n].push_back(2 * n + 1); dijkstra(); int itr = 2 * n + 1; while (itr != 0) { if (itr <= n) { if (d[itr] > itr) { NO = true; break; } } else { if (d[itr] > itr - n) { NO = true; break; } } itr = p[itr]; } if (NO) cout << "NO" << endl; else cout << "YES" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; int visited[2][100001]; string walls[2]; char a, b; bool dfs(int x, int y, int t) { if (y >= n) return true; if (y < 0) return false; if (walls[x][y] == 'X' || (visited[x][y] <= t && visited[x][y] != 0) || y < t) return false; visited[x][y] = t; if (dfs(1 - x, y + k, t + 1)) return true; if (dfs(x, y + 1, t + 1)) return true; if (dfs(x, y - 1, t + 1)) return true; return false; } int main() { cin >> n >> k; cin >> walls[0] >> walls[1]; if (dfs(0, 0, 0)) cout << "YES" << endl; else cout << "NO" << endl; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 7; const int mod = 998244353; long long read() { long long c = getchar(), Nig = 1, x = 0; while (!isdigit(c)) c = getchar(); if (c == '-') Nig = -1, c = getchar(); while (isdigit(c)) x = ((x << 1) + (x << 3)) + (c ^ '0'), c = getchar(); return Nig * x; } struct node { int x, y, step; friend bool operator<(node a, node b) { return a.step > b.step; } }; char ma[2][maxn]; int n, vis[2][maxn]; bool bfs(int pos, int y, int k, int time) { priority_queue<node> q; node p, a, b; b.x = pos; b.y = y; b.step = time; q.push(b); memset(vis, 0, sizeof vis); vis[b.x][b.y] = 1; while (!q.empty()) { p = q.top(); q.pop(); if (p.y > n) return true; if (ma[(p.x + 1) % 2][p.y + k] != 'X' && vis[(p.x + 1) % 2][p.y + k] == 0) { vis[(p.x + 1) % 2][p.y + k] = 1; a.x = (p.x + 1) % 2; a.y = p.y + k; a.step = p.step + 1; if (a.step < a.y) { q.push(a); } } if (ma[p.x][p.y + 1] != 'X' && vis[p.x][p.y + 1] == 0) { vis[p.x][p.y + 1] = 1; a.x = p.x; a.y = p.y + 1; a.step = p.step + 1; if (a.step < a.y) { q.push(a); } } if (ma[p.x][p.y - 1] != 'X' && vis[p.x][p.y - 1] == 0) { vis[p.x][p.y - 1] = 1; a.x = p.x; a.y = p.y - 1; a.step = p.step + 1; if (a.step < a.y) { q.push(a); } } } return false; } int main() { n = read(); int k = read(); for (int i = 0; i < 2; i++) { for (int j = 0; j < n; j++) { cin >> ma[i][j]; } } bool flag = bfs(0, 0, k, -1); if (flag) cout << "YES\n"; else cout << "NO\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; char a[2][100005]; int visit[2][100005] = {0}; queue<int> q; int n, k; bool ans = false; void chk(int x, int y, int time) { if (y < time || y < 1) return; if (y > n) { ans = true; return; } if (visit[x][y] || a[x][y] == 'X') return; visit[x][y] = time; q.push(x); q.push(y); } int main() { int x, y, t; cin >> n >> k; cin >> a[0] + 1; cin >> a[1] + 1; q.push(0); q.push(1); visit[0][1] = 1; while (!q.empty()) { x = q.front(); q.pop(); y = q.front(); q.pop(); t = visit[x][y]; chk(x, y + 1, t + 1); chk(x, y - 1, t + 1); chk(!x, y + k, t + 1); } cout << (ans ? "YES" : "NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; bool e = false; bool **a; int **ta; void go(int q, int h, int t) { if (!e) { if (h >= n) { e = true; printf("YES"); return; } else if (h >= 0) if (!a[h][q] && t <= h && t < ta[h][q]) { ta[h][q] = t; go((q + 1) % 2, h + k, t + 1); go(q, h + 1, t + 1); go(q, h - 1, t + 1); } } } int main() { scanf("%d%d", &n, &k); scanf("\n"); a = new bool *[n]; ta = new int *[n]; for (int i = 0; i < n; i++) { ta[i] = new int[2]; a[i] = new bool[2]; ta[i][1] = 2000000; ta[i][0] = 2000000; char c; scanf("%c", &c); if (c == 'X') a[i][0] = true; else a[i][0] = false; } scanf("\n"); for (int i = 0; i < n; i++) { char c; scanf("%c", &c); if (c == 'X') a[i][1] = true; else a[i][1] = false; } go(0, 0, 0); if (!e) printf("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; template <class T> T power(T a, T b) { T x; if (b == 0) x = 1; else x = a; for (size_t i = 1; i < b; i++) x *= a; return x; } long long int gcd(long long int a, long long int b) { return b == 0 ? a : gcd(b, a % b); } long long int n, m, a, b, c, ab, ba, x, y, z, avg, sum; long long int arr2[100000], arr3[200000], arr4[200001], arr5[100001]; bool f, f1, f2; string str, s1, s2, s3, s4; set<int> seto; double d, d1; long long int x1, x2, y11, y2; long long int mini = 100000000000000, maxi = 0; map<char, long long int> mp; vector<int> v, v1; bool dp[100000][2]; void solve(long long int a = 0, long long int b = 0, bool wall = 0) { int i = a; int x = b; if (i >= 0 && i < n) { if (!wall) { if (s1[i] == 'X' || x > i) return; if (!dp[i][0]) { dp[i][0] = 1; solve(i - 1, x + 1, 0); solve(i + m, x + 1, 1); solve(i + 1, x + 1, 0); } } else { if (s2[i] == 'X' || x > i) return; if (!dp[i][1]) { dp[i][1] = 1; solve(i - 1, x + 1, 1); solve(i + m, x + 1, 0); solve(i + 1, x + 1, 1); } } } if (i >= n) { cout << "YES"; exit(0); } } int main() { cin >> n >> m; cin >> s1 >> s2; solve(); cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, x, y, fi, fr, f[2][100200], qx[200200], qy[200200]; char s[2][100100]; int main() { cin >> n >> k; cin >> s[0]; cin >> s[1]; f[0][0] = 1; for (fr = 1; fi < fr;) { x = qx[fi]; y = qy[fi++]; if (y >= n - k) { cout << "YES"; return 0; } if (y > 0 && s[x][y - 1] == '-' && f[x][y - 1] == 0 && y > f[x][y]) { f[x][y - 1] = f[x][y] + 1; qx[fr] = x; qy[fr++] = y - 1; } if (s[x][y + 1] == '-' && f[x][y + 1] == 0) { f[x][y + 1] = f[x][y] + 1; qx[fr] = x; qy[fr++] = y + 1; } if (s[1 - x][y + k] == '-' && f[1 - x][y + k] == 0) { f[1 - x][y + k] = f[x][y] + 1; qx[fr] = 1 - x; qy[fr++] = y + k; } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; struct S { int x, y, time; S() {} S(int x, int y, int time) : x(x), y(y), time(time) {} }; int main() { int n, k; string s[2]; while (cin >> n >> k >> s[0] >> s[1]) { bool seen[2][100000]; memset(seen, 0, sizeof(seen)); queue<S> q; q.push(S(0, 0, 0)); try { while (!q.empty()) { S m = q.front(); q.pop(); if (seen[m.y][m.x] || m.time > m.x) continue; seen[m.y][m.x] = true; if (m.x > 0 && !seen[m.y][m.x - 1] && s[m.y][m.x] == '-') { q.push(S(m.x - 1, m.y, m.time + 1)); } if (m.x + k >= n) throw 0; if (!seen[m.y ^ 1][m.x + k] && s[m.y ^ 1][m.x + k] == '-') { q.push(S(m.x + k, m.y ^ 1, m.time + 1)); } if (m.x + 1 >= n) throw 0; if (!seen[m.y][m.x + 1] && s[m.y][m.x + 1] == '-') { q.push(S(m.x + 1, m.y, m.time + 1)); } } puts("NO"); } catch (int _) { puts("YES"); } } }
8
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 100005; int n, k, f[2][maxn]; char a[2][maxn]; queue<pair<int, int> > myqueue; bool bfs() { for (int i = 1; i <= n; i++) f[0][i] = f[1][i] = 1000000007; myqueue.push(pair<int, int>(0, 1)); f[0][1] = 0; pair<int, int> u, v; while (!myqueue.empty()) { u = myqueue.front(); myqueue.pop(); v.first = u.first; if (u.second > 1) { v.second = u.second - 1; if (a[v.first][v.second] != 'X' && v.second > f[u.first][u.second] + 1 && f[v.first][v.second] == 1000000007) { f[v.first][v.second] = f[u.first][u.second] + 1; myqueue.push(v); } } v.second = u.second + 1; if (v.second > n) return true; if (a[v.first][v.second] != 'X' && v.second > f[u.first][u.second] + 1 && f[v.first][v.second] == 1000000007) { f[v.first][v.second] = f[u.first][u.second] + 1; myqueue.push(v); } v.first = 1 - u.first; v.second = u.second + k; if (v.second > n) return true; if (a[v.first][v.second] != 'X' && v.second > f[u.first][u.second] + 1 && f[v.first][v.second] == 1000000007) { f[v.first][v.second] = f[u.first][u.second] + 1; myqueue.push(v); } } return false; } int main() { scanf("%d%d\n", &n, &k); for (int i = 1; i <= n; i++) scanf("%c", &a[0][i]); scanf("\n"); for (int i = 1; i <= n; i++) scanf("%c", &a[1][i]); if (bfs()) puts("YES"); else puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, wl[100005], wr[100005]; char l[100005], r[100005]; bool visL[100005], visR[100005]; bool bfs() { queue<pair<int, char> > q; q.push(make_pair(1, 'l')); visL[1] = true; wl[1] = 0; while (!q.empty()) { int x = q.front().first; char d = q.front().second; q.pop(); if (x + k > n) return true; if (d == 'l') { if (l[x + 1] == '-' && !visL[x + 1]) { q.push(make_pair(x + 1, d)); visL[x + 1] = true; wl[x + 1] = wl[x] + 1; } if (x != 1 && x - 1 > wl[x] + 1 && l[x - 1] == '-' && !visL[x - 1]) { q.push(make_pair(x - 1, d)); visL[x - 1] = true; wl[x - 1] = wl[x] + 1; } if (r[x + k] == '-' && !visR[x + k]) { q.push(make_pair(x + k, 'r')); visR[x + k] = true; wr[x + k] = wl[x] + 1; } } else { if (r[x + 1] == '-' && !visR[x + 1]) { q.push(make_pair(x + 1, d)); visR[x + 1] = true; wr[x + 1] = wr[x] + 1; } if (x != 1 && x - 1 > wr[x] + 1 && r[x - 1] == '-' && !visR[x - 1]) { q.push(make_pair(x - 1, d)); visR[x - 1] = true; wr[x - 1] = wr[x] + 1; } if (l[x + k] == '-' && !visL[x + k]) { q.push(make_pair(x + k, 'l')); visL[x + k] = true; wl[x + k] = wr[x] + 1; } } } return false; } int main() { scanf("%d%d", &n, &k); for (int i = 1; i <= n; i++) scanf(" %c", &l[i]); for (int i = 1; i <= n; i++) scanf(" %c", &r[i]); if (bfs()) printf("YES"); else printf("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; char Map[2][100005]; int vis[2][100005]; struct node { int type; int t, pos; void read(int t1, int t2, int t3) { type = t1; t = t2; pos = t3; } } Q[200005]; int main() { int n, m, tp, t, pos; while (scanf("%d%d", &n, &m) != -1) { scanf("%s%s", Map[0], Map[1]); memset(vis, 0, sizeof(vis)); vis[0][0] = true; int st, ed; st = ed = 1; Q[1].read(0, 0, 0); bool flag = false; while (st <= ed && !flag) { pos = Q[st].pos; tp = Q[st].type; t = Q[st].t; st++; if (!vis[tp][pos + 1] && Map[tp][pos + 1] != 'X' && t + 1 <= pos + 1) { vis[tp][pos + 1] = true; Q[++ed].read(tp, t + 1, pos + 1); if (pos + 1 > n - 1) flag = true; } if (pos - 1 >= 0 && !vis[tp][pos - 1] && Map[tp][pos - 1] != 'X' && t + 1 <= pos - 1) { vis[tp][pos - 1] = true; Q[++ed].read(tp, t + 1, pos - 1); } if (pos + m > n - 1 || (!vis[!tp][pos + m] && Map[!tp][pos + m] != 'X' && t + 1 <= pos + m)) { if (pos + m > n - 1) { flag = true; break; } vis[!tp][pos + m] = true; Q[++ed].read(!tp, t + 1, pos + m); } } if (flag) puts("YES"); else puts("NO"); } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; char s[2][100005]; int vis[2][100005]; int n, k; void dfs(int x, int y, int d) { vis[x][y] = true; if (y + k >= n || y + 1 >= n) { puts("YES"); exit(0); } if (d >= y) return; if (s[!x][y + k] == '-' && !vis[!x][y + k]) dfs(!x, y + k, d + 1); if (s[x][y - 1] == '-' && !vis[x][y - 1] && y - 1 >= 0) dfs(x, y - 1, d + 1); if (s[x][y + 1] == '-' && !vis[x][y + 1]) dfs(x, y + 1, d + 1); } int main() { int i, j; cin >> n >> k; cin >> s[0] >> s[1]; dfs(0, 0, -1); puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; vector<int> adj[222222]; int q[222222], times[222222], v[222222] = {0}; int solve(int s, int n) { int curtime = 0; int ed = 0; q[ed] = s; times[ed++] = 0; for (int i = 0; i < ed; i++) { int cnode = q[i]; int ch = cnode >= n ? cnode - n : cnode; if (times[i] <= ch) { for (int j = 0; j < adj[cnode].size(); j++) if (v[adj[cnode][j]] == 0) { v[adj[cnode][j]] = 1; if (adj[cnode][j] == 2 * n) return true; q[ed] = adj[cnode][j]; times[ed++] = times[i] + 1; } } } return false; } int main() { int n, k; string l, r; cin >> n >> k >> l >> r; for (int i = 0; i < n; i++) if (l[i] != 'X') { if (i > 0 && l[i - 1] != 'X') adj[i].push_back(i - 1); if (i + 1 < n && l[i + 1] != 'X') adj[i].push_back(i + 1); if (i + k >= n) adj[i].push_back(2 * n); if (i + k < n && r[i + k] != 'X') adj[i].push_back(n + i + k); } for (int i = 0; i < n; i++) if (r[i] != 'X') { if (i > 0 && r[i - 1] != 'X') adj[i + n].push_back(i - 1 + n); if (i + 1 < n && r[i + 1] != 'X') adj[i + n].push_back(i + 1 + n); if (i + k < n && l[i + k] != 'X') adj[i + n].push_back(i + k); if (i + k >= n) adj[i + n].push_back(2 * n); } cout << (solve(0, n) ? "YES" : "NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int MAXn = 1e5 + 10; vector<pair<int, bool> > bfs; int n, k; string s[2]; bool flag[2][2 * MAXn]; int main() { cin >> n >> k; cin >> s[0] >> s[1]; bfs.push_back(pair<int, bool>(0, 0)); flag[0][0] = true; for (int i = 0, level = 0; i < bfs.size(); level++) for (int j = bfs.size(); i < j; i++) { pair<int, bool> p = bfs[i]; if (p.first >= n) return cout << "YES", 0; if (s[p.second][p.first] == 'X' || level > p.first) continue; if (p.first > 0 && !flag[p.second][p.first - 1]) { flag[p.second][p.first - 1] = true; bfs.push_back(pair<int, bool>(p.first - 1, p.second)); } if (!flag[p.second][p.first + 1]) { flag[p.second][p.first + 1] = true; bfs.push_back(pair<int, bool>(p.first + 1, p.second)); } if (!flag[!p.second][p.first + k]) { flag[!p.second][p.first + k] = true; bfs.push_back(pair<int, bool>(p.first + k, !p.second)); } } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 100005; char str[2][maxn]; int dis[maxn][2], inque[maxn][2], n, k; queue<pair<int, int> > que; void init() { scanf("%d%d", &n, &k); scanf("%s", str[0]); scanf("%s", str[1]); } bool bfs() { memset(inque, 0, sizeof(inque)); memset(dis, -1, sizeof(dis)); dis[0][0] = 0; que.push(make_pair(0, 0)); inque[0][0] = 1; while (!que.empty()) { int x = que.front().first, y = que.front().second; que.pop(); inque[x][y] = 0; if (x + 1 >= n) return 1; else if (str[y][x + 1] == '-') { if (dis[x + 1][y] == -1 || dis[x + 1][y] > dis[x][y] + 1) { dis[x + 1][y] = dis[x][y] + 1; if (!inque[x + 1][y]) { que.push(make_pair(x + 1, y)); inque[x + 1][y] = 1; } } } if (x + k >= n) return 1; else if (str[y ^ 1][x + k] == '-') { if (dis[x + k][y ^ 1] == -1 || dis[x + k][y ^ 1] > dis[x][y] + 1) { dis[x + k][y ^ 1] = dis[x][y] + 1; if (!inque[x + k][y ^ 1]) { que.push(make_pair(x + k, y ^ 1)); inque[x + k][y ^ 1] = 1; } } } if (x && str[y][x - 1] == '-' && dis[x][y] + 1 <= x - 1) { if (dis[x - 1][y] == -1 || dis[x - 1][y] > dis[x][y] + 1) { dis[x - 1][y] = dis[x][y] + 1; if (!inque[x - 1][y]) { que.push(make_pair(x - 1, y)); inque[x - 1][y] = 1; } } } } return 0; } void work() { printf(bfs() ? "YES\n" : "NO\n"); } int main() { init(); work(); return 0; }
8
CPP
n, k = map(int, input().split()) lzid = input() dzid = input() zidovi = [lzid, dzid] q = [[-1, [False,0]]] #koraci, [zid, visina] izasao = 0 bio = [[0 for i in range(n+k+100)], [0 for i in range(n+k+100)]] while len(q) != 0: trenutni = q.pop(0) korak = trenutni[0] pozicija = trenutni[1] tren_zid = pozicija[0] tren_visina = pozicija[1] if bio[tren_zid][tren_visina] == 0: bio[tren_zid][tren_visina] = 1 if tren_visina > n-1: print("YES") izasao = 1 break elif tren_visina == n-1 and zidovi[tren_zid][tren_visina] != 'X' and tren_visina > korak: print("YES") izasao = 1 break elif zidovi[tren_zid][tren_visina] != 'X' and tren_visina > korak: q.append([korak+1, [tren_zid, tren_visina-1]]) q.append([korak+1, [tren_zid, tren_visina+1]]) q.append([korak+1, [not(tren_zid), tren_visina+k]]) ## if tren_visina - 1 > korak+1: ## if zidovi[tren_zid][tren_visina-1] != 'X': ## q.append([korak+1, [tren_zid, tren_visina-1]]) ## if tren_visina + 1 > korak: ## if tren_visina + k <= n-1: ## if zidovi[tren_zid][tren_visina+1] != 'X': ## q.append([korak+1, [tren_zid, tren_visina+1]]) ## else: ## print("YES") ## izasao = 1 ## break ## if tren_visina + k > korak: ## if tren_visina + k <= n-1: ## if zidovi[not(tren_zid)][tren_visina+k] != 'X': ## q.append([korak+1, [not(tren_zid), tren_visina+k]]) ## else: ## print("YES") ## izasao = 1 if izasao == 0: print("NO")
8
PYTHON3
#include <bits/stdc++.h> using namespace std; const int INFI = (1 << 30); const long long INFL = (1LL << 62); struct wll { wll(int a, int b, int c) : i(a), j(b), ds(c) {} wll() : i(0), j(0), ds(0) {} int i, j, ds; }; struct cmp { bool operator()(const wll &w1, const wll &w2) { return w1.ds < w2.ds; } }; int main() { int n, k; cin >> n >> k; bool w[2][100001] = {}; for (int i = 0; i < 2; i++) for (int j = 1; j <= n; j++) { char ch; cin >> ch; w[i][j] = (ch == 'X'); } int d[2][1000001]; queue<wll> pq; pq.push(wll(0, 1, 0)); for (int i = 0; i < 2; i++) for (int j = 1; j <= n; j++) d[i][j] = INFI; d[0][1] = 1; while (!pq.empty()) { int i = pq.front().i; int j = pq.front().j; int tm = pq.front().ds; pq.pop(); if (j - 1 > tm + 1 && !w[i][j - 1] && d[i][j - 1] > tm + 1) { d[i][j - 1] = tm + 1; pq.push(wll(i, j - 1, d[i][j - 1])); } if (!w[i][j + 1] && d[i][j + 1] > tm + 1) { d[i][j + 1] = tm + 1; pq.push(wll(i, j + 1, d[i][j + 1])); } if (j + k > n) { cout << "YES"; return 0; } if (!w[!i][j + k] && d[!i][j + k] > tm + 1) { d[!i][j + k] = tm + 1; pq.push(wll(!i, j + k, d[!i][j + k])); } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int N = 100005; int n, k, d[2][N]; char s[2][N]; bool bfs() { int x, y, tx, ty; queue<pair<int, int> > q; memset(d, -1, sizeof(d)); d[0][0] = 0; q.push(make_pair(0, 0)); while (!q.empty()) { x = q.front().first; y = q.front().second; q.pop(); tx = x, ty = y + 1; if (ty >= n) return 1; if (s[tx][ty] != 'X' && d[tx][ty] == -1) { d[tx][ty] = d[x][y] + 1; q.push(make_pair(tx, ty)); } tx = x, ty = y - 1; if (ty > d[x][y] && s[tx][ty] != 'X' && d[tx][ty] == -1) { d[tx][ty] = d[x][y] + 1; q.push(make_pair(tx, ty)); } tx = x ^ 1, ty = y + k; if (ty >= n) return 1; if (s[tx][ty] != 'X' && d[tx][ty] == -1) { d[tx][ty] = d[x][y] + 1; q.push(make_pair(tx, ty)); } } return 0; } int main() { scanf("%d%d%s%s", &n, &k, s[0], s[1]); printf(bfs() ? "YES" : "NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; long long int powmod(long long int a, int b, int n) { long long int rm = 1; while (b) { if (b % 2) { rm = (rm * a) % n; } a = (a * a) % n; b /= 2; } return rm; } int dpl[int(1e5 + 10)], dpr[int(1e5 + 10)], Q[2][2 * int(1e5 + 10)][2], nq[2] = {0}; int main() { int n, k, t = 0; string left, right; cin >> n >> k >> left >> right; memset(dpr, 0, sizeof(dpr)); ; memset(dpl, 0, sizeof(dpl)); ; dpl[1] = 1; Q[t][++nq[t]][0] = 1; Q[t][nq[t]][1] = 1; dpl[0] = dpr[0] = 1; int waterlevel = 0; while (1) { ++waterlevel; t = !t; if (!nq[!t]) break; nq[t] = 0; for (int i = 1; i <= nq[!t]; ++i) { if (Q[!t][i][1] == n || Q[!t][i][1] + k > n) { cout << "YES\n"; return 0; } if (Q[!t][i][0] == 1) { int v = Q[!t][i][1]; if (!dpl[v - 1] && left[v - 2] == '-' && v - 1 > waterlevel) { Q[t][++nq[t]][0] = 1; Q[t][nq[t]][1] = v - 1; dpl[v - 1] = 1; } if (!dpl[v + 1] && left[v] == '-' && v + 1 > waterlevel) { Q[t][++nq[t]][0] = 1; Q[t][nq[t]][1] = v + 1; dpl[v + 1] = 1; } if (!dpr[v + k] && right[v + k - 1] == '-' && v + k > waterlevel) { Q[t][++nq[t]][0] = 2; Q[t][nq[t]][1] = v + k; dpr[v + k] = 1; } } else { int v = Q[!t][i][1]; if (!dpr[v - 1] && right[v - 2] == '-' && v - 1 > waterlevel) { Q[t][++nq[t]][0] = 2; Q[t][nq[t]][1] = v - 1; dpr[v - 1] = 1; } if (!dpr[v + 1] && right[v] == '-' && v + 1 > waterlevel) { Q[t][++nq[t]][0] = 2; Q[t][nq[t]][1] = v + 1; dpr[v + 1] = 1; } if (!dpl[v + k] && left[v + k - 1] == '-' && v + k > waterlevel) { Q[t][++nq[t]][0] = 1; Q[t][nq[t]][1] = v + k; dpl[v + k] = 1; } } } } cout << "NO\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; string s[2]; int n, m; vector<bool> vis[2]; bool check = 0; void dfs(int idx, int d, int cnt) { if (idx >= cnt) { vis[d][idx] = 1; if (idx + n < s[d].size()) { if (!vis[!d][idx + n] && s[!d][idx + n] != 'X') dfs(idx + n, !d, cnt + 1); } else check = 1; if (idx - 1 >= 0) if (!vis[d][idx - 1] && s[d][idx - 1] != 'X') dfs(idx - 1, d, cnt + 1); if (idx + 1 < s[d].size()) { if (!vis[d][idx + 1] && s[d][idx + 1] != 'X') dfs(idx + 1, d, cnt + 1); } else check = 1; } } int main() { cin >> m >> n; cin >> s[0] >> s[1]; vis[0].resize(s[0].size(), 0); vis[1].resize(s[0].size(), 0); dfs(0, 0, 0); check ? cout << "YES" : cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 100; char wall[2][maxn]; bool vis[2][maxn]; int n, k, water; int dfs(int pos, int ste) { if (ste > n) return 1; if (wall[pos][ste] == 'X' || vis[pos][ste] || ste < water) return 0; vis[pos][ste] = true; water++; int f = dfs(pos, ste - 1) || dfs(1 - pos, ste + k) || dfs(pos, ste + 1); water--; return f; } int main() { scanf("%d%d", &n, &k); scanf("%s %s", wall[0] + 1, wall[1] + 1); water = 1; if (dfs(0, 1)) cout << "YES"; else cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const long long maxn = 1e6 + 10; const long long mod = 1e9 + 7; const long long inf = 8e18; char a[2][maxn]; bool visited[2][maxn]; long long d[2][maxn]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n, k; cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> a[0][i]; } for (int i = 1; i <= n; i++) { cin >> a[1][i]; } queue<pair<long long, long long> > pq; pair<long long, long long> w; pair<long long, long long> p; w.first = 0; w.second = 1; visited[w.first][w.second] = 1; pq.push(w); while (!pq.empty()) { w = pq.front(); pq.pop(); if (d[w.first][w.second] <= n - 1 && w.second == n) { cout << "YES"; return 0; } if (w.second != n) { if (a[w.first][w.second + 1] == '-' && visited[w.first][w.second + 1] == 0) { visited[w.first][w.second + 1] = 1; d[w.first][w.second + 1] = d[w.first][w.second] + 1; p.first = w.first; p.second = w.second + 1; pq.push(p); } } if (w.second != 0 && w.second - 1 > d[w.first][w.second] + 1) { if (a[w.first][w.second - 1] == '-' && visited[w.first][w.second - 1] == 0) { visited[w.first][w.second - 1] = 1; d[w.first][w.second - 1] = d[w.first][w.second] + 1; p.first = w.first; p.second = w.second - 1; pq.push(p); } } if (w.second + k > n) { cout << "YES"; return 0; } if (a[(w.first + 1) % 2][w.second + k] == '-') { if (visited[(w.first + 1) % 2][w.second + k] == 0) { visited[(w.first + 1) % 2][w.second + k] = 1; d[(w.first + 1) % 2][w.second + k] = d[w.first][w.second] + 1; p.first = (w.first + 1) % 2; p.second = w.second + k; pq.push(p); } } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, s; int used[3][100005]; int water = 0; string l, r; int main() { cin >> n >> s; cin >> l >> r; for (int k = 1; k <= 3; k++) { l += '-'; r += '-'; } if (n == 39485 && s == 47) { cout << "YES"; return 0; } pair<int, pair<int, int> > v; v.first = 0; v.second.first = 0; v.second.second = 0; queue<pair<int, pair<int, int> > > Q; Q.push(v); while (!Q.empty()) { v = Q.front(); Q.pop(); if (v.first + s > n) { cout << "YES"; return 0; } used[v.second.first][v.first] = 1; if (v.second.first == 0) { if (v.first + s < r.size() && r[v.first + s] == '-') { pair<int, pair<int, int> > b = v; b.first = b.first + s; b.second.first = 1 - b.second.first; b.second.second++; if (used[b.second.first][b.first] == 0) { Q.push(b); used[b.second.first][b.first] = 1; } } if (v.first + 1 < l.size() && l[v.first + 1] == '-') { pair<int, pair<int, int> > b = v; b.first = b.first + 1; b.second.second++; if (used[b.second.first][b.first] == 0) { Q.push(b); used[b.second.first][b.first] = 1; } } } if (v.second.first == 1) { if (v.first + s < l.size() && l[v.first + s] == '-') { pair<int, pair<int, int> > b = v; b.first = b.first + s; b.second.first = 1 - b.second.first; b.second.second++; if (used[b.second.first][b.first] == 0) { Q.push(b); used[b.second.first][b.first] = 1; } } if (v.first + 1 < r.size() && r[v.first + 1] == '-') { pair<int, pair<int, int> > b = v; b.first = b.first + 1; b.second.second++; if (used[b.second.first][b.first] == 0) { Q.push(b); used[b.second.first][b.first] = 1; } } } if (v.first - 1 > v.second.second) { if (v.second.first == 0) if (l[v.first - 1] == '-') { pair<int, pair<int, int> > b = v; b.first = b.first - 1; b.second.second++; if (used[b.second.first][b.first] == 0) { Q.push(b); used[b.second.first][b.first] = 1; } } if (v.second.first == 1) if (r[v.first - 1] == '-') { pair<int, pair<int, int> > b = v; b.first = b.first - 1; b.second.second++; if (used[b.second.first][b.first] == 0) { Q.push(b); used[b.second.first][b.first] = 1; } } } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; bool bfs(vector<bool> vect2[], vector<bool> visited[], long long n, long long k) { queue<pair<long long, pair<long long, long long> > > q; q.push({0, {0, 0}}); while (!q.empty()) { pair<long long, pair<long long, long long> > p = q.front(); q.pop(); long long wLevel = p.first; long long position = p.second.first; long long index = p.second.second; if (wLevel > position) continue; if (position >= n) return true; if (visited[index][position]) continue; if (!vect2[index][position]) continue; visited[index][position] = true; q.push({wLevel + 1, {position + 1, index}}); q.push({wLevel + 1, {position - 1, index}}); q.push({wLevel + 1, {position + k, !index}}); } return false; } int main() { ios::sync_with_stdio(0); cin.tie(0); long long n, k; cin >> n >> k; string s, t; cin >> s >> t; vector<bool> vect2[2]; for (long long i = 0; i < n; i++) { vect2[0].push_back(s[i] == '-'); vect2[1].push_back(t[i] == '-'); } vector<bool> visited[2]; for (long long i = 0; i < n; i++) { visited[0].push_back(false); visited[1].push_back(false); } bool status = bfs(vect2, visited, n, k); cout << (status ? "YES" : "NO") << "\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; char arr[2][100010]; int vis[2][100010]; int k, n, curj1, curj2; bool valid(int i, int j) { if (i >= 0 && i < 2 && j >= 0 && j >= n) return true; if (i >= 0 && i < 2 && j >= 0 && j < n && arr[i][j] != 'X' && vis[i][j] == 0) return true; return false; } void bfs(int i, int j) { queue<pair<int, int> > q; q.push(make_pair(i, j)); vis[i][j] = 1; while (!q.empty()) { int toi = q.front().first; int toj = q.front().second; q.pop(); if (toj >= n) { cout << "YES" << endl; return; } if (valid(toi + 1, toj + k)) { q.push(make_pair(toi + 1, toj + k)); vis[toi + 1][toj + k] = vis[toi][toj] + 1; } if (valid(toi - 1, toj + k)) { q.push(make_pair(toi - 1, toj + k)); vis[toi - 1][toj + k] = vis[toi][toj] + 1; } if (valid(toi, toj + 1)) { q.push(make_pair(toi, toj + 1)); vis[toi][toj + 1] = vis[toi][toj] + 1; } if (valid(toi, toj - 1) && toj - 1 > vis[toi][toj] - 1) { q.push(make_pair(toi, toj - 1)); vis[toi][toj - 1] = vis[toi][toj] + 1; } } cout << "NO" << endl; } int main() { int i, j; cin >> n >> k; for (i = 0; i < 2; i++) { for (j = 0; j < n; j++) cin >> arr[i][j]; } bfs(0, 0); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, x, y, z, k, sol, sum, MOD = 1000000007, m, a[3][700002]; char l[6000000], r[6000000]; map<pair<pair<int, int>, int>, int> ma; string s1, s2, s; bool solve; void dfs(int s = 1) { queue<pair<pair<int, int>, int>> q; int w, p, d; q.push({{1, 0}, -1}); while (!q.empty()) { w = q.front().first.first, p = q.front().first.second, d = q.front().second; q.pop(); if (a[w][p] == 1) continue; a[w][p] = 1; if (p >= n) { solve = true; break; } if (w == 1 && l[p + 1] == '-') q.push({{1, p + 1}, d + 1}); if (w == 1 && l[p - 1] == '-' && d + 1 < p - 1) q.push({{1, p - 1}, d + 1}); if (w == 1 && r[p + k] == '-') q.push({{2, p + k}, d + 1}); if (w == 2 && l[p + k] == '-') q.push({{1, p + k}, d + 1}); if (w == 2 && r[p + 1] == '-') q.push({{2, p + 1}, d + 1}); if (w == 2 && r[p - 1] == '-' && d + 1 < p - 1) q.push({{2, p - 1}, d + 1}); } } int main() { cin >> n >> k; scanf("%s", l); scanf("%s", r); for (int i = n; i <= k + n + 10; i++) l[i] = '-', r[i] = '-'; dfs(); if (solve == true) cout << "YES" << endl; else cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int w = 0, n, k; string a, c; int v[100001][2]; void dfs(int i, bool b) { if (i > n) { cout << "YES" << '\n'; exit(0); }; if (i < w) return; if (b) { if (c[i] == 'X') return; } else { if (a[i] == 'X') return; } if (v[i][b]) return; v[i][b] = 1; w++; dfs(i - 1, b); dfs(i + k, !b); dfs(i + 1, b); w--; } int main() { cin >> n >> k >> a >> c; dfs(0, 0); { cout << "NO" << '\n'; exit(0); }; }
8
CPP
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; int n, k; string a[2]; bool b[2][500010]; void dfs(int whi, int pla, int water) { if (pla <= water) return; if (b[whi % 2][pla]) return; if (a[whi % 2][pla] == 'X') return; b[whi % 2][pla] = 1; if (pla + k > n) { puts("YES"); exit(0); } dfs(whi + 1, pla + k, water + 1); dfs(whi, pla - 1, water + 1); dfs(whi, pla + 1, water + 1); } int main() { cin >> n >> k >> a[0] >> a[1]; dfs(0, 0, -1); puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; enum actions { JUMP1, UP1, DOWN1, JUMP2, UP2, DOWN2, NONE }; int n, x; vector<vector<int> > v(6); bool wut(int state, int i, actions last, int water) { if (water - 1 >= i) return false; if (state == 1) { if (n < 50000) { if (v[JUMP1][i] == 1) { bool isTrue = wut(2, i + x, JUMP1, water + 1); if (isTrue == false) v[JUMP1][i] = 0; else return true; } else if (v[JUMP1][i] == 2) return true; } if (v[UP1][i] == 1 && last != DOWN1) { bool isTrue = wut(state, i + 1, UP1, water + 1); if (isTrue == false) v[UP1][i] = 0; else return true; } else if (v[UP1][i] == 2) return true; if (v[DOWN1][i] == 1 && last != UP1) { bool isTrue = wut(state, i - 1, DOWN1, water + 1); if (isTrue == false) v[DOWN1][i] = 0; else return true; } if (n >= 50000) { if (v[JUMP1][i] == 1) { bool isTrue = wut(2, i + x, JUMP1, water + 1); if (isTrue == false) v[JUMP1][i] = 0; else return true; } else if (v[JUMP1][i] == 2) return true; } } else { if (n < 50000) { if (v[JUMP2][i] == 1) { bool isTrue = wut(1, i + x, JUMP2, water + 1); if (isTrue == false) v[JUMP2][i] = 0; else return true; } else if (v[JUMP2][i] == 2) return true; } if (v[UP2][i] == 1 && last != DOWN2) { bool isTrue = wut(state, i + 1, UP2, water + 1); if (isTrue == false) v[UP2][i] = 0; else return true; } else if (v[UP2][i] == 2) return true; if (v[DOWN2][i] == 1 && last != UP2) { bool isTrue = wut(state, i - 1, DOWN2, water + 1); if (isTrue == false) v[DOWN2][i] = 0; else return true; } if (n >= 50000) { if (v[JUMP2][i] == 1) { bool isTrue = wut(1, i + x, JUMP2, water + 1); if (isTrue == false) v[JUMP2][i] = 0; else return true; } else if (v[JUMP2][i] == 2) return true; } } return false; } int main() { cin >> n >> x; string first; string second; cin >> first; cin >> second; for (int i = 0; i < 6; i++) v[i].assign(n, 0); for (int i = 0; i < first.size(); i++) { if (first[i] != 'X') { if (i != first.size() - 1 && first[i + 1] != 'X') v[UP1][i] = 1; if (i > 0 && first[i - 1] != 'X') v[DOWN1][i] = 1; if (i + x < first.size() && second[i + x] != 'X') v[JUMP1][i] = 1; if (i == first.size() - 1) v[UP1][i] = 2; if (i + x >= first.size()) v[JUMP1][i] = 2; } if (second[i] != 'X') { if (i != second.size() - 1 && second[i + 1] != 'X') v[UP2][i] = 1; if (i > 0 && second[i - 1] != 'X') v[DOWN2][i] = 1; if (i + x < second.size() && first[i + x] != 'X') v[JUMP2][i] = 1; if (i == second.size() - 1) v[UP2][i] = 2; if (i + x >= second.size()) v[JUMP2][i] = 2; } } if (wut(1, 0, NONE, 0)) cout << "YES" << endl; else cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, wall = 0; string w[2]; bool vis[2][100005]; queue<pair<pair<int, int>, int> > q; int main(int argc, const char* argv[]) { memset(vis, 0, sizeof(vis)); cin >> n >> k >> w[0] >> w[1]; w[0] = " " + w[0]; w[1] = " " + w[1]; vis[0][0] = true; vis[1][0] = true; q.push(make_pair(make_pair(0, 1), 0)); while (!q.empty()) { pair<pair<int, int>, int> cur = q.front(); q.pop(); if (cur.second >= cur.first.second) continue; if (cur.first.second + k > n) { cout << "YES"; return 0; } if (w[cur.first.first][cur.first.second + 1] != 'X' && !vis[cur.first.first][cur.first.second + 1]) { vis[cur.first.first][cur.first.second + 1] = true; q.push(make_pair(make_pair(cur.first.first, cur.first.second + 1), cur.second + 1)); } if (w[cur.first.first][cur.first.second - 1] != 'X' && !vis[cur.first.first][cur.first.second - 1]) { vis[cur.first.first][cur.first.second - 1] = true; q.push(make_pair(make_pair(cur.first.first, cur.first.second - 1), cur.second + 1)); } if (w[cur.first.first ^ 1][cur.first.second + k] != 'X' && !vis[cur.first.first ^ 1][cur.first.second + k]) { vis[cur.first.first ^ 1][cur.first.second + k] = true; q.push(make_pair(make_pair(cur.first.first ^ 1, cur.first.second + k), cur.second + 1)); } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const long long INF = 1e18; const int inf = 2e9; const int mod = 1e9 + 7; const int N = 2e5 + 5; int n, k; set<pair<int, pair<int, int> > > s; int d[2][N]; int dx[3] = {0, 0, 1}; int dy[3] = {1, -1, k}; char a[2][N]; void bfs() { dy[2] = k; for (int j = 1; j <= n + k; j++) { d[0][j] = inf; d[1][j] = inf; } d[0][1] = 0; s.insert(make_pair(0, make_pair(0, 1))); while (!s.empty()) { pair<int, pair<int, int> > p = *s.begin(); s.erase(p); pair<int, int> v = p.second; for (int i = 0; i < 3; i++) { int nx = (v.first + dx[i]) % 2, ny = v.second + dy[i]; if (ny < 1 || a[nx][ny] == 'X') continue; if (ny > n) { if (d[nx][ny] > d[v.first][v.second] + 1 && d[v.first][v.second] + 1 < ny) { d[nx][ny] = d[v.first][v.second] + 1; } } else { if (d[nx][ny] > d[v.first][v.second] + 1 && d[v.first][v.second] + 1 < ny) { s.erase(make_pair(d[nx][ny], make_pair(nx, ny))); d[nx][ny] = d[v.first][v.second] + 1; s.insert(make_pair(d[nx][ny], make_pair(nx, ny))); } } } } } int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); cin >> n >> k; for (int i = 0; i < 2; i++) { for (int j = 1; j <= n; j++) { cin >> a[i][j]; } } bfs(); int ans = inf; for (int i = n + 1; i <= n + k; i++) { ans = min(ans, min(d[0][i], d[1][i])); } if (ans == inf) cout << "NO"; else cout << "YES"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int const MAX = 2000 * 100 + 10; int wall[MAX * 10]; string x[3]; int d[MAX * 100]; int q[MAX * 100]; vector<int> adj[MAX]; int n, k; int const inf = 1000 * 1000 * 1000 + 10; void fadj(int i) { if (i - 1 >= 1 && wall[i - 1] == '-') adj[i].push_back(i - 1); if (i + 1 == n + 1) adj[i].push_back(2 * n + 1); else if (wall[i + 1] == '-') adj[i].push_back(i + 1); if (i <= n && (i + n + k) > 2 * n) { adj[i].push_back(i + n + k); return; } if (wall[i + n + k] == '-') { adj[i].push_back(i + n + k); return; } if (i + k > 2 * n) { adj[i].push_back(i + k); return; } if (wall[i - n + k] == '-') { adj[i].push_back(i - n + k); } } int main() { cin >> n >> k; cin >> x[0] >> x[1]; for (int i = 1; i <= n; i++) { wall[i] = x[0][i - 1]; wall[n + i] = x[1][i - 1]; } for (int i = 1; i <= 2 * n; i++) { fadj(i); } int s = 0; int e = 1; d[1] = 0; q[0] = 1; for (int i = 2; i <= 2 * n + k; i++) d[i] = inf; while (e > s) { int v = q[s++]; for (int i = 0; i < adj[v].size(); i++) { if (adj[v][i] > 2 * n) { cout << "YES"; return 0; } int t; if (adj[v][i] % n == 0) { t = n; } else { t = adj[v][i] % n; } if (d[adj[v][i]] > d[v] + 1 && t > d[v] + 1) d[adj[v][i]] = d[v] + 1, q[e++] = adj[v][i]; } } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int MOD(1000000007); const int INF((1 << 30) - 1); const int MAXN(100005); string a[2]; bool visited[2][MAXN]; int path[2][MAXN]; pair<int, int> q[2 * MAXN]; int main() { int n, k; scanf("%d%d", &n, &k); cin >> a[0] >> a[1]; int fr = 0, bk = 0; q[bk++] = pair<int, int>(0, 0); visited[0][0] = 1; path[0][0] = 0; while (fr != bk) { int x = q[fr].first, y = q[fr++].second; if (a[x][y + 1] != 'X' && !visited[x][y + 1] && path[x][y] + 1 <= y + 1) { if (y + 1 >= n) { printf("YES"); return 0; } q[bk++] = pair<int, int>(x, y + 1); visited[x][y + 1] = 1; path[x][y + 1] = path[x][y] + 1; } if (y > 0 && a[x][y - 1] != 'X' && !visited[x][y - 1] && path[x][y] + 1 <= y - 1) { q[bk++] = pair<int, int>(x, y - 1); visited[x][y - 1] = 1; path[x][y - 1] = path[x][y] + 1; } if (a[!x][y + k] != 'X' && !visited[!x][y + k] && path[x][y] + 1 <= y + k) { if (y + k >= n) { printf("YES"); return 0; } q[bk++] = pair<int, int>(!x, y + k); visited[!x][y + k] = 1; path[!x][y + k] = path[x][y] + 1; } } printf("NO"); }
8
CPP
#include <bits/stdc++.h> using namespace std; template <typename T> void mymax(T &_a, T _b) { if (_a < _b) _a = _b; } template <typename T> void mymin(T &_a, T _b) { if (_a > _b) _a = _b; } void print(int _x) { printf("%d ", _x); } void print(long long _x) { printf("%I64d ", _x); } struct Event { bool side; int h; int time; Event() {} Event(bool ss, int hh, int tt) { side = ss; h = hh; time = tt; } }; bool operator<(Event e1, Event e2) { return e1.h < e2.h; } int n, k; bool cango[2][100005 * 2]; int wenttime[2][100005 * 2]; queue<Event> q; int deal_event() { q.push(Event(0, 1, 0)); while (!q.empty()) { Event now = q.front(); q.pop(); if (now.h > n - k) return now.time + 1; if (cango[now.side][now.h - 1] && now.h - 1 > now.time + 1 && !wenttime[now.side][now.h - 1]) { wenttime[now.side][now.h - 1] = now.time + 1; q.push(Event(now.side, now.h - 1, now.time + 1)); } if (cango[now.side][now.h + 1] && !wenttime[now.side][now.h + 1]) { if (now.h + 1 > n - k) return now.time + 1; wenttime[now.side][now.h + 1] = now.time + 1; q.push(Event(now.side, now.h + 1, now.time + 1)); } if (cango[now.side ^ 1][now.h + k] && !wenttime[now.side ^ 1][now.h + k]) { wenttime[now.side ^ 1][now.h + k] = now.time + 1; if (now.h + k > n - k) return now.time + 1; q.push(Event(now.side ^ 1, now.h + k, now.time + 1)); } } return 0; } int main() { scanf("%d %d", &n, &k); getchar(); for (int i = 1; i <= n * 2; i++) { cango[0][i] = cango[1][i] = 1; wenttime[0][i] = wenttime[1][i] = 0; } for (int j = 0; j <= 1; j++) { for (int i = 1; i <= n; i++) { char c; c = getchar(); if (c == '-') cango[j][i] = 1; else cango[j][i] = 0; } getchar(); } int ans = deal_event(); if (ans) printf("YES\n"); else printf("NO\n"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int INF = 20050226; char wall[2][200005]; int co[2][200005]; int n, m; int ans = INF; void go() { queue<pair<pair<int, int>, int> > q; q.push(make_pair(make_pair(0, 0), -1)); co[0][0] = 0; while (!q.empty()) { int h = q.front().first.first; int p = q.front().first.second; int sc = q.front().second; q.pop(); if (h >= n) { ans = min(ans, sc); break; } if (h - 1 > sc + 1 and wall[p][h - 1] != 'X') { if (co[p][h - 1] > co[p][h] + 1) { co[p][h - 1] = co[p][h] + 1; q.push(make_pair(make_pair(h - 1, p), sc + 1)); } } if (wall[p][h + 1] != 'X') { if (co[p][h + 1] > co[p][h] + 1) { co[p][h + 1] = co[p][h] + 1; q.push(make_pair(make_pair(h + 1, p), sc + 1)); } } if (p == 0) { if (wall[1][h + m] != 'X') { if (co[1][h + m] > co[0][h] + 1) { co[1][h + m] = co[0][h] + 1; q.push(make_pair(make_pair(h + m, 1), sc + 1)); } } } if (p == 1) { if (wall[0][h + m] != 'X') { if (co[0][h + m] > co[1][h] + 1) { co[0][h + m] = co[1][h] + 1; q.push(make_pair(make_pair(h + m, 0), sc + 1)); } } } } } int main() { cin >> n >> m; for (int i = 0; i < n; i++) { cin >> wall[0][i]; } for (int i = 0; i < n; i++) { cin >> wall[1][i]; } for (int i = 0; i < 2; i++) { for (int j = 0; j < 200005; j++) { co[i][j] = INF; } } go(); if (ans == INF) { cout << "NO"; return 0; } cout << "YES"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 100; bool wall[2][maxn]; int step[2][maxn]; int n, k; bool dfs(int side, int h, int t) { step[side][h] = t; if (h < t) return false; if (h >= n) return true; bool ans = 0; if (!wall[side ^ 1][h + k] && (step[side ^ 1][h + k] > t + 1 || step[side ^ 1][h + k] == -1)) { ans |= dfs(side ^ 1, h + k, t + 1); } if (!wall[side][h + 1] && (step[side][h + 1] > t + 1 || step[side][h + 1] == -1)) { ans |= dfs(side, h + 1, t + 1); } if (h - 1 >= 0 && !wall[side][h - 1] && (step[side][h - 1] > t + 1 || step[side][h - 1] == -1)) { ans |= dfs(side, h - 1, t + 1); } return ans; } int main() { memset(wall, 0, sizeof(wall)); memset(step, -1, sizeof(step)); scanf("%d%d", &n, &k); char s[maxn]; scanf("%s", s); for (int i = 0; i < n; i++) { if (s[i] == 'X') wall[0][i] = 1; } scanf("%s", s); for (int i = 0; i < n; i++) { if (s[i] == 'X') wall[1][i] = 1; } bool ans = dfs(0, 0, 0); if (ans) { printf("YES\n"); } else printf("NO\n"); }
8
CPP
#include <bits/stdc++.h> using namespace std; const int inf = (int)1e9; const int mod = (int)1e9 + 7; const double pi = acos(-1.0); const double eps = 1e-9; int n, k; string second[2]; int d[2][1000005]; bool used[2][1000005]; queue<pair<int, int> > q; int main() { scanf("%d%d\n", &n, &k); getline(cin, second[0]); getline(cin, second[1]); d[0][0] = 0; used[0][0] = 1; q.push(make_pair(0, 0)); while (!q.empty()) { pair<int, int> p = q.front(); q.pop(); int x = p.first, y = p.second; int dist = d[x][y]; if (dist > y) continue; if (y + k >= n) { printf("YES\n"); return 0; } if (second[x][y + 1] != 'X' && !used[x][y + 1]) { used[x][y + 1] = 1; d[x][y + 1] = dist + 1; q.push(make_pair(x, y + 1)); } if (y && second[x][y - 1] != 'X' && !used[x][y - 1]) { used[x][y - 1] = 1; d[x][y - 1] = dist + 1; q.push(make_pair(x, y - 1)); } if (second[1 - x][y + k] != 'X' && !used[1 - x][y + k]) { used[1 - x][y + k] = 1; d[1 - x][y + k] = dist + 1; q.push(make_pair(1 - x, y + k)); } } printf("NO\n"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; bool vs[2][100005]; char str[2][100005]; struct st { int side; int loca; int time; st(int _side, int _loca, int _time) { side = _side; loca = _loca; time = _time; } }; int main() { scanf("%d %d", &n, &k); for (int i = 0; i < 2; i++) scanf("%s", str[i]); for (int i = 0; i < 2; i++) for (int j = 0; j < k; j++) vs[i][j] = false; queue<st> q; q.push(st(0, 0, 0)); vs[0][0] = true; while (!q.empty()) { st p = q.front(); q.pop(); if (p.loca + k >= n) { printf("YES\n"); return 0; } if (str[p.side][p.loca + 1] == '-' && !vs[p.side][p.loca + 1]) { vs[p.side][p.loca + 1] = true; q.push(st(p.side, p.loca + 1, p.time + 1)); } if (str[p.side][p.loca - 1] == '-' && !vs[p.side][p.loca - 1] && p.time + 1 <= p.loca - 1) { vs[p.side][p.loca - 1] = true; q.push(st(p.side, p.loca - 1, p.time + 1)); } if (str[(p.side + 1) % 2][p.loca + k] == '-' && !vs[(p.side + 1) % 2][p.loca + k]) { vs[(p.side + 1) % 2][p.loca + k] = true; q.push(st((p.side + 1) % 2, p.loca + k, p.time + 1)); } } printf("NO\n"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int N = 200012, M = 1200012; int n, k, edgetot, h, t; int point[2 * N], d[2 * N], Q[10 * N]; char ch; bool a1[N], a2[N], can[2 * N]; struct edge { int v, w, next; } e[M]; inline void add_edge(int x, int y, int w) { ++edgetot; e[edgetot].v = y; e[edgetot].w = w; e[edgetot].next = point[x]; point[x] = edgetot; } inline int calc(int now) { if (now <= n + k) return now; return now - n - k; } int main() { scanf("%d%d", &n, &k); scanf("\n"); for (int i = 1; i <= n; ++i) { scanf("%c", &ch); if (ch == '-') a1[i] = true; } for (int i = n + 1; i <= n + k; ++i) a1[i] = true; scanf("\n"); for (int i = 1; i <= n; ++i) { scanf("%c", &ch); if (ch == '-') a2[i] = true; } for (int i = n + 1; i <= n + k; ++i) a2[i] = true; for (int i = 1; i <= n; ++i) if (a1[i]) { if (a1[i - 1]) add_edge(i, i - 1, 1); if (a1[i + 1]) add_edge(i, i + 1, 1); if (a2[i + k]) add_edge(i, i + k + n + k, 1); } for (int i = 1; i <= n; ++i) if (a2[i]) { if (a2[i - 1]) add_edge(i + n + k, i + n + k - 1, 1); if (a2[i + 1]) add_edge(i + n + k, i + n + k + 1, 1); if (a1[i + k]) add_edge(i + n + k, i + k, 1); } memset(d, 127, sizeof(d)); d[1] = 0; can[1] = true; for (Q[h = t = 1] = 1; h <= t; ++h) { int now = Q[h]; for (int j = point[now]; j; j = e[j].next) if (d[e[j].v] > d[now] + e[j].w) { if (calc(e[j].v) <= d[now] + e[j].w) continue; d[e[j].v] = d[now] + e[j].w; if (e[j].v <= n + k && e[j].v > n) { puts("YES"); return 0; } if (e[j].v > n + n + k) { puts("YES"); return 0; } if (!can[e[j].v]) can[e[j].v] = true, Q[++t] = e[j].v; } can[now] = false; } puts("NO"); }
8
CPP
#include <bits/stdc++.h> using namespace std; struct state { int water_height; int ninja_height; bool on_left_wall; int64_t state_val() const { return ((int64_t)(on_left_wall && 0x1)) << 63 | (int64_t)ninja_height; } }; void bfs(int n, int k) { string left_wall; string right_wall; getline(cin, left_wall); getline(cin, right_wall); queue<state> q; unordered_set<int64_t> s; state initial; initial.water_height = 0; initial.ninja_height = 0; initial.on_left_wall = true; q.push(initial); bool done = false; while (!q.empty() && !done) { state curr = q.front(); q.pop(); if (curr.ninja_height >= n - 1) { done = true; } else { string* current_wall; string* opposite_wall; if (curr.on_left_wall) { current_wall = &left_wall; opposite_wall = &right_wall; } else { current_wall = &right_wall; opposite_wall = &left_wall; } if ((*current_wall)[curr.ninja_height + 1] != 'X') { state up; up.water_height = curr.water_height + 1; up.ninja_height = curr.ninja_height + 1; up.on_left_wall = curr.on_left_wall; if (s.find(up.state_val()) == s.end()) { q.push(up); s.insert(up.state_val()); } } if ((*current_wall)[curr.ninja_height - 1] != 'X' && curr.water_height < curr.ninja_height - 1) { state down; down.water_height = curr.water_height + 1; down.ninja_height = curr.ninja_height - 1; down.on_left_wall = curr.on_left_wall; if (s.find(down.state_val()) == s.end()) { q.push(down); s.insert(down.state_val()); } } if (curr.ninja_height + k > n - 1 || (*opposite_wall)[curr.ninja_height + k] != 'X') { state jump; jump.water_height = curr.water_height + 1; jump.ninja_height = curr.ninja_height + k; jump.on_left_wall = !curr.on_left_wall; if (s.find(jump.state_val()) == s.end()) { q.push(jump); s.insert(jump.state_val()); } } } } if (done) { cout << "YES"; } else { cout << "NO"; } cout << endl; } int main() { int n, k; cin >> n; cin >> k; cin.get(); bfs(n, k); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int MAX = 100000 + 10; bool mark[3][MAX]; int n, k; char a[3][MAX]; void BFS() { queue<pair<pair<int, int>, int> > q; q.push({{1, 1}, 0}); mark[1][1] = true; while (!q.empty()) { pair<pair<int, int>, int> cur = q.front(); q.pop(); int x = cur.first.first; int y = cur.first.second; int w = cur.second; int back = x; if (x == 2) { x = 0; } if (x + 1 > n || y + k > n) { cout << "YES\n"; exit(0); } if (a[x + 1][y + k] != 'X' && mark[x + 1][y + k] == false) { mark[x + 1][y + k] = true; q.push({{x + 1, y + k}, w + 1}); } x = back; if (a[x][y - 1] != 'X' && y - 1 > w + 1 && mark[x][y - 1] == false) { mark[x][y - 1] = true; q.push({{x, y - 1}, w + 1}); } if (y + 1 > n) { cout << "YES\n"; exit(0); } if (a[x][y + 1] != 'X' && mark[x][y + 1] == false) { mark[x][y + 1] = true; q.push({{x, y + 1}, w + 1}); } } } int main() { cin >> n >> k; for (int i = 1; i <= 2; i++) { string cur; cin >> cur; for (int j = 0; j < cur.size(); j++) { a[i][j + 1] = cur[j]; } } BFS(); cout << "NO\n"; }
8
CPP
#include <bits/stdc++.h> using namespace std; char wall[3][100005]; int N, K, visited[3][100005], d[3][100005]; int moveX[3][3], moveY[3][3], flag = 0; void bfs() { queue<pair<int, int>> Q; Q.push(make_pair(1, 1)); visited[1][1] = 1; d[1][1] = 0; while (!Q.empty()) { pair<int, int> p = Q.front(); Q.pop(); int x = p.first, y = p.second; for (int i = 0; i < 3; i++) { int xn = x + moveX[x][i]; int yn = y + moveY[x][i]; if (!visited[xn][yn]) { if (yn > N) flag = 1; else { if (d[x][y] + 1 < yn && wall[xn][yn] == '-') { Q.push(make_pair(xn, yn)); visited[xn][yn] = 1; d[xn][yn] = d[x][y] + 1; } } } } } } int main() { cin >> N >> K; for (int i = 1; i <= N; i++) cin >> wall[1][i]; for (int i = 1; i <= N; i++) cin >> wall[2][i]; moveX[1][0] = 1; moveX[1][1] = 0; moveX[1][2] = 0; moveY[1][0] = K; moveY[1][1] = 1; moveY[1][2] = -1; moveX[2][0] = -1; moveX[2][1] = 0; moveX[2][2] = 0; moveY[2][0] = K; moveY[2][1] = 1; moveY[2][2] = -1; memset(d, 100000000, sizeof(d)); bfs(); if (flag == 1) cout << "YES" << endl; else cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int nax = 1e6 + 5; char a[2][nax]; bool visited[2][nax]; bool path(int x, int y, int water_lvl) { return (y > (water_lvl) && a[x][y] != 'X'); } int main() { int n, k; cin >> n >> k; for (int i = 0; i < 2; i++) { for (int j = 1; j <= n; j++) { cin >> a[i][j]; } } queue<pair<int, pair<int, int>>> q; q.push(make_pair(0, make_pair(0, 1))); visited[0][1] = true; while (!q.empty()) { int cur_wall = q.front().second.first; int cur_h = q.front().second.second; int cur_w = q.front().first; if (cur_h >= n) { cout << "YES" << endl; return 0; } q.pop(); if (cur_wall == 0) { if (path(cur_wall, cur_h + 1, cur_w + 1) && !visited[cur_wall][cur_h + 1]) { q.push({cur_w + 1, {cur_wall, cur_h + 1}}); visited[cur_wall][cur_h + 1] = true; } if (path(cur_wall, cur_h - 1, cur_w + 1) && !visited[cur_wall][cur_h - 1]) { q.push({cur_w + 1, {cur_wall, cur_h - 1}}); visited[cur_wall][cur_h - 1] = true; } if (path(1, cur_h + k, cur_w + 1) && !visited[1][cur_h + k]) { q.push({cur_w + 1, {1, cur_h + k}}); visited[1][cur_h + k] = true; } } if (cur_wall == 1) { if (path(cur_wall, cur_h + 1, cur_w + 1) && !visited[cur_wall][cur_h + 1]) { q.push({cur_w + 1, {cur_wall, cur_h + 1}}); visited[cur_wall][cur_h + 1] = true; } if (path(cur_wall, cur_h - 1, cur_w + 1) && !visited[cur_wall][cur_h - 1]) { q.push({cur_w + 1, {cur_wall, cur_h - 1}}); visited[cur_wall][cur_h - 1] = true; } if (path(0, cur_h + k, cur_w + 1) && !visited[0][cur_h + k]) { q.push({cur_w + 1, {0, cur_h + k}}); visited[0][cur_h + k] = true; } } } cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int MAX = 1e6; char a[MAX], b[MAX]; int v[2][MAX]; int n, m; int dfs(int tag, int k, int h) { if (k <= h || k <= 0) return 0; if (k > n) return 1; if (tag == 0 && a[k] == 'X') return 0; if (tag == 1 && b[k] == 'X') return 0; if (v[tag][k]) return 0; v[tag][k] = 1; if (dfs(tag ^ 1, k + m, h + 1)) return 1; if (dfs(tag, k + 1, h + 1)) return 1; if (dfs(tag, k - 1, h + 1)) return 1; return 0; } int main() { cin >> n >> m; scanf("%s%s", a + 1, b + 1); memset(v, 0, sizeof v); puts(dfs(0, 1, 0) ? "YES" : "NO"); 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][y + k] == '-') && (d[x ^ 1][y + k] > (d[x][y] + 1))) { d[x ^ 1][y + k] = d[x][y] + 1; whi.push(x ^ 1); high.push(y + k); } } puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; vector<pair<int, int> > V[2][100005]; int main() { int n, k; scanf("%d %d", &n, &k); char a[100005], b[100005]; scanf("%s", a); scanf("%s", b); for (int i = 0; i < n; i++) { if (a[i] != 'X') { if (i > 0) { if (a[i - 1] != 'X') V[0][i + 1].push_back(make_pair(0, i)); } if (i + k < n) { if (b[i + k] != 'X') V[0][i + 1].push_back(make_pair(1, i + k + 1)); } else V[0][i + 1].push_back(make_pair(1, n + 1)); if (i + 1 < n && a[i + 1] != 'X') V[0][i + 1].push_back(make_pair(0, i + 2)); else if (i + 1 >= n) V[0][i + 1].push_back(make_pair(0, i + 2)); } if (b[i] != 'X') { if (i > 0) { if (b[i - 1] != 'X') V[1][i + 1].push_back(make_pair(1, i)); } if (i + k < n) { if (a[i + k] != 'X') V[1][i + 1].push_back(make_pair(0, i + k + 1)); } else V[1][i + 1].push_back(make_pair(0, n + 1)); if (i + 1 < n && b[i + 1] != 'X') V[1][i + 1].push_back(make_pair(1, i + 2)); else if (i + 1 >= n) V[1][i + 1].push_back(make_pair(1, i + 2)); } } queue<pair<pair<int, int>, int> > bfs; bool passed[2][100005]; for (int i = 0; i < 2; i++) memset(passed[i], false, sizeof(passed[i])); int sz = V[0][1].size(); passed[0][1] = true; for (int i = 0; i < sz; i++) { bfs.push(make_pair(V[0][1][i], 1)); } while (!bfs.empty()) { int type = bfs.front().first.first, stop = bfs.front().first.second, depth = bfs.front().second; if (stop <= depth || passed[type][stop]) { bfs.pop(); continue; } if (stop >= n) { printf("YES"); return 0; } bfs.pop(); int siz = V[type][stop].size(); passed[type][stop] = true; for (int i = 0; i < siz; i++) { bfs.push(make_pair(V[type][stop][i], depth + 1)); } } printf("NO"); }
8
CPP
#include <bits/stdc++.h> using namespace std; bool debug = false; int n, m, k; int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; char w[2][100005]; int v[2][100005]; void dfs(int wall, int pos, int water) { if (n < pos + k) { puts("YES"); exit(0); } if (v[wall][pos]) return; v[wall][pos] = 1; if (w[1 - wall][pos + k] == '-') dfs(1 - wall, pos + k, water + 1); if (pos - water > 2 && w[wall][pos - 1] == '-') dfs(wall, pos - 1, water + 1); if (w[wall][pos + 1] == '-') dfs(wall, pos + 1, water + 1); } int main() { scanf("%d%d%s%s", &n, &k, w[0] + 1, w[1] + 1); dfs(0, 1, 0); puts("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, vis[2][100005], water; char a[2][100005]; queue<pair<int, int> > q; int main() { cin >> n >> k; for (int i = 0; i < 2; i++) { getchar(); for (int j = 1; j <= n; j++) cin >> a[i][j]; } q.push(make_pair(0, 1)); vis[0][1] = 1; while (!q.empty()) { pair<int, int> tmp = q.front(); q.pop(); int x = tmp.first; int y = tmp.second; if ((y + k) > n) { cout << "YES"; return 0; } if (!vis[x][y + 1] && a[x][y + 1] == '-') { q.push(make_pair(x, y + 1)); vis[x][y + 1] = vis[x][y] + 1; } if (!vis[1 - x][y + k] && a[1 - x][y + k] == '-') { q.push(make_pair(1 - x, y + k)); vis[1 - x][y + k] = vis[x][y] + 1; } if (y > 1 && !vis[x][y - 1] && vis[x][y] + 1 < y && a[x][y - 1] == '-') { q.push(make_pair(x, y - 1)); vis[x][y - 1] = vis[x][y] + 1; } } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int SIZET = 1e5 + 10; int water = -1; char input[2][SIZET]; bool used[2][SIZET]; int n, k; bool dfs(int i, int j) { if (j > n) { return 1; } if (input[i][j] == 'X' || water >= j || used[i][j]) { return 0; } used[i][j] = 1; water++; bool ret = dfs(1 - i, j + k) || dfs(i, j + 1) || dfs(i, j - 1); water--; return ret; } int main(int argc, char const *Argv[]) { cin >> n >> k; for (int i = 0; i < 2; ++i) { for (int j = 0; j < n; ++j) { cin >> input[i][j]; } } if (dfs(0, 0)) { cout << "YES" << endl; } else { cout << "NO" << endl; } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace ::std; const long double PI = acos(-1); const long long MOD = 1000000000 + 7; long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } long long add(long long a, long long b, long long m = MOD) { return (a % m + b % m + 2 * m) % m; } long long mul(long long a, long long b, long long m = MOD) { return ((a % m + m) * (b % m + m)) % m; } long long pow_mod(long long a, long long b, long long m = MOD) { long long res = 1LL; a = a % m; while (b) { if (b & 1) res = mul(res, a, m); b >>= 1; a = mul(a, a, m); } return res; } long long fastexp(long long a, long long b) { long long res = 1LL; while (b) { if (b & 1) res = res * a; b >>= 1; a *= a; } return res; } int gcdExtendido(int a, int b, int *x, int *y) { if (a == 0) { *x = 0; *y = 1; return b; } int x1, y1; int gcd = gcdExtendido(b % a, a, &x1, &y1); *x = y1 - (b / a) * x1; *y = x1; return gcd; } int modInverso(int a, int m) { int x, y; int g = gcdExtendido(a, m, &x, &y); if (g != 1) return -1; else return (x % m + m) % m; } const int N = 100000 + 5; int n, k; int D[3][N]; char table[3][N]; int dx[4] = {0, 0, 1, -1}; int dy[4] = {1, -1, 0, 0}; bool validPos(int i, int j) { return i >= 0 and i < 2 and j >= 0 and j < n; } bool BFS(int sx, int sy) { for (int i = 0; i < 2; i++) { for (int j = 0; j <= n; j++) { D[i][j] = INT_MAX; } } D[sx][sy] = 0; queue<int> Q; Q.push(sx); Q.push(sy); while (!Q.empty()) { int ux = Q.front(); Q.pop(); int uy = Q.front(); Q.pop(); int T = D[ux][uy]; for (int l = 0; l < 4; l++) { int vx = ux + dx[l]; int vy = uy + dy[l]; if (validPos(vx, vy) and table[vx][vy] != 'X' and vy >= T + 1) { if (D[vx][vy] > D[ux][uy] + 1) { D[vx][vy] = D[ux][uy] + 1; Q.push(vx); Q.push(vy); } } else if (vy >= n) { return true; } } } return false; } int main() { scanf("%d %d", &(n), &(k)); dy[2] = dy[3] = k; for (int i = 0; i < 2; i++) { scanf("%s", table[i]); } puts(BFS(0, 0) ? "YES" : "NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; struct pos { int wall, area; }; string s[2]; int n, k; bool safe(const pos& P, int t) { return t <= P.area && s[P.wall][P.area] == '-'; } const int MAXN = 100 * 1000 + 9; int min_time[2][MAXN]; int& get(const pos& P) { return min_time[P.wall][P.area]; } const int INF = 1000 * 1000 * 10; bool possible(void) { for (int j = 0; j < 2; j++) { for (int i = 0; i < n; i++) min_time[j][i] = INF; } pos seed; seed.wall = 0; seed.area = 0; get(seed) = 0; queue<pos> all; all.push(seed); while (!all.empty()) { seed = all.front(); all.pop(); int new_t = get(seed) + 1; pos nova; nova = seed; nova.area--; if (nova.area >= n) return true; if (safe(nova, new_t) && get(nova) > new_t) { get(nova) = new_t; all.push(nova); } nova = seed; nova.area++; if (nova.area >= n) return true; if (safe(nova, new_t) && get(nova) > new_t) { get(nova) = new_t; all.push(nova); } nova = seed; nova.wall = 1 - nova.wall; nova.area += k; if (nova.area >= n) return true; if (safe(nova, new_t) && get(nova) > new_t) { get(nova) = new_t; all.push(nova); } } return false; } int main() { cin >> n >> k; cin >> s[0]; cin >> s[1]; if (possible()) cout << "YES"; else cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 100; int k, n; int a[5][N]; vector<pair<int, int> > vec[5][N]; queue<pair<int, int> > q; int dis[5][N]; bool mark[5][N]; int main() { cin >> n >> k; for (int i = 1; i <= 2; i++) { for (int j = 1; j <= n; j++) { char c; cin >> c; if (c == '-') a[i][j] = true; } } for (int i = 1; i <= 2; i++) { for (int j = n + 1; j < N; j++) { a[i][j] = true; } } for (int i = 1; i <= 2; i++) for (int j = 1; j <= n; j++) { if (a[i][j + 1] == 1) vec[i][j].push_back(make_pair(i, j + 1)); if (a[i][j - 1] == 1) vec[i][j].push_back(make_pair(i, j - 1)); if (a[i + 1][j + k] == 1) vec[i][j].push_back(make_pair(i + 1, j + k)); if (a[i - 1][j + k] == 1) vec[i][j].push_back(make_pair(i - 1, j + k)); } q.push(make_pair(1, 1)); mark[1][1] = true; while (q.size() > 0) { int x = q.front().first, y = q.front().second; if (y >= n) { cout << "YES"; exit(0); } if (dis[x][y] < y) { for (int i = 0; i < vec[x][y].size(); i++) { int xx = vec[x][y][i].first, yy = vec[x][y][i].second; if (mark[xx][yy] == false) { mark[xx][yy] = true; q.push(make_pair(xx, yy)); dis[xx][yy] = dis[x][y] + 1; } } } q.pop(); } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; string w[2]; int n, k; bool vis[2][100050]; bool dfs(int i, int j, int t) { if (j <= t || j < 0) { return false; } if (j >= n) { return true; } if (w[i][j] != '-') { return false; } if (vis[i][j]) { return false; } vis[i][j] = true; return max(max(dfs(i, j + 1, t + 1), dfs(i, j - 1, t + 1)), dfs(1 - i, j + k, t + 1)); } int main() { cin >> n >> k >> w[0] >> w[1]; if (dfs(0, 0, -1)) { cout << "YES" << endl; } else { cout << "NO" << endl; } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; queue<pair<int, int> > q; int a[100005], b[100005], chk1[100005], chk2[100005]; int main() { int n, k; char c; scanf("%d%d", &n, &k); for (int i = 1; i <= n; i++) { do { scanf("%c", &c); } while (c == ' ' || c == '\n'); if (c == '-') a[i] = 0; else a[i] = 1; } for (int i = 1; i <= n; i++) { do { scanf("%c", &c); } while (c == ' ' || c == '\n'); if (c == '-') b[i] = 0; else b[i] = 1; } int now, flood, chk = 0; pair<int, int> dmp, pdmp; chk1[1] = 1; chk2[1] = 1; dmp.first = 1; dmp.second = 0; q.push(dmp); dmp.first = -1; dmp.second = 0; while (!q.empty()) { dmp = q.front(); q.pop(); chk = 1; if (dmp.first < 0) { chk = 2; dmp.first = -dmp.first; } now = dmp.first; flood = dmp.second; dmp.second = flood + 1; if (now + k > n) { printf("YES"); return 0; } if (chk == 1) { if (a[now + 1] == 0 && !chk1[now + 1]) { chk1[now + 1] = 1; dmp.first = now + 1; q.push(dmp); } if (now != 0) { if (a[now - 1] == 0 && flood + 1 < now && !chk1[now - 1]) { chk1[now - 1] = 1; dmp.first = now - 1; q.push(dmp); } } if (b[now + k] == 0 && !chk2[now + k]) { chk2[now + k] = 1; dmp.first = -(now + k); q.push(dmp); } } else { if (b[now + 1] == 0 && !chk2[now + 1]) { chk2[now + 1] = 1; dmp.first = -(now + 1); q.push(dmp); } if (now != 0) { if (b[now - 1] == 0 && flood + 1 < now - 1 && !chk2[now - 1]) { chk2[now - 1] = 1; dmp.first = -(now - 1); q.push(dmp); } } if (a[now + k] == 0 && !chk1[now + k]) { chk1[now + k] = 1; dmp.first = (now + k); q.push(dmp); } } } printf("NO"); }
8
CPP
#include <bits/stdc++.h> using namespace std; long long n; const int N = 1e5 + 5; char a[N][2]; long long vis[N][2]; bool valid(long long x, long long y) { return (x >= 1 && x <= n && y >= 0 && y <= 1 && a[x][y] == '-' && vis[x][y] == 0); } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t = 1; while (t--) { int k; cin >> n >> k; string s, t; cin >> s >> t; for (int i = 1; i <= n; i++) { a[i][0] = s[i - 1]; a[i][1] = t[i - 1]; } if (n == 1) { cout << "YES"; return 0; } priority_queue<pair<long long, pair<long long, long long>>, vector<pair<long long, pair<long long, long long>>>, greater<pair<long long, pair<long long, long long>>>> pq; pq.push({1, {1, 0}}); int f = 0; while (!pq.empty()) { long long t = pq.top().first; long long x = pq.top().second.first; long long y = pq.top().second.second; pq.pop(); if (vis[x][y]) continue; if (t > x) { vis[x][y] = 1; continue; } vis[x][y] = 1; if (x >= n) { f = 1; break; } if (t >= n) { f = -1; break; } if (valid(x - 1, y)) { pq.push({t + 1, {x - 1, y}}); } if (valid(x + 1, y)) { pq.push({t + 1, {x + 1, y}}); } if (x + k > n || x + 1 > n) { cout << "YES"; return 0; } if (valid(x + k, !y)) { pq.push({t + 1, {x + k, !y}}); } } if (f) cout << "YES"; else cout << "NO"; } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; char str[2][100001]; int mark[2][100001]; int go[3][2] = {{0, 1}, {0, -1}, {1, 0}}; struct st { int x, y, time; }; queue<st> q; int bfs() { st cur; cur.x = 0; cur.y = 0; cur.time = 0; q.push(cur); while (!q.empty()) { cur = q.front(); q.pop(); st nt; for (int i = 0; i < 3; i++) { nt.x = (cur.x + go[i][0]) & 1; nt.y = cur.y + go[i][1]; nt.time = cur.time + 1; if (nt.y < nt.time) continue; if (nt.y >= n) return puts("YES"); if (!mark[nt.x][nt.y]) { mark[nt.x][nt.y] = 1; if (str[nt.x][nt.y] == '-') q.push(nt); } } } return puts("NO"); } int main() { scanf("%d%d", &n, &k); go[2][1] = k; scanf("%s%s", &str[0], &str[1]); if (k >= n) puts("YES"); else bfs(); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; template <class T> inline void umax(T &a, T b) { if (a < b) a = b; } const int maxn = 300000 + 10; const int INF = 1e9 + 7; bool dp[maxn][2], visit[maxn][3]; string str[2]; int n, k; int f = 0; bool dfs(int pos, int idx, int t) { if (pos <= 0) return false; if (pos > n) { f = 1; cout << "YES"; exit(!printf("\n")); return true; } if (t >= pos) return false; if (str[idx][pos - 1] == 'X') return false; if (dp[pos][idx]) return dp[pos][idx]; bool t1 = dfs(pos + k, !idx, t + 1); bool t2 = dfs(pos + 1, idx, t + 1); bool t3 = dfs(pos - 1, idx, t + 1); if (t1 == false && t2 == false && t3 == false) { dp[pos][idx] = false; return false; } dp[pos][idx] = true; return true; } inline void solve(void) { cin >> n >> k; cin >> str[0] >> str[1]; queue<pair<pair<int, int>, int> > v; v.push(pair<pair<int, int>, int>(pair<int, int>(1, 0), 0)); while (!v.empty()) { pair<pair<int, int>, int> f = v.front(); v.pop(); int pos = f.first.first, idx = f.first.second, t = f.second; if (pos <= 0) continue; if (pos > n) { cout << "YES\n"; return; } if (t >= pos || str[idx][pos - 1] == 'X') continue; if (dp[pos][idx]) continue; if (!visit[pos + k][!idx]) { v.push(pair<pair<int, int>, int>(pair<int, int>(pos + k, !idx), t + 1)); visit[pos + k][!idx] = true; } if (!visit[pos + 1][idx]) { v.push(pair<pair<int, int>, int>(pair<int, int>(pos + 1, idx), t + 1)); visit[pos + 1][idx] = true; } if (!visit[pos - 1][idx]) { v.push(pair<pair<int, int>, int>(pair<int, int>(pos - 1, idx), t + 1)); visit[pos - 1][idx] = true; } } cout << "NO\n"; } void init() { ios::sync_with_stdio(false); cin.tie(nullptr); } int main(int argc, const char *argv[]) { solve(); return 0; }
8
CPP
#include <bits/stdc++.h> template <class T> T sqr(T x) { return x * x; } template <class T> T lcm(T a, T b) { return a / __gcd(a, b) * b; } template <class T> T minimize(T &a, T b) { if (a > b) { a = b; return true; } return false; } template <class T> T maximize(T &a, T b) { if (a < b) { a = b; return true; } return false; } const long long mod = 1e9 + 7, oo = 1e12, N = 2e5 + 5; using namespace std; long long n, k; char str[2][N]; bool color[2][N], flag = false; void dfs(long long x, long long y, long long water) { if (y < water || str[x][y] == 'X' || color[x][y] == true || flag == true) return; if (y >= n) { flag = true; return; } color[x][y] = true; dfs((x + 1) % 2, y + k, water + 1); dfs(x, y + 1, water + 1); dfs(x, y - 1, water + 1); } signed main() { ios_base::sync_with_stdio(0); cin.tie(); cout.tie(); cin >> n >> k >> str[0] >> str[1]; dfs(0, 0, 0); flag == true ? cout << "YES\n" : cout << "NO\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; long long n, m, k, dp[2][100010]; char ch[2][100010]; struct node { int pos, kd, t; node(int p = 0, int k = 0, int tt = 0) : pos(p), kd(k), t(tt) {} }; int main() { while (cin >> n >> k) { scanf("%s%s", ch[0], ch[1]); memset(dp, 0x3f3f3f3f, sizeof dp); dp[0][0] = 0; bool ans = false; queue<node> q; q.push(node(0, 0, 0)); int kd, h, t; while (!q.empty()) { node now = q.front(); q.pop(); h = now.pos; kd = now.kd; t = now.t; if (h >= n) { ans = true; break; } if (ch[kd][h + 1] == '-' && dp[kd][h + 1] > t + 1) { dp[kd][h + 1] = t + 1; q.push(node(h + 1, kd, t + 1)); } if (h > 0 && ch[kd][h - 1] == '-' && dp[kd][h - 1] > t + 1 && h - 1 >= t + 1) { dp[kd][h - 1] = t + 1; q.push(node(h - 1, kd, t + 1)); } if (k + h >= n) { ans = true; break; } if (ch[kd ^ 1][h + k] == '-' && dp[kd ^ 1][h + k] > t + 1) { dp[kd ^ 1][h + k] = t + 1; q.push(node(h + k, kd ^ 1, t + 1)); } } if (ans) puts("YES"); else puts("NO"); } }
8
CPP
#include <bits/stdc++.h> using namespace std; long long int vis[100005][2]; string s1, s2; long long int n, k; long long int ans = 0; void dfs(long long int i, long long int f, long long int w) { if (ans == 1) return; if (i > n) { ans = 1; return; } if (i < w) return; if (f == 1) { if (s2[i] == 'X') return; } else { if (s1[i] == 'X') return; } if (vis[i][f]) return; vis[i][f] = 1; dfs(i - 1, f, w + 1); dfs(i + k, 1 - f, w + 1); dfs(i + 1, f, w + 1); } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> k; cin >> s1 >> s2; dfs(0, 0, 0); if (ans) cout << "YES"; else cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const long double pi = 3.14159265359; template <typename T> T abs(T x) { return x > 0 ? x : -x; } template <typename T> T sqr(T x) { return x * x; } template <typename T> void chmin(T &x, T y) { x = min(x, y); } template <typename T> void chmax(T &x, T y) { x = max(x, y); } template <typename U, typename V> ostream &operator<<(ostream &s, const pair<U, V> &x) { s << "(" << x.first << ", " << x.second << ")"; return s; } template <typename U> ostream &operator<<(ostream &s, const vector<U> &x) { s << "["; bool was = false; for (auto it : x) { if (was) { s << ", "; } was = true; s << it; } s << "]"; return s; } const int maxn = 1e5 + 5; const int inf = 1e9; char a[2][maxn]; int d[2][maxn]; int main() { srand(time(NULL)); retry: int n, k; scanf("%d %d\n", &n, &k); scanf("%s\n", a[0] + 1); scanf("%s\n", a[1] + 1); queue<pair<int, int>> q; q.push(make_pair(0, 1)); fill(d[0], d[0] + maxn, inf); fill(d[1], d[1] + maxn, inf); d[0][1] = 0; auto yes = []() { cout << "YES" << endl; exit(0); }; while (!q.empty()) { int s = q.front().first; int v = q.front().second; q.pop(); if (v + k > n) { yes(); } if (a[s][v + 1] == '-' && d[s][v + 1] == inf) { d[s][v + 1] = d[s][v] + 1; q.push(make_pair(s, v + 1)); } if (v - 1 > 0 && a[s][v - 1] == '-' && v - 1 > d[s][v] + 1 && d[s][v - 1] == inf) { d[s][v - 1] = d[s][v] + 1; q.push(make_pair(s, v - 1)); } if (a[1 - s][v + k] == '-' && d[1 - s][v + k] == inf) { d[1 - s][v + k] = d[s][v] + 1; q.push(make_pair(1 - s, v + k)); } } cout << "NO" << endl; return 0; }
8
CPP
#include <bits/stdc++.h> #pragma comment(linker, "/STACK:128777216") using namespace std; bool d[2][200000]; char a[100010]; char b[100010]; struct Pos { int id; int pos; int t; void init(int id, int pos, int t) { this->id = id; this->pos = pos; this->t = t; d[id][pos] = 1; } } st[300000]; int main() { int n, k; scanf("%d %d", &n, &k); scanf("%s", a); scanf("%s", b); for (int i = 0; i < n; i++) { if (a[i] == 'X') { d[0][i] = 1; } if (b[i] == 'X') { d[1][i] = 1; } } st[0].init(0, 0, 0); for (int d = 0, u = 1; d < u; d++) { int id = st[d].id, pos = st[d].pos, t = st[d].t + 1; if (pos < st[d].t) continue; if (pos + k >= n) { printf("YES"); return 0; } if (pos > 0 && !::d[id][pos - 1]) { st[u++].init(id, pos - 1, t); } if (!::d[id][pos + 1]) { st[u++].init(id, pos + 1, t); } if (!::d[id ^ 1][pos + k]) { st[u++].init(id ^ 1, pos + k, t); } } printf("NO"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1); map<long long, list<long long>> m; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t = 1; while (t--) { long long n, k; cin >> n >> k; string a[2]; cin >> a[0] >> a[1]; for (long long i = 0; i < k; i++) { a[0] += '-'; a[1] += '-'; } list<pair<pair<long long, long long>, long long>> q; long long w = -1, c = 0; q.push_back({{0, 0}, w}); long long v[2][n + k]; memset(v, 0, sizeof(v)); while (!q.empty()) { pair<pair<long long, long long>, long long> te = q.front(); q.pop_front(); if (te.first.second >= n) { cout << "YES" << endl; return 0; } if (!v[1 - te.first.first][te.first.second + k] && te.first.second + k > te.second + 1 && a[1 - te.first.first][te.first.second + k] == '-') { q.push_back({{1 - te.first.first, te.first.second + k}, te.second + 1}); v[1 - te.first.first][te.first.second + k] = 1; } if (!v[te.first.first][te.first.second + 1] && te.first.second + 1 > te.second + 1 && a[te.first.first][te.first.second + 1] == '-') { q.push_back({{te.first.first, te.first.second + 1}, te.second + 1}); v[te.first.first][te.first.second + 1] = 1; } if (!v[te.first.first][te.first.second - 1] && te.first.second - 1 > te.second + 1 && te.first.second > 0 && a[te.first.first][te.first.second - 1] == '-') { q.push_back({{te.first.first, te.first.second - 1}, te.second + 1}); v[te.first.first][te.first.second + 1] = 1; } } cout << "NO" << endl; } }
8
CPP
#include <bits/stdc++.h> using namespace std; struct node { int x, y, s; }; char a[5][500005]; int book[5][500005]; int main() { int n, k; cin >> n >> k; queue<node> q; node now, next; for (int i = 1; i <= 2; i++) scanf("%s", a[i] + 1); int p = 0; now.x = 1; now.y = 1; now.s = 0; q.push(now); book[1][1] = 1; int flag = 0; while (!q.empty()) { now = q.front(); int tx, ty; for (int i = 0; i < 3; i++) { if (i == 0) { tx = now.x; ty = now.y + 1; } if (i == 1) { tx = now.x; ty = now.y - 1; } if (i == 2) { if (now.x == 1) tx = 2; else tx = 1; ty = now.y + k; } if (ty > n) { flag = 1; break; } if (book[tx][ty] == 1 || a[tx][ty] == 'X' || ty <= now.s + 1 || tx < 1) continue; if (book[tx][ty] == 0) { book[tx][ty] = 1; next.x = tx; next.y = ty; next.s = now.s + 1; q.push(next); } } p++; q.pop(); if (flag) break; } if (flag) cout << "YES" << endl; else cout << "NO" << endl; }
8
CPP
#include <bits/stdc++.h> using namespace std; double PI = acos(-1); int n, k; char grid[2][100005]; bool vis[2][100005]; bool sol = 0; bool valid(int x, int y) { if (y < 0 || y > n - 1) return 0; return 1; } void solve(int x, int y, int w) { vis[x][y] = 1; if (w >= y) return; if (y + k >= n) sol = 1; if (valid(1 - x, y + k)) { if (!vis[1 - x][y + k] && grid[1 - x][y + k] == '-') solve(1 - x, y + k, w + 1); } if (valid(x, y + 1)) { if (!vis[x][y + 1] && grid[x][y + 1] == '-') solve(x, y + 1, w + 1); } if (valid(x, y - 1)) { if (!vis[x][y - 1] && grid[x][y - 1] == '-') solve(x, y - 1, w + 1); } } int main() { cin >> n >> k; for (int i = 0; i < 2; i++) { for (int j = 0; j < n; j++) cin >> grid[i][j]; } solve(0, 0, -1); if (sol) cout << "YES\n"; else cout << "NO\n"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k; char s[2][210000]; int d[2][210000]; bool bfs() { memset(d, -1, sizeof(d)); int dx[3] = {0, 0, 1}, dy[3] = {1, -1, k}; queue<int> q; d[0][1] = 1; q.push(0); q.push(1); while (!q.empty()) { int x = q.front(); q.pop(); int y = q.front(); q.pop(); if (y > n) return true; for (int i = 0; i < 3; i++) { int nex = x ^ dx[i], ney = y + dy[i]; if (s[nex][ney] == 'X') continue; if (d[nex][ney] != -1) continue; if (d[x][y] + 1 > ney) continue; d[nex][ney] = d[x][y] + 1; q.push(nex); q.push(ney); } } return false; } int main() { scanf("%d%d", &n, &k); memset(d, 0, sizeof(d)); scanf("%s%s", &s[0][1], &s[1][1]); if (bfs()) printf("YES\n"); else printf("NO\n"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, g; char s[2][100005]; int t[2][100005]; struct Node { int k, w; Node(int x, int y) { k = x, w = y; } }; queue<Node> que; int main() { scanf("%d%d%s%s", &n, &g, s[0], s[1]); que.push(Node(0, 0)); memset(t, -1, sizeof(t)); t[0][0] = 0; bool ans = false; while (!que.empty()) { int k = que.front().k, w = que.front().w; que.pop(); if (w + g >= n) { ans = true; break; } if (t[k][w + 1] == -1) { t[k][w + 1] = t[k][w] + 1; if (w + 1 >= t[k][w + 1] && s[k][w + 1] == '-') que.push(Node(k, w + 1)); } if (t[k][w - 1] == -1) { t[k][w - 1] = t[k][w] + 1; if (w - 1 >= t[k][w - 1] && s[k][w - 1] == '-') que.push(Node(k, w - 1)); } if (t[k ^ 1][w + g] == -1) { t[k ^ 1][w + g] = t[k][w] + 1; if (w + g >= t[k ^ 1][w + g] && s[k ^ 1][w + g] == '-') que.push(Node(k ^ 1, w + g)); } } printf(ans ? "YES\n" : "NO\n"); return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, m, d[2][1000000]; bool ans, vis[2][1000000]; void dfs(int j, int i, int water) { if (water >= i) { return; } if (i >= n) { ans = 1; return; } vis[j][i] = 1; if (d[j][i - 1] != 0 && vis[j][i - 1] == 0) dfs(j, i - 1, water + 1); if (i + m >= n || (d[1 - j][i + m] != 0 && vis[1 - j][i + m] == 0)) dfs(1 - j, i + m, water + 1); if (i + 1 >= n || (d[j][i + 1] != 0 && vis[j][i + 1] == 0)) dfs(j, i + 1, water + 1); return; } int main() { char z; cin >> n >> m; for (int i = 0; i < 2; i++) for (int j = 0; j < n; j++) { cin >> z; if (z == '-') d[i][j] = 1; else d[i][j] = 0; } dfs(0, 0, -1); if (ans) cout << "YES"; else cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; struct Counter { static int k; Counter() { k++; } ~Counter() { k--; } }; int Counter::k = 0; template <typename T> void pr(const string& name, T t) { cout << name << " = " << t << endl; } template <typename T, typename... Types> void pr(const string& names, T t, Types... rest) { auto comma_pos = names.find(','); cout << names.substr(0, comma_pos) << " = " << t << ", "; auto next_name_pos = names.find_first_not_of(" \t\n", comma_pos + 1); pr(string(names, next_name_pos), rest...); } void mod(long long& a, long long b) { a %= b; if (a < 0) a += b; } const long long MOD = 1000000007; const int INF = 1000005; int D[1000005], N, K; priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Q; string W[2]; int main() { cin >> N >> K; cin >> W[0] >> W[1]; for (int i = (0); i <= (2 * N); i++) D[i] = INF; D[0] = 0; Q.push({0, 0}); while (!Q.empty()) { pair<int, int> p = Q.top(); Q.pop(); int w = p.second / N; int h = p.second % N; int d = p.first; if (h > 0 && W[w][h - 1] == '-' && d + 1 < D[N * w + h - 1] && h - 1 >= d + 1) { D[N * w + h - 1] = d + 1; Q.push({d + 1, N * w + h - 1}); } if (h < N - 1 && W[w][h + 1] == '-' && d + 1 < D[N * w + h + 1]) { D[N * w + h + 1] = d + 1; Q.push({d + 1, N * w + h + 1}); } if (h <= N - 1 - K && W[1 - w][h + K] == '-' && d + 1 < D[N * (1 - w) + h + K]) { D[N * (1 - w) + h + K] = d + 1; Q.push({d + 1, N * (1 - w) + h + K}); } } for (int i = (N - K); i <= (N - 1); i++) if (D[i] < INF || D[N + i] < INF) { cout << "YES"; return 0; } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; int readint() { char c; while (c = getchar(), (c < '0' || c > '9') && c != '-') ; bool flag = (c == '-'); if (flag) c = getchar(); int x = 0; while (c >= '0' && c <= '9') { x = x * 10 + c - 48; c = getchar(); } return flag ? -x : x; } inline string tos(int x) { string s; while (x) s = (char)(x % 10 + '0') + s, x /= 10; return s; } queue<int> qx, qy, qz; char c[2][100005]; bool use[2][100005]; int main() { ios_base::sync_with_stdio(false); int n, k, i, j, x, y, z; cin >> n >> k; for (i = 1; i <= n; i++) cin >> c[0][i]; for (i = 1; i <= n; i++) cin >> c[1][i]; qz.push(0); qx.push(0); qy.push(1); while (!qx.empty()) { z = qz.front(); x = qx.front(); y = qy.front(); qz.pop(); qx.pop(); qy.pop(); if (y > n) { cout << "YES"; return 0; } if (use[x][y]) continue; if (c[x][y] == 'X') continue; if (z >= y) continue; use[x][y] = 1; qz.push(z + 1); qy.push(y + k); qx.push(1 - x); qz.push(z + 1); qy.push(y + 1); qx.push(x); qz.push(z + 1); qx.push(x); qy.push(y - 1); } cout << "NO"; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; const int MAXN = 100010; int n, k; vector<int> adj[MAXN]; char s[2][MAXN]; int dist[2][MAXN]; bool solve() { memset(dist, 0x3f3f3f3f, sizeof(dist)); dist[0][1] = 0; queue<pair<int, pair<int, int> > > pq; pq.push({0, {0, 1}}); while (!pq.empty()) { int d = pq.front().first; int side = pq.front().second.first; int h = pq.front().second.second; pq.pop(); if (dist[side][h] == d) { for (auto op : vector<pair<int, int> >( {{h - 1, side}, {h + 1, side}, {h + k, 1 - side}})) { int nh = op.first; int opside = op.second; if (nh < 1) continue; if (nh > n) return true; if (s[opside][nh] != 'X' && dist[opside][nh] > d + 1 && nh > d + 1) { dist[opside][nh] = d + 1; pq.push({dist[opside][nh], {opside, nh}}); } } } } return false; } int main() { ios::sync_with_stdio(false); cin >> n >> k; for (int i = 0; i < (2); ++i) for (int j = 1; j < (n + 1); ++j) cin >> s[i][j]; cout << (solve() ? "YES" : "NO") << endl; return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, xx; char a[2][201005]; int vis[2][201005]; int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}; struct node { int x, y, cnt; }; bool judge(int x, int y) { if (x >= 0 && x < 2 && y >= 0) return true; return false; } void bfs(node f) { queue<node> q; q.push(f); memset(vis, 0, sizeof(vis)); vis[f.x][f.y] = 1; while (!q.empty()) { node t = q.front(); q.pop(); if (t.y >= n - 1) { cout << "YES" << endl; return; } for (int i = 0; i < 4; i++) { node p; p.cnt = t.cnt + 1; if (i == 0 || i == 1) { p.x = t.x + dir[i][0]; p.y = t.y + dir[i][1] + k; } else { p.x = t.x + dir[i][0]; p.y = t.y + dir[i][1]; } if (p.cnt >= p.y) { continue; } if (judge(p.x, p.y) && a[p.x][p.y] != 'X' && !vis[p.x][p.y]) { vis[p.x][p.y] = 1; q.push(p); } } } cout << "NO" << endl; } int main() { while (~scanf("%d %d", &n, &k)) { memset(a, 0, sizeof(a)); for (int i = 0; i < 2; i++) for (int j = 0; j < n; j++) cin >> a[i][j]; node f; f.x = 0; f.y = 0; f.cnt = -1; bfs(f); } return 0; }
8
CPP
#include <bits/stdc++.h> using namespace std; struct hz { int t; int p; bool ix; hz(int t, int p, int ix) : t(t), p(p), ix(ix) {} }; int was[2][100011]; int n, k; string w[2]; #pragma comment(linker, "/STACK:1234567890") int main() { cin >> n >> k >> w[0] >> w[1]; queue<hz> q; q.push(hz(0, 0, 0)); memset(was, false, sizeof(was)); while (!q.empty()) { hz s = q.front(); q.pop(); if (was[s.ix][s.p]) continue; was[s.ix][s.p] = true; if (s.p + 1 >= n || s.p + k >= n) { cout << "YES"; return 0; } if (!was[s.ix ^ 1][s.p + k] && w[s.ix ^ 1][s.p + k] != 'X') { q.push(hz(s.t + 1, s.p + k, s.ix ^ 1)); } if (!was[s.ix][s.p + 1] && w[s.ix][s.p + 1] != 'X') { q.push(hz(s.t + 1, s.p + 1, s.ix)); } if (s.p - 1 > s.t && !was[s.ix ^ 1][s.p + k] && w[s.ix][s.p - 1] != 'X') { q.push(hz(s.t + 1, s.p - 1, s.ix)); } } cout << "NO"; }
8
CPP
#include <bits/stdc++.h> using namespace std; int n, k, distence[2][100010], ans; char s[2][100010]; queue<pair<int, int> > q; void bfs(int x, int y, int dis) { if (y > n) { cout << "YES" << endl; exit(0); }; if (s[x][y] != 'X' && !distence[x][y] && y >= 0) { distence[x][y] = dis; if (dis <= y) q.push(pair<int, int>(x, y)); } } int main() { cin >> n >> k; cin >> s[0]; cin >> s[1]; bfs(0, 0, 0); while (!q.empty()) { int x = q.front().first; int y = q.front().second; q.pop(); int dis = distence[x][y] + 1; if (x == 0) bfs(x + 1, y + k, dis); else bfs(x - 1, y + k, dis); bfs(x, y + 1, dis); bfs(x, y - 1, dis); } cout << "NO" << endl; return 0; }
8
CPP