#include <bits/stdc++.h>
using namespace std;

vector<string> rd() {
    vector<string> v;
    string s;
    while (getline(cin, s)) v.push_back(s);
    return v;
}

tuple<int, vector<string>, vector<string>> ps() {
    auto d = rd();
    int i = 0;
    while (i < (int)d.size() && d[i].find_first_not_of(" \t\r") == string::npos) i++;
    if (i >= (int)d.size()) return {0, {}, {}};
    int n = stoi(d[i++]);
    while (i < (int)d.size() && d[i].find_first_not_of(" \t\r") == string::npos) i++;
    if (i < (int)d.size() && string(d[i].begin(), d[i].end()) == "shuffled") i++;
    vector<string> sh;
    for (int k = 0; k < n && i < (int)d.size(); k++) {
        while (i < (int)d.size() && d[i].empty()) i++;
        sh.push_back(d[i++]);
    }
    while (i < (int)d.size() && d[i].find_first_not_of(" \t\r") == string::npos) i++;
    if (i < (int)d.size() && string(d[i].begin(), d[i].end()) == "original") i++;
    vector<string> og;
    for (int k = 0; k < n && i < (int)d.size(); k++) {
        while (i < (int)d.size() && d[i].empty()) i++;
        og.push_back(d[i++]);
    }
    return {n, sh, og};
}

vector<int> mpv(const vector<string>& sh, const vector<string>& og) {
    unordered_map<string,int> m;
    for (int i = 0; i < (int)og.size(); i++) m[og[i]] = i + 1;
    vector<int> a;
    for (auto& s : sh) a.push_back(m[s]);
    return a;
}

vector<vector<int>> nb(const vector<int>& st) {
    int n = st.size();
    vector<vector<int>> res;
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            vector<int> sg(st.begin() + i, st.begin() + j + 1);
            vector<int> rm;
            rm.insert(rm.end(), st.begin(), st.begin() + i);
            rm.insert(rm.end(), st.begin() + j + 1, st.end());
            for (int k = 0; k <= (int)rm.size(); k++) {
                if (k == i) continue;
                vector<int> y = rm;
                y.insert(y.begin() + k, sg.begin(), sg.end());
                res.push_back(y);
            }
        }
    }
    return res;
}

