text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
struct state {
int a, b;
bool t;
};
vector<int> graph[501];
bool vis[501][501][2];
state parent[501][501][2];
int main() {
int n, m;
cin >> n >> m;
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
--u, --v;
graph[u].push_back(v);
graph[v].push_back(u);
}
queue<state> q;
q.push(state{0, n - 1, 0});
parent[0][n - 1][0].a = -1;
vis[0][n - 1][0] = true;
while (!q.empty()) {
state curr = q.front();
q.pop();
int a = curr.a;
int b = curr.b;
bool t = curr.t;
if (t) {
for (auto& v : graph[b]) {
if (v != a && !vis[a][v][!t]) {
q.push(state{a, v, !t});
parent[a][v][!t] = curr;
vis[a][v][!t] = true;
}
}
} else {
for (auto& v : graph[a]) {
if (!vis[v][b][!t]) {
q.push(state{v, b, !t});
parent[v][b][!t] = curr;
vis[v][b][!t] = true;
}
}
}
}
if (!vis[n - 1][0][0]) {
cout << "-1\n";
} else {
vector<int> ansA, ansB;
state fn = state{n - 1, 0, 0};
while (fn.a != -1) {
if (fn.t == 0) {
ansA.push_back(fn.a);
ansB.push_back(fn.b);
}
fn = parent[fn.a][fn.b][fn.t];
}
reverse(ansA.begin(), ansA.end());
reverse(ansB.begin(), ansB.end());
cout << ansA.size() - 1 << endl;
for (auto& e : ansA) {
cout << e + 1 << " ";
}
cout << "\n";
for (auto& e : ansB) {
cout << e + 1 << " ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct State {
int v1;
int v2;
int turn;
State(int _v1 = -1, int _v2 = -1, int _turn = -1)
: v1(_v1), v2(_v2), turn(_turn) {}
};
const int LIM = 501;
int used[LIM][LIM][2];
State p[LIM][LIM][2];
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > g(n);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
State start(0, n - 1, 0);
queue<State> q;
used[start.v1][start.v2][start.turn] = 1;
q.push(start);
State front;
bool path_found = false;
while (!q.empty()) {
front = q.front();
q.pop();
if (front.v1 == n - 1 && front.v2 == 0 && front.turn == 0) {
path_found = true;
break;
}
if (front.turn == 0) {
for (int i = 0; i < g[front.v1].size(); ++i) {
int u = g[front.v1][i];
State next = State(u, front.v2, 1);
if (!used[next.v1][next.v2][next.turn]) {
used[next.v1][next.v2][next.turn] = 1;
p[next.v1][next.v2][next.turn] = front;
q.push(next);
}
}
} else {
for (int i = 0; i < g[front.v2].size(); ++i) {
int u = g[front.v2][i];
State next = State(front.v1, u, 0);
if (!used[next.v1][next.v2][next.turn] && next.v1 != next.v2) {
used[next.v1][next.v2][next.turn] = 1;
p[next.v1][next.v2][next.turn] = front;
q.push(next);
}
}
}
}
if (!path_found) {
cout << -1 << endl;
return 0;
}
vector<State> r;
while (front.v1 != -1) {
r.push_back(front);
front = p[front.v1][front.v2][front.turn];
}
reverse(r.begin(), r.end());
cout << r.size() / 2 << endl;
for (int i = 0; i < r.size(); ++i) {
if (r[i].turn == 0) {
cout << r[i].v1 + 1 << ' ';
}
}
cout << endl;
for (int i = 0; i < r.size(); ++i) {
if (r[i].turn == 0) {
cout << r[i].v2 + 1 << ' ';
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265359;
const long long Mod = 1000 * 1000 * 1000 + 7;
const long long MaxN = 500 + 10;
long long n, m;
pair<int, pair<int, int> > mark[MaxN][MaxN][2];
vector<int> adj[MaxN];
int d[MaxN][MaxN][2];
void BFS() {
mark[1][n][0].first = 1;
queue<pair<pair<int, int>, int> > q;
q.push({{1, n}, 0});
while (q.size()) {
pair<pair<int, int>, int> ru = q.front();
if (ru.second == 0) {
for (int i = 0; i < adj[ru.first.first].size(); i++) {
if (!mark[adj[ru.first.first][i]][ru.first.second][1].first) {
mark[adj[ru.first.first][i]][ru.first.second][1].first = 1;
q.push({{adj[ru.first.first][i], ru.first.second}, 1});
d[adj[ru.first.first][i]][ru.first.second][1] =
1 + d[ru.first.first][ru.first.second][0];
mark[adj[ru.first.first][i]][ru.first.second][1].second = {
ru.first.first, ru.first.second};
}
}
} else {
for (int i = 0; i < adj[ru.first.second].size(); i++) {
if (!mark[ru.first.first][adj[ru.first.second][i]][0].first &&
adj[ru.first.second][i] != ru.first.first) {
mark[ru.first.first][adj[ru.first.second][i]][0].first = 1;
d[ru.first.first][adj[ru.first.second][i]][0] =
1 + d[ru.first.first][ru.first.second][1];
mark[ru.first.first][adj[ru.first.second][i]][0].second = {
ru.first.first, ru.first.second};
q.push({{ru.first.first, adj[ru.first.second][i]}, 0});
}
}
}
q.pop();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> m;
long long t, t1;
for (int i = 0; i < m; i++) {
cin >> t >> t1;
adj[t].push_back(t1);
adj[t1].push_back(t);
}
BFS();
vector<int> Fi;
vector<int> Se;
if (mark[n][1][0].first == 0) return cout << -1, 0;
long long Cnt = d[n][1][0] / 2;
cout << Cnt << '\n';
pair<pair<int, int>, int> No;
No = {{n, 1}, 0};
while (Fi.size() != Cnt || Se.size() != Cnt + 1) {
if (No.second == 0) {
Se.push_back(No.first.second);
No = {{mark[No.first.first][No.first.second][0].second}, 1};
} else {
Fi.push_back(No.first.first);
No = {{mark[No.first.first][No.first.second][1].second}, 0};
}
}
Fi.push_back(1);
for (int i = Fi.size() - 1; i >= 0; i--) cout << Fi[i] << ' ';
cout << '\n';
for (int i = Se.size() - 1; i >= 0; i--) cout << Se[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, d[600][600];
vector<int> g[600];
pair<int, int> p[600][600];
vector<pair<int, int> > ans;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
queue<pair<int, int> > q;
q.push({1, n});
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = 0;
d[1][n] = 1;
p[1][n] = {-1, -1};
while (!q.empty() && !d[n][1]) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (auto i : g[u])
for (auto j : g[v])
if (!d[i][j] && i != j) {
p[i][j] = {u, v};
d[i][j] = d[u][v] + 1;
q.push({i, j});
}
}
if (d[n][1] == 0)
cout << -1;
else {
int u = n, v = 1;
while (u != -1) {
ans.push_back({u, v});
auto x = p[u][v];
u = x.first;
v = x.second;
}
reverse(ans.begin(), ans.end());
cout << ans.size() - 1 << endl;
for (auto i : ans) cout << i.first << " ";
cout << endl;
for (auto i : ans) cout << i.second << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dis[(501)][(501)][2];
vector<int> e[(501)];
pair<int, int> par[(501)][(501)][2];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d%d", &v, &u);
e[v].push_back(u);
e[u].push_back(v);
}
queue<pair<pair<int, int>, bool> > q;
q.push({{1, n}, 0});
dis[1][n][0] = 1;
while (q.size()) {
int x = q.front().first.first, y = q.front().first.second;
bool p = q.front().second;
q.pop();
if (p)
for (int i = 0; i < e[y].size(); i++) {
int y2 = e[y][i];
if (y2 != x && !dis[x][y2][0])
par[x][y2][0] = {x, y}, dis[x][y2][0] = dis[x][y][1] + 1,
q.push({{x, y2}, 0});
}
else
for (int i = 0; i < e[x].size(); i++) {
int x2 = e[x][i];
if (!dis[x2][y][1])
par[x2][y][1] = {x, y}, dis[x2][y][1] = dis[x][y][0] + 1,
q.push({{x2, y}, 1});
}
}
stack<int> ans1, ans2;
if (!dis[n][1][0]) {
printf("-1");
return 0;
}
printf("%d\n", (dis[n][1][0] - 1) / 2);
int x = n, y = 1, tmp;
for (int i = 0; i < dis[n][1][0]; i += 2)
ans2.push(y), tmp = x, x = par[x][y][(i & 1)].first,
y = par[tmp][y][(i & 1)].second, tmp = x,
x = par[x][y][((i + 1) & 1)].first,
y = par[tmp][y][((i + 1) & 1)].second;
x = n, y = 1;
for (int i = 0; i < dis[n][1][0]; i += 2)
ans1.push(x), tmp = x, x = par[x][y][(i & 1)].first,
y = par[tmp][y][(i & 1)].second, tmp = x,
x = par[x][y][((i + 1) & 1)].first,
y = par[tmp][y][((i + 1) & 1)].second;
while (ans1.size()) printf("%d ", ans1.top()), ans1.pop();
printf("\n");
while (ans2.size()) printf("%d ", ans2.top()), ans2.pop();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[501][501][2];
bool used[501][501][2];
vector<vector<int>> g;
int n, m;
bool ok = 0;
vector<int> ans1, ans2;
int vis[502];
void dfs(int v) {
vis[v] = 1;
for (auto to : g[v]) {
if (!vis[to]) {
dfs(to);
}
}
}
struct st {
int a, b, t;
st() : a(0), b(0), t(0) {}
st(int a, int b, int t) : a(a), b(b), t(t) {}
};
void bfs() {
p[0][n - 1][0] = {-1, -1};
used[0][n - 1][0] = 1;
queue<st> q;
q.push(st(0, n - 1, 0));
while (!q.empty()) {
int a = q.front().a, b = q.front().b, t = q.front().t;
q.pop();
if (t == 0) {
for (auto to : g[a]) {
if (!used[to][b][1]) {
used[to][b][1] = 1;
p[to][b][1] = {a, b};
q.push({to, b, 1});
}
}
} else {
for (auto to : g[b]) {
if (to == a) continue;
if (!used[a][to][0]) {
used[a][to][0] = 1;
p[a][to][0] = {a, b};
q.push({a, to, 0});
}
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
g.resize(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
bfs();
if (!used[n - 1][0][0] || !vis[n - 1]) {
cout << -1;
return 0;
}
int a = n - 1, b = 0, t = 0;
ans1.push_back(n - 1), ans2.push_back(0);
while (p[a][b][t].first != -1) {
int xa = p[a][b][t].first, xb = p[a][b][t].second;
t = 1 - t;
if (t == 0)
ans1.push_back(xa);
else
ans2.push_back(xb);
a = xa, b = xb;
}
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
cout << ans1.size() - 1 << '\n';
for (int i = 0; i < ans1.size(); ++i) {
cout << ans1[i] + 1 << ' ';
}
cout << '\n';
for (int i = 0; i < ans1.size(); ++i) {
cout << ans2[i] + 1 << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tstate {
int x, y, t;
tstate() {}
tstate(int x, int y, int t) : x(x), y(y), t(t) {}
} nxt[501][501][2];
int dist[501][501][2];
int n, m;
vector<int> g[501];
vector<int> rx, ry;
void out(int x, int y, int t) {
if (dist[x][y][t] > 0) {
out(nxt[x][y][t].x, nxt[x][y][t].y, nxt[x][y][t].t);
if (t == 0) {
ry.push_back(y);
} else {
rx.push_back(x);
}
}
}
void print() {
out(n, 1, 0);
cout << dist[n][1][0] / 2 << endl;
cout << 1;
for (int i = 0; i < rx.size(); ++i) {
cout << " " << rx[i];
}
cout << endl;
cout << n;
for (int i = 0; i < ry.size(); ++i) {
cout << " " << ry[i];
}
cout << endl;
exit(0);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
memset(dist, -1, sizeof dist);
dist[1][n][0] = 0;
queue<int> q;
q.push(1);
q.push(n);
q.push(0);
for (; !q.empty();) {
int x = q.front();
q.pop();
int y = q.front();
q.pop();
int t = q.front();
q.pop();
if (x == n && y == 1 && t == 0) {
print();
}
if (t == 0) {
for (int i = 0; i < g[x].size(); ++i) {
if (dist[g[x][i]][y][1] == -1) {
dist[g[x][i]][y][1] = dist[x][y][0] + 1;
nxt[g[x][i]][y][1] = tstate(x, y, 0);
q.push(g[x][i]);
q.push(y);
q.push(1);
}
}
} else {
for (int i = 0; i < g[y].size(); ++i) {
if (dist[x][g[y][i]][0] == -1 && g[y][i] != x) {
dist[x][g[y][i]][0] = dist[x][y][1] + 1;
nxt[x][g[y][i]][0] = tstate(x, y, 1);
q.push(x);
q.push(g[y][i]);
q.push(0);
}
}
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6e2;
vector<int> v[N], v1, v2;
queue<pair<int, int> > q;
queue<int> q2;
int n, ma, u, x, y, w, m[N][N][3], pa1[N][N][3], pa2[N][N][3], d[N][N][3];
void bfs(int s1, int s2) {
pair<int, int> p = make_pair(s1, s2);
m[s1][s2][0] = 1;
pa1[s1][s2][0] = 0;
pa2[s1][s2][0] = 0;
d[s1][s2][0] = 0;
q.push(p);
q2.push(0);
while (!q.empty()) {
p = q.front();
w = q2.front();
x = p.first;
y = p.second;
if (w == 0)
for (int i = 0; i < v[x].size(); i++) {
u = v[x][i];
if (m[u][y][1] == 0) {
m[u][y][1] = 1;
pa1[u][y][1] = x;
pa2[u][y][1] = y;
d[u][y][1] = d[x][y][0] + 1;
q.push({u, y});
q2.push(1);
}
}
if (w == 1)
for (int i = 0; i < v[y].size(); i++) {
u = v[y][i];
if (x == u) continue;
if (m[x][u][0] == 0) {
m[x][u][0] = 1;
pa1[x][u][0] = x;
pa2[x][u][0] = y;
d[x][u][0] = d[x][y][1] + 1;
q.push({x, u});
q2.push(0);
}
}
q.pop();
q2.pop();
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> ma;
for (int i = 1; i <= ma; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
bfs(1, n);
if (m[n][1][0] == 0) {
cout << -1;
return 0;
}
cout << d[n][1][0] / 2 << '\n';
w = 0;
v1.push_back(n);
v2.push_back(1);
x = pa1[n][1][0];
y = pa2[n][1][0];
while (x != 0 || y != 0) {
w = 1 - w;
u = x;
v1.push_back(x);
v2.push_back(y);
x = pa1[x][y][w];
y = pa2[u][y][w];
}
for (int i = v1.size() - 1; i >= 0; i -= 2) cout << v1[i] << ' ';
cout << '\n';
for (int i = v2.size() - 1; i >= 0; i -= 2) cout << v2[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int E[561][561];
int pre[1 << 18];
int dis[1 << 18];
int qu[1 << 18];
int p, q;
int solve() {
memset(pre, 0xff, sizeof pre);
for (int i = (0); i < (1 << 18); i++) dis[i] = 1000000001;
dis[(((0) << 9) + (N - 1))] = 0;
p = 0, q = 0;
qu[q++] = (((0) << 9) + (N - 1));
while (p < q) {
int c = qu[p++];
int x = ((c) >> 9), y = ((c) & ((1 << 9) - 1));
for (int i = (1); i < (E[x][0] + 1); i++)
for (int j = (1); j < (E[y][0] + 1); j++) {
int nx = E[x][i], ny = E[y][j];
if (nx == ny) continue;
int nc = (((nx) << 9) + (ny));
if (dis[nc] != 1000000001) continue;
dis[nc] = min(dis[nc], dis[c] + 1);
pre[nc] = c;
if (nx == N - 1 && ny == 0) return dis[nc];
qu[q++] = nc;
}
}
return -1;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = (0); i < (561); i++) E[i][0] = 0;
for (int i = (0); i < (M); i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
E[u][++E[u][0]] = v;
E[v][++E[v][0]] = u;
}
int ans = solve();
if (ans == -1) {
printf("-1\n");
return 0;
}
printf("%d\n", ans);
vector<pair<int, int> > vp;
int c = (((N - 1) << 9) + (0));
while (c != -1)
vp.push_back(make_pair(((c) >> 9), ((c) & ((1 << 9) - 1)))), c = pre[c];
for (int i = (0); i < (vp.size()); i++) printf("%d ", vp[i].second + 1);
printf("\n");
for (int i = (0); i < (vp.size()); i++) printf("%d ", vp[i].first + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 502;
int n, m;
pair<int, int> dad[maxn][maxn], x;
vector<int> graph[maxn], ans1, ans2;
bool mark[maxn][maxn];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0, a, b; i < m; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
queue<pair<int, int>> q;
q.push({1, n});
mark[1][n] = 1;
dad[1][n] = {0, 0};
while (!q.empty()) {
x = q.front();
q.pop();
for (int u : graph[x.first])
for (int v : graph[x.second])
if (u != v && !mark[u][v]) {
dad[u][v] = x;
mark[u][v] = 1;
q.push({u, v});
}
}
if (!mark[n][1]) return cout << "-1 \n", 0;
x = {n, 1};
while (x != make_pair(0, 0)) {
ans1.push_back(x.first);
ans2.push_back(x.second);
x = dad[x.first][x.second];
}
cout << ans1.size() - 1 << endl;
for (int i = ans1.size() - 1; i > -1; i--) cout << ans1[i] << " ";
cout << endl;
for (int i = ans2.size() - 1; i > -1; i--) cout << ans2[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int h[5][maxn][maxn], pr[5][maxn][maxn], n, m;
vector<int> aj[maxn];
queue<int> trn, a, b;
vector<int> ans0, ans1;
void prps(bool t, int aa, int bb) {
if (t == 0 and aa == 0 and bb == n - 1) {
ans1.push_back(n - 1);
ans0.push_back(0);
return;
}
if (t) {
ans0.push_back(aa);
prps(!t, pr[t][aa][bb], bb);
} else {
ans1.push_back(bb);
prps(!t, aa, pr[t][aa][bb]);
}
return;
}
void psh(bool t, int aa, int bb) {
trn.push(t);
a.push(aa);
b.push(bb);
}
void pp() {
trn.pop();
a.pop();
b.pop();
}
void bfs() {
h[0][0][n - 1] = 1;
psh(0, 0, n - 1);
while ((int)(a).size()) {
int aa = a.front(), bb = b.front();
bool t = trn.front();
if (!t) {
for (int i = 0; i < (int)(aj[aa]).size(); i++) {
int u = aj[aa][i];
if (!h[!t][u][bb]) {
h[!t][u][bb] = h[t][aa][bb] + 1;
pr[!t][u][bb] = aa;
psh(!t, u, bb);
}
}
} else {
for (int i = 0; i < (int)(aj[bb]).size(); i++) {
int u = aj[bb][i];
if (!h[!t][aa][u] and u != aa) {
h[!t][aa][u] = h[t][aa][bb] + 1;
pr[!t][aa][u] = bb;
psh(!t, aa, u);
}
if (u == 0 and aa == n - 1) return;
}
}
pp();
}
return;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
aj[u].push_back(v);
aj[v].push_back(u);
}
bfs();
if (!h[0][n - 1][0])
cout << -1 << endl;
else {
cout << h[0][n - 1][0] / 2 << endl;
prps(0, n - 1, 0);
for (int i = (int)(ans0).size() - 1; i >= 0; i--)
cout << ans0[i] + 1 << ' ';
cout << endl;
for (int i = (int)(ans1).size() - 1; i >= 0; i--)
cout << ans1[i] + 1 << ' ';
}
return false;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long double EPS = 1e-9;
int n, m;
const int N = 505;
vector<int> g[N];
bool read() {
if (!(cin >> n >> m)) return false;
for (int i = 0; i < int(m); ++i) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
return false;
}
int d[N][N][2];
pair<pair<int, int>, int> from[N][N][2];
void solve() {
for (int i = 0; i < int(N); ++i)
for (int j = 0; j < int(N); ++j)
for (int k = 0; k < int(2); ++k) d[i][j][k] = INF;
d[0][n - 1][0] = 0;
queue<pair<pair<int, int>, int>> q;
q.push(make_pair(make_pair(0, n - 1), 0));
while (!q.empty()) {
pair<int, int> v = q.front().first;
int cur = q.front().second;
q.pop();
if (cur == 0) {
for (int i = 0; i < int(g[v.first].size()); ++i) {
int to = g[v.first][i];
if (d[to][v.second][1] == INF) {
d[to][v.second][1] = d[v.first][v.second][0] + 1;
from[to][v.second][1] = make_pair(v, cur);
q.push(make_pair(make_pair(to, v.second), 1));
}
}
} else {
for (int i = 0; i < int(g[v.second].size()); ++i) {
int to = g[v.second][i];
if (to == v.first) continue;
if (d[v.first][to][0] == INF) {
d[v.first][to][0] = d[v.first][v.second][1] + 1;
from[v.first][to][0] = make_pair(v, cur);
q.push(make_pair(make_pair(v.first, to), 0));
}
}
}
}
if (d[n - 1][0][0] == INF)
cout << -1 << endl;
else {
cout << d[n - 1][0][0] / 2 << endl;
vector<int> ans[2];
ans[1].push_back(0);
pair<pair<int, int>, int> cur = make_pair(make_pair(n - 1, 0), 0);
while (cur != make_pair(make_pair(0, n - 1), 0)) {
if (cur.second)
ans[1].push_back(cur.first.second);
else
ans[0].push_back(cur.first.first);
cur = from[cur.first.first][cur.first.second][cur.second];
}
ans[0].push_back(0);
for (int i = 0; i < int(2); ++i) {
reverse(ans[i].begin(), ans[i].end());
for (int j = 0; j < int(ans[i].size()); ++j) cout << ans[i][j] + 1 << ' ';
cout << endl;
}
}
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3f;
static const double EPS = 1e-10;
static const double PI = acos(-1.0);
inline int read() {
int X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
inline void write(int X) {
if (X < 0) {
X = ~(X - 1);
putchar('-');
}
if (X > 9) write(X / 10);
putchar(X % 10 + '0');
}
static const int MAXN = 500 + 10;
vector<int> g[MAXN];
int d[1 << 19], pre[1 << 19];
int n, m, u, v;
int main() {
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &u, &v);
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
memset(d, -1, sizeof(d));
d[n - 1] = 0;
queue<int> Q;
Q.push(n - 1);
while (!Q.empty()) {
int t = Q.front();
Q.pop();
bool flag = false;
if (t & (1 << 18)) {
flag = true;
t ^= (1 << 18);
}
int u = t >> 9, v = t & 511;
if (flag) t ^= (1 << 18);
if (flag) {
for (int i = 0; i < g[v].size(); i++)
if (g[v][i] != u && d[(u << 9) | g[v][i]] == -1) {
d[(u << 9) | g[v][i]] = d[t] + 1;
pre[(u << 9) | g[v][i]] = t;
Q.push((u << 9) | g[v][i]);
}
} else {
for (int i = 0; i < g[u].size(); i++)
if (d[(1 << 18) | (g[u][i] << 9) | v] == -1) {
d[(1 << 18) | (g[u][i] << 9) | v] = d[t];
pre[(1 << 18) | (g[u][i] << 9) | v] = t;
Q.push((1 << 18) | (g[u][i] << 9) | v);
}
}
}
int pos = (n - 1) << 9;
if (d[pos] == -1)
puts("-1");
else {
printf("%d\n", d[pos]);
vector<int> ans1, ans2;
ans1.push_back(n - 1);
ans2.push_back(0);
while (pos != n - 1) {
pos = pre[pre[pos]];
ans1.push_back(pos >> 9);
ans2.push_back(pos & 511);
}
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (auto it : ans1) printf("%d ", it + 1);
puts("");
for (auto it : ans2) printf("%d ", it + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int dis[N][N];
pair<int, int> par[N][N];
vector<int> graph[N];
int n, m;
void pre() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j] = -1;
}
}
}
void bfs() {
queue<pair<int, int> > q;
q.push({0, n - 1});
par[0][n - 1] = {-1, -1};
dis[0][n - 1] = 0;
while (q.size()) {
pair<int, int> p = q.front();
q.pop();
int x = p.first;
int y = p.second;
for (auto u : graph[x]) {
for (int v : graph[y]) {
if (u == v) {
continue;
}
if (dis[u][v] == -1) {
par[u][v] = p;
dis[u][v] = dis[x][y] + 1;
q.push({u, v});
}
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
graph[u - 1].push_back(v - 1);
graph[v - 1].push_back(u - 1);
}
pre();
bfs();
if (dis[n - 1][0] < 0) {
cout << -1 << '\n';
exit(0);
}
cout << dis[n - 1][0] << '\n';
vector<int> path1;
vector<int> path2;
pair<int, int> p = {n - 1, 0};
pair<int, int> check = {-1, -1};
while (p != check) {
path1.push_back(p.first);
path2.push_back(p.second);
p = par[p.first][p.second];
}
reverse(path1.begin(), path1.end());
reverse(path2.begin(), path2.end());
for (auto nei : path1) {
cout << nei + 1 << " ";
}
cout << '\n';
for (auto nei : path2) {
cout << nei + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[505][505], na[505];
int b[505][505];
int last[505][505][2];
int Q[500005];
int c[505][505];
int main(void) {
int n, m, x, y;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &x, &y);
a[x][na[x]++] = y;
a[y][na[y]++] = x;
}
int qb = 0, qe = 0;
qb = qe = 0;
Q[qe++] = 1;
Q[qe++] = n;
b[1][n] = 1;
last[1][n][0] = -1;
while (qb < qe && !b[n][1]) {
x = Q[qb++];
y = Q[qb++];
int w[505] = {}, nw = 0;
for (int j = 0; j < na[y]; j++)
if (c[x][a[y][j]] == 0) {
w[nw++] = a[y][j];
c[x][a[y][j]] = 1;
}
for (int i = 0; i < na[x]; i++)
for (int j = 0; j < nw; j++)
if (a[x][i] != w[j]) {
if (last[a[x][i]][w[j]][0] == 0) {
b[a[x][i]][w[j]] = b[x][y] + 1;
last[a[x][i]][w[j]][0] = x;
last[a[x][i]][w[j]][1] = y;
Q[qe++] = a[x][i];
Q[qe++] = w[j];
}
}
}
if (qb == qe) {
puts("-1");
} else {
x = n, y = 1;
vector<pair<int, int> > sol;
while (x > 0) {
sol.push_back(make_pair(x, y));
int tx = last[x][y][0];
int ty = last[x][y][1];
x = tx;
y = ty;
}
printf("%d\n", sol.size() - 1);
for (int i = 0; i < sol.size(); i++) printf("%d ", sol[i].second);
puts("");
for (int i = 0; i < sol.size(); i++) printf("%d ", sol[i].first);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int const N = 5e2 + 5, mod = 1e9 + 7, inf = 1e17;
long long int a[N], b[N], dp[N], sq = 500, dis[N][N][2], n;
pair<long long int, long long int> upd[N][N][2];
queue<pair<pair<long long int, long long int>, long long int>> q;
vector<long long int> vt[N];
void bfs(pair<long long int, long long int> v1) {
dis[v1.first][v1.second][0] = 0;
for (long long int x : vt[1]) {
q.push({{x, n}, 1});
dis[x][n][1] = 1;
upd[x][n][1] = {1, n};
}
while (q.size()) {
pair<pair<long long int, long long int>, long long int> v = q.front();
q.pop();
if (v.second == 0) {
for (long long int x : vt[v.first.first]) {
if (dis[x][v.first.second][1] == -1) {
q.push({{x, v.first.second}, 1});
dis[x][v.first.second][1] = dis[v.first.first][v.first.second][0] + 1;
upd[x][v.first.second][1] = {v.first.first, v.first.second};
}
}
} else {
for (long long int x : vt[v.first.second]) {
if (dis[v.first.first][x][0] == -1 && v.first.first != x) {
q.push({{v.first.first, x}, 0});
dis[v.first.first][x][0] = dis[v.first.first][v.first.second][1] + 1;
upd[v.first.first][x][0] = {v.first.first, v.first.second};
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
vt[u].push_back(v);
vt[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j][0] = -1, dis[i][j][1] = -1;
}
}
bfs({1, n});
if (dis[n][1][0] == -1)
cout << -1 << "\n";
else {
cout << dis[n][1][0] / 2 << '\n';
vector<pair<long long int, long long int>> vec;
long long int l = n, r = 1, l1, r1;
vec.push_back({l, r});
while (upd[l][r][0].first != 0 || upd[l][r][0].second != 0) {
l1 = upd[l][r][0].first, r1 = upd[l][r][0].second;
l = l1, r = r1;
l1 = upd[l][r][1].first, r1 = upd[l][r][1].second;
l = l1, r = r1;
vec.push_back({l, r});
}
reverse(vec.begin(), vec.end());
for (auto x : vec) {
cout << x.first << " ";
}
cout << "\n";
for (auto x : vec) {
cout << x.second << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 500 + 10;
int n, m;
int d[Maxn][Maxn][2];
pair<pair<int, int>, int> par[Maxn][Maxn][2];
bool mark[Maxn][Maxn][2];
vector<int> nei[Maxn];
void input();
void dyn();
void output();
int main() {
input();
dyn();
output();
return 0;
}
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
nei[a].push_back(b);
nei[b].push_back(a);
}
}
void dyn() {
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(0, n - 1), 0));
d[0][n - 1][0] = 0;
mark[0][n - 1][0] = true;
while (!q.empty()) {
pair<pair<int, int>, int> v = q.front();
for (int i = 0; i < nei[(v.second ? v.first.second : v.first.first)].size();
i++) {
pair<pair<int, int>, int> u = v;
(v.second ? u.first.second : u.first.first) =
nei[(v.second ? v.first.second : v.first.first)][i];
u.second = !u.second;
if (!mark[u.first.first][u.first.second][u.second] &&
!(u.second == 0 && u.first.first == u.first.second)) {
q.push(u);
mark[u.first.first][u.first.second][u.second] = true;
d[u.first.first][u.first.second][u.second] =
d[v.first.first][v.first.second][v.second] + 1;
par[u.first.first][u.first.second][u.second] = v;
}
}
q.pop();
}
}
void output() {
vector<int> ans[2];
pair<pair<int, int>, int> sink = make_pair(make_pair(n - 1, 0), 0);
if (!mark[n - 1][0][0])
cout << -1 << endl;
else {
int ansnum = d[n - 1][0][0];
cout << ansnum / 2 << endl;
ans[0].push_back(n - 1);
ans[1].push_back(0);
for (int i = 0; i < ansnum; i++) {
sink = par[sink.first.first][sink.first.second][sink.second];
ans[sink.second].push_back(
(sink.second ? sink.first.second : sink.first.first));
}
for (int i = ans[0].size() - 1; i >= 0; i--) cout << ans[0][i] + 1 << " ";
cout << endl;
for (int i = ans[1].size() - 1; i >= 0; i--) cout << ans[1][i] + 1 << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 600, maxm = 10010;
struct state {
int first, sec;
bool lastM;
state(int f = 0, int s = 0, bool l = 0) {
first = f;
sec = s;
lastM = l;
}
};
int n, m;
vector<int> nei[maxn], one, two;
queue<state> que;
int dis[maxn][maxn][2];
bool mark[maxn][maxn][2];
state par[maxn][maxn][2];
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
nei[a].push_back(b);
nei[b].push_back(a);
}
}
void bfs() {
state first(0, n - 1, 1);
que.push(first);
mark[0][n - 1][1] = true;
while (!que.empty()) {
state u = que.front();
que.pop();
if (u.lastM == 1)
for (int i = 0; i < (int)nei[u.first].size(); i++) {
int uu = nei[u.first][i];
if (!mark[uu][u.sec][0]) {
dis[uu][u.sec][0] = dis[u.first][u.sec][1];
mark[uu][u.sec][0] = true;
state v(uu, u.sec, 0);
par[uu][u.sec][0] = u;
que.push(v);
}
}
else
for (int i = 0; i < (int)nei[u.sec].size(); i++) {
int uu = nei[u.sec][i];
if (uu == u.first) continue;
if (!mark[u.first][uu][1]) {
dis[u.first][uu][1] = dis[u.first][u.sec][0] + 1;
mark[u.first][uu][1] = true;
state v(u.first, uu, 1);
par[u.first][uu][1] = u;
que.push(v);
}
}
}
}
void find_path(int ans) {
one.push_back(n - 1);
two.push_back(0);
int a = n - 1, b = 0;
for (int i = 0; i < ans; i++) {
state gh = par[a][b][1];
b = gh.sec;
gh = par[a][b][0];
a = gh.first;
one.push_back(a);
two.push_back(b);
}
}
void output() {
if (!mark[n - 1][0][1])
cout << "-1" << endl;
else {
int ans = dis[n - 1][0][1];
find_path(ans);
cout << ans << endl;
for (int i = one.size() - 1; i >= 0; i--) cout << one[i] + 1 << " ";
cout << endl;
for (int i = two.size() - 1; i >= 0; i--) cout << two[i] + 1 << " ";
cout << endl;
}
}
int main() {
input();
bfs();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dis[567][567];
vector<int> a[567], ans1, ans2;
queue<int> q;
pair<int, int> p[567][567];
int main() {
int n, m, x, y;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
dis[1][n] = 1;
q.push(1);
q.push(n);
int u, v;
p[1][n] = {0, 0};
while (q.size()) {
u = q.front();
q.pop();
v = q.front();
q.pop();
if (u == v) continue;
for (auto e : a[u]) {
for (auto w : a[v]) {
if (!dis[e][w]) {
dis[e][w] = dis[u][v] + 1;
q.push(e);
q.push(w);
p[e][w] = {u, v};
}
}
}
}
if (!dis[n][1]) {
puts("-1");
exit(0);
}
u = n;
v = 1;
while (u + v > 0) {
ans1.push_back(u);
ans2.push_back(v);
x = p[u][v].first;
v = p[u][v].second;
u = x;
}
cout << ans1.size() - 1 << endl;
for (int i = 0; i < ans1.size(); i++) {
cout << ans2[i] << ' ';
}
cout << endl;
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 550, inf = 1e9;
vector<int> adj[maxn];
int n, m, dp[maxn][maxn];
pair<int, int> par[maxn][maxn];
void dijkstra() {
queue<pair<int, int> > q;
q.push({1, n});
dp[1][n] = 0;
while (!q.empty()) {
int u = q.front().first, v = q.front().second;
for (int i : adj[u]) {
for (int j : adj[v]) {
if (i ^ j && dp[i][j] > dp[u][v] + 1) {
dp[i][j] = dp[u][v] + 1;
par[i][j] = {u, v};
q.push({i, j});
}
}
}
q.pop();
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) dp[i][j] = inf;
}
dijkstra();
if (dp[n][1] >= inf) {
cout << "-1";
return 0;
}
cout << dp[n][1] << endl;
vector<int> x, y;
for (int i = n, j = 1; i || j;) {
pair<int, int> o = par[i][j];
x.push_back(j), y.push_back(i);
i = o.first, j = o.second;
}
for (int i = 0; i < dp[n][1]; i++) printf("%d ", x[i]);
cout << n << endl;
for (int i = 0; i < dp[n][1]; i++) printf("%d ", y[i]);
cout << 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> se[2050];
int n, m, tot;
int head[2050];
struct node {
int to, next;
} edge[2100000];
struct node1 {
int a, b;
} p, Q[2050 * 2050];
int mat[2050][2050], pre[2050 * 2050];
int main() {
int i, j, cas, a, b;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
mat[i][j] = -1;
}
}
for (i = 0; i <= n; i++) se[i].clear();
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
se[a].push_back(b);
se[b].push_back(a);
}
int L = 1, h = 1, y, yy;
a = 1;
b = n;
Q[h].a = a;
Q[h].b = b;
pre[0] = 0;
mat[1][n] = 0;
int ans = -1;
while (L <= h) {
a = Q[L].a;
b = Q[L].b;
for (i = 0; i < se[a].size(); i++) {
y = se[a][i];
for (j = 0; j < se[b].size(); j++) {
yy = se[b][j];
if (y != yy && mat[y][yy] == -1) {
h++;
mat[y][yy] = mat[a][b] + 1;
Q[h].a = y;
Q[h].b = yy;
pre[h] = L;
if (y == n && yy == 1) {
ans = h;
}
}
}
}
if (ans != -1) break;
L++;
}
if (mat[n][1] == -1) {
printf("-1\n");
continue;
}
printf("%d\n", mat[n][1]);
int now = ans;
while (now > 1) {
printf("%d ", Q[now].b);
now = pre[now];
}
printf("%d\n", Q[now].b);
now = ans;
while (now > 1) {
printf("%d ", Q[now].a);
now = pre[now];
}
printf("%d\n", Q[now].a);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gr[500][500];
int d[500][500][2], sz[500] = {0};
struct triple {
int x, y, c;
triple(int x_ = 0, int y_ = 0, int c_ = 0) {
x = x_;
y = y_;
c = c_;
}
};
pair<int, int> par[500][500][2];
int v[2][10001];
queue<triple> q;
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
gr[a - 1][sz[a - 1]++] = b - 1;
gr[b - 1][sz[b - 1]++] = a - 1;
}
memset(d, -1, sizeof d);
d[0][n - 1][0] = 0;
int ans = -1, C = 0;
q.push(triple(0, n - 1, 0));
while (!q.empty()) {
triple p = q.front();
q.pop();
int x = p.x, y = p.y, c = p.c;
if (x == n - 1 && y == 0 && c == 0) {
ans = d[x][y][c];
break;
}
if (!c) {
for (int i = 0; i < sz[x]; i++) {
if (d[gr[x][i]][y][1] == -1) {
d[gr[x][i]][y][1] = d[x][y][c] + 1;
par[gr[x][i]][y][1] = pair<int, int>(x, y);
q.push(triple(gr[x][i], y, 1));
}
}
} else
for (int j = 0; j < sz[y]; j++) {
if (gr[y][j] != x && d[x][gr[y][j]][0] == -1) {
d[x][gr[y][j]][0] = d[x][y][c];
par[x][gr[y][j]][0] = pair<int, int>(x, y);
q.push(triple(x, gr[y][j], 0));
}
}
}
cout << ans << endl;
if (ans > -1) {
int x = n - 1, y = 0, z1 = 0, z2 = 0;
C = 0;
while (x != 0 || y != n - 1) {
if (!C)
v[1][z2++] = x;
else
v[0][z1++] = y;
pair<int, int> p = par[x][y][C];
x = p.first;
y = p.second;
C = 1 - C;
}
cout << 1;
for (int i = z2 - 1; i >= 0; i--) printf(" %d", v[1][i] + 1);
cout << endl;
for (int i = z1 - 1; i >= 0; i--) printf("%d ", v[0][i] + 1);
cout << 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, m, a, b, pre[501][501][2], p1, p2;
bool ja[501][501];
vector<int> adj[501], c[2];
vector<int>::iterator it, jt, ie, je;
queue<pair<int, int> > q;
void read() {
scanf("%d %d", &N, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
}
bool process() {
pre[1][N][0] = -1;
pair<int, int> p(1, N), pp;
q.push(p);
while (!q.empty() && pre[N][1][0] == 0) {
p = q.front();
q.pop();
p1 = p.first;
p2 = p.second;
for (it = adj[p1].begin(), ie = adj[p1].end(); it < ie; it++) {
if (ja[*it][p2]) continue;
ja[*it][p2] = true;
for (jt = adj[p2].begin(), je = adj[p2].end(); jt < je; jt++) {
if (*it == *jt) continue;
if (pre[*it][*jt][0] == 0) {
pre[*it][*jt][0] = p1;
pre[*it][*jt][1] = p2;
pp = make_pair(*it, *jt);
q.push(pp);
}
}
}
}
if (pre[N][1][0] == 0) return false;
int x = N, y = 1, z;
while (x > 0) {
c[0].push_back(x);
c[1].push_back(y);
z = x;
x = pre[x][y][0];
y = pre[z][y][1];
}
return true;
}
int main() {
read();
if (process()) {
printf("%d\n", c[0].size() - 1);
for (int i = 0; i < 2; i++) {
for (it = c[i].end() - 1, ie = c[i].begin(); it >= ie; it--)
printf("%d ", *it);
printf("\n");
}
} else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int n, m;
vector<int> g[maxn], r1, rn;
int f[maxn][maxn][2];
pair<pair<int, int>, int> q[maxn * maxn * 2], trace[maxn][maxn][2];
int front, rear;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
memset(f, -1, sizeof f);
front = 1;
rear = 1;
q[1] = make_pair(make_pair(1, n), 0);
f[1][n][0] = 0;
while (front <= rear) {
int p1 = q[front].first.first;
int pn = q[front].first.second;
int t = q[front].second;
if (t == 0)
for (int i = 0; i < g[p1].size(); i++) {
int u = g[p1][i];
if (f[u][pn][1] == -1) {
f[u][pn][1] = f[p1][pn][t] + 1;
trace[u][pn][1] = make_pair(make_pair(p1, pn), t);
q[++rear] = make_pair(make_pair(u, pn), 1);
}
}
else
for (int i = 0; i < g[pn].size(); i++) {
int u = g[pn][i];
if (u != p1 && f[p1][u][0] == -1) {
f[p1][u][0] = f[p1][pn][t] + 1;
trace[p1][u][0] = make_pair(make_pair(p1, pn), t);
q[++rear] = make_pair(make_pair(p1, u), 0);
}
}
++front;
}
if (f[n][1][0] == -1) {
cout << -1;
return 0;
}
cout << f[n][1][0] / 2 << endl;
rn.push_back(1);
r1.push_back(n);
pair<pair<int, int>, int> t = trace[n][1][0];
while (t.first.first != 0) {
if (t.second == 0)
r1.push_back(t.first.first);
else
rn.push_back(t.first.second);
t = trace[t.first.first][t.first.second][t.second];
}
for (int i = r1.size() - 1; i >= 0; i--) cout << r1[i] << " ";
cout << endl;
for (int i = rn.size() - 1; i >= 0; i--) cout << rn[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 7;
int n, m, us[N][N], u, v;
pair<int, int> pre[N][N];
vector<int> vc[N];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> v >> u;
vc[v].push_back(u);
vc[u].push_back(v);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
us[i][j] = -1;
}
}
queue<pair<int, int> > q;
q.push({1, n});
us[1][n] = 0;
while (!q.empty()) {
auto f = q.front();
q.pop();
if (us[n][1] != -1) break;
for (auto x : vc[f.first]) {
for (auto y : vc[f.second]) {
if (x == y || us[x][y] != -1) continue;
q.push({x, y});
pre[x][y] = f;
us[x][y] = us[f.first][f.second] + 1;
}
}
}
pair<int, int> p = {n, 1};
vector<int> v1, v2;
if (us[n][1] == -1) {
cout << -1 << endl;
return 0;
}
while (true) {
v1.push_back(p.first);
v2.push_back(p.second);
if (p == make_pair(1, n)) break;
p = pre[p.first][p.second];
}
reverse(v1.begin(), v1.end());
reverse(v2.begin(), v2.end());
cout << v1.size() - 1 << endl;
for (auto i : v1) cout << i << ' ';
cout << endl;
for (auto i : v2) cout << i << ' ';
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int hashu[505][505];
int ar[501][501];
int xline[250001], yline[250001], fline[250001];
int main() {
int n, m, a, b;
cin >> n >> m;
memset(ar, 0, sizeof(ar));
memset(hashu, -1, sizeof(hashu));
for (int i = 0; i < m; ++i) {
cin >> a >> b;
ar[a][++ar[a][0]] = b;
ar[b][++ar[b][0]] = a;
}
int fin = 0, l = 1, r = 1;
xline[l] = 1, yline[l] = n;
hashu[1][n] = 0;
while (l <= r) {
int nowx = xline[l];
int nowy = yline[l];
for (int x = 1; x <= ar[nowx][0]; ++x) {
for (int y = 1; y <= ar[nowy][0]; ++y) {
int nex = ar[nowx][x], ney = ar[nowy][y];
if (hashu[nex][ney] == -1 && nex != ney) {
++r;
hashu[nex][ney] = hashu[nowx][nowy] + 1;
xline[r] = nex;
yline[r] = ney;
fline[r] = l;
if (xline[r] == n && yline[r] == 1) fin = r;
}
}
}
if (fin) break;
++l;
}
cout << hashu[n][1] << endl;
if (hashu[n][1] == 0) {
cout << l << " " << r << endl;
}
if (hashu[n][1] == -1) return 0;
int now = fin;
while (true) {
cout << yline[now] << " ";
if (now == 1) break;
now = fline[now];
}
now = fin;
cout << endl;
while (true) {
cout << xline[now] << " ";
if (now == 1) break;
now = fline[now];
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[1234];
bool has_reached[1234][1234];
pair<long long, long long> parent[1234][1234];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long from, to;
cin >> from >> to;
g[from].push_back(to);
g[to].push_back(from);
continue;
}
memset(has_reached, false, sizeof has_reached);
has_reached[1][n] = true;
parent[1][n] = {0, 0};
queue<pair<long long, long long> > q;
q.push(make_pair(1, n));
while (!q.empty()) {
long long u = q.front().first;
long long v = q.front().second;
q.pop();
if (u == v) continue;
for (auto x : g[u]) {
for (auto y : g[v]) {
if (has_reached[x][y] == false) {
has_reached[x][y] = true;
q.push(make_pair(x, y));
parent[x][y] = {u, v};
}
}
}
}
if (has_reached[n][1] == false) {
cout << -1 << endl;
cout.flush();
return 0;
}
vector<long long> v1;
v1.clear();
vector<long long> v2;
v2.clear();
long long a = n;
long long b = 1;
while (a + b) {
v2.push_back(b);
v1.push_back(a);
int foo = parent[a][b].first;
b = parent[a][b].second;
a = foo;
}
cout << v2.size() - 1 << endl;
for (auto x : v2) {
cout << x << " ";
}
cout << endl;
cout.flush();
for (auto y : v1) {
cout << y << " ";
}
cout.flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> t(n);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
--x, --y;
t[x].push_back(y);
t[y].push_back(x);
}
vector<int> dist(n * n, -1);
vector<pair<int, int>> parent(n * n, make_pair(-1, -1));
vector<bool> order(n * n, false);
queue<pair<int, int>> q;
q.push(make_pair(0, n - 1));
dist[n - 1] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop();
if (p.first == n - 1 && p.second == 0) {
int len = dist[(n - 1) * n];
printf("%d\n", len);
vector<int> r1, r2;
r1.push_back(n - 1);
r2.push_back(0);
int pos1 = n - 1, pos2 = 0;
while (pos1 != 0 || pos2 != n - 1) {
int tmp = pos1;
pos1 = parent[pos1 * n + pos2].first;
pos2 = parent[tmp * n + pos2].second;
r1.push_back(pos1);
r2.push_back(pos2);
}
for (int i = len; i >= 0; --i) printf("%d ", r1[i] + 1);
printf("\n");
for (int i = len; i >= 0; --i) printf("%d ", r2[i] + 1);
printf("\n");
return 0;
}
for (auto i : t[p.first]) {
if (order[i * n + p.second]) continue;
order[i * n + p.second] = true;
for (auto j : t[p.second]) {
if (i != j && dist[i * n + j] == -1) {
parent[i * n + j] = p;
dist[i * n + j] = dist[p.first * n + p.second] + 1;
q.push(make_pair(i, j));
}
}
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
struct qe {
short a, b;
bool i;
};
int tab[512][512][2];
qe par[512][512][2];
std::vector<short> conns[10007];
int main() {
short n;
int m;
short a, b;
scanf("%hi %i", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%hi %hi", &a, &b);
conns[a].push_back(b);
conns[b].push_back(a);
}
std::queue<qe> q;
q.push({1, n, true});
tab[1][n][true] = 1;
while (!q.empty()) {
auto p = q.front();
q.pop();
int v = tab[p.a][p.b][p.i];
if (p.i) {
for (short nb : conns[p.a]) {
if (!tab[nb][p.b][false]) {
tab[nb][p.b][false] = v + 1;
par[nb][p.b][false] = p;
q.push({nb, p.b, false});
}
}
} else {
for (short nb : conns[p.b]) {
if (!tab[p.a][nb][true] && p.a != nb) {
tab[p.a][nb][true] = v + 1;
par[p.a][nb][true] = p;
q.push({p.a, nb, true});
}
}
}
}
if (!tab[n][1][true]) {
printf("-1\n");
return 0;
}
printf("%i\n", (tab[n][1][true] - 1) / 2);
std::stack<int> rq[2];
qe ci = {n, 1, true};
while (ci.a != 0) {
if (ci.i)
rq[1].push(ci.b);
else
rq[0].push(ci.a);
ci = par[ci.a][ci.b][ci.i];
}
rq[0].push(1);
while (!rq[0].empty()) {
printf("%i ", rq[0].top());
rq[0].pop();
}
printf("\n");
while (!rq[1].empty()) {
printf("%i ", rq[1].top());
rq[1].pop();
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
int n, m;
vector<int> mat[N];
int d[N][N][2];
struct state {
int fir, sec;
bool is;
state(int f = 0, int s = 0, bool i = false) { fir = f, sec = s, is = i; }
} par[N][N][2];
queue<state> q;
vector<int> out[2];
void input() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--;
v--;
mat[v].push_back(u);
mat[u].push_back(v);
}
}
void init() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < 2; k++) d[i][j][k] = -1, par[i][j][k] = 0;
}
void process() {
state f(0, n - 1, 0);
q.push(f);
d[0][n - 1][0] = 0;
while (q.empty() == false) {
state u = q.front();
q.pop();
for (int i = 0; i < (int)mat[u.is == 0 ? u.fir : u.sec].size(); i++) {
int f = u.is == 0 ? mat[u.is == 0 ? u.fir : u.sec][i] : u.fir;
int s = u.is == 1 ? mat[u.is == 0 ? u.fir : u.sec][i] : u.sec;
state v(f, s, !u.is);
if (d[v.fir][v.sec][v.is] == -1) {
if (v.is == 1 && v.sec == u.fir) continue;
d[v.fir][v.sec][v.is] = d[u.fir][u.sec][u.is];
d[v.fir][v.sec][v.is] += (u.is == 1 ? 1 : 0);
par[v.fir][v.sec][v.is] = u;
q.push(v);
}
}
}
}
void output() {
out[0].push_back(0);
out[1].push_back(n - 1);
int f = n - 1, s = 0;
for (int i = 0; i < d[n - 1][0][0]; i++) {
s = par[f][s][0].sec;
f = par[f][s][1].fir;
out[0].push_back(s);
out[1].push_back(f);
}
cout << d[n - 1][0][0] << endl;
if (d[n - 1][0][0] == -1) return;
for (int i = 1; i >= 0; i--) {
for (int j = (int)out[i].size() - 1; j >= 0; j--)
cout << out[i][j] + 1 << " ";
cout << endl;
}
}
int main() {
input();
init();
process();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e2 + 10, inf = 1e18, mod = 1e9 + 7;
struct node {
long long x, y, c;
};
bool mk[maxn][maxn][2];
node mnd(long long x, long long y, long long c) {
node n;
n.x = x, n.y = y, n.c = c;
mk[x][y][c] = 1;
return n;
}
long long n, m;
vector<long long> g[maxn];
node fa[maxn][maxn][2];
bool bfs() {
queue<node> q;
q.push(mnd(0, n - 1, 0));
while (q.size()) {
node u = q.front();
q.pop();
if (!u.c) {
for (int i = 0; i < g[u.x].size(); i++) {
if (!mk[g[u.x][i]][u.y][1]) {
q.push(mnd(g[u.x][i], u.y, 1)),
fa[g[u.x][i]][u.y][1] = mnd(u.x, u.y, u.c);
}
}
} else {
for (int i = 0; i < g[u.y].size(); i++) {
if (!mk[u.x][g[u.y][i]][0] && u.x != g[u.y][i]) {
q.push(mnd(u.x, g[u.y][i], 0)),
fa[u.x][g[u.y][i]][0] = mnd(u.x, u.y, u.c);
}
}
}
if (u.x == n - 1 && u.y == 0 && u.c == 0) {
return 1;
}
}
return 0;
}
vector<int> jj1, jj2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
long long v, u;
while (m--) {
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
if (!bfs()) {
return cout << "-1", 0;
;
}
node no = mnd(n - 1, 0, 0);
while (no.x != 0 || no.y != n - 1 || no.c != 0) {
jj1.push_back(no.x);
jj2.push_back(no.y);
no = fa[no.x][no.y][no.c];
}
jj1.push_back(0);
jj2.push_back(n - 1);
reverse(jj1.begin(), jj1.end());
reverse(jj2.begin(), jj2.end());
cout << (long long)floor((long double)jj1.size() / 2) << endl;
for (int i = 0; i < jj1.size(); i += 2) {
cout << jj1[i] + 1 << " ";
}
cout << endl;
for (int i = 0; i < jj2.size(); i += 2) {
cout << jj2[i] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[505];
pair<int, int> a[505][505];
bool vis[505][505];
vector<int> ans1, ans2;
int n, m;
void bfs() {
queue<pair<int, int> > q;
q.push(make_pair(1, n));
while (!q.empty()) {
pair<int, int> pos = q.front();
q.pop();
int l, m;
l = pos.first;
m = pos.second;
int i, j, sz = v[l].size(), sz1 = v[m].size();
int nl, nm;
for (i = 0; i < sz; i++) {
nl = v[l][i];
for (j = 0; j < sz1; j++) {
nm = v[m][j];
if (nl == nm) continue;
if (!vis[nl][nm]) {
vis[nl][nm] = true;
a[nl][nm] = make_pair(l, m);
q.push(make_pair(nl, nm));
if (nl == n && nm == 1) {
return;
}
}
}
}
}
}
int main() {
cin >> n >> m;
int x, y;
while (m--) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
int i, j;
bfs();
x = n, y = 1;
a[1][n] = make_pair(0, 0);
while (a[x][y].first) {
ans1.push_back(x);
ans2.push_back(y);
pair<int, int> p = a[x][y];
x = p.first;
y = p.second;
}
if (ans1.size()) {
int sz = ans1.size();
printf("%d\n", sz);
printf("1");
for (i = sz - 1; i >= 0; i--) {
printf(" %d", ans1[i]);
}
printf("\n%d", n);
for (i = sz - 1; i >= 0; i--) {
printf(" %d", ans2[i]);
}
printf("\n");
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LL_MIN = std::numeric_limits<long long>::min();
const long long LL_MAX = std::numeric_limits<long long>::max();
template <class T, class R>
ostream& operator<<(ostream& o, const pair<T, R>& p) {
o << "(" << p.first << ", " << p.second << ")";
return o;
}
template <class T, class R>
istream& operator>>(istream& o, pair<T, R>& p) {
o >> p.first >> p.second;
return o;
}
template <class T>
string to_string(const T& x) {
stringstream o;
o << "[";
for (__typeof((x).begin()) i = ((x).begin()); i != (x).end(); ++i) {
o << ((i != x.begin()) ? ", " : "") << *i;
}
o << "]";
string r;
getline(o, r);
return r;
}
template <class T>
T get_next(string& s) {
stringstream ss(s);
T r;
ss >> r;
getline(ss, s);
return r;
}
template <class T>
void split_string(const string& s, vector<T>& o) {
stringstream ss(s);
o.clear();
T x;
while (ss >> x) {
o.push_back(x);
}
}
void trim(string& s) {
stringstream ss;
ss << s;
s.clear();
ss >> s;
}
template <class T, class R>
ostream& operator<<(ostream& o, const map<T, R>& x) {
o << to_string(x);
return o;
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& x) {
o << to_string(x);
return o;
};
template <class T>
ostream& operator<<(ostream& o, const set<T>& x) {
o << to_string(x);
return o;
};
template <class T>
ostream& operator<<(ostream& o, const deque<T>& x) {
o << to_string(x);
return o;
};
const long long INFL = 1000000000LL * 1000000000LL + 1000LL;
const int INF = 1000000000 + 1000;
const long long MOD = 1000000009;
struct Tri {
int a, b, c;
Tri(int a, int b, int c) : a(a), b(b), c(c) {}
};
queue<Tri> q;
int n, m, a, b;
vector<int> graf[510];
bool sol[510][510][2];
int dist[510][510][2], f[510][510][2];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a, &b);
graf[a].push_back(b);
graf[b].push_back(a);
}
dist[1][n][0] = 0;
q.push(Tri(1, n, 0));
sol[1][n][0] = true;
while (q.size()) {
Tri t = q.front();
q.pop();
if (t.c == 0) {
for (__typeof((graf[t.a]).begin()) a = ((graf[t.a]).begin());
a != (graf[t.a]).end(); ++a) {
if (!sol[*a][t.b][1]) {
sol[*a][t.b][1] = true;
dist[*a][t.b][1] = dist[t.a][t.b][0] + 1;
q.push(Tri(*a, t.b, 1));
f[*a][t.b][1] = t.a;
}
}
} else {
for (__typeof((graf[t.b]).begin()) b = ((graf[t.b]).begin());
b != (graf[t.b]).end(); ++b) {
if (!sol[t.a][*b][0] && t.a != *b) {
sol[t.a][*b][0] = true;
dist[t.a][*b][0] = dist[t.a][t.b][1];
q.push(Tri(t.a, *b, 0));
f[t.a][*b][0] = t.b;
}
}
}
}
if (!sol[n][1][0]) {
printf("-1\n");
} else {
printf("%d\n", dist[n][1][0]);
a = n;
b = 1;
vector<int> ra, rb;
ra.push_back(n);
rb.push_back(1);
while (make_pair(a, b) != make_pair(1, n)) {
rb.push_back(f[a][b][0]);
b = f[a][b][0];
ra.push_back(f[a][b][1]);
a = f[a][b][1];
}
for (__typeof((rb).begin()) it = ((rb).begin()); it != (rb).end(); ++it) {
printf("%d ", *it);
}
printf("\n");
for (__typeof((ra).begin()) it = ((ra).begin()); it != (ra).end(); ++it) {
printf("%d ", *it);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long int N = 5e2 + 20, mod = 1e9 + 7, inf = 8e18, maxk = 1e5 + 20;
const long double eps = 0.0001;
vector<int> adj[N];
int d[N][N][2];
pair<long long int, long long int> par[N][N][2];
int n, m;
void bfs() {
queue<pair<pair<long long int, long long int>, bool> > q;
q.push({{1, n}, 0});
par[1][n][0] = {0, 0};
while (!q.empty()) {
auto p = q.front();
int u = p.first.first, v = p.first.second;
q.pop();
if (p.second) {
for (int w : adj[v]) {
if (par[u][w][0].first == -1) {
d[u][w][0] = d[u][v][1] + 1;
par[u][w][0] = {u, v};
q.push({{u, w}, 0});
}
}
} else {
for (int w : adj[u]) {
if (par[w][v][1].first == -1) {
d[w][v][1] = d[u][v][0] + 1;
par[w][v][1] = {u, v};
q.push({{w, v}, 1});
}
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
par[i][j][0] = {-1, -1};
par[i][j][1] = {-1, -1};
}
}
for (int i = 1; i < n + 1; i++) par[i][i][0].first = 0;
bfs();
if (!d[n][1][0]) {
cout << -1;
return 0;
}
cout << d[n][1][0] / 2 << '\n';
int u = n, v = 1, i = 0;
vector<int> ve1, ve2;
while (par[u][v][i].first) {
if (i)
ve2.push_back(u);
else
ve1.push_back(v);
pair<long long int, long long int> p = par[u][v][i];
i = 1 - i;
u = p.first;
v = p.second;
}
ve2.push_back(1);
ve1.push_back(n);
reverse(ve1.begin(), ve1.end());
reverse(ve2.begin(), ve2.end());
for (int w : ve2) cout << w << ' ';
cout << '\n';
for (int w : ve1) cout << w << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 510, maxm = 10010;
bool mark[maxn][maxn][3], f = 0;
pair<pair<int, int>, int> mas[maxn][maxn][3];
vector<long long int> a[maxn];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m, q1, q2;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d %d", &q1, &q2), a[q1].push_back(q2), a[q2].push_back(q1);
queue<pair<pair<int, int>, int> > q;
q.push({{1, n}, 1});
mark[1][n][1] = 1;
while (q.size()) {
pair<int, int> v = q.front().first;
int num = q.front().second;
q.pop();
if (v.first == n && v.second == 1 && num == 1) {
f = 1;
break;
}
if (num == 1) {
int j = v.second;
for (auto i : a[v.first]) {
if (!mark[i][j][3 - num]) {
mark[i][j][3 - num] = 1;
mas[i][j][3 - num] = {v, num};
q.push({{i, j}, 3 - num});
}
}
} else {
int i = v.first;
for (auto j : a[v.second])
if (i != j) {
if (!mark[i][j][3 - num]) {
mark[i][j][3 - num] = 1;
mas[i][j][3 - num] = {v, num};
q.push({{i, j}, 3 - num});
}
}
}
}
if (mark[n][1][1] == 0) return cout << -1 << endl, 0;
pair<pair<int, int>, int> v = {{n, 1}, 1};
vector<pair<pair<int, int>, int> > ans;
ans.push_back({{n, 1}, 1});
int num = 1;
while (mas[v.first.first][v.first.second][num] !=
make_pair(make_pair(0, 0), 0)) {
ans.push_back(mas[v.first.first][v.first.second][num]);
v = mas[v.first.first][v.first.second][num];
num = 3 - num;
}
reverse(ans.begin(), ans.end());
cout << (ans.size() - 1) / 2 << endl;
f = 1;
for (auto i : ans) {
if (f) printf("%d ", i.first.first);
f = !f;
}
cout << endl;
f = 1;
for (auto i : ans) {
if (f) printf("%d ", i.first.second);
f = !f;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxix = 510;
int mark[2][maxix][maxix];
int si[2][maxix][maxix];
pair<int, int> parent[2][maxix][maxix];
deque<int> bfs;
vector<int> a[maxix];
vector<int> ansfor1, ansforn;
int main() {
int n, m;
cin >> n >> m;
int x, y;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
bfs.push_back(0);
bfs.push_back(1);
bfs.push_back(n);
mark[0][1][n] = 1;
while (bfs.size()) {
int turn = bfs[0];
bfs.pop_front();
x = bfs[0];
bfs.pop_front();
y = bfs[0];
bfs.pop_front();
if (turn == 0) {
for (auto u : a[x]) {
if (mark[1][u][y] == 0) {
mark[1][u][y] = 1;
bfs.push_back(1);
bfs.push_back(u);
bfs.push_back(y);
parent[1][u][y] = {x, y};
si[1][u][y] = si[0][x][y] + 1;
}
}
} else {
for (auto u : a[y]) {
if (mark[0][x][u] == 0 && u != x) {
mark[0][x][u] = 1;
bfs.push_back(0);
bfs.push_back(x);
bfs.push_back(u);
parent[0][x][u] = {x, y};
si[0][x][u] = si[1][x][y] + 1;
}
}
}
}
if (mark[0][n][1] == 0) {
cout << -1;
return 0;
}
cout << (si[0][n][1] + 1) / 2 << "\n";
cout << 1 << " ";
int ss = si[0][n][1];
int cnt = 0;
int now = n;
x = n;
y = 1;
while (ss != 0) {
ss--;
now = x;
if (cnt == 0) {
ansfor1.push_back(now);
}
int f, s;
f = parent[cnt][x][y].first;
s = parent[cnt][x][y].second;
x = f;
y = s;
if (cnt == 1)
cnt = 0;
else
cnt = 1;
}
for (int i = ansfor1.size() - 1; i >= 0; i--) cout << ansfor1[i] << " ";
cout << "\n";
cnt = 0;
now = 1;
x = n;
y = 1;
ss = si[0][n][1];
while (ss != 0) {
ss--;
now = y;
if (cnt == 1) {
ansforn.push_back(now);
}
int f, s;
f = parent[cnt][x][y].first;
s = parent[cnt][x][y].second;
x = f;
y = s;
if (cnt == 1)
cnt = 0;
else
cnt = 1;
}
for (int i = ansforn.size() - 1; i >= 0; i--) cout << ansforn[i] << " ";
cout << 1;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> adj[500 + 1];
void link(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
int d[500 + 1][500 + 1][2];
struct state {
int u1, u2;
bool first;
} p[500 + 1][500 + 1][2];
void bfs(int n) {
memset(d, -1, sizeof d);
d[1][n][1] = 0;
p[1][n][1] = {-1, -1};
queue<state> q;
q.push({1, n, 1});
while (not q.empty()) {
int u1 = q.front().u1;
int u2 = q.front().u2;
bool first = q.front().first;
q.pop();
for (int v : adj[first ? u1 : u2]) {
int v1 = first ? v : u1;
int v2 = first ? u2 : v;
if ((first or v1 != v2) and d[v1][v2][not first] == -1) {
d[v1][v2][not first] = d[u1][u2][first] + 1;
p[v1][v2][not first] = {u1, u2, first};
q.push({v1, v2, not first});
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
link(u, v);
}
bfs(n);
if (d[n][1][1] != -1) {
vector<int> a, b = {1};
state cur = {n, 1, 1};
while (cur.u1 > 0 and cur.u2 > 0) {
(cur.first ? a : b).push_back((cur.first ? cur.u1 : cur.u2));
cur = p[cur.u1][cur.u2][cur.first];
}
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
cout << d[n][1][1] / 2 << '\n';
for (int x : a) cout << x << " ";
cout << '\n';
for (int x : b) cout << x << " ";
cout << '\n';
} else {
cout << -1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, d[600][600];
vector<int> g[600];
pair<int, int> p[600][600];
vector<pair<int, int> > ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
queue<pair<int, int> > q;
q.push({1, n});
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = 0;
d[1][n] = 1;
p[1][n] = {-1, -1};
while (!q.empty() && !d[n][1]) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (auto i : g[u])
for (auto j : g[v])
if (!d[i][j] && i != j) {
p[i][j] = {u, v};
d[i][j] = d[u][v] + 1;
q.push({i, j});
}
}
if (d[n][1] == 0)
cout << -1;
else {
int u = n, v = 1;
while (u != -1) {
ans.push_back({u, v});
auto x = p[u][v];
u = x.first;
v = x.second;
}
reverse(ans.begin(), ans.end());
cout << ans.size() - 1 << endl;
for (auto i : ans) cout << i.first << " ";
cout << endl;
for (auto i : ans) cout << i.second << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int hashu[505][505];
int ar[501][501];
int xline[250001], yline[250001], fline[250001];
int main() {
int n, m, a, b;
cin >> n >> m;
memset(ar, 0, sizeof(ar));
memset(hashu, -1, sizeof(hashu));
for (int i = 0; i < m; ++i) {
cin >> a >> b;
ar[a][++ar[a][0]] = b;
ar[b][++ar[b][0]] = a;
}
int fin = 0, l = 1, r = 1;
xline[l] = 1, yline[l] = n;
hashu[1][n] = 0;
while (l <= r) {
int nowx = xline[l];
int nowy = yline[l];
for (int x = 1; x <= ar[nowx][0]; ++x) {
for (int y = 1; y <= ar[nowy][0]; ++y) {
int nex = ar[nowx][x], ney = ar[nowy][y];
if (hashu[nex][ney] == -1 && nex != ney) {
++r;
hashu[nex][ney] = hashu[nowx][nowy] + 1;
xline[r] = nex;
yline[r] = ney;
fline[r] = l;
if (xline[r] == n && yline[r] == 1) fin = r;
}
}
}
if (fin) break;
++l;
}
cout << hashu[n][1] << endl;
if (hashu[n][1] == 0) {
cout << l << " " << r << endl;
}
if (hashu[n][1] == -1) return 0;
int now = fin;
while (true) {
cout << yline[now] << " ";
if (now == 1) break;
now = fline[now];
}
now = fin;
cout << endl;
while (true) {
cout << xline[now] << " ";
if (now == 1) break;
now = fline[now];
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int oo = numeric_limits<int>::max() / 2;
constexpr int N = 501;
int n, m;
vector<int> g[N];
int d[N][N][2];
int fromx[N][N][2];
int fromy[N][N][2];
struct State {
State(int x_, int y_, int t_) : x(x_), y(y_), t(t_) {}
int x, y, t;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
d[i][j][0] = d[i][j][1] = oo;
}
}
fromx[0][n - 1][0] = -1;
fromy[0][n - 1][0] = -1;
d[0][n - 1][0] = 0;
queue<State> q;
q.emplace(0, n - 1, 0);
while (!q.empty()) {
auto& cur = q.front();
if (cur.t == 0) {
for (auto to : g[cur.x]) {
if (d[to][cur.y][1] > d[cur.x][cur.y][0] + 1) {
d[to][cur.y][1] = d[cur.x][cur.y][0] + 1;
q.emplace(to, cur.y, 1);
fromx[to][cur.y][1] = cur.x;
fromy[to][cur.y][1] = cur.y;
}
}
} else {
for (auto to : g[cur.y]) {
if (to == cur.x) {
continue;
}
if (d[cur.x][to][0] > d[cur.x][cur.y][1] + 1) {
d[cur.x][to][0] = d[cur.x][cur.y][1] + 1;
q.emplace(cur.x, to, 0);
fromx[cur.x][to][0] = cur.x;
fromy[cur.x][to][0] = cur.y;
}
}
}
q.pop();
}
if (d[n - 1][0][0] == oo) {
cout << -1 << endl;
} else {
vector<int> path[2];
function<void(int, int, int, bool)> build = [&](int i, int j, int t,
bool flag) {
while (1) {
if (i == -1 || j == -1) {
break;
}
int pi = fromx[i][j][t];
int pj = fromy[i][j][t];
if (flag) {
path[0].push_back(i);
path[1].push_back(j);
} else {
if (t == 1) {
path[1].push_back(j);
} else {
path[0].push_back(i);
}
}
flag = false;
t = 1 - t;
i = pi;
j = pj;
}
};
cout << d[n - 1][0][0] / 2 << endl;
build(n - 1, 0, 0, true);
reverse(path[0].begin(), path[0].end());
for (int i : path[0]) {
cout << (i + 1) << " ";
}
cout << endl;
reverse(path[1].begin(), path[1].end());
for (int i : path[1]) {
cout << (i + 1) << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long NN = 3e3 + 7;
const int N = 1e3 + 7;
const int M = 6;
const int mod = 1e9 + 7;
const long long inf = 1e18 + 7;
const double long rf = 1e-14;
const int B = sqrt(N);
int n, m;
int d[N][N];
bool used[N][N];
vector<int> v[N];
pair<int, int> p[N][N];
void solve1() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[i][j] = 1e9;
}
}
d[1][n] = 0;
queue<pair<int, int> > q;
q.push({1, n});
while (!q.empty()) {
auto x = q.front();
q.pop();
if (d[n][1] != 1e9) break;
for (auto y : v[x.first]) {
if (used[y][x.second]) continue;
used[y][x.second] = true;
for (auto h : v[x.second]) {
int nx = y;
int ny = h;
if (nx == ny || d[nx][ny] != 1e9) continue;
d[nx][ny] = d[x.first][x.second] + 1;
p[nx][ny] = x;
q.push({nx, ny});
}
}
}
if (d[n][1] == 1e9) {
cout << -1;
return;
}
vector<pair<int, int> > v;
cout << d[n][1] << "\n";
pair<int, int> x = {n, 1};
while (x.first != 0) {
v.push_back(x);
x = p[x.first][x.second];
}
reverse(v.begin(), v.end());
for (auto x : v) {
cout << x.first << " ";
}
cout << "\n";
for (auto x : v) {
cout << x.second << " ";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int cghf = 1;
while (cghf--) {
solve1();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int MAX = 512;
int n;
int m;
vector<int> ra, rb;
int g[MAX][MAX], w[MAX], d[MAX][MAX], p[MAX][MAX];
int q[250000];
int out(int a, int b) {
ra.push_back(a + 1);
rb.push_back(b + 1);
if (d[a][b] == 1) return 0;
out(p[a][b] >> 10, p[a][b] & 1023);
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
g[a][w[a]++] = b;
g[b][w[b]++] = a;
}
int l = 0, r = 1;
q[0] = n - 1;
memset(d, 0, sizeof(d));
d[0][n - 1] = 1;
int a, b, c, e;
while (l < r) {
a = q[l] >> 10;
b = q[l] & 1023;
int D = d[a][b] + 1, P = (a << 10) + b;
if (a == n - 1 && b == 0) break;
l++;
int *I = &g[a][0], *J = &g[b][0], *i, *j;
int *II = I + w[a], *JJ = J + w[b];
for (i = I; i != II; i++)
for (j = J; j != JJ; j++) {
c = *i;
e = *j;
if (c != e && !d[c][e]) {
d[c][e] = D;
p[c][e] = P;
q[r++] = (c << 10) + e;
}
}
}
if (!d[n - 1][0]) {
printf("-1\n");
return 0;
}
printf("%d\n", d[n - 1][0] - 1);
out(n - 1, 0);
reverse((ra).begin(), (ra).end());
reverse((rb).begin(), (rb).end());
for (int i = 0; i < ra.size(); i++) printf("%d ", ra[i]);
printf("\n");
for (int i = 0; i < rb.size(); i++) printf("%d ", rb[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m;
vector<int> g[N];
bool mrk[N][N][3];
pair<pair<int, int>, bool> how[N][N][3], nil;
void BFS() {
queue<pair<pair<int, int>, bool> > Q;
Q.push({{1, n}, 0});
while (Q.size()) {
pair<pair<int, int>, bool> v = Q.front();
Q.pop();
if (v.second == false) {
for (auto u : g[v.first.first])
if (mrk[u][v.first.second][1] == false)
Q.push({{u, v.first.second}, 1}), how[u][v.first.second][1] = v,
mrk[u][v.first.second][1] = true;
} else {
for (auto u : g[v.first.second])
if (mrk[v.first.first][u][0] == false && v.first.first != u)
Q.push({{v.first.first, u}, 0}), how[v.first.first][u][0] = v,
mrk[v.first.first][u][0] = true;
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0, u, v; i < m; i++)
cin >> u >> v, g[v].push_back(u), g[u].push_back(v);
BFS();
if (mrk[n][1][0] == false) return cout << -1, 0;
vector<int> mmd, mjd;
pair<pair<int, int>, bool> v = {{n, 1}, 0};
while (v.first.first != 1 || v.first.second != n || v.second != 0) {
mmd.push_back(v.first.first);
mjd.push_back(v.first.second);
v = how[v.first.first][v.first.second][v.second];
}
mmd.push_back(1);
mjd.push_back(n);
reverse(mmd.begin(), mmd.end());
reverse(mjd.begin(), mjd.end());
cout << mmd.size() / 2 << endl;
for (int i = 0; i < mmd.size(); i += 2) cout << mmd[i] << " ";
cout << endl;
for (int i = 0; i < mmd.size(); i += 2) cout << mjd[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int M = 10006;
vector<int> adj[N];
deque<pair<pair<int, int>, int> > d;
int mark[N][N][2];
pair<int, int> par[N][N][2];
void BFS(int n, int m) {
d.clear();
d.push_back({{1, n}, 0});
mark[1][n][0] = 1;
while (!d.empty()) {
int a = d.front().first.first;
int b = d.front().first.second;
int t = d.front().second;
d.pop_front();
if (!t) {
for (int u : adj[a])
if (!mark[u][b][1]) {
mark[u][b][1] = 1 + mark[a][b][t];
par[u][b][1] = {a, b};
d.push_back({{u, b}, 1});
}
} else {
for (int u : adj[b])
if (!mark[a][u][0] && a != u) {
mark[a][u][0] = mark[a][b][t];
par[a][u][0] = {a, b};
d.push_back({{a, u}, 0});
}
}
}
}
void SOLVE(int n, int m) {
if (!mark[n][1][0]) {
cout << "-1\n";
return;
}
cout << mark[n][1][0] - 1 << endl;
vector<int> A, B;
A.push_back(n);
B.push_back(1);
int t = 0, a = n, b = 1;
pair<int, int> k;
while (a != 1 || b != n) {
k = par[a][b][t];
if (a == 0) {
cout << "CHOS\n";
break;
}
if (!t) {
b = k.second;
B.push_back(b);
} else {
a = k.first;
A.push_back(a);
}
t ^= 1;
}
for (int i = A.size(); i >= 1; i--) {
cout << A[i - 1] << ' ';
}
cout << '\n';
for (int i = B.size(); i >= 1; i--) {
cout << B[i - 1] << ' ';
}
cout << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
BFS(n, m);
SOLVE(n, m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
struct node {
int u, v;
bool t;
node() {}
node(int u, int v, bool t) {
this->u = u;
this->v = v;
this->t = t;
}
bool ok() const { return (t) || (u != v); }
bool operator==(const node v) const {
return (this->u == v.u) && (this->v == v.v) && (this->t == v.t);
}
bool operator!=(const node v) const {
return (this->u != v.u) || (this->v != v.v) || (this->t != v.t);
}
};
int dis[maxn][maxn][2];
vector<int> g[maxn];
node par[maxn][maxn][2];
void bfs(node s) {
dis[s.u][s.v][s.t] = 1;
queue<node> q;
q.push(s);
while (!q.empty()) {
node u = q.front();
q.pop();
if (u.t)
for (int x : g[u.v]) {
node v(u.u, x, 0);
if (v.ok() && !dis[v.u][v.v][v.t])
dis[v.u][v.v][v.t] = dis[u.u][u.v][u.t] + 1, par[v.u][v.v][v.t] = u,
q.push(v);
}
else
for (int x : g[u.u]) {
node v(x, u.v, 1);
if (v.ok() && !dis[v.u][v.v][v.t])
dis[v.u][v.v][v.t] = dis[u.u][u.v][u.t] + 1, par[v.u][v.v][v.t] = u,
q.push(v);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0, u, v; i < m; i++)
cin >> u >> v, g[u].push_back(v), g[v].push_back(u);
node s(1, n, 0), f(n, 1, 0);
bfs(s);
if (!dis[f.u][f.v][f.t]) return cout << -1, 0;
cout << dis[f.u][f.v][f.t] / 2 << '\n';
vector<int> path1, path2;
for (node t = f; t != s; t = par[t.u][t.v][t.t])
if (!t.t) path1.push_back(t.u), path2.push_back(t.v);
path1.push_back(s.u), path2.push_back(s.v);
reverse(path1.begin(), path1.end()), reverse(path2.begin(), path2.end());
for (int u : path1) cout << u << ' ';
cout << '\n';
for (int u : path2) cout << u << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10;
int dis[maxn][maxn][3];
vector<int> adj[maxn];
bool mark[maxn][maxn];
pair<int, int> par[maxn][maxn][3];
void bfs(int x, int y) {
queue<pair<pair<int, int>, int>> q;
q.push({{x, y}, 0});
dis[x][y][0] = 0;
while (q.size()) {
int x = q.front().first.first;
int y = q.front().first.second;
int t = q.front().second;
q.pop();
if (!t) {
for (int u : adj[x]) {
if (dis[u][y][1] > dis[x][y][0] + 1) {
dis[u][y][1] = dis[x][y][0] + 1;
par[u][y][1] = {x, 0};
q.push({{u, y}, 1});
}
}
} else {
for (int u : adj[y]) {
if (u != x && dis[x][u][0] > dis[x][y][1]) {
dis[x][u][0] = dis[x][y][1];
par[x][u][0] = {y, 1};
q.push({{x, u}, 0});
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
par[0][n - 1][0] = {-1, -1};
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j][0] = dis[i][j][1] = INT_MAX;
}
}
bfs(0, n - 1);
if (dis[n - 1][0][0] == INT_MAX) {
cout << -1;
return 0;
}
cout << dis[n - 1][0][0] << endl;
int x = n - 1, y = 0;
int t = 0;
vector<int> v1;
vector<int> v2;
while (x != -1 && y != -1) {
int u = par[x][y][t].first;
t = par[x][y][t].second;
if (t == 0) {
v1.push_back(x);
x = u;
} else {
v2.push_back(y);
y = u;
}
}
v1.push_back(x);
reverse(v1.begin(), v1.end());
reverse(v2.begin(), v2.end());
for (int i : v1) cout << i + 1 << " ";
cout << endl;
for (int i : v2) {
cout << i + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct state {
int x, y, op;
state(int x, int y, int op) : x(x), y(y), op(op) {}
};
bool vis[510][510];
int n, inf, b[510], a[20010][2], d[510][510], pre[510][510][2];
vector<int> ans[2];
queue<state> Q;
void bfs(int x0, int y0) {
Q.push(state(x0, y0, 0));
memset(d, 63, sizeof(d));
inf = d[0][0];
d[x0][y0] = 0;
while (!Q.empty()) {
int p = Q.front().x, q = Q.front().y, op = Q.front().op;
Q.pop();
if (op == 0)
for (int i = b[p]; i; i = a[i][1]) {
int x = a[i][0];
if (!vis[x][q]) {
vis[x][q] = true;
Q.push(state(x, q, p));
}
}
else
for (int i = b[q]; i; i = a[i][1]) {
int y = a[i][0];
if (p != y && d[p][y] == inf) {
d[p][y] = d[op][q] + 1;
pre[p][y][0] = op;
pre[p][y][1] = q;
Q.push(state(p, y, 0));
}
}
}
}
void print(int x, int y) {
if (x != 1 || y != n) print(pre[x][y][0], pre[x][y][1]);
ans[0].push_back(x);
ans[1].push_back(y);
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[i][0] = y, a[i][1] = b[x], b[x] = i;
a[i + m][0] = x, a[i + m][1] = b[y], b[y] = i + m;
}
bfs(1, n);
if (d[n][1] == inf)
printf("-1\n");
else {
printf("%d\n", d[n][1]);
print(n, 1);
for (int i = 0; i < ans[0].size(); i++)
printf("%d%c", ans[0][i], i == ans[0].size() - 1 ? '\n' : ' ');
for (int i = 0; i < ans[1].size(); i++)
printf("%d%c", ans[1][i], i == ans[1].size() - 1 ? '\n' : ' ');
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 500 + 10, N2 = 4e6, delta = 46639, mod = 998244353,
oo = 1e18, LOG = 20;
const long double PI = 3.141592653589793;
bool mark[N][N];
vector<long long int> v[N], path1, path2;
pair<long long int, long long int> par[N][N];
void p(long long int x, long long int y) {
if (x == -1 || y == -1) return;
path1.push_back(x);
path2.push_back(y);
p(par[x][y].first, par[x][y].second);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int x, y;
cin >> x >> y;
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
}
queue<pair<long long int, long long int> > q;
q.push({0, n - 1});
mark[0][n - 1] = true;
par[0][n - 1] = {-1, -1};
while (q.size()) {
pair<long long int, long long int> p = q.front();
if (p.first != p.second)
for (auto u : v[p.first])
for (auto x : v[p.second]) {
if (!mark[u][x]) {
q.push({u, x});
mark[u][x] = true;
par[u][x] = {p.first, p.second};
}
}
q.pop();
}
if (!mark[n - 1][0]) return cout << -1, 0;
p(n - 1, 0);
cout << path1.size() - 1 << '\n';
for (auto u : path2) cout << ++u << ' ';
cout << '\n';
for (auto u : path1) cout << ++u << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
const long long mod = 1000000000 + 7;
const int maxn = 500 + 10;
const int inf = 1000000000;
int n, m, par[maxn][maxn][2], dist[maxn][maxn][2];
vector<int> v[maxn], e[2];
queue<pair<pair<int, int>, int> > q;
bool mark[maxn][maxn][2];
void pr(int x, int y, int o) {
if (par[x][y][o] == -1) return;
if (o == 0) {
pr(x, par[x][y][o], 1 - o);
e[o].push_back(y);
} else {
pr(par[x][y][o], y, 1 - o);
e[o].push_back(x);
}
}
int main() {
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++) dist[i][j][0] = dist[i][j][1] = inf;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
q.push(make_pair(make_pair(1, n), 0));
par[1][n][0] = -1;
mark[1][n][0] = 1;
dist[1][n][0] = 0;
while (!q.empty()) {
int x = q.front().first.first;
int y = q.front().first.second;
int o = q.front().second;
q.pop();
if (o == 0) {
for (int i = 0; i < v[x].size(); i++)
if (!mark[v[x][i]][y][1]) {
q.push(make_pair(make_pair(v[x][i], y), 1));
dist[v[x][i]][y][1] = dist[x][y][0] + 1;
mark[v[x][i]][y][1] = 1;
par[v[x][i]][y][1] = x;
}
} else {
for (int i = 0; i < v[y].size(); i++)
if (v[y][i] != x && !mark[x][v[y][i]][0]) {
q.push(make_pair(make_pair(x, v[y][i]), 0));
dist[x][v[y][i]][0] = dist[x][y][1] + 1;
mark[x][v[y][i]][0] = 1;
par[x][v[y][i]][0] = y;
}
}
}
if (dist[n][1][0] != inf) {
cout << dist[n][1][0] / 2 << endl;
pr(n, 1, 0);
cout << 1 << ' ';
for (int i = 0; i < e[1].size(); i++) cout << e[1][i] << ' ';
cout << endl << n << ' ';
for (int i = 0; i < e[0].size(); i++) cout << e[0][i] << ' ';
cout << endl;
} else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e3 + 2;
const long double SADAT = 7.84e-17;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
const long double PI = 4 * atan((long double)1);
long long pw(long long a, long long b) {
return (!b ? 1
: (b & 1 ? a * pw(a * a % mod, b / 2) % mod
: pw(a * a % mod, b / 2) % mod));
}
int n, m;
vector<int> adj[maxn], ans1, ans2;
int dist[510][510][2];
pair<pair<long long, long long>, bool> par[510][510][2];
bool mark[510][510][2];
queue<pair<pair<long long, long long>, bool> > q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> v >> u;
adj[v].push_back(u);
;
adj[u].push_back(v);
;
}
memset(dist, 63, sizeof dist);
;
dist[1][n][0] = 0;
q.push({pair<long long, long long>(1, n), 0});
while (!q.empty()) {
pair<pair<long long, long long>, bool> X;
X = q.front();
q.pop();
int v = X.first.first, u = X.first.second;
bool state = X.second;
if (state) {
for (auto x : adj[u]) {
if (dist[v][x][0] != dist[0][0][0] or v == x) continue;
par[v][x][0] = {{v, u}, 1};
dist[v][x][0] = dist[v][u][1] + 1;
q.push({{v, x}, 0});
}
} else {
for (auto x : adj[v]) {
if (dist[x][u][1] != dist[0][0][0]) continue;
par[x][u][1] = {{v, u}, 0};
dist[x][u][1] = dist[v][u][0];
q.push({{x, u}, 1});
}
}
}
if (dist[n][1][0] >= 1e7) {
cout << -1;
return (0);
;
}
cout << dist[n][1][0] << '\n';
int s = 1, e = n;
while (s != n or e != 1) {
auto v = par[e][s][0];
v = par[v.first.first][v.first.second][1];
e = v.first.first;
s = v.first.second;
ans1.push_back(e);
;
ans2.push_back(s);
;
}
reverse(ans1.begin(), ans1.end());
for (int i = 0; i < ans1.size(); i++) cout << ans1[i] << ' ';
;
cout << n << '\n';
reverse(ans2.begin(), ans2.end());
for (int i = 0; i < ans2.size(); i++) cout << ans2[i] << ' ';
;
cout << 1;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int head[501], e;
int dp[501][501][2], pre[501][501][2];
vector<int> ansa, ansb;
queue<int> q;
struct N {
int v, next;
} edge[20005];
void addedge(int u, int v) {
edge[e].v = v;
edge[e].next = head[u];
head[u] = e++;
edge[e].v = u;
edge[e].next = head[v];
head[v] = e++;
}
int main() {
scanf("%d%d", &n, &m);
e = 0;
int i;
memset(head, -1, sizeof(head));
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a, b);
}
int j;
q.push(1);
q.push(n);
q.push(0);
bool flag = true;
while (!q.empty() && flag) {
int a, b, c, v;
a = q.front();
q.pop();
b = q.front();
q.pop();
c = q.front();
q.pop();
if (c == 0) {
for (i = head[a]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (dp[v][b][1] == 0) {
dp[v][b][1] = dp[a][b][0] + 1;
pre[v][b][1] = a;
q.push(v);
q.push(b);
q.push(1);
}
}
} else {
for (i = head[b]; flag && i != -1; i = edge[i].next) {
v = edge[i].v;
if (v == a) continue;
if (dp[a][v][0] == 0) {
dp[a][v][0] = dp[a][b][1] + 1;
pre[a][v][0] = b;
q.push(a);
q.push(v);
q.push(0);
}
if (a == n && v == 1) flag = false;
}
}
}
int ans = dp[n][1][0];
if (ans == 0)
printf("-1\n");
else {
printf("%d\n", ans / 2);
ansa.push_back(n);
ansb.push_back(1);
int k1, k2;
k1 = n;
k2 = 1;
for (i = 0; i < ans / 2; i++) {
k2 = pre[k1][k2][0];
ansb.push_back(k2);
k1 = pre[k1][k2][1];
ansa.push_back(k1);
}
for (i = ansa.size() - 1; i >= 0; i--) {
if (i != 0)
printf("%d ", ansa[i]);
else
printf("%d", ansa[i]);
}
printf("\n");
for (i = ansb.size() - 1; i >= 0; i--) {
if (i != 0)
printf("%d ", ansb[i]);
else
printf("%d", ansb[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, dp[N][N];
queue<pair<int, int>> q;
vector<int> ans[2], adj[N];
pair<int, int> par[N][N], zero;
int main() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
adj[--u].push_back(--v);
adj[v].push_back(u);
}
memset(dp, 63, sizeof dp);
for (q.push({0, n - 1}), dp[0][n - 1] = 0; q.size(); q.pop()) {
auto [u, v] = q.front();
if (u == n - 1 && v == 0) {
cout << dp[u][v] << endl;
for (pair<int, int> x = {u, v}; x != zero; x = par[x.first][x.second]) {
ans[1].push_back(x.first);
ans[0].push_back(x.second);
}
for (int i = 0; i < 2; i++, cout << endl)
for (int x : ans[i]) cout << x + 1 << ' ';
return 0;
}
for (int x : adj[u])
for (int y : adj[v])
if (x ^ y && dp[u][v] + 1 < dp[x][y]) {
dp[x][y] = dp[u][v] + 1;
par[x][y] = {u, v};
q.push({x, y});
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, dp[N][N];
queue<pair<int, int>> q;
vector<int> ans[2], adj[N];
pair<int, int> par[N][N], zero;
int main() {
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
adj[--u].push_back(--v);
adj[v].push_back(u);
}
memset(dp, 127, sizeof dp);
for (q.push({0, n - 1}), dp[0][n - 1] = 0; q.size(); q.pop()) {
auto [u, v] = q.front();
if (u == n - 1 && v == 0) {
cout << dp[u][v] << endl;
for (pair<int, int> x = {u, v}; x != zero; x = par[x.first][x.second]) {
ans[1].push_back(x.first);
ans[0].push_back(x.second);
}
for (int i = 0; i < 2; i++, cout << endl)
for (int x : ans[i]) cout << x + 1 << ' ';
return 0;
}
for (int x : adj[u])
for (int y : adj[v])
if (x ^ y && dp[u][v] + 1 < dp[x][y]) {
dp[x][y] = dp[u][v] + 1;
par[x][y] = {u, v};
q.push({x, y});
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct state {
int v1, v2, dis;
};
const int nmax = 505;
vector<int> g[nmax];
char col[nmax][nmax][2];
int prv[nmax][nmax][2], n;
queue<state> qq;
vector<int> ans1, ans2;
void bfs() {
state tmp_st, tmp_st1;
int f = 0, i, ind;
tmp_st.v1 = 1;
tmp_st.v2 = n;
tmp_st.dis = 0;
col[1][n][0] = 1;
qq.push(tmp_st);
while (!qq.empty()) {
tmp_st = qq.front();
qq.pop();
if (tmp_st.v1 == n && tmp_st.v2 == 1 && !(tmp_st.dis & 1)) {
f = 1;
break;
}
if (!(tmp_st.dis & 1)) {
for (i = 0; i < (int)g[tmp_st.v1].size(); i++)
if (!col[g[tmp_st.v1][i]][tmp_st.v2][1]) {
col[g[tmp_st.v1][i]][tmp_st.v2][1] = 1;
prv[g[tmp_st.v1][i]][tmp_st.v2][1] = tmp_st.v1;
tmp_st1.v1 = g[tmp_st.v1][i];
tmp_st1.v2 = tmp_st.v2;
tmp_st1.dis = tmp_st.dis + 1;
qq.push(tmp_st1);
}
} else {
for (i = 0; i < (int)g[tmp_st.v2].size(); i++)
if (!col[tmp_st.v1][g[tmp_st.v2][i]][0] &&
tmp_st.v1 != g[tmp_st.v2][i]) {
col[tmp_st.v1][g[tmp_st.v2][i]][0] = 1;
prv[tmp_st.v1][g[tmp_st.v2][i]][0] = tmp_st.v2;
tmp_st1.v1 = tmp_st.v1;
tmp_st1.v2 = g[tmp_st.v2][i];
tmp_st1.dis = tmp_st.dis + 1;
qq.push(tmp_st1);
}
}
}
if (!f) {
printf("-1");
return;
}
printf("%d\n", tmp_st.dis / 2);
for (; tmp_st.dis;) {
if (!(tmp_st.dis & 1)) {
ans2.push_back(tmp_st.v2);
tmp_st.v2 = prv[tmp_st.v1][tmp_st.v2][0];
} else {
ans1.push_back(tmp_st.v1);
tmp_st.v1 = prv[tmp_st.v1][tmp_st.v2][1];
}
tmp_st.dis--;
}
ans1.push_back(1);
ans2.push_back(n);
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (i = 0; i < (int)ans1.size(); i++) printf("%d ", ans1[i]);
putchar('\n');
for (i = 0; i < (int)ans2.size(); i++) printf("%d ", ans2[i]);
}
int main() {
int m, a, b, i;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
bfs();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e2 + 10;
int n, m;
vector<int> aa, bb, adj[maxn];
bool mark[maxn][maxn][2];
pair<pair<int, int>, bool> par[maxn][maxn][2];
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
}
void bfs() {
queue<pair<pair<int, int>, bool> > q;
mark[0][n - 1][0] = true;
q.push({{0, n - 1}, false});
while (!q.empty()) {
auto tmp = q.front();
q.pop();
int v = tmp.first.first, u = tmp.first.second, b = tmp.second;
if (v == u && b == 0) continue;
if (b) {
for (auto x : adj[u])
if (!mark[v][x][1 - b])
mark[v][x][b ^ 1] = true, par[v][x][1 - b] = tmp,
q.push({{v, x}, b ^ 1});
} else {
for (auto x : adj[v])
if (!mark[x][u][1 - b])
mark[x][u][1 ^ b] = true, par[x][u][1 - b] = tmp,
q.push({{x, u}, b ^ 1});
}
}
}
void print(int v, int u, bool b) {
if (v == 0 && u == n - 1 && b == 0) return;
auto tmp = par[v][u][b];
print(tmp.first.first, tmp.first.second, tmp.second);
if (!b)
aa.push_back(tmp.first.second);
else
bb.push_back(tmp.first.first);
}
int main() {
input();
bfs();
if (!mark[n - 1][0][0])
cout << -1 << endl;
else {
print(n - 1, 0, 0);
cout << aa.size() << endl;
for (auto b : bb) cout << b + 1 << " ";
cout << n << endl;
for (auto a : aa) cout << a + 1 << " ";
cout << 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 511;
int n, m;
vector<int> a[N];
bool h[N][N];
struct State {
int x, y, last;
};
vector<State> q;
void out(int i) {
vector<int> f1, f2;
while (i >= 0) {
f1.push_back(q[i].x);
f2.push_back(q[i].y);
i = q[i].last;
}
printf("%d\n", (int)f1.size() - 1);
for (int i = 0; i < f1.size(); ++i) {
printf("%d%s", f1[i], i == f1.size() - 1 ? "\n" : " ");
}
for (int i = 0; i < f2.size(); ++i) {
printf("%d%s", f2[i], i == f2.size() - 1 ? "\n" : " ");
}
exit(0);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
if (n > 1) {
h[n][1] = true;
q.push_back({n, 1, -1});
}
int op = 0;
for (int cc = 0; cc < N; ++cc) {
int cl = q.size();
while (op < cl) {
int x = q[op].x;
int y = q[op].y;
for (int xx : a[x])
for (int yy : a[y])
if (!h[xx][yy] && xx != yy) {
h[xx][yy] = true;
q.push_back({xx, yy, op});
if (xx == 1 && yy == n) {
out(q.size() - 1);
}
}
++op;
}
}
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 10;
const int maxn5 = 5 * 1000 * 100 + 10;
const int maxnJ = 1000 + 10;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long inf = 1LL * 2 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 10;
int h[600][600];
queue<pair<int, int>> q;
vector<int> adj[maxn5], ans1, ans2;
pair<int, int> par[600][600];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0; i < 600; i++)
for (int j = 0; j < 600; j++) h[i][j] = -1;
q.push({1, n});
h[1][n] = 0;
while (!q.empty()) {
int a = q.front().first, b = q.front().second;
q.pop();
for (auto u : adj[a])
for (auto v : adj[b])
if (u != v and h[u][v] == -1) {
h[u][v] = h[a][b] + 1;
q.push({u, v});
par[u][v] = {a, b};
}
}
if (h[n][1] == -1) return cout << -1 << endl, 0;
if (true) {
if (true) {
int a = n, b = 1;
cout << h[a][b] << endl;
int hv = h[a][b];
ans1.push_back(a);
ans2.push_back(b);
while (hv--) {
int x = par[a][b].first, y = par[a][b].second;
a = x;
b = y;
ans1.push_back(a);
ans2.push_back(b);
}
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (auto u : ans1) cout << u << ' ';
cout << endl;
for (auto u : ans2) cout << u << ' ';
return cout << endl, 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
struct V {
int a, b;
int wybor;
};
std::vector<int> v[507];
V prev[507][507][2];
int odl[507][507][2];
bool odw[507][507][2];
std::queue<V> Q;
int wynik[1000007][2];
int main() {
int N, M;
scanf("%d%d", &N, &M);
int a, b;
for (int i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
Q.push({1, N, 0});
odw[1][N][0] = true;
while (!Q.empty()) {
V ter = Q.front();
Q.pop();
if (ter.a == N && ter.b == 1 && ter.wybor == 0) break;
if (ter.a == ter.b && ter.wybor == 0) continue;
a = ter.a, b = ter.b;
if (ter.wybor == 0) {
for (auto it : v[a]) {
if (!odw[it][b][1]) {
odw[it][b][1] = true;
odl[it][b][1] = odl[ter.a][ter.b][ter.wybor] + 1;
prev[it][b][1] = ter;
Q.push({it, b, 1});
}
}
} else {
for (auto it : v[b]) {
if (!odw[a][it][0]) {
odw[a][it][0] = true;
odl[a][it][0] = odl[ter.a][ter.b][ter.wybor] + 1;
prev[a][it][0] = ter;
Q.push({a, it, 0});
}
}
}
}
if (odl[N][1][0] == 0) {
printf("-1");
return 0;
}
int wyn = odl[N][1][0] / 2;
auto ter = V{N, 1, 0};
wynik[wyn][1] = 1;
while (ter.a != 0) {
wynik[odl[ter.a][ter.b][ter.wybor] / 2][ter.wybor] =
ter.wybor ? ter.b : ter.a;
ter = prev[ter.a][ter.b][ter.wybor];
}
printf("%d\n", wyn);
for (int i = 0; i <= wyn; i++) printf("%d ", wynik[i][0]);
printf("\n");
for (int i = 0; i <= wyn; i++) printf("%d ", wynik[i][1]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e2 + 12;
int dp[2][MAXN][MAXN];
int par[2][MAXN][MAXN];
vector<int> adj[MAXN];
queue<pair<bool, pair<int, int> > > saf;
vector<int> ans1;
vector<int> ans2;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
memset(dp, -1, sizeof dp);
memset(par, -1, sizeof par);
saf.push(make_pair(1, make_pair(n - 1, 0)));
dp[1][n - 1][0] = 0;
while (saf.size()) {
bool tpe = saf.front().first;
int a = saf.front().second.first, b = saf.front().second.second;
saf.pop();
if (tpe == 0) {
for (auto v : adj[a]) {
if (dp[1][v][b] == -1 && v != b) {
dp[1][v][b] = dp[0][a][b];
par[1][v][b] = a;
saf.push(make_pair(1, make_pair(v, b)));
}
}
} else {
for (auto v : adj[b]) {
if (dp[0][a][v] == -1) {
dp[0][a][v] = dp[1][a][b] + 1;
par[0][a][v] = b;
saf.push(make_pair(0, make_pair(a, v)));
}
}
}
}
if (dp[1][0][n - 1] == -1) {
cout << -1;
return 0;
}
cout << dp[1][0][n - 1] << "\n";
bool q = 1;
int x = 0, y = n - 1;
while (x >= 0 && y >= 0) {
if (q)
ans1.push_back(x + 1), x = par[q][x][y];
else
ans2.push_back(y + 1), y = par[q][x][y];
q ^= 1;
}
ans2.push_back(1);
for (int i = 0; i < ans1.size(); i++) cout << ans1[i] << " ";
cout << "\n";
for (int i = 0; i < ans2.size(); i++) cout << ans2[i] << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[500];
queue<int> q;
int d[1 << 19];
int pre[1 << 19];
vector<int> ans1, ans2;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < (int)(m); ++i) {
int from, to;
cin >> from >> to, --from, --to;
g[from].push_back(to);
g[to].push_back(from);
}
for (int i = 0; i < (int)(1 << 19); ++i) d[i] = -1;
d[n - 1] = 0;
q.push(n - 1);
while (!q.empty()) {
int tmp = q.front();
q.pop();
bool flag = false;
if (tmp & (1 << 18)) {
flag = true;
tmp ^= (1 << 18);
}
int u = tmp >> 9;
int v = tmp & 511;
if (flag) tmp ^= (1 << 18);
if (flag) {
for (int to : g[v])
if (to != u) {
int val = (u << 9) | to;
if (d[val] == -1) {
d[val] = d[tmp] + 1;
pre[val] = tmp;
q.push(val);
}
}
} else {
for (int to : g[u]) {
int val = (1 << 18) | (to << 9) | v;
if (d[val] == -1) {
d[val] = d[tmp];
pre[val] = tmp;
q.push(val);
}
}
}
}
int pos = (n - 1) << 9;
if (d[pos] == -1) {
cout << -1 << '\n';
return 0;
}
cout << d[pos] << '\n';
ans1.push_back(n - 1);
ans2.push_back(0);
while (pos != n - 1) {
pos = pre[pos];
pos = pre[pos];
ans1.push_back(pos >> 9);
ans2.push_back(pos & 511);
}
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
for (int i = 0; i < (int)(ans1.size()); ++i) cout << ans1[i] + 1 << ' ';
cout << '\n';
for (int i = 0; i < (int)(ans2.size()); ++i) cout << ans2[i] + 1 << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
const int X = 500 * 500 * 2 + 100;
int n, m, h[N][N][2], par[N], cnt, d[N], bab[N][N][2];
vector<int> adj[N], t1, t2;
int mark[N][N][2];
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[--v].push_back(--u);
adj[u].push_back(v);
}
}
void pp(int a, int b, bool f) {
if (a == 0 && b == n - 1 && !f) return;
int c = bab[a][b][f];
if (f) {
t1.push_back(a);
pp(c, b, 0);
} else {
t2.push_back(b);
pp(a, c, 1);
}
return;
}
void BFS2() {
queue<pair<pair<long long, long long>, bool> > q;
q.push(make_pair(make_pair(0, n - 1), 0));
mark[0][n - 1][0] = 1;
while (!q.empty()) {
pair<pair<long long, long long>, bool> temp = q.front();
q.pop();
int u = temp.first.first;
int v = temp.first.second;
bool f = temp.second;
if (u == n - 1 && v == 0 && f == 0) {
pp(n - 1, 0, 0);
t1.push_back(0);
t2.push_back(n - 1);
cout << t1.size() - 1 << endl;
for (int i = t1.size() - 1; i >= 0; i--) cout << t1[i] + 1 << " ";
cout << endl;
for (int i = t2.size() - 1; i >= 0; i--) cout << t2[i] + 1 << " ";
exit(0);
return;
}
if (f) {
for (int i = 0; i < adj[v].size(); i++) {
int z = adj[v][i];
if (z == u) continue;
if (!mark[u][z][0]) {
mark[u][z][0] = 1;
q.push(make_pair(make_pair(u, z), 0));
bab[u][z][0] = v;
}
}
} else {
for (int i = 0; i < adj[u].size(); i++) {
int z = adj[u][i];
if (!mark[z][v][1]) {
mark[z][v][1] = 1;
q.push(make_pair(make_pair(z, v), 1));
bab[z][v][1] = u;
}
}
}
}
cout << -1 << endl;
return;
}
int main() {
input();
BFS2();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 503;
vector<int> adj[N];
int d[N][N][2];
int p[N][N][2];
int main() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(d, -1, sizeof d);
d[1][n][0] = 0;
queue<pair<int, int> > Q[2];
Q[0].push(pair<int, int>(1, n));
while (!Q[0].empty()) {
while (!Q[0].empty()) {
int u = Q[0].front().first;
int v = Q[0].front().second;
Q[0].pop();
for (vector<int>::iterator it = adj[u].begin(); it != adj[u].end(); ++it)
if (d[*it][v][1] == -1) {
d[*it][v][1] = d[u][v][0] + 1;
p[*it][v][1] = u;
Q[1].push(pair<int, int>(*it, v));
}
}
while (!Q[1].empty()) {
int u = Q[1].front().first;
int v = Q[1].front().second;
Q[1].pop();
for (vector<int>::iterator it = adj[v].begin(); it != adj[v].end(); ++it)
if (d[u][*it][0] == -1 && u != *it) {
d[u][*it][0] = d[u][v][1];
p[u][*it][0] = v;
Q[0].push(pair<int, int>(u, *it));
}
}
}
if (d[n][1][0] == -1) {
puts("-1");
return 0;
}
vector<int> res[2];
res[0].push_back(n);
res[1].push_back(1);
int u = n, v = 1;
while (p[u][v][0]) {
v = p[u][v][0];
res[1].push_back(v);
u = p[u][v][1];
res[0].push_back(u);
}
reverse(res[0].begin(), res[0].end());
reverse(res[1].begin(), res[1].end());
printf("%d\n", d[n][1][0]);
for (int i = 0; i < (int)res[0].size(); ++i) {
if (i) printf(" ");
printf("%d", res[0][i]);
}
printf("\n");
for (int i = 0; i < (int)res[1].size(); ++i) {
if (i) printf(" ");
printf("%d", res[1][i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 505;
pair<pair<int, int>, int> par[MAXN][MAXN][2];
int d[MAXN][MAXN][2], ans[2][MAXN], in;
int n, m;
bool mark[MAXN][MAXN][2], g[MAXN][MAXN];
queue<pair<pair<int, int>, int> > q;
void enque(int x, int y, int t, pair<pair<int, int>, int> P, int dist) {
mark[x][y][t] = true;
q.push({{x, y}, t});
par[x][y][t] = P;
d[x][y][t] = dist + 1;
}
void BFS(int x, int y, int t) {
enque(x, y, t, {{-1, -1}, 0}, -1);
while (!q.empty()) {
auto x = q.front();
q.pop();
if (x.second == 0) {
for (int i = 0; i < n; i++)
if (g[x.first.first][i] && !mark[i][x.first.second][1])
enque(i, x.first.second, 1, x,
d[x.first.first][x.first.second][x.second]);
} else
for (int i = 0; i < n; i++)
if (i != x.first.first && g[i][x.first.second] &&
!mark[x.first.first][i][0])
enque(x.first.first, i, 0, x,
d[x.first.first][x.first.second][x.second]);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a][b] = g[b][a] = 1;
}
BFS(0, n - 1, 0);
if (d[n - 1][0][0] == 0) {
cout << -1 << endl;
return 0;
}
cout << d[n - 1][0][0] / 2 << endl;
pair<pair<int, int>, int> p = {{n - 1, 0}, 0};
while (p != par[0][n - 1][0]) {
ans[0][in] = p.first.second;
ans[1][in] = p.first.first;
in++;
p = par[p.first.first][p.first.second][p.second];
if (p == par[0][n - 1][0]) break;
p = par[p.first.first][p.first.second][p.second];
}
for (int j = 0; j < 2; j++, cout << endl)
for (int i = in - 1; i >= 0; i--) cout << ans[1 - j][i] + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 505;
int N, M;
vector<int> adj[MAXN];
pair<int, int> bt[MAXN][MAXN][2];
queue<tuple<int, int, int> > Q;
deque<pair<int, int> > ans;
void go(int a, int b, int c) {
if (!c) ans.push_back(pair<int, int>(a, b));
pair<int, int>& x = bt[a][b][c];
if (x.first != a || x.second != b) go(x.first, x.second, c ^ 1);
}
int main(int argc, char* argv[]) {
scanf("%d%d", &N, &M);
for (int i = 0, _i = M; i < _i; ++i) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
Q.push(tuple<int, int, int>(N, 1, 0));
bt[N][1][0] = pair<int, int>(N, 1);
while (!Q.empty()) {
int a, b, c;
tie(a, b, c) = Q.front();
Q.pop();
if (c == 0) {
for (decltype((adj[a]).begin()) it = (adj[a]).begin(),
_it = (adj[a]).end();
it != _it; ++it) {
if (!bt[*it][b][1].first) {
bt[*it][b][1] = pair<int, int>(a, b);
Q.push(tuple<int, int, int>(*it, b, 1));
}
}
} else {
for (decltype((adj[b]).begin()) it = (adj[b]).begin(),
_it = (adj[b]).end();
it != _it; ++it) {
if (!bt[a][*it][0].first && *it != a) {
bt[a][*it][0] = pair<int, int>(a, b);
Q.push(tuple<int, int, int>(a, *it, 0));
}
}
}
}
if (!bt[1][N][0].first) return puts("-1") & 0;
go(1, N, 0);
printf("%d\n", ans.size() - 1);
for (decltype((ans).begin()) it = (ans).begin(), _it = (ans).end(); it != _it;
++it)
printf("%d ", it->first);
puts("");
for (decltype((ans).begin()) it = (ans).begin(), _it = (ans).end(); it != _it;
++it)
printf("%d ", it->second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[512];
int dis[512][512];
int head, tail;
pair<int, int> par[512][512];
pair<int, int> q[512 * 512];
int main() {
int n, m, a, b;
cin >> n >> m;
while (m--) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
head = tail = 0;
memset(dis, -1, sizeof dis);
q[tail++] = pair<int, int>(1, n);
dis[1][n] = 0;
par[1][n] = pair<int, int>(-1, -1);
while (head < tail && dis[n][1] == -1) {
a = q[head].first;
b = q[head].second;
head++;
for (int i = 0; i < adj[a].size(); i++) {
int c = adj[a][i], d;
for (int j = 0; j < adj[b].size(); j++) {
d = adj[b][j];
if (dis[c][d] == -1 && c != d) {
par[c][d] = pair<int, int>(a, b);
dis[c][d] = dis[a][b] + 1;
q[tail++] = pair<int, int>(c, d);
}
}
}
}
cout << dis[n][1] << endl;
if (dis[n][1] != -1) {
pair<int, int> start(n, 1);
vector<int> x, y;
do {
x.push_back(start.first);
y.push_back(start.second);
start = par[start.first][start.second];
if (start.first == -1) break;
} while (true);
reverse(x.begin(), x.end());
reverse(y.begin(), y.end());
for (int i = 0; i < x.size(); i++) cout << (i == 0 ? "" : " ") << x[i];
cout << endl;
for (int i = 0; i < y.size(); i++) cout << (i == 0 ? "" : " ") << y[i];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5e2 + 10, inf = 1e9 + 7;
int n, m;
int dis[2][MAX_N][MAX_N];
pair<int, pair<int, int> > par[2][MAX_N][MAX_N];
vector<int> G[MAX_N];
pair<int, pair<int, int> > Arr[MAX_N * MAX_N * 8];
int L, R;
vector<int> ans[2];
void bfs() {
L = R = MAX_N * MAX_N * 4;
for (int i = 0; i < 2; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) dis[i][j][k] = inf;
dis[0][0][n - 1] = 0;
Arr[R++] = {0, {0, n - 1}};
while (L < R) {
int type = Arr[L].first;
int v = Arr[L].second.first;
int u = Arr[L++].second.second;
if (type == 0) {
for (int i = 0; i < G[v].size(); i++)
if (1 + dis[0][v][u] < dis[1][G[v][i]][u]) {
dis[1][G[v][i]][u] = 1 + dis[0][v][u];
par[1][G[v][i]][u] = {0, {v, u}};
Arr[R++] = {1, {G[v][i], u}};
}
} else {
for (int i = 0; i < G[u].size(); i++) {
if (dis[1][v][u] < dis[0][v][G[u][i]] && v != G[u][i]) {
dis[0][v][G[u][i]] = dis[1][v][u];
par[0][v][G[u][i]] = {1, {v, u}};
Arr[--L] = {0, {v, G[u][i]}};
}
}
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie();
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
G[v].push_back(u);
G[u].push_back(v);
}
bfs();
if (dis[0][n - 1][0] == inf) {
cout << "-1\n";
return 0;
}
cout << dis[0][n - 1][0] << "\n";
int t = 0, v = n - 1, u = 0;
while (v != 0 || u != n - 1) {
pair<int, pair<int, int> > tmp = par[t][v][u];
if (t)
ans[0].push_back(v + 1);
else
ans[1].push_back(u + 1);
t = tmp.first;
v = tmp.second.first;
u = tmp.second.second;
}
reverse(ans[0].begin(), ans[0].end());
reverse(ans[1].begin(), ans[1].end());
cout << 1 << " ";
for (int i = 0; i < ans[0].size(); i++) cout << ans[0][i] << " ";
cout << "\n";
cout << n << " ";
for (int i = 0; i < ans[1].size(); i++) cout << ans[1][i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, l, r, tot, ans[2][1000005], hed[510];
struct node {
int a, b, dis, pre, flag;
node(int aa = 0, int bb = 0, int dd = 0, int pp = 0, int ff = 0) {
a = aa;
b = bb;
dis = dd;
pre = pp;
flag = ff;
}
};
node q[1000005];
bool visa[520][520], visb[520][520];
struct edg {
int to, nxt;
} e[1000005];
void add(int x, int y) {
e[++tot] = (edg){y, hed[x]};
hed[x] = tot;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
l = r = 1;
q[r++] = node(1, n, 0, 0, 1);
tot = 0;
while (l < r) {
node p = q[l];
if (p.a == n && p.b == 1 && p.flag == 1) {
printf("%d\n", p.dis / 2);
for (int i = l; i; i = q[i].pre) {
if (q[i].flag == 1) {
tot++;
ans[0][tot] = q[i].a;
ans[1][tot] = q[i].b;
}
}
for (int i = tot; i >= 1; i--) printf("%d ", ans[0][i]);
printf("\n");
for (int i = tot; i >= 1; i--) printf("%d ", ans[1][i]);
printf("\n");
return 0;
}
if (p.flag == 1) {
for (int i = hed[p.a]; i; i = e[i].nxt) {
if (!visa[e[i].to][p.b]) {
visa[e[i].to][p.b] = 1;
q[r++] = node(e[i].to, p.b, p.dis + 1, l, 0);
}
}
} else {
for (int i = hed[p.b]; i; i = e[i].nxt) {
if (!visb[p.a][e[i].to] && p.a != e[i].to) {
visb[p.a][e[i].to] = 1;
q[r++] = node(p.a, e[i].to, p.dis + 1, l, 1);
}
}
}
l++;
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10;
int d[maxn][maxn][3], n;
vector<int> adj[maxn], x, y;
queue<pair<pair<int, int>, int> > q;
pair<pair<int, int>, int> par[maxn][maxn][3];
void pp(int a, int b, int turn) {
if (turn)
x.push_back(a + 1);
else
y.push_back(b + 1);
if (a == 0 && b == n - 1 && turn == 0)
return;
else
pp(par[a][b][turn].first.first, par[a][b][turn].first.second,
par[a][b][turn].second);
}
void bfs_state() {
int a, b, turn;
d[0][n - 1][0] = 0;
q.push({{0, n - 1}, 0});
while (!q.empty()) {
a = q.front().first.first, b = q.front().first.second,
turn = q.front().second;
q.pop();
if (turn == 0) {
for (auto u : adj[a])
if (d[u][b][1] == -1) {
q.push({{u, b}, 1});
d[u][b][1] = d[a][b][0];
par[u][b][1] = {{a, b}, 0};
}
} else {
for (auto u : adj[b])
if (d[a][u][0] == -1 && u != a) {
q.push({{a, u}, 0});
d[a][u][0] = d[a][b][1] + 1;
par[a][u][0] = {{a, b}, 1};
}
}
}
return;
}
int main() {
int m, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
u--;
v--;
adj[v].push_back(u);
adj[u].push_back(v);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j][0] = d[i][j][1] = -1;
bfs_state();
int ans = d[n - 1][0][0];
cout << ans << endl;
if (ans != -1) {
pp(n - 1, 0, 0);
x.push_back(1);
for (auto i : y) cout << i << " ";
cout << endl;
for (auto i : x) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
vector<vector<int> > graph;
void init() { graph.assign(n + 7, vector<int>()); }
void add_edge(int u, int v) {
graph[u].push_back(v);
graph[v].push_back(u);
}
void bfs() {
vector<vector<int> > dist(n + 7, vector<int>(n + 7, -1));
vector<vector<pair<int, int> > > pred(
n + 7, vector<pair<int, int> >(n + 7, pair<int, int>(-1, -1)));
deque<pair<int, int> > q;
dist[1][n] = 0;
q.push_back(pair<int, int>(1, n));
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop_front();
if (cur.first == n && cur.second == 1) break;
for (int v1 : graph[cur.first]) {
for (int v2 : graph[cur.second]) {
if (v1 == v2) continue;
pair<int, int> nxt = pair<int, int>(v1, v2);
if (dist[v1][v2] != -1) continue;
dist[v1][v2] = 1;
pred[v1][v2] = cur;
q.push_back(pair<int, int>(nxt));
}
}
}
if (dist[n][1] == -1) {
cout << -1 << endl;
return;
}
vector<int> out1, out2;
pair<int, int> cur = pair<int, int>(n, 1);
while (true) {
out2.push_back(cur.first);
out1.push_back(cur.second);
if (cur == pair<int, int>(1, n)) break;
cur = pred[cur.first][cur.second];
}
cout << out1.size() - 1 << endl;
for (int i = 0; i < out1.size(); i++) {
if (i) cout << " ";
cout << out1[i];
}
cout << endl;
for (int i = 0; i < out2.size(); i++) {
if (i) cout << " ";
cout << out2[i];
}
cout << endl;
}
int main() {
cin >> n >> m;
init();
for (int i = 0; i < m; i++) {
cin >> a >> b;
add_edge(a, b);
}
bfs();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 5, inf = 1e9;
int n, m, dp[N][N];
pair<short int, short int> par[N][N];
vector<int> adj[N];
void bfs() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dp[i][j] = inf;
par[0][n - 1] = make_pair(-1, -1);
dp[0][n - 1] = 0;
queue<pair<short int, short int> > q;
q.push(make_pair(0, n - 1));
while (!q.empty()) {
pair<short int, short int> p = q.front();
q.pop();
int v = p.first, u = p.second;
for (auto x : adj[v])
for (auto y : adj[u])
if (x != y && dp[x][y] == inf) {
dp[x][y] = dp[v][u] + 1;
par[x][y] = p;
q.push(make_pair(x, y));
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--, u--;
adj[v].push_back(u);
adj[u].push_back(v);
}
bfs();
if (dp[n - 1][0] == inf) return cout << -1 << "\n", 0;
cout << dp[n - 1][0] << "\n";
vector<int> ans[2];
int x = n - 1, y = 0;
do {
ans[0].push_back(x);
ans[1].push_back(y);
pair<short int, short int> p = par[x][y];
x = p.first, y = p.second;
} while (x != -1 && y != -1);
for (int i = 0; i < 2; i++) {
reverse(ans[i].begin(), ans[i].end());
for (auto v : ans[i]) cout << v + 1 << " ";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxN = 1e3 + 13;
vector<int> adj[maxN];
int sp[maxN][maxN];
pair<int, int> par[maxN][maxN];
queue<pair<int, int>> qu;
vector<int> vec1, vec2;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
sp[1][n] = 1;
qu.push({1, n});
par[1][n] = {0, 0};
while (qu.size()) {
int u = qu.front().first, v = qu.front().second;
qu.pop();
if (u != v) {
for (auto a : adj[u])
for (auto b : adj[v]) {
if (!sp[a][b]) {
sp[a][b] = sp[u][v] + 1;
qu.push({a, b});
par[a][b] = {u, v};
}
}
}
}
int x = n, y = 1;
if (!sp[x][y]) return cout << -1 << endl, 0;
while (x + y > 0) {
vec1.push_back(x);
vec2.push_back(y);
int tmp = par[x][y].first;
y = par[x][y].second;
x = tmp;
}
cout << vec1.size() - 1 << endl;
for (int i = 0; i < vec2.size(); i++) cout << vec2[i] << " ";
cout << endl;
for (int i = 0; i < vec1.size(); i++) cout << vec1[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int Dn[510][510][2];
int Dad[510][510][2][3];
int Pri[510][2];
int Push;
vector<int> Way[510];
queue<pair<pair<int, int>, int> > q;
int main() {
scanf("%d%d", &N, &M);
for (int i = 1, a, b; i <= M; i++) {
scanf("%d%d", &a, &b);
Way[a].push_back(b);
Way[b].push_back(a);
}
pair<pair<int, int>, int> tmp;
q.push(pair<pair<int, int>, int>(pair<int, int>(1, N), 0));
Dn[1][N][0] = 1;
while (!q.empty()) {
tmp = q.front();
q.pop();
int a, b, k;
a = tmp.first.first;
b = tmp.first.second;
k = tmp.second;
if (k == 0 && a == N && b == 1) {
printf("%d\n", Dn[a][b][k] - 1);
for (int ta, tb, tk; a != 1 || b != N || k != 0;) {
if (!k) {
Push++;
Pri[Push][1] = b;
} else
Pri[Push][0] = a;
ta = a;
tb = b;
tk = k;
a = Dad[ta][tb][tk][0];
b = Dad[ta][tb][tk][1];
k = Dad[ta][tb][tk][2];
}
Pri[++Push][0] = 1;
Pri[Push][1] = N;
for (int i = Push; i; i--) printf("%d ", Pri[i][0]);
printf("\n");
for (int i = Push; i; i--) printf("%d ", Pri[i][1]);
printf("\n");
return 0;
}
if (k == 0) {
for (int i = 0, mi = Way[a].size(); i < mi; i++)
if (!Dn[Way[a][i]][b][1]) {
Dn[Way[a][i]][b][1] = Dn[a][b][0];
Dad[Way[a][i]][b][1][0] = a;
Dad[Way[a][i]][b][1][1] = b;
Dad[Way[a][i]][b][1][2] = 0;
q.push(pair<pair<int, int>, int>(pair<int, int>(Way[a][i], b), 1));
}
} else {
for (int i = 0, mi = Way[b].size(); i < mi; i++)
if (!Dn[a][Way[b][i]][0] && Way[b][i] != a) {
Dn[a][Way[b][i]][0] = Dn[a][b][1] + 1;
Dad[a][Way[b][i]][0][0] = a;
Dad[a][Way[b][i]][0][1] = b;
Dad[a][Way[b][i]][0][2] = 1;
q.push(pair<pair<int, int>, int>(pair<int, int>(a, Way[b][i]), 0));
}
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 510, MAX2 = 1e4 + 10;
struct node {
int x, y, c;
};
bool mark[MAX][MAX][2];
node make_node(int x, int y, int c) {
node n;
n.x = x, n.y = y, n.c = c;
mark[x][y][c] = true;
return n;
}
int n, m;
vector<int> g[MAX];
node fa[MAX][MAX][2];
bool bfs() {
queue<node> q;
q.push(make_node(0, n - 1, 0));
while (q.size()) {
node u = q.front();
q.pop();
if (!u.c) {
for (int i = 0; i < g[u.x].size(); i++)
if (!mark[g[u.x][i]][u.y][1])
q.push(make_node(g[u.x][i], u.y, 1)),
fa[g[u.x][i]][u.y][1] = make_node(u.x, u.y, u.c);
} else {
for (int i = 0; i < g[u.y].size(); i++)
if (!mark[u.x][g[u.y][i]][0] && u.x != g[u.y][i])
q.push(make_node(u.x, g[u.y][i], 0)),
fa[u.x][g[u.y][i]][0] = make_node(u.x, u.y, u.c);
}
if (u.x == n - 1 && u.y == 0 && u.c == 0) return true;
}
return false;
}
vector<int> ans1, ans2;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
if (!bfs()) {
cout << -1 << endl;
return 0;
}
node no = make_node(n - 1, 0, 0);
while (no.x != 0 || no.y != n - 1 || no.c != 0) {
ans1.push_back(no.x);
ans2.push_back(no.y);
no = fa[no.x][no.y][no.c];
}
ans1.push_back(0);
ans2.push_back(n - 1);
reverse(ans1.begin(), ans1.end());
reverse(ans2.begin(), ans2.end());
cout << (int)floor(ans1.size() * 1.0 / 2) << endl;
for (int i = 0; i < ans1.size(); i += 2) cout << ans1[i] + 1 << " ";
cout << endl;
for (int i = 0; i < ans2.size(); i += 2) cout << ans2[i] + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 5, M = 2e4 + 5;
int fir[N], nxt[M], to[M], ect = 0, n, m;
int f[N][N], G[N][N];
pair<int, int> paf[N][N], pag[N][N];
struct state {
int x, y, val;
state() { x = y = val = 0; }
state(int _x, int _y, int _val) {
x = _x;
y = _y;
val = _val;
}
};
queue<state> q1, q2;
inline void bfs() {
q1.push(state(1, n, f[1][n] = 0));
while (!q1.empty() || !q2.empty()) {
state tmp1 = state(), tmp2 = state();
if (!q1.empty()) tmp1 = q1.front();
if (!q2.empty()) tmp2 = q2.front();
if (!q1.empty()) q1.pop();
if (!q2.empty()) q2.pop();
int x1 = tmp1.x, y1 = tmp1.y, v1 = f[x1][y1];
int x2 = tmp2.x, y2 = tmp2.y, v2 = G[x2][y2];
if (x1)
for (int e = fir[x1], v; v = to[e], e; e = nxt[e]) {
if (G[v][y1] > v1) {
q2.push(state(v, y1, G[v][y1] = v1));
pag[v][y1] = make_pair(x1, y1);
}
}
if (y2)
for (int e = fir[y2], v; v = to[e], e; e = nxt[e]) {
if (f[x2][v] > v2 + 1 && x2 != v) {
q1.push(state(x2, v, f[x2][v] = v2 + 1));
paf[x2][v] = make_pair(x2, y2);
}
}
}
}
inline void addedge(int u1, int v1) {
nxt[++ect] = fir[u1];
fir[u1] = ect;
to[ect] = v1;
}
int res1[N], res2[N], cnt1 = 0, cnt2 = 0;
inline void print(int x, int y, int opt) {
if (!x && !y) return;
if (opt == 1) print(paf[x][y].first, paf[x][y].second, 2);
if (opt == 2) print(pag[x][y].first, pag[x][y].second, 1);
if (opt == 1) res1[++cnt1] = x, res2[++cnt2] = y;
}
int main() {
memset(f, 63, sizeof f);
memset(G, 63, sizeof G);
cin >> n >> m;
for (int i = 1, x, y; i <= m; i++)
cin >> x >> y, addedge(x, y), addedge(y, x);
bfs();
if (f[n][1] > 1e9)
return cout << -1 << endl, 0;
else
cout << f[n][1] << endl;
print(n, 1, 1);
for (int i = 1; i <= cnt1; i++) cout << res1[i] << ' ';
cout << endl;
for (int i = 1; i <= cnt2; i++) cout << res2[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
const int maxd = 250010;
const int maxm = 20010;
struct edge {
int y, d, next;
} a[maxm];
struct node {
int x, y;
} q[maxd];
int n;
int len, first[maxn];
int pre[maxn][maxn][2], ans[maxd][2], tot;
bool v1[maxn][maxn];
void ins(int x, int y) {
len++;
a[len].y = y;
a[len].next = first[x];
first[x] = len;
}
void init() {
int m, x, y;
scanf("%d%d", &n, &m);
len = 0;
memset(first, -1, sizeof(first));
while (m--) {
scanf("%d%d", &x, &y);
ins(x, y);
ins(y, x);
}
}
void solve() {
int head, tail, x, y, xx, yy, z;
node tmp, now;
head = tail = 1;
q[1].x = 1;
q[1].y = n;
memset(v1, false, sizeof(v1));
v1[1][n] = true;
pre[1][n][0] = -1;
while (head <= tail) {
now = q[head++];
x = now.x;
y = now.y;
for (int k = first[x]; k != -1; k = a[k].next) {
xx = a[k].y;
if (v1[xx][y]) continue;
v1[xx][y] = true;
for (int k = first[y]; k != -1; k = a[k].next) {
yy = a[k].y;
if (xx == yy) continue;
if (!pre[xx][yy][0]) {
pre[xx][yy][0] = x;
pre[xx][yy][1] = y;
tmp.x = xx;
tmp.y = yy;
q[++tail] = tmp;
}
}
}
}
if (!pre[n][1][0])
printf("-1\n");
else {
tot = 0;
x = n;
y = 1;
while (x != -1) {
tot++;
ans[tot][0] = x;
ans[tot][1] = y;
z = x;
x = pre[x][y][0];
y = pre[z][y][1];
}
printf("%d\n", tot - 1);
for (int i = tot; i >= 1; i--) printf("%d ", ans[i][0]);
printf("\n");
for (int i = tot; i >= 1; i--) printf("%d ", ans[i][1]);
printf("\n");
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M4 = 1e4 + 100, M5 = 1e5 + 100, M6 = 1e6 + 100, M7 = 1e7 + 100,
M8 = 1e8 + 100, M9 = 1e9 + 100;
int mark[2][501][501];
vector<int> adj[M5];
pair<int, int> ans, par[2][501][501];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d %d", &v, &u);
adj[v].push_back(u), adj[u].push_back(v);
}
queue<pair<pair<int, int>, bool> > q;
q.push({{1, n}, 0});
mark[0][1][n] = 1;
par[0][1][n] = make_pair(-1, -1);
while ((int)(q).size()) {
int v1 = q.front().first.first, v2 = q.front().first.second,
r = q.front().second;
q.pop();
if (r == 0) {
if (v1 == v2) continue;
if (v1 == n && v2 == 1) {
if ((mark[0][ans.first][ans.second] > 0 &&
mark[0][ans.first][ans.second] > mark[0][v1][v2]) ||
(mark[0][ans.first][ans.second] == 0))
ans = make_pair(v1, v2);
}
for (auto x : adj[v1]) {
auto p = make_pair(make_pair(x, v2), 1 - r);
if (!mark[1 - r][x][v2])
mark[1 - r][x][v2] = mark[r][v1][v2] + 1,
par[1 - r][x][v2] = make_pair(v1, v2), q.push(p);
}
} else {
for (auto x : adj[v2]) {
auto p = make_pair(make_pair(v1, x), 1 - r);
if (!mark[1 - r][v1][x])
mark[1 - r][v1][x] = mark[r][v1][v2] + 1,
par[1 - r][v1][x] = make_pair(v1, v2), q.push(p);
}
}
}
if (ans.first == 0 && ans.second == 0) return cout << -1, 0;
int r = 1;
printf("%d\n", (mark[0][ans.first][ans.second] - 1) / 2);
vector<int> w1, w2;
while (ans.first > 0 && ans.second > 0) {
w1.push_back(ans.first), w2.push_back(ans.second);
ans = par[1 - r][ans.first][ans.second];
r = 1 - r;
}
w1.push_back(1), w2.push_back(n);
w1.resize(unique((w1).begin(), (w1).end()) - w1.begin());
w2.resize(unique((w2).begin(), (w2).end()) - w2.begin());
for (int i = (int)(w1).size() - 1; ~i; i--) printf("%d ", w1[i]);
printf("\n");
for (int i = (int)(w2).size() - 1; ~i; i--) printf("%d ", w2[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct state {
int bo;
int al;
int nMov;
int pers;
};
vector<int> graph[502], pathAl, pathBo;
int vist[502][502][2];
int retr[502][502][2];
int n, m, BOB = 0, ALEX = 1;
void bfs() {
memset(vist, 0, sizeof(vist));
memset(retr, 0, sizeof(retr));
queue<state> cola;
state actual, next;
actual.bo = 1;
actual.al = n;
actual.nMov = 0;
actual.pers = ALEX;
cola.push(actual);
vist[actual.bo][actual.al][actual.pers] = 1;
while (!cola.empty()) {
actual = cola.front();
cola.pop();
if (actual.bo == n && actual.al == 1 && actual.pers == ALEX) break;
if (actual.pers == ALEX) {
next.pers = BOB;
next.al = actual.al;
next.nMov = actual.nMov + 1;
for (int i = 0; i < graph[actual.bo].size(); i++) {
next.bo = graph[actual.bo][i];
if (!vist[next.bo][next.al][next.pers]) {
vist[next.bo][next.al][next.pers] = 1;
retr[next.bo][next.al][next.pers] = actual.bo;
cola.push(next);
}
}
} else {
next.pers = ALEX;
next.bo = actual.bo;
next.nMov = actual.nMov;
for (int i = 0; i < graph[actual.al].size(); i++) {
next.al = graph[actual.al][i];
if (!vist[next.bo][next.al][next.pers] && next.al != next.bo) {
vist[next.bo][next.al][next.pers] = 1;
retr[next.bo][next.al][next.pers] = actual.al;
cola.push(next);
}
}
}
}
if (actual.bo != n || actual.al != 1 || actual.pers != ALEX)
printf("-1\n");
else {
for (int i = 0; i < actual.nMov * 2 + 2; i++) {
if (actual.pers == ALEX) {
pathAl.push_back(actual.al);
actual.al = retr[actual.bo][actual.al][actual.pers];
actual.pers = BOB;
} else {
pathBo.push_back(actual.bo);
actual.bo = retr[actual.bo][actual.al][actual.pers];
actual.pers = ALEX;
}
}
reverse(pathAl.begin(), pathAl.end());
reverse(pathBo.begin(), pathBo.end());
printf("%d\n", actual.nMov);
for (int i = 0; i < pathBo.size(); i++)
printf("%d %c", pathBo[i], i + 1 != pathBo.size() ? ' ' : '\n');
for (int i = 0; i < pathAl.size(); i++)
printf("%d %c", pathAl[i], i + 1 != pathAl.size() ? ' ' : '\n');
}
}
int main() {
int a, b;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
bfs();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10;
bool mark[maxn][maxn][2];
pair<pair<int, int>, int> mp[maxn][maxn][2];
vector<int> v[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(1, n), 1));
mark[1][n][1] = 1;
while (q.size()) {
pair<int, int> u = q.front().first;
int k = q.front().second;
q.pop();
if (u.first == n && u.second == 1 && k == 1) break;
if (k == 1) {
for (int i = 0; i < v[u.first].size(); i++) {
if (!mark[v[u.first][i]][u.second][1 - k]) {
mark[v[u.first][i]][u.second][1 - k] = 1;
mp[v[u.first][i]][u.second][1 - k] = make_pair(u, k);
q.push(make_pair(make_pair(v[u.first][i], u.second), 1 - k));
}
}
} else {
for (int j = 0; j < v[u.second].size(); j++)
if (u.first != v[u.second][j]) {
if (!mark[u.first][v[u.second][j]][1 - k]) {
mark[u.first][v[u.second][j]][1 - k] = 1;
mp[u.first][v[u.second][j]][1 - k] = make_pair(u, k);
q.push(make_pair(make_pair(u.first, v[u.second][j]), 1 - k));
}
}
}
}
if (mark[n][1][1] == 0) return cout << -1 << endl, 0;
pair<pair<int, int>, int> u = make_pair(make_pair(n, 1), 1);
vector<pair<pair<int, int>, int> > ans;
ans.push_back(make_pair(make_pair(n, 1), 1));
int k = 1;
while (mp[u.first.first][u.first.second][k] !=
make_pair(make_pair(0, 0), 0)) {
ans.push_back(mp[u.first.first][u.first.second][k]);
u = mp[u.first.first][u.first.second][k];
k = 1 - k;
}
reverse(ans.begin(), ans.end());
cout << (ans.size() - 1) / 2 << endl;
int ps = 1;
for (int i = 0; i < ans.size(); i++) {
if (ps == 1) printf("%d ", ans[i].first.first);
ps = !ps;
}
cout << endl;
ps = 1;
for (int i = 0; i < ans.size(); i++) {
if (ps == 1) printf("%d ", ans[i].first.second);
ps = !ps;
}
return 0;
}
|
#include <bits/stdc++.h>
struct edge_type {
int y, next;
} edge[10010 << 1];
struct queue_type {
int x, xx, step, fa;
} Q[250010];
int n, m, cnt, first[510], ans[510][2], head, tail;
bool bo[510][510];
void ins(int x, int y) {
edge[++cnt].y = y;
edge[cnt].next = first[x];
first[x] = cnt;
}
int bfs() {
int x, xx, k, kk, y, yy;
Q[1].x = 1;
Q[1].xx = n;
bo[1][n] = true;
for (head = tail = 1; head <= tail; head++) {
x = Q[head].x;
xx = Q[head].xx;
for (k = first[x]; k; k = edge[k].next) {
y = edge[k].y;
for (kk = first[xx]; kk; kk = edge[kk].next) {
yy = edge[kk].y;
if (y != yy && !bo[y][yy]) {
Q[++tail].x = y;
Q[tail].xx = yy;
Q[tail].step = Q[head].step + 1;
Q[tail].fa = head;
bo[y][yy] = true;
if (y == n && yy == 1) return Q[tail].step;
}
}
}
}
return -1;
}
int main() {
int i, j, x, y;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
ins(x, y);
ins(y, x);
}
x = bfs();
printf("%d\n", x);
if (x != -1) {
head = 0;
for (i = tail; i; i = Q[i].fa) {
ans[++head][0] = (Q[i].x);
ans[head][1] = Q[i].xx;
}
for (i = head; i > 1; i--) printf("%d ", ans[i][0]);
printf("%d\n", ans[1][0]);
for (i = head; i > 1; i--) printf("%d ", ans[i][1]);
printf("%d\n", ans[1][1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > g;
int b[500][500][2], p1[500][500][2], p2[500][500][2];
int q1[500 * 500 * 2], q2[500 * 500 * 2], q3[500 * 500 * 2];
int l, c;
bool found;
vector<int> a1, a2;
int main() {
scanf("%d%d", &n, &m);
g.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++) b[i][j][k] = 0;
b[0][n - 1][0] = 1;
p1[0][n - 1][0] = -1;
p2[0][n - 1][0] = -1;
l = 0;
c = 0;
q1[0] = 0;
q2[0] = n - 1;
q3[0] = 0;
int v1, v2, u1, u2, stp;
found = 0;
while (c <= l) {
v1 = q1[c];
v2 = q2[c];
stp = q3[c];
c++;
if (stp == 0) {
for (int i = 0; i < g[v1].size() && !found; i++) {
int u1 = g[v1][i];
if (!b[u1][v2][1]) {
b[u1][v2][1] = 1;
p1[u1][v2][1] = v1;
p2[u1][v2][1] = v2;
l++;
q1[l] = u1;
q2[l] = v2;
q3[l] = 1;
}
}
} else {
for (int i = 0; i < g[v2].size() && !found; i++) {
int u2 = g[v2][i];
if (!b[v1][u2][0] && v1 != u2) {
b[v1][u2][0] = 1;
p1[v1][u2][0] = v1;
p2[v1][u2][0] = v2;
l++;
q1[l] = v1;
q2[l] = u2;
q3[l] = 0;
if (v1 == n - 1 && u2 == 0) found = 1;
}
}
}
if (found) break;
}
if (found) {
for (u1 = n - 1, u2 = 0;;) {
a1.push_back(u1);
a2.push_back(u2);
v1 = p1[u1][u2][0];
v2 = p2[u1][u2][0];
if (v1 == -1 || v2 == -1) break;
u1 = v1;
u2 = v2;
v1 = p1[u1][u2][1];
v2 = p2[u1][u2][1];
if (v1 == -1 || v2 == -1) break;
u1 = v1;
u2 = v2;
}
printf("%d\n", a1.size() - 1);
for (int i = a1.size() - 1; i >= 0; i--) printf("%d ", a1[i] + 1);
printf("\n");
for (int i = a2.size() - 1; i >= 0; i--) printf("%d ", a2[i] + 1);
printf("\n");
} else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long maxn = 500 * 1001;
const long long mod = 998244353;
long long n, m, k;
vector<int> g[maxn], vg[maxn];
int node[510][510][2];
pair<pair<int, int>, int> nod[maxn];
queue<int> q;
bool mark[maxn];
int dis[maxn], par[maxn];
void bfs(long long u) {
mark[u] = 1;
dis[u] = 0;
q.push(u);
while (q.size()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++)
if (mark[g[v][i]] == 0) {
dis[g[v][i]] = dis[v] + 1;
mark[g[v][i]] = 1;
par[g[v][i]] = v;
q.push(g[v][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
vg[u].push_back(v);
vg[v].push_back(u);
}
int o = 1;
for (int v = 1; v <= n; v++)
for (int u = 1; u <= n; u++)
if (u != v) {
node[v][u][0] = o;
nod[o] = {{v, u}, 0};
dis[o] = INF;
o++;
node[v][u][1] = o;
nod[o] = {{v, u}, 1};
dis[o] = INF;
o++;
} else {
node[v][u][1] = o;
nod[o] = {{v, u}, 1};
dis[o] = INF;
o++;
}
for (int v = 1; v <= n; v++)
for (int u = 1; u <= n; u++)
if (u != v) {
o = node[v][u][0];
for (int ii = 0; ii < vg[v].size(); ii++)
g[o].push_back(node[vg[v][ii]][u][1]);
o++;
for (int ii = 0; ii < vg[u].size(); ii++)
if (vg[u][ii] != v) g[o].push_back(node[v][vg[u][ii]][0]);
} else {
for (int ii = 0; ii < vg[v].size(); ii++)
g[node[v][v][1]].push_back(node[v][vg[v][ii]][0]);
}
bfs(node[1][n][0]);
o = node[n][1][0];
vector<int> ans, ans1;
if (dis[o] == INF)
cout << -1;
else {
cout << dis[o] / 2 << "\n";
long long i = 0;
while (o) {
int v = nod[o].first.first;
int u = nod[o].first.second;
int t = nod[o].second;
if (t == 1)
ans.push_back(v);
else
ans1.push_back(u);
o = par[o];
}
cout << 1 << " ";
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
cout << "\n";
for (int i = ans1.size() - 1; i >= 0; i--) cout << ans1[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int oo = numeric_limits<int>::max() / 2;
constexpr int N = 501;
int n, m;
vector<int> g[N];
int d[N][N][2];
int fromx[N][N][2];
int fromy[N][N][2];
struct State {
State(int x_, int y_, int t_) : x(x_), y(y_), t(t_) {}
int x, y, t;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
d[i][j][0] = d[i][j][1] = oo;
}
}
fromx[0][n - 1][0] = -1;
fromy[0][n - 1][0] = -1;
d[0][n - 1][0] = 0;
queue<State> q;
q.emplace(0, n - 1, 0);
while (!q.empty()) {
auto& cur = q.front();
if (cur.t == 0) {
for (auto to : g[cur.x]) {
if (d[to][cur.y][1] > d[cur.x][cur.y][0] + 1) {
d[to][cur.y][1] = d[cur.x][cur.y][0] + 1;
q.emplace(to, cur.y, 1);
fromx[to][cur.y][1] = cur.x;
fromy[to][cur.y][1] = cur.y;
}
}
} else {
for (auto to : g[cur.y]) {
if (to == cur.x) {
continue;
}
if (d[cur.x][to][0] > d[cur.x][cur.y][1] + 1) {
d[cur.x][to][0] = d[cur.x][cur.y][1] + 1;
q.emplace(cur.x, to, 0);
fromx[cur.x][to][0] = cur.x;
fromy[cur.x][to][0] = cur.y;
}
}
}
q.pop();
}
if (d[n - 1][0][0] == oo) {
cout << -1 << endl;
} else {
vector<int> path[2];
function<void(int, int, int, bool)> build = [&](int i, int j, int t,
bool flag) {
if (i == -1 || j == -1) {
return;
}
int pi = fromx[i][j][t];
int pj = fromy[i][j][t];
if (flag) {
path[0].push_back(i);
path[1].push_back(j);
} else {
if (t == 1) {
path[1].push_back(j);
} else {
path[0].push_back(i);
}
}
build(pi, pj, 1 - t, false);
};
cout << d[n - 1][0][0] / 2 << endl;
build(n - 1, 0, 0, true);
reverse(path[0].begin(), path[0].end());
for (int i : path[0]) {
cout << (i + 1) << " ";
}
cout << endl;
reverse(path[1].begin(), path[1].end());
for (int i : path[1]) {
cout << (i + 1) << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 5;
int dis[maxn][maxn][3];
vector<int> adj[maxn];
bool mark[maxn][maxn];
pair<int, int> par[maxn][maxn][3];
void bfs(int x, int y) {
queue<pair<pair<int, int>, int>> q;
q.push({{x, y}, 0});
dis[x][y][0] = 0;
while (q.size()) {
int x = q.front().first.first;
int y = q.front().first.second;
int t = q.front().second;
q.pop();
if (!t) {
for (int u : adj[x]) {
if (dis[u][y][1] > dis[x][y][0] + 1) {
dis[u][y][1] = dis[x][y][0] + 1;
par[u][y][1] = {x, 0};
q.push({{u, y}, 1});
}
}
} else {
for (int u : adj[y]) {
if (u != x && dis[x][u][0] > dis[x][y][1]) {
dis[x][u][0] = dis[x][y][1];
par[x][u][0] = {y, 1};
q.push({{x, u}, 0});
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
par[0][n - 1][0] = {-1, -1};
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j][0] = dis[i][j][1] = INT_MAX;
}
}
bfs(0, n - 1);
if (dis[n - 1][0][0] == INT_MAX) {
cout << -1;
return 0;
}
cout << dis[n - 1][0][0] << endl;
int x = n - 1, y = 0;
int t = 0;
vector<int> v1;
vector<int> v2;
while (x != -1 && y != -1) {
int u = par[x][y][t].first;
t = par[x][y][t].second;
if (t == 0) {
v1.push_back(x);
x = u;
} else {
v2.push_back(y);
y = u;
}
}
v1.push_back(x);
reverse(v1.begin(), v1.end());
reverse(v2.begin(), v2.end());
for (int i : v1) cout << i + 1 << " ";
cout << endl;
for (int i : v2) {
cout << i + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
struct tnode {
int sum;
tnode *lson, *rson;
tnode(int x = 0) {
sum = x;
lson = rson = NULL;
}
};
void pushup(tnode* cur) {
cur->sum = (cur->lson == NULL ? 0 : cur->lson->sum) +
(cur->rson == NULL ? 0 : cur->rson->sum);
}
tnode* modify(tnode* cur, int id, int val, int cl = 0, int cr = 1048575) {
if (cl == cr) return new tnode(val);
int mid = (cl + cr) >> 1;
tnode* ret = new tnode();
tnode *ls = cur == NULL ? NULL : cur->lson,
*rs = cur == NULL ? NULL : cur->rson;
ret->lson = id <= mid ? modify(ls, id, val, cl, mid) : ls;
ret->rson = id > mid ? modify(rs, id, val, mid + 1, cr) : rs;
pushup(ret);
return ret;
}
int query(tnode* cur, int l, int r, int cl = 0, int cr = 1048575) {
if (cur == NULL) return 0;
if (l == cl && r == cr) return cur->sum;
int mid = (cl + cr) >> 1;
if (r <= mid)
return query(cur->lson, l, r, cl, mid);
else if (l > mid)
return query(cur->rson, l, r, mid + 1, cr);
else
return query(cur->lson, l, mid, cl, mid) +
query(cur->rson, mid + 1, r, mid + 1, cr);
}
int n, q, p0[1000005], occ[1000005], p1[1000005];
tnode* tre[1000005];
int x;
int f(int z) { return (z - 1 + x) % n + 1; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= (int)(n); i++) {
scanf("%d", &p0[i]);
occ[p0[i]] = i;
}
for (int i = 1; i <= (int)(n); i++) scanf("%d", &p1[i]);
for (int i = 1; i <= (int)(n); i++)
tre[i] = modify(tre[i - 1], occ[p1[i]], 1);
scanf("%d", &q);
x = 0;
for (int i = 0; i < (int)(q); i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a = f(a);
b = f(b);
c = f(c);
d = f(d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
x = query(tre[d], a, b) - query(tre[c - 1], a, b) + 1;
printf("%d\n", x - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1 << 20];
int it[22][1 << 20];
int pos[1 << 20];
int LOW, UP;
void makeTree(int l, int r, int lvl) {
if (l == r) {
it[lvl][l] = arr[l];
return;
}
int mid = (l + r) / 2;
makeTree(l, mid, lvl + 1);
makeTree(mid + 1, r, lvl + 1);
merge(it[lvl + 1] + l, it[lvl + 1] + mid + 1, it[lvl + 1] + mid + 1,
it[lvl + 1] + r + 1, it[lvl] + l);
}
int query(int l, int r, int lvl, int f, int t) {
if (l > t || r < f) return 0;
if (l >= f && r <= t) {
int *lw = lower_bound(it[lvl] + l, it[lvl] + r + 1, LOW);
int *up = upper_bound(it[lvl] + l, it[lvl] + r + 1, UP);
return up - lw;
}
int mid = (l + r) / 2;
return query(l, mid, lvl + 1, f, t) + query(mid + 1, r, lvl + 1, f, t);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
pos[x] = i;
}
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] = pos[arr[i]];
}
makeTree(1, n, 0);
x = 0;
int q;
cin >> q;
int a, b, c, d;
for (int i = 0; i < q; i++) {
cin >> a >> b >> c >> d;
a = (a - 1 + x) % n + 1;
b = (b - 1 + x) % n + 1;
if (a > b) swap(a, b);
c = (c - 1 + x) % n + 1;
d = (d - 1 + x) % n + 1;
if (c > d) swap(c, d);
LOW = a;
UP = b;
x = query(1, n, 0, c, d);
cout << x << endl;
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
int a[1001005], b[1001005], pp[4];
int t[1001005 * 21], cnt, root[1001005], lc[1001005 * 21], rc[1001005 * 21];
void update(int rt, int &cur, int l, int r, int v) {
cur = ++cnt;
if (l + 1 == r) {
t[cur] = t[rt] + 1;
return;
}
int mid = (l + r) >> 1;
if (v <= mid) {
update(lc[rt], lc[cur], l, mid, v);
rc[cur] = rc[rt];
} else {
update(rc[rt], rc[cur], mid, r, v);
lc[cur] = lc[rt];
}
t[cur] = t[lc[cur]] + t[rc[cur]];
}
int qy(int rt, int cur, int l, int r, int L, int R) {
if (R <= l || r <= L) return 0;
if (L <= l && r <= R) {
return t[cur] - t[rt];
}
int mid = (l + r) >> 1;
int x = qy(lc[rt], lc[cur], l, mid, L, R);
int y = qy(rc[rt], rc[cur], mid, r, L, R);
return x + y;
}
int f(int x, int z) { return (z - 1 + x) % n + 1; }
int main() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", &k);
b[k] = i;
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
update(root[i - 1], root[i], 0, n, b[a[i]]);
}
int x = 0;
scanf("%d", &m);
for (int(i) = 0; (i) < (int)(m); (i)++) {
for (int(j) = 0; (j) < (int)(4); (j)++) {
scanf("%d", pp + j);
pp[j] = f(x, pp[j]);
}
int l1 = min(pp[0], pp[1]);
int r1 = max(pp[0], pp[1]);
int l2 = min(pp[2], pp[3]);
int r2 = max(pp[2], pp[3]);
printf("%d\n", x = qy(root[l1 - 1], root[r1], 0, n, l2 - 1, r2));
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1 << 20;
int n, X, tmp, m, a, b, c, d;
vector<int> s[M * 2];
int p[M], q[M];
int qu(int l1, int r1, int l2, int r2, int small = 0, int big = M - 1,
int index = 1) {
l1 = max(l1, small);
r1 = min(r1, big);
if (l1 > r1) return 0;
if (small == l1 and big == r1)
return upper_bound((s[index]).begin(), (s[index]).end(), r2) -
lower_bound((s[index]).begin(), (s[index]).end(), l2);
return qu(l1, r1, l2, r2, small, (small + big) / 2, 2 * index) +
qu(l1, r1, l2, r2, (small + big) / 2 + 1, big, index * 2 + 1);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> tmp;
p[tmp] = i;
}
for (int i = 1; i <= n; ++i) {
cin >> tmp;
q[tmp] = i;
}
for (int i = 1; i <= n; ++i) s[p[i] + M].push_back(q[i]);
for (int i = M - 1; i >= 0; --i)
merge((s[i * 2]).begin(), (s[i * 2]).end(), (s[i * 2 + 1]).begin(),
(s[i * 2 + 1]).end(), back_inserter(s[i]));
cin >> m;
while (m--) {
cin >> a >> b >> c >> d;
int l1 = min(((((a)-1 + X) % n) + 1), ((((b)-1 + X) % n) + 1)),
r1 = max(((((a)-1 + X) % n) + 1), ((((b)-1 + X) % n) + 1)),
l2 = min(((((c)-1 + X) % n) + 1), ((((d)-1 + X) % n) + 1)),
r2 = max(((((c)-1 + X) % n) + 1), ((((d)-1 + X) % n) + 1));
X = qu(l1, r1, l2, r2);
cout << X++ << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000,1000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
long long n, m, ans = 0;
long long a[1000005], b[1000005];
vector<long long> t[4000005];
inline long long f(long long x) {
long long res = ((x + ans - 1) % n + n) % n;
return res;
}
void build(long long v, long long l, long long r) {
if (l == r) {
t[v].push_back(a[l]);
return;
}
long long m = (l + r) >> 1LL;
if (l <= m) build(v + v, l, m);
if (r > m) build(v + v + 1, m + 1, r);
merge(t[v + v].begin(), t[v + v].end(), t[v + v + 1].begin(),
t[v + v + 1].end(), back_inserter(t[v]));
}
long long get(long long v, long long tl, long long tr, long long a, long long b,
long long c, long long d) {
if (a <= tl && b >= tr) {
return upper_bound((t[v]).begin(), (t[v]).end(), d) -
lower_bound((t[v]).begin(), (t[v]).end(), c);
}
long long tm = (tl + tr) >> 1LL;
long long res = 0;
if (a <= tm) res += get(v + v, tl, tm, a, b, c, d);
if (b > tm) res += get(v + v + 1, tm + 1, tr, a, b, c, d);
return res;
}
int main(void) {
cin >> n;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
int x;
scanf("%d", &x);
b[x - 1] = i;
}
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
int x;
scanf("%d", &x);
a[i] = b[x - 1];
}
build(1, 0, n - 1);
cin >> m;
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a = f(a);
b = f(b);
c = f(c);
d = f(d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
ans = get(1, 0, n - 1, c, d, a, b);
printf("%d\n", (int)ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T read1() {
T t = 0;
char k;
bool vis = 0;
do (k = getchar()) == '-' && (vis = 1);
while ('0' > k || k > '9');
while ('0' <= k && k <= '9')
t = (t << 3) + (t << 1) + (k ^ '0'), k = getchar();
return vis ? -t : t;
}
struct node {
node *l, *r;
int v;
node() {
l = r = NULL;
v = 0;
}
} * root[1000005];
int s, m, a[1000005];
node *insert(node *n, int x, int l = 1, int r = 1000000) {
node *v = new node;
if (n) v->l = n->l, v->r = n->r, v->v = n->v;
++v->v;
if (l == r) return v;
int mid = l + r >> 1;
if (x <= mid)
v->l = insert(v->l, x, l, mid);
else
v->r = insert(v->r, x, mid + 1, r);
return v;
}
int value(node *x) { return x ? x->v : 0; }
node *L(node *x) { return x ? x->l : NULL; }
node *R(node *x) { return x ? x->r : NULL; }
int query(node *x, node *y, int lx, int rx, int l = 1, int r = 1000000) {
if (l == lx && r == rx) return value(y) - value(x);
if (!x && !y) return 0;
int mid = l + r >> 1;
if (rx <= mid) return query(L(x), L(y), lx, rx, l, mid);
if (lx > mid) return query(R(x), R(y), lx, rx, mid + 1, r);
return query(L(x), L(y), lx, mid, l, mid) +
query(R(x), R(y), mid + 1, rx, mid + 1, r);
}
int main() {
s = read1<long long>();
for (int i = 1; i <= s; ++i) a[read1<long long>()] = i;
for (int i = 1; i <= s; ++i)
root[i] = insert(root[i - 1], a[read1<long long>()]);
int la = 0;
for (int T = read1<long long>(); T--;) {
int l1 = (read1<long long>() + la - 1) % s + 1,
r1 = (read1<long long>() + la - 1) % s + 1,
l2 = (read1<long long>() + la - 1) % s + 1,
r2 = (read1<long long>() + la - 1) % s + 1;
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
printf("%d\n", la = query(root[l2 - 1], root[r2], l1, r1));
++la;
}
return 0;
}
|
#include <bits/stdc++.h>
class Counter {
public:
Counter(std::vector<size_t> perm1, std::vector<size_t> perm2)
: size_(perm1.size()) {
std::vector<size_t> inv2(size_, 0);
for (size_t i = 0; i < size_; ++i) {
inv2[perm2[i]] = i;
}
auto& points = perm1;
for (size_t x = 0; x < size_; ++x) {
points[x] = inv2[perm1[x]];
}
size_t nextPowOfTwo = 1;
while (nextPowOfTwo < size_) nextPowOfTwo <<= 1;
segTree_.resize(2 * nextPowOfTwo - 1);
build(points, 0, 0, size_ - 1);
}
int count(size_t minX, size_t maxX, size_t minY, size_t maxY) {
return countAux(0, 0, size_ - 1, minX, maxX, minY, maxY);
}
private:
void build(const std::vector<size_t>& points, int vertex, int from, int to) {
if (from == to) {
segTree_[vertex].push_back(points[from]);
} else {
int middle = from + (to + 1 - from) / 2;
build(points, 2 * vertex + 1, from, middle - 1);
build(points, 2 * vertex + 2, middle, to);
const auto& left = segTree_[2 * vertex + 1];
const auto& right = segTree_[2 * vertex + 2];
segTree_[vertex].reserve(left.size() + right.size());
std::merge(left.begin(), left.end(), right.begin(), right.end(),
std::back_inserter(segTree_[vertex]));
}
}
int countAux(int vertex, int from, int to, int minX, int maxX, int minY,
int maxY) {
if (maxX < minX) {
return 0;
}
if (from == minX && to == maxX) {
const auto& range = segTree_[vertex];
auto it1 = std::lower_bound(range.begin(), range.end(), minY);
auto it2 = std::lower_bound(range.begin(), range.end(), maxY + 1);
return it2 - it1;
}
int middle = from + (to + 1 - from) / 2;
int countLeft = countAux(2 * vertex + 1, from, middle - 1, minX,
std::min(maxX, middle - 1), minY, maxY);
int countRight = countAux(2 * vertex + 2, middle, to,
std::max(minX, middle), maxX, minY, maxY);
return countLeft + countRight;
}
private:
size_t size_;
std::vector<std::vector<int>> segTree_;
};
int main() {
size_t size;
::scanf("%lu", &size);
auto readPerm = [](size_t size) {
std::vector<size_t> perm;
perm.reserve(size);
for (size_t i = 0; i < size; ++i) {
size_t elem;
::scanf("%lu", &elem);
--elem;
perm.push_back(elem);
}
return perm;
};
auto perm1 = readPerm(size);
auto perm2 = readPerm(size);
Counter counter(std::move(perm1), std::move(perm2));
size_t nQueries;
::scanf("%lu", &nQueries);
size_t x = 0;
auto f = [&](size_t z) { return (z + x - 1) % size; };
for (size_t i = 0; i < nQueries; ++i) {
size_t a, b, c, d;
::scanf("%lu %lu %lu %lu", &a, &b, &c, &d);
size_t count = counter.count(std::min(f(a), f(b)), std::max(f(a), f(b)),
std::min(f(c), f(d)), std::max(f(c), f(d)));
std::cout << count << "\n";
x = count + 1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e6 + 5, Mlog = 21;
int seg[Mlog * M], Rch[Mlog * M], Lch[Mlog * M], root[M], pos[M], n, ans = -1,
q, x, cnt;
int f(int z) { return (z + ans) % n + 1; }
int upd(int id, int p, int l = 0, int r = n) {
int nod = ++cnt;
if (r - l < 2) return seg[nod] = 1, nod;
int mid = (l + r) / 2;
if (p < mid)
Lch[nod] = upd(Lch[id], p, l, mid), Rch[nod] = Rch[id];
else
Rch[nod] = upd(Rch[id], p, mid, r), Lch[nod] = Lch[id];
return seg[nod] = seg[Lch[nod]] + seg[Rch[nod]], nod;
}
int get(int id, int ql, int qr, int l = 0, int r = n) {
if (r <= ql || qr <= l) return 0;
if (ql <= l && r <= qr) return seg[id];
int mid = (l + r) / 2;
return get(Lch[id], ql, qr, l, mid) + get(Rch[id], ql, qr, mid, r);
}
int32_t main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &x), pos[x] = i;
for (int i = 0; i < n; i++)
scanf("%d", &x), root[i + 1] = upd(root[i], pos[x]);
cin >> q;
while (q--) {
int a, b, c, d, l1, l2, r1, r2;
scanf("%d%d%d%d", &a, &b, &c, &d), a = f(a), b = f(b), c = f(c), d = f(d);
l1 = min(a, b), r1 = max(a, b), l2 = min(c, d), r2 = max(c, d);
printf("%d\n",
(ans = get(root[r2], l1 - 1, r1) - get(root[l2 - 1], l1 - 1, r1)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, D = N * 22;
int n, px[N], py[N], a[N], root[N];
int sum[D], l[D], r[D], dn;
int m, key, ans;
int insert(int d, int lt, int rt, int w) {
int md = (lt + rt) >> 1;
int nd = ++dn;
sum[nd] = sum[d] + 1;
if (lt != rt) {
if (w <= md) {
l[nd] = insert(l[d], lt, md, w);
r[nd] = r[d];
} else {
r[nd] = insert(r[d], md + 1, rt, w);
l[nd] = l[d];
}
}
return nd;
}
int query(int d, int lt, int rt, int lq, int rq) {
if (!d) {
return 0;
}
if (lq <= lt && rt <= rq) {
return sum[d];
}
int md = (lt + rt) >> 1;
int ret = 0;
if (lq <= md) {
ret += query(l[d], lt, md, lq, rq);
}
if (md < rq) {
ret += query(r[d], md + 1, rt, lq, rq);
}
return ret;
}
int init() {
int x;
scanf("%d", &x);
return (x - 1 + key) % n + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1, v; i <= n; ++i) {
scanf("%d", &v), px[v] = i;
}
for (int i = 1, v; i <= n; ++i) {
scanf("%d", &v), py[v] = i;
}
for (int v = 1; v <= n; ++v) {
a[px[v]] = v;
}
root[0] = ++dn;
for (int i = 1; i <= n; ++i) {
root[i] = insert(root[i - 1], 1, n, py[a[i]]);
}
scanf("%d", &m);
ans = -1;
for (int im = 1; im <= m; ++im) {
key = ans + 1;
int l1 = init(), r1 = init(), l2 = init(), r2 = init();
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
ans = query(root[r1], 1, n, l2, r2) - query(root[l1 - 1], 1, n, l2, r2);
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using ll = long long;
using pi = pair<int, int>;
using vi = vc<int>;
using vvi = vvc<int>;
int topbit(int t) {
assert(t > 0);
return 31 - __builtin_clz(t);
}
struct X {
int s;
vvi buf;
X(vi first) {
s = 1;
while (s < int((first).size())) s *= 2;
buf.resize(2 * s);
for (int i = int(1); i < int(2 * s); i++) buf[i] = vi(s >> topbit(i));
for (int i = int(0); i < int(int((first).size())); i++)
buf[s + i][0] = first[i];
for (int i = int(s) - 1; i >= int(1); i--)
merge((buf[2 * i]).begin(), (buf[2 * i]).end(), (buf[2 * i + 1]).begin(),
(buf[2 * i + 1]).end(), buf[i].begin());
}
int in(int i, int second, int e) {
return distance(lower_bound((buf[i]).begin(), (buf[i]).end(), second),
lower_bound((buf[i]).begin(), (buf[i]).end(), e));
}
int get(int second, int e, int b1, int e1) {
int i = second + s;
int j = e + s;
int res = 0;
while (i < j) {
if (i & 1) res += in(i++, b1, e1);
if (j & 1) res += in(--j, b1, e1);
i /= 2;
j /= 2;
}
return res;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vi p(n);
for (int i = int(0); i < int(n); i++) {
cin >> p[i];
p[i]--;
}
vi q(n);
for (int i = int(0); i < int(n); i++) {
cin >> q[i];
q[i]--;
}
vi iq(n);
for (int i = int(0); i < int(n); i++) iq[q[i]] = i;
vi v(n);
for (int i = int(0); i < int(n); i++) v[i] = iq[p[i]];
X x(v);
int m;
cin >> m;
int last = 0;
auto f = [&](int z) -> int { return (z + last - 1) % n + 1; };
for (int _ = int(0); _ < int(m); _++) {
int first, second, c, d;
cin >> first >> second >> c >> d;
int l1 = min(f(first), f(second)) - 1;
int r1 = max(f(first), f(second));
int l2 = min(f(c), f(d)) - 1;
int r2 = max(f(c), f(d));
last = x.get(l1, r1, l2, r2);
cout << last << '\n';
last++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1008611;
struct ST {
int i, j, l, r, mid;
vector<int> vv;
} st[maxn * 4];
int p1[maxn];
int p2[maxn];
int xx[maxn];
void bd(int d, int x, int y) {
st[d].i = x, st[d].j = y;
st[d].mid = (x + y) >> 1;
st[d].vv.clear();
for (int i = x; i <= y; i++) st[d].vv.push_back(xx[i]);
sort(st[d].vv.begin(), st[d].vv.end());
if (x < y) {
st[d].l = d << 1;
st[d].r = d << 1 | 1;
bd(st[d].l, x, st[d].mid);
bd(st[d].r, st[d].mid + 1, y);
}
}
int query(int d, int x, int y, int l2, int r2) {
if (x <= st[d].i && y >= st[d].j) {
int ll =
lower_bound(st[d].vv.begin(), st[d].vv.end(), l2) - st[d].vv.begin();
int rr =
upper_bound(st[d].vv.begin(), st[d].vv.end(), r2) - st[d].vv.begin();
return rr - ll;
} else {
int temp = 0;
if (x <= st[d].mid) temp += query(st[d].l, x, y, l2, r2);
if (y > st[d].mid) temp += query(st[d].r, x, y, l2, r2);
return temp;
}
}
int n;
int rr = 0;
int f(int z) { return ((z - 1 + rr) % n) + 1; }
int tmp[maxn];
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) scanf("%d", &p1[i]);
for (int i = 1; i <= n; i++) scanf("%d", &p2[i]);
for (int i = 1; i <= n; i++) tmp[p2[i]] = i;
for (int i = 1; i <= n; i++) xx[i] = tmp[p1[i]];
int m;
bd(1, 1, n);
cin >> m;
rr = 0;
int a, b, c, d;
while (m--) {
cin >> a >> b >> c >> d;
int l1, r1, l2, r2;
l1 = min(f(a), f(b));
r1 = max(f(a), f(b));
l2 = min(f(c), f(d));
r2 = max(f(c), f(d));
rr = query(1, l1, r1, l2, r2);
cout << rr << endl;
rr++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ((1 << 30) - 1);
const long long linf = ((1ll << 62) - 1);
const int cmax = 1e6;
const int kmax = 1 << 12;
int n;
int a[cmax], b[cmax], res[cmax];
vector<int> rmq[cmax * 4], _left[cmax * 4], _right[cmax * 4];
void buildLowerBound(vector<int> &a, vector<int> &b, vector<int> &res) {
int it = 0, size1 = ((int)(a).size()), size2 = ((int)(b).size());
for (int i = 0; i < size1; i++) {
while (it < size2 && b[it] < a[i]) ++it;
res[i] = it;
}
}
void make_rmq(int i, int l, int r) {
if (l == r) {
rmq[i].resize(1);
rmq[i][0] = a[l];
return;
}
make_rmq(i * 2, l, (l + r) / 2);
make_rmq(i * 2 + 1, (l + r) / 2 + 1, r);
int size = r - l + 1;
rmq[i].resize(size);
merge((rmq[i * 2]).begin(), (rmq[i * 2]).end(), (rmq[i * 2 + 1]).begin(),
(rmq[i * 2 + 1]).end(), rmq[i].begin());
_left[i].resize(size), _right[i].resize(size);
buildLowerBound(rmq[i], rmq[i * 2], _left[i]);
buildLowerBound(rmq[i], rmq[i * 2 + 1], _right[i]);
}
inline int getValue(int i, int ll, int rr, int l, int r, int b, int t) {
t = min(t, rr - ll + 1);
if (ll > r || rr < l) return 0;
if (l <= ll && rr <= r) return max(0, t - b);
return getValue(i * 2, ll, (ll + rr) / 2, l, r,
(b >= ((int)(_left[i]).size()) ? ((int)(_left[i]).size())
: _left[i][b]),
(t >= ((int)(_left[i]).size()) ? ((int)(_left[i]).size())
: _left[i][t])) +
getValue(i * 2 + 1, (ll + rr) / 2 + 1, rr, l, r,
(b >= ((int)(_right[i]).size()) ? ((int)(_right[i]).size())
: _right[i][b]),
(t >= ((int)(_right[i]).size()) ? ((int)(_right[i]).size())
: _right[i][t]));
}
int x = 0;
int f(int z) { return ((z - 1 + x) % n) + 1; }
int main() {
assert(scanf("%d", &n));
for (int i = 0; i < n; i++) {
assert(scanf("%d", &a[i])), --a[i];
}
for (int i = 0; i < n; i++) {
int t;
assert(scanf("%d", &t)), --t;
b[t] = i;
}
for (int i = 0; i < n; i++) res[i] = b[a[i]];
memcpy(a, res, sizeof(int) * n);
make_rmq(1, 0, n - 1);
int m;
assert(scanf("%d", &m));
for (int i = 0; i < m; i++) {
int a, b, c, d;
assert(scanf("%d%d%d%d", &a, &b, &c, &d));
int l1 = min(f(a), f(b)) - 1, r1 = max(f(a), f(b)) - 1;
int l2 = min(f(c), f(d)) - 1, r2 = max(f(c), f(d)) - 1;
printf("%d\n",
x = getValue(1, 0, n - 1, l1, r1,
lower_bound((rmq[1]).begin(), (rmq[1]).end(), l2) -
rmq[1].begin(),
upper_bound((rmq[1]).begin(), (rmq[1]).end(), r2) -
rmq[1].begin())),
x++;
if ((i & 2047) == 2047) ({});
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int son[1110100 * 21][2], S[1110100 * 21], root[1110100], a[1110100],
b[1110100], tmp[1110100];
int n, m, cc = 0, ans;
inline int read() {
int t = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') t = t * 10 + ch - '0', ch = getchar();
return t * f;
}
inline void Add(int la, int &p, int l, int r, int x) {
p = ++cc;
son[p][0] = son[la][0], son[p][1] = son[la][1], S[p] = S[la] + 1;
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid)
Add(son[la][0], son[p][0], l, mid, x);
else
Add(son[la][1], son[p][1], mid + 1, r, x);
}
inline void query(int la, int p, int l, int r, int s, int t) {
if (l == s && r == t) {
ans += S[p] - S[la];
return;
}
int mid = (l + r) >> 1;
if (t <= mid)
query(son[la][0], son[p][0], l, mid, s, t);
else if (s > mid)
query(son[la][1], son[p][1], mid + 1, r, s, t);
else
query(son[la][0], son[p][0], l, mid, s, mid),
query(son[la][1], son[p][1], mid + 1, r, mid + 1, t);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) b[i] = read();
for (int i = 1; i <= n; i++) tmp[b[i]] = i;
for (int i = 1; i <= n; i++) Add(root[i - 1], root[i], 1, n, tmp[a[i]]);
m = read();
int l1, l2, r1, r2, t1, t2;
ans = 0;
for (int T = 1; T <= m; T++) {
l1 = read(), r1 = read(), t1 = ((l1 - 1 + ans) % n + 1),
t2 = ((r1 - 1 + ans) % n + 1), l1 = min(t1, t2), r1 = max(t1, t2);
l2 = read(), r2 = read(), t1 = ((l2 - 1 + ans) % n + 1),
t2 = ((r2 - 1 + ans) % n + 1), l2 = min(t1, t2), r2 = max(t1, t2);
ans = 0;
query(root[l1 - 1], root[r1], 1, n, l2, r2);
printf("%d\n", ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p[1000005], q[1000005];
vector<int> rt[2000005];
void init() {
for (int i = (n); i < (n + n); i++) rt[i].push_back(q[i - n]);
for (int i = n - 1; i; i--)
merge(rt[2 * i].begin(), rt[2 * i].end(), rt[2 * i + 1].begin(),
rt[2 * i + 1].end(), back_inserter(rt[i]));
}
int qu(int l, int r, int a, int b) {
int res = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l & 1) {
res += lower_bound(rt[l].begin(), rt[l].end(), b) -
lower_bound(rt[l].begin(), rt[l].end(), a);
l++;
}
if (r & 1) {
r--;
res += lower_bound(rt[r].begin(), rt[r].end(), b) -
lower_bound(rt[r].begin(), rt[r].end(), a);
}
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
int x;
scanf("%d", &x);
p[x - 1] = i;
}
for (int i = (0); i < (n); i++) {
int x;
scanf("%d", &x);
q[i] = p[x - 1];
}
init();
int m;
scanf("%d", &m);
int x = 0;
for (int i = (0); i < (m); i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a = ((a - 1 + x) % n), b = ((b - 1 + x) % n), c = ((c - 1 + x) % n),
d = ((d - 1 + x) % n);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
b++;
d++;
x = qu(c, d, a, b) + 1;
printf("%d\n", x - 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = 2e5 + 5;
int rt[N];
int lson[N * 23], rson[N * 23], val[N * 23];
int n, m, ans, q;
int a[N], b[N], d[N];
void build(int pos, int x, int y) {
if (x == y) return;
int mid = (x + y) >> 1;
lson[pos] = ++m;
rson[pos] = ++m;
build(lson[pos], x, mid);
build(rson[pos], mid + 1, y);
}
void build(int ppos, int pos, int x, int y, int p) {
if (x == y) {
val[pos]++;
return;
}
int mid = (x + y) >> 1;
if (p <= mid) {
lson[pos] = ++m;
rson[pos] = rson[ppos];
build(lson[ppos], lson[pos], x, mid, p);
val[pos] = val[lson[pos]] + val[rson[pos]];
} else {
rson[pos] = ++m;
lson[pos] = lson[ppos];
build(rson[ppos], rson[pos], mid + 1, y, p);
val[pos] = val[lson[pos]] + val[rson[pos]];
}
}
int query(int pos, int x, int y, int l, int r) {
if (x >= l && y <= r) return val[pos];
if (x > r || y < l) return 0;
int mid = (x + y) >> 1;
return query(lson[pos], x, mid, l, r) + query(rson[pos], mid + 1, y, l, r);
}
int F(int x) { return (x - 1 + ans) % n + 1; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
for (int i = 1; i <= n; i++) d[b[i]] = i;
rt[0] = ++m;
build(rt[0], 1, n);
for (int i = 1; i <= n; i++) {
rt[i] = ++m;
build(rt[i - 1], rt[i], 1, n, d[a[i]]);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int A, B, C, D, l1, r1, l2, r2;
scanf("%d%d%d%d", &A, &B, &C, &D);
l1 = min(F(A), F(B));
r1 = max(F(A), F(B));
l2 = min(F(C), F(D));
r2 = max(F(C), F(D));
ans = query(rt[r1], 1, n, l2, r2) - query(rt[l1 - 1], 1, n, l2, r2);
printf("%d\n", ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
class CcT {
public:
int l[21000200], r[21000200], a[21000200];
int n;
int ins(int o, int p, int s) {
int m = ++n;
a[m] = a[o] + 1;
if (s == 1) return m;
if (p < (s >> 1))
l[m] = ins(l[o], p, s >> 1), r[m] = r[o];
else
l[m] = l[o], r[m] = ins(r[o], p - (s >> 1), s >> 1);
return m;
}
int find(int o, int p, int s) {
if (s == 1)
return a[o];
else if (p < (s >> 1))
return find(l[o], p, s >> 1);
else
return find(r[o], p - (s >> 1), s >> 1) + a[l[o]];
}
} X;
void gi(int &x) {
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
}
void pi(int x) {
if (x > 9) pi(x / 10);
putchar(x % 10 + 48);
}
int p[1000020], q[1000020], P[1000020], s[1000020], root[1000020];
int n, m, x, l1, r1, l2, r2, a, b, c, d, i, j, k;
int main() {
gi(n);
for (i = 1; i <= n; i++) gi(p[i]);
for (i = 1; i <= n; i++) gi(q[i]);
for (i = 1; i <= n; i++) P[q[i]] = i;
for (i = 1; i <= n; i++) s[i] = P[p[i]];
for (i = 1; i <= n; i++) root[i] = X.ins(root[i - 1], s[i], 1048576);
gi(m);
x = 0;
while (m--) {
gi(a);
gi(b);
gi(c);
gi(d);
l1 = (((a - 1 + x) % n) + 1);
r1 = (((b - 1 + x) % n) + 1);
l2 = (((c - 1 + x) % n) + 1);
r2 = (((d - 1 + x) % n) + 1);
if (l1 > r1) l1 ^= r1, r1 ^= l1, l1 ^= r1;
if (l2 > r2) l2 ^= r2, r2 ^= l2, l2 ^= r2;
l1--;
l2--;
x = X.find(root[l1], l2, 1048576) + X.find(root[r1], r2, 1048576) -
X.find(root[l1], r2, 1048576) - X.find(root[r1], l2, 1048576);
pi(x);
putchar('\n');
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, x, a[N], b[N], ans;
vector<int> t[4 * N];
inline int f(int z) { return ((z - 1 + ans) % n + n) % n + 1; }
void build(int v, int l, int r) {
if (l == r) {
t[v].push_back(a[l]);
return;
}
int mid = (r + l) >> 1;
build(v + v, l, mid);
build(v + v + 1, mid + 1, r);
merge(t[v + v].begin(), t[v + v].end(), t[v + v + 1].begin(),
t[v + v + 1].end(), back_inserter(t[v]));
}
void get(int v, int l, int r, int tl, int tr, int x, int y) {
if (l > r || l > tr || tl > r) {
return;
}
if (tl <= l && r <= tr) {
int val = int(upper_bound(t[v].begin(), t[v].end(), y) -
lower_bound(t[v].begin(), t[v].end(), x));
ans += val;
return;
}
int mid = (r + l) >> 1;
get(v + v, l, mid, tl, tr, x, y);
get(v + v + 1, mid + 1, r, tl, tr, x, y);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
b[x] = i;
}
for (int i = 1; i <= n; i++) {
cin >> x;
a[i] = b[x];
}
build(1, 1, n);
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a = f(a);
b = f(b);
c = f(c);
d = f(d);
if (a > b) {
swap(a, b);
}
if (c > d) {
swap(c, d);
}
ans = 0;
get(1, 1, n, c, d, a, b);
cout << ans << "\n";
ans++;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.