Go: package main

import (
	"fmt"
	"math"
)

type Position struct {
	X int64
	Y int64
}

func (one Position) Distance(another Position) int64 {
	return int64(math.Abs(float64(one.X-another.X)) + math.Abs(float64(one.Y-another.Y)))
}

type PersonPosition struct {
	Takayuki Position
	Kazuyuki Position
}

func (one PersonPosition) Distance() int64 {
	return one.Takayuki.Distance(one.Kazuyuki)
}

type Status struct {
	Person PersonPosition
	Turn   int64
}

type PQStatus []*Status

func (pq PQStatus) Len() int {
	return len(pq)
}
func (pq PQStatus) Less(i, j int) bool {
	if pq[i].Turn == pq[j].Turn {
		return pq[i].Person.Distance() < pq[j].Person.Distance()
	}
	return pq[i].Turn < pq[j].Turn
}

func (pq PQStatus) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PQStatus) Push(x interface{}) {
	item := x.(*Status)
	*pq = append(*pq, item)
}

func (pq *PQStatus) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[0 : n-1]
	return item
}

func solve(h, w int64) {
	var tx, ty, kx, ky int64
	fmt.Scan(&tx, &ty, &kx, &ky)
	tx--
	ty--
	kx--
	ky--
	m := make([][]int64, h)
	for i := range m {
		m[i] = make([]int64, w)
		for j := int64(0); j < w; j++ {
			fmt.Scan(&m[i][j])
		}
	}
	start := &Status{Person: PersonPosition{Takayuki: Position{X: tx, Y: ty}, Kazuyuki: Position{X: kx, Y: ky}}, Turn: 0}
	pq := make(PQStatus, 0)
	//heap.Init(&pq)
	//heap.Push(&pq, start)
	//pq.Push(start)
	pq = append(pq, start)
	dx := []int64{0, 1, 0, -1}
	dy := []int64{1, 0, -1, 0}
	memo := make(map[PersonPosition]int64, 0)
	ans := int64(101)
	for pq.Len() > 0 {
		//now := heap.Pop(&pq).(*Status)
		//now := pq.Pop().(*Status)
		now := pq[0]
		pq = pq[1:]
		if now.Person.Distance() == 0 && ans > now.Turn {
			ans = now.Turn
		}
		if ans <= now.Turn {
			continue
		}

		if _, ok := memo[now.Person]; ok {
			continue
		}
		memo[now.Person] = now.Turn

		for i := 0; i < 4; i++ {
			next := &Status{}
			*next = *now
			next.Person.Kazuyuki.X += dx[i]
			next.Person.Kazuyuki.Y += dy[i]
			if next.Person.Kazuyuki.X < 0 || next.Person.Kazuyuki.X >= w ||
				next.Person.Kazuyuki.Y < 0 || next.Person.Kazuyuki.Y >= h ||
				m[next.Person.Kazuyuki.Y][next.Person.Kazuyuki.X] == 1 {
				next.Person.Kazuyuki.X -= dx[i]
				next.Person.Kazuyuki.Y -= dy[i]
			}
			next.Person.Takayuki.X -= dx[i]
			next.Person.Takayuki.Y -= dy[i]
			if next.Person.Takayuki.X < 0 || next.Person.Takayuki.X >= w ||
				next.Person.Takayuki.Y < 0 || next.Person.Takayuki.Y >= h ||
				m[next.Person.Takayuki.Y][next.Person.Takayuki.X] == 1 {
				next.Person.Takayuki.X += dx[i]
				next.Person.Takayuki.Y += dy[i]
			}
			next.Turn += 1
			if next.Turn <= 100 {
				//heap.Push(&pq, next)
				//pq.Push(next)
				pq = append(pq, next)
			}
		}
	}
	if ans == 101 {
		fmt.Println("NA")
	} else {
		fmt.Println(ans)
	}
}

func main() {
	var h, w int64
	for {
		fmt.Scan(&h, &w)
		if h == 0 && w == 0 {
			break
		}
		solve(h, w)
	}
}

C++: #include<stdio.h>
#include<queue>
#define INF 1000
using namespace std;
typedef struct{
	int a,b;
	int t;
}data;
bool con[50][50];
int dp[2500][2500];
int dx[4]={-1,0,0,1};
int dy[4]={0,1,-1,0};
int min(int a,int b){return a<b?a:b;}
int main(){
	queue<data> que;
	int w,h,sx,sy,tx,ty,i,j;
	while(1){
	scanf("%d %d",&w,&h);
	if(w==0)return 0;
	scanf("%d %d",&sx,&sy);
	scanf("%d %d",&tx,&ty);
	for(i=0;i<w*h;i++)for(j=0;j<w*h;j++)dp[i][j]=INF;
	int p;
	for(i=0;i<h;i++)for(j=0;j<w;j++){
		scanf("%d",&p);
		if(p==1)con[i][j]=false;
		else con[i][j]=true;
	}
	data dat;
	dat.a=(sy-1)*w+sx-1;
	dat.b=(ty-1)*w+tx-1;
	dat.t=0;
	dp[dat.a][dat.b]=0;
	que.push(dat);
	int ax,ay,bx,by;
	int nax,nay,nbx,nby;
	while(!que.empty()){
		data d=que.front();
		que.pop();
		if(d.t>=100)continue;
		ax=d.a%w;
		ay=d.a/w;
		bx=d.b%w;
		by=d.b/w;
		for(i=0;i<4;i++){
			if(ax+dx[i]>=0&&ax+dx[i]<w&&ay+dy[i]>=0&&ay+dy[i]<h&&con[ay+dy[i]][ax+dx[i]]){
				nax=ax+dx[i];
				nay=ay+dy[i];
			}else{nax=ax;nay=ay;}
			if(bx-dx[i]>=0&&bx-dx[i]<w&&by-dy[i]>=0&&by-dy[i]<h&&con[by-dy[i]][bx-dx[i]]){
				nbx=bx-dx[i];
				nby=by-dy[i];
			}else{nbx=bx;nby=by;}
			if(dp[nay*w+nax][nby*w+nbx]==INF){
				dp[nay*w+nax][nby*w+nbx]=d.t+1;
				data d2;
				d2.a=nay*w+nax;
				d2.b=nby*w+nbx;
				d2.t=d.t+1;
				que.push(d2);
			}
		}
	}
	int ans=INF;
	for(i=0;i<w*h;i++){
		ans=min(ans,dp[i][i]);
	}
	if(ans==INF)printf("NA\n");
	else printf("%d\n",ans);
	}
}

