Link

That's a good question,

subject

solution

From "only one chess piece can be skipped at a time", an important property of this question is obtained:
There are at most three jumping methods for these three chess pieces at a certain time: the middle piece jumps left and right, or the piece closer to the middle piece jumps to the middle. like this

When AB=BC, there are only two jumping methods (A cannot jump to the position of A ')
When the outside point jumps in, the range of these three pieces will be smaller and smaller until there is a situation that they can't jump in.
We find that the state at this time is unique: the three pieces cannot reproduce the relative state at this time elsewhere.
We take this state as the root;
Judge the roots of two groups of pieces. If they are different, it means that they can never look like another group; Direct output No.
If they can be placed in the same root, then we need LCA.
The first group of pieces will eventually move to the state of LCA and then to the state of the second group of pieces.

be careful

• For LCA, we can't use multiplication, but we can use dichotomy to accelerate
• In case AB is close and BC is far away, it can be optimized here, like this:
  
  When AB moves, just add (k-1)*AB directly. (translation method) since there is no special difference between chess pieces, you don't need to care about whether the AB position is exchanged.

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
int astep,bstep;
struct asdf{
 int a,b,c;
} A,B,Fka,Fkb;
void px(asdf &LL){   //Sort
 if(LL.a>LL.b) swap(LL.a,LL.b);
 if(LL.a>LL.c) swap(LL.a,LL.c);
 if(LL.b>LL.c) swap(LL.b,LL.c);
}
int getroot(int &aa,int &bb,int &cc){  //Find root
 int step = 0,l,jl1,jl2;
 while(aa+cc!=bb*2){  //If AB= AC
  jl1 = bb-aa;//AB
  jl2 = cc-bb;//BC
  if(jl1<jl2){  //Left inward
   l = jl2/jl1;  //How many times can you jump
   if(jl2%jl1 == 0) --l;
   aa += jl1*l;  //translation
   bb += jl1*l;
   step += l;  //Statistical steps
  } 
  else {  //Right inward / / ditto
   l = jl1/jl2;
   if(jl1%jl2 == 0) --l;
   bb -= jl2*l;
   cc -= jl2*l;
   step += l;
  }
 }
 return step;
}
asdf jummp(asdf ll,int step){  //Skip step on ll status
 int l,jl1,jl2;
 while(step){ 
  jl1 = ll.b-ll.a;  //It's the same as finding the root. I don't want to comment
  jl2 = ll.c-ll.b;
  if(jl1<jl2){
   l = jl2/jl1;
   if(jl2%jl1 == 0) --l;
   l = min(l,step);
   ll.a += jl1*l;
   ll.b += jl1*l;
   step -= l;
  } 
  else {
   l = jl1/jl2;
   if(jl1%jl2 == 0) --l;
   l = min(l,step);
   ll.b -= jl2*l;
   ll.c -= jl2*l;
   step -= l;
  }
 }
 return ll;
}
bool db(asdf aa,asdf bb){  //Compare whether the two states are the same
 if(aa.a!=bb.a||aa.b!=bb.b||aa.c!=bb.c) return 0;
 return 1;
}
int main(){
 scanf("%d%d%d%d%d%d",&A.a,&A.b,&A.c,&B.a,&B.b,&B.c);
 px(A); px(B);  //sort
 Fka = A;   //Temporary storage
 Fkb = B;
 astep = getroot(Fka.a,Fka.b,Fka.c);   //Find root
 bstep = getroot(Fkb.a,Fkb.b,Fkb.c);
 if(db(Fka,Fkb)==0){  //Different roots
  printf("NO");
  return 0;
 }
 if(astep > bstep) A = jummp(A,astep-bstep);  //Jump to the same height first
 else B = jummp(B,bstep-astep);
 int l = 0,r = min(astep,bstep), mid;  //Dichotomy
 while(l<r){
  mid = (l+r)/2;
  Fka = jummp(A,mid);
  Fkb = jummp(B,mid);
  if(db(Fka,Fkb) == 1) r = mid;  //Jump mid*2 steps to reach
  else l = mid+1;   //no way
 }
 printf("YES\n%d",max(astep-bstep,bstep-astep)+r*2);
}