int bfs(vector<int> s, vector<int> t) {
    if (s == t) return 0;
    unordered_map<string,int> ds, dt;
    deque<vector<int>> qs, qt;
    auto to_str = [&](const vector<int>& v) {
        string r;
        for (int x : v) r += char('a' + x);
        return r;
    };
    qs.push_back(s);
    qt.push_back(t);
    ds[to_str(s)] = 0;
    dt[to_str(t)] = 0;
    while (!qs.empty() && !qt.empty()) {
        if (qs.size() <= qt.size()) {
            int m = qs.size();
            while (m--) {
                auto x = qs.front(); qs.pop_front();
                int dx = ds[to_str(x)];
                for (auto& y : nb(x)) {
                    string ky = to_str(y);
                    if (ds.count(ky)) continue;
                    ds[ky] = dx + 1;
                    if (dt.count(ky)) return ds[ky] + dt[ky];
                    qs.push_back(y);
                }
            }
        } else {
            int m = qt.size();
            while (m--) {
                auto x = qt.front(); qt.pop_front();
                int dx = dt[to_str(x)];
                for (auto& y : nb(x)) {
                    string ky = to_str(y);
                    if (dt.count(ky)) continue;
                    dt[ky] = dx + 1;
                    if (ds.count(ky)) return ds[ky] + dt[ky];
                    qt.push_back(y);
                }
            }
        }
    }
    return -1;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    auto [n, sh, og] = ps();
    if (n == 0) {
        cout << 0;
        return 0;
    }
    auto s = mpv(sh, og);
    vector<int> t(n);
    iota(t.begin(), t.end(), 1);
    cout << bfs(s, t);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int a, b;
    bool operator==(const Node &o) const { return a == o.a && b == o.b; }
};
struct NodeHash {
    size_t operator()(const Node &p) const {
        return (uint64_t(uint32_t(p.a)) << 32) ^ uint32_t(p.b);
    }
};
struct State {
    int a, b, id;
    bool operator==(const State &o) const { return a == o.a && b == o.b && id == o.id; }
};
struct StateHash {
    size_t operator()(const State &k) const {
        uint64_t val = k.a;
        val = (val << 20) ^ k.b;
        val = (val << 20) ^ k.id;
        return size_t(val);
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    vector<long long> in;
    long long t;
    while (cin >> t) in.push_back(t);

    int idx = 0, n = (int)in[idx++];
    vector<array<int, 4>> seg(n);
    for (int i = 0; i < n; i++) {
        seg[i][0] = (int)in[idx++];
        seg[i][1] = (int)in[idx++];
        seg[i][2] = (int)in[idx++];
        seg[i][3] = (int)in[idx++];
    }

    int sx = (int)in[idx++], sy = (int)in[idx++], energy = (int)in[idx++];

    unordered_map<Node, vector<int>, NodeHash> grid;
    unordered_map<State, pair<int, int>, StateHash> moveNext;

    for (int id = 0; id < n; id++) {
        int x1 = seg[id][0], y1 = seg[id][1];
        int x2 = seg[id][2], y2 = seg[id][3];
        int dx = (x2 > x1) ? 1 : -1;
        int dy = (y2 > y1) ? 1 : -1;
        int len = abs(x2 - x1);

        if (dy == -1) {
            for (int s = 0; s < len; s++) {
                int nx = x1 + dx * s;
                int ny = y1 - s;
                grid[{nx, ny}].push_back(id);
                moveNext[{nx, ny, id}] = {nx + dx, ny - 1};
            }
            grid[{x2, y2}].push_back(id);
        } else {
            for (int s = 0; s < len; s++) {
                int nx = x2 - dx * s;
                int ny = y2 - s;
                grid[{nx, ny}].push_back(id);
                moveNext[{nx, ny, id}] = {nx - dx, ny - 1};
            }
            grid[{x1, y1}].push_back(id);
        }
    }

    auto fall = [&](int cx, int cy) -> pair<int, int> {
        for (int yy = cy - 1; yy >= 0; yy--) {
            if (grid.count({cx, yy})) return {cx, yy};
        }
        return {cx, 0};
    };

    int x = sx, y = sy;
    if (!grid.count({x, y})) tie(x, y) = fall(x, y);

    while (true) {
        if (y == 0) break;

        auto it = grid.find({x, y});
        if (it == grid.end()) {
            tie(x, y) = fall(x, y);
            continue;
        }

        auto &ids = it->second;
        if (ids.size() == 1) {
            int sid = ids[0];
            auto nxt = moveNext.find({x, y, sid});
            if (nxt == moveNext.end()) {
                tie(x, y) = fall(x, y);
                continue;
            }
            if (energy == 0) break;
            energy--;
            x = nxt->second.first;
            y = nxt->second.second;
        } else {
            long long cost = 1LL * x * y;
            vector<pair<int, pair<int, int>>> nxtList;
            for (int sid : ids) {
                auto it2 = moveNext.find({x, y, sid});
                if (it2 != moveNext.end()) nxtList.push_back({sid, it2->second});
            }

            if (energy <= cost) {
                if (nxtList.empty()) {
                    tie(x, y) = fall(x, y);
                    continue;
                }
                break;
            }

            energy -= (int)cost;
            if (nxtList.empty()) {
                tie(x, y) = fall(x, y);
                continue;
            }

            int bx = 0, by = -1;
            for (auto &it3 : nxtList) {
                if (it3.second.second > by) {
                    by = it3.second.second;
                    bx = it3.second.first;
                }
            }
            if (energy == 0) break;
            energy--;
            x = bx;
            y = by;
        }
    }

    cout << x << " " << y;
    return 0;
}

import sys, heapq

def read_input():
    lines = [l.strip() for l in sys.stdin if l.strip()]
    n = int(lines[0])
    shuffled = lines[2:2+n]
    original = lines[3+n:]
    return n, shuffled, original

def make_perm(shuffled, original):
    idx = {v: i for i, v in enumerate(original)}
    return tuple(idx[x] for x in shuffled)

def neighbors(state):
    n = len(state)
    for i in range(n):
        for j in range(i, n):
            seg = state[i:j+1]
            rem = state[:i] + state[j+1:]
            for k in range(len(rem)+1):
                if k == i:
                    continue
                yield rem[:k] + seg + rem[k:]

def heuristic(state):
    h = 0
    for i in range(len(state)-1):
        if abs(state[i+1]-state[i]) != 1:
            h += 1
    return h

def astar(start, goal):
    pq = [(heuristic(start), 0, start)]
    dist = {start: 0}
    while pq:
        f, g, cur = heapq.heappop(pq)
        if cur == goal:
            return g
        for nxt in neighbors(cur):
            ng = g + 1
            if nxt not in dist or ng < dist[nxt]:
                dist[nxt] = ng
                heapq.heappush(pq, (ng + heuristic(nxt), ng, nxt))
    return -1

def main():
    n, shuffled, original = read_input()
    if n == 0:
        print(0, end="")
        return
    start = make_perm(shuffled, original)
    goal = tuple(range(n))
    print(astar(start, goal), end="")

main()

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;