C++: #include<iostream>
#include<queue>
#include<cstring>
using namespace std;

int w,h;
int tx,ty;
int kx,ky;
int maze[100][100]; //y,x
bool d[55][55][55][55];
int dx[] = {1,0,0,-1};
int dy[] = {0,1,-1,0};
struct P{
  int f,s,sf,ss,c;
  P (int f,int s,int sf,int ss,int c):f(f),s(s),sf(sf),ss(ss),c(c) {};
};

int bfs(){
  queue < P > que;
  que.push( P(tx,ty,kx,ky,0) );
  d[tx][ty][kx][ky] = true;

  int cnt = 0;
  while( !que.empty() ){
    P p = que.front(); que.pop();

    if(cnt == 100) return -1;
    if(p.f == p.sf && p.s == p.ss) return p.c;

    cnt++;
    for(int i=0;i<4;i++){
      int ntx = p.f + dx[i];
      int nty = p.s + dy[i];
      int nkx = p.sf - dx[i];
      int nky = p.ss - dy[i];


      if(ntx < 0 || nty < 0 || ntx == w || nty == h || maze[nty][ntx] == 1){
	ntx = p.f;
	nty = p.s;
      }

      if(nkx < 0 || nky < 0 || nkx == w || nky == h || maze[nky][nkx] == 1){
	nkx = p.sf;
	nky = p.ss;
      }

      if(ntx == p.f && nty == p.s && nkx == p.sf && nky == p.ss) continue;

      if(!d[ntx][nty][nkx][nky]){
	d[ntx][nty][nkx][nky] = true;
	que.push( P(ntx,nty,nkx,nky,p.c+1) );
      }

    }
  }

  return -1;

}

int main(){

  while(true){
    cin >> w >> h;
    if(!w && !h) break;

    cin >> tx >> ty;
    cin >> kx >> ky;

    tx--; ty--; kx--; ky--;

    memset(maze,0,sizeof(maze));
    memset(d,false,sizeof(d));

    for(int i=0;i<h;i++){
      for(int j=0;j<w;j++) cin >> maze[i][j];
    }

    int ans = bfs();

    if(ans < 0) cout << "NA\n";
    else cout << ans << endl;

  }
}

C++: #include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#define limX(a)(min(max(1,a),X))
#define limY(a)(min(max(1,a),Y))
using namespace std;
typedef struct d{int tx,ty,kx,ky,time;}D;
int G[55][55],X,Y,R,tx,ty,kx,ky,mx[4]={0,-1,0,1},my[4]={-1,0,1,0},F[51][51][51][51];
struct Order{bool operator ()(D const& a, D const& b) const{return a.time>b.time;}};

int main()
{
	D tmp,tmp2;
	for(;scanf("%d%d",&X,&Y),X;)
	{
		memset(F,0,sizeof(F));
		priority_queue<D,vector<D>,Order>Q;
		R=-1;
		tmp.time=0;
		scanf("%d%d%d%d",&tmp.tx,&tmp.ty,&tmp.kx,&tmp.ky);
		for(int i=1;i<=Y;i++)for(int j=1;j<=X;j++)scanf("%d",&G[i][j]);
		Q.push(tmp);
		for(;!Q.empty();)
		{
			tmp=tmp2=Q.top();Q.pop();
			if(tmp.time>100)break;
			if(tmp.kx==tmp.tx&&tmp.ky==tmp.ty){R=tmp.time;break;}
			for(int i=0;i<4;tmp=tmp2,i++)
			{
				tmp.kx=limX(tmp.kx+mx[i]);
				tmp.ky=limY(tmp.ky+my[i]);
				if(G[tmp.ky][tmp.ky])tmp.kx=tmp2.kx,tmp.ky=tmp2.ky;
				tmp.tx=limX(tmp.tx-mx[i]);
				tmp.ty=limY(tmp.ty-my[i]);
				if(G[tmp.ty][tmp.ty])tmp.tx=tmp2.tx,tmp.ty=tmp2.ty;
				tmp.time++;
				if(!F[tmp.kx][tmp.ky][tmp.tx][tmp.ty])
				{
					F[tmp.kx][tmp.ky][tmp.tx][tmp.ty]=1;
					Q.push(tmp);
				}
			}
		}
		printf("%d\n",R);
	}
}