Solution Notes: This problem is solved using breadth-first search to find the shortest path from our initial state to a state where all objects have disjoint bounding boxes. Our current state is described by 4 numbers, giving the (x,y) offset of objects 2 and 3 relative to their initial positions. Each move we make, we can change one of these numbers by +1 or -1 to slide either object 2 or 3 (as long as this doesn't create any overlap between the objects), or we can change both x offsets or both y offsets by +1 or -1 to simulate moving object 1 (since moving object 1 is equivalent to keeping object 1 fixed and moving both objects 2 and 3 in the opposite direction).

``````
#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
#include <cstdio>
#include <set>

using namespace std;

int W[3];
int H[3];

int sx[3];
int sy[3];

bool A[3][10][10];

int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};

struct state {
state(int d) : d(d) {
for(int i = 2; i >= 0; i--) {
sx[i] -= sx[0];
sy[i] -= sy[0];
}
memcpy(ssx, sx, sizeof(ssx));
memcpy(ssy, sy, sizeof(ssy));
}

state(const state& st) {
d = st.d;
memcpy(ssx, st.ssx, sizeof(ssx));
memcpy(ssy, st.ssy, sizeof(ssy));
}

state& operator=(const state& st) {
d = st.d;
memcpy(ssx, st.ssx, sizeof(ssx));
memcpy(ssy, st.ssy, sizeof(ssy));
return *this;
}

void unpack() {
memcpy(sx, ssx, sizeof(ssx));
memcpy(sy, ssy, sizeof(ssy));
}

bool operator<(const state& st) const {
int r = memcmp(ssx, st.ssx, sizeof(ssx));
if(!r) r = memcmp(ssy, st.ssy, sizeof(ssy));
return r < 0;
}

int d;
int ssx[3];
int ssy[3];
};

bool intersect(int i, int j) {
return sx[i] < sx[j] + W[j] && sx[j] < sx[i] + W[i] &&
sy[i] < sy[j] + H[j] && sy[j] < sy[i] + H[i];
}

bool check() {
for(int i = 0; i < 3; i++) {
if(sx[i] < -20 || sx[i] > 20 || sy[i] < -20 || sy[i] > 20) return false;
for(int j = i + 1; j < 3; j++) {
for(int x = 0; x < W[i]; x++) {
for(int y = 0; y < H[i]; y++) {
if(!A[i][x][y]) continue;
int nx = sx[i] + x - sx[j], ny = sy[i] + y - sy[j];
if(nx < 0 || nx >= W[j] || ny < 0 || ny >= H[j] ||
!A[j][nx][ny]) continue;
return false;
}
}
}
}
return true;
}

int main() {
freopen("unlock.in", "r", stdin);
freopen("unlock.out", "w", stdout);

int N[3];
cin >> N[0] >> N[1] >> N[2];
for(int i = 0; i < 3; i++) {
int mx = 10, my = 10;
int gx = 0, gy = 0;
for(int j = 0; j < N[i]; j++) {
int x, y; cin >> x >> y;
A[i][x][y] = true;
mx = min(mx, x); my = min(my, y);
gx = max(gx, x + 1); gy = max(gy, y + 1);
}
W[i] = gx - mx; H[i] = gy - my;
for(int x = mx; x < 10; x++)
for(int y = my; y < 10; y++) {
A[i][x - mx][y - my] = A[i][x][y];
if(mx || my) A[i][x][y] = false;
}
sx[i] = mx;
sy[i] = my;
}
queue<state> q;
set<state> vis;
q.push(state(0));
while(!q.empty()) {
state st = q.front();
q.pop();
st.unpack();
if(!intersect(0, 1) && !intersect(0, 2) && !intersect(1, 2)) {
cout << st.d << endl;
return 0;
}
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 4; j++) {
st.unpack();
sx[i] += dx[j];
sy[i] += dy[j];
state nst = state(st.d + 1);
if(vis.insert(nst).second && check()) q.push(nst);
}
}
}
cout << -1 << endl;
}
``````