    vector<string> g(n);
    for (int i = 0; i < n; i++) {
        g[i].resize(m);
        for (int j = 0; j < m; j++) cin >> g[i][j];
    }

    vector<int> hr, vr;
    for (int i = 0; i < n; i++) {
        if (all_of(g[i].begin(), g[i].end(), [](char c){ return c != '.'; }))
            hr.push_back(i);
    }
    for (int j = 0; j < m; j++) {
        bool ok = true;
        for (int i = 0; i < n; i++) if (g[i][j] == '.') ok = false;
        if (ok) vr.push_back(j);
    }

    vector<vector<bool>> cross(n, vector<bool>(m));
    for (int c : vr)
        for (int i = 0; i < n; i++) {
            int l = c - 1, r = c + 1;
            if (l >= 0 && r < m && g[i][l] == 'C' && g[i][r] == 'C')
                cross[i][c] = true;
        }
    for (int r : hr)
        for (int j = 0; j < m; j++) {
            int u = r - 1, d = r + 1;
            if (u >= 0 && d < n && g[u][j] == 'C' && g[d][j] == 'C')
                cross[r][j] = true;
        }

    vector<vector<bool>> cab(n, vector<bool>(m));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (g[i][j] == 'C' || cross[i][j]) cab[i][j] = true;

    vector<vector<int>> adj(n * m);
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) {
            if (!cab[i][j]) continue;
            int id = i * m + j;
            for (int d = 0; d < 4; d++) {
                int ni = i + dx[d], nj = j + dy[d];
                if (ni >= 0 && ni < n && nj >= 0 && nj < m && cab[ni][nj])
                    adj[id].push_back(ni * m + nj);
            }
        }

    int st = -1;
    for (int i = 0; i < n && st == -1; i++)
        for (int j = 0; j < m; j++)
            if (cab[i][j] && adj[i * m + j].size() == 1) {
                st = i * m + j;
                break;
            }

    vector<bool> vis(n * m);
    vector<int> sh(n), sv(m);
    int cur = st, pre = -1;
    vis[cur] = true;

    while (true) {
        int r = cur / m, c = cur % m, nxt = -1;
        for (int nb : adj[cur])
            if (nb != pre && !vis[nb]) { nxt = nb; break; }

        if (cross[r][c] && pre != -1) {
            int pr = pre / m, pc = pre % m, sgn = (g[r][c] == 'C') ? 1 : -1;
            if (pr == r) sv[c] += ((pc < c) ? 1 : -1) * sgn;
            else sh[r] += ((pr < r) ? 1 : -1) * sgn;
        }

        if (nxt == -1) break;
        pre = cur;
        cur = nxt;
        vis[cur] = true;
    }

    long long ans = 0;
    for (int r : hr) ans += abs(sh[r]) / 2;
    for (int c : vr) ans += abs(sv[c]) / 2;
    cout << ans;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int minimize_difference(int n, vector<int>& a, int k, vector<int>& b) {
    vector<vector<int>> vals(n);
    for (int i = 0; i < n; i++) {
        set<int> st;
        for (int m = 0; m < (1 << k); m++) {
            int v = a[i];
            for (int j = 0; j < k; j++) if (m & (1 << j)) v ^= b[j];
            st.insert(v);
        }
        vals[i] = vector<int>(st.begin(), st.end());
        sort(vals[i].begin(), vals[i].end());
    }
    vector<pair<int,int>> all;
    for (int i = 0; i < n; i++) for (int v : vals[i]) all.emplace_back(v, i);
    sort(all.begin(), all.end());
    map<int,int> cnt;
    int l = 0, d = 0, res = INT_MAX;
    for (int r = 0; r < all.size(); r++) {
        int val = all[r].first, idx = all[r].second;
        if (cnt[idx] == 0) d++;
        cnt[idx]++;
        while (d == n) {
            res = min(res, val - all[l].first);
            int li = all[l].second;
            cnt[li]--;
            if (cnt[li] == 0) d--;
            l++;
        }
    }
    return res;
}

int main() {
    int n, k;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    cin >> k;
    vector<int> b(k);
    for (int i = 0; i < k; i++) cin >> b[i];
    cout << minimize_difference(n, a, k, b);
    return 0;
}

import sys
def solve():
    def cbit(c): return '1' if c != ' ' else '0'
    def binstr(l1,l2,l3,s): return ''.join(cbit(l1[s+i]) for i in range(3))+''.join(cbit(l2[s+i]) for i in range(3))+''.join(cbit(l3[s+i]) for i in range(3))
    def aop(op,b,a=None):
        if op=='!': return ''.join('1' if x=='0' else '0' for x in b)
        l=max(len(a),len(b)); a=a.zfill(l); b=b.zfill(l)
        if op=='||': return ''.join('1' if a[i]=='1' or b[i]=='1' else '0' for i in range(l))
        if op=='&&': return ''.join('1' if a[i]=='1' and b[i]=='1' else '0' for i in range(l))
    def prec(o1,o2):
        p={'&&':1,'||':2,'!':3}
        if o2 in '()': return False
        return p[o2]>=p[o1]
    try:
        l1=sys.stdin.readline().rstrip('\n');l2=sys.stdin.readline().rstrip('\n');l3=sys.stdin.readline().rstrip('\n')
        l4=sys.stdin.readline().rstrip('\n');l5=sys.stdin.readline().rstrip('\n');l6=sys.stdin.readline().rstrip('\n')
        l7=sys.stdin.readline().rstrip('\n');l8=sys.stdin.readline().rstrip('\n');l9=sys.stdin.readline().rstrip('\n')
    except: return
    dmap={binstr(l1,l2,l3,i*3):str(i) for i in range(10)}
    smap={binstr(l4,l5,l6,i*3):s for i,s in enumerate(["||","&&","!","(",")"])}
    t=[]; cur=""; i=0
    while i*3<len(l7):
        s=i*3; b=binstr(l7,l8,l9,s)
        if b in dmap: cur+=b
        elif b in smap:
            if cur: t.append(cur); cur=""
            t.append(smap[b])
        i+=1
    if cur: t.append(cur)
    v=[]; o=[]
    def op():
        x=o.pop()
        if x=='!': v.append(aop(x,v.pop()))
        else:
            b=v.pop(); a=v.pop()
            v.append(aop(x,a,b))
    for tk in t:
        if tk not in ['&&','||','!','(',')']:
            v.append(tk)
        elif tk=='(':
            o.append(tk)
        elif tk==')':
            while o and o[-1]!='(': op()
            if o: o.pop()
        else:
            while o and prec(tk,o[-1]): op()
            o.append(tk)
    while o: op()
    r=v[0]; ans=""; i=0
    while i<len(r):
        ch=r[i:i+9]
        if ch in dmap: ans+=dmap[ch]
        i+=9
    print(ans,end="")
solve()

def f(R, C, ins):
    s = [[[r * C + c + 1] for c in range(C)] for r in range(R)]
    for t in ins:
        if not t:
            continue
        k, i = t[0], int(t[1:])
        if k == 'v':
            l = i
            rws, cls = len(s), len(s[0])
            rgt = cls - l
            nc = max(l, rgt)
            ns = [[[] for _ in range(nc)] for _ in range(rws)]
            for r in range(rws):
                for c in range(l):
                    ncx = nc - (l - c)
                    if 0 <= ncx < nc:
                        ns[r][ncx] = list(s[r][c])
            for r in range(rws):
                for c in range(rgt):
                    ncx = nc - 1 - c
                    if 0 <= ncx < nc and l + c < cls:
                        ns[r][ncx].extend(reversed(s[r][l + c]))
            s = ns
        elif k == 'h':
            tpx = i
            rws, cls = len(s), len(s[0])
            btm = rws - tpx
            nr = max(tpx, btm)
            ns = [[[] for _ in range(cls)] for _ in range(nr)]
            for r in range(tpx):
                nrx = nr - (tpx - r)
                if 0 <= nrx < nr:
                    for c in range(cls):
                        ns[nrx][c] = list(s[r][c])
            for r in range(btm):
                nrx = nr - 1 - r
                if 0 <= nrx < nr and tpx + r < rws:
                    for c in range(cls):
                        ns[nrx][c].extend(reversed(s[tpx + r][c]))
            s = ns
    tp = bt = None
    for r in range(len(s)):
        for c in range(len(s[0])):
            if s[r][c]:
                tp = s[r][c][-1]
                bt = s[r][c][0]
    return tp, bt

R, C = map(int, input().split())
ins = input().split()
tp, bt = f(R, C, ins)
print(tp, bt, end="")

🚀 Get Ready to Crack Your Dream IT Job! 💼💻

Follow 🇮🇳 </>Code_icons👨‍💻💯™ on WhatsApp 👇
🔗

👨‍🎓 Only 2026 Batch:

🎓 Upto 2025 Batch: