Problem:
Score : 400 points

Problem Statement

A maze is composed of a grid of H \times W squares - H vertical, W horizontal.

The square at the i-th row from the top and the j-th column from the left - (i,j) - is a wall if S_{ij} is # and a road if S_{ij} is ..

There is a magician in (C_h,C_w). He can do the following two kinds of moves:

Move A: Walk to a road square that is vertically or horizontally adjacent to the square he is currently in.

Move B: Use magic to warp himself to a road square in the 5\times 5 area centered at the square he is currently in.

In either case, he cannot go out of the maze.

At least how many times does he need to use the magic to reach (D_h, D_w)?

Constraints

1 \leq H,W \leq 10^3

1 \leq C_h,D_h \leq H

1 \leq C_w,D_w \leq W

S_{ij} is # or ..

S_{C_h C_w} and S_{D_h D_w} are ..

(C_h,C_w) \neq (D_h,D_w)

Input

Input is given from Standard Input in the following format:

H W
C_h C_w
D_h D_w
S_{11}\ldots S_{1W}
\vdots
S_{H1}\ldots S_{HW}

Output

Print the minimum number of times the magician needs to use the magic. If he cannot reach (D_h,D_w), print -1 instead.

Sample Input 1

4 4
1 1
4 4
..#.
..#.
.#..
.#..

Sample Output 1

1

For example, by walking to (2,2) and then using the magic to travel to (4,4), just one use of magic is enough.

Note that he cannot walk diagonally.

Sample Input 2

4 4
1 4
4 1
.##.
####
####
.##.

Sample Output 2

-1

He cannot move from there.

Sample Input 3

4 4
2 2
3 3
....
....
....
....

Sample Output 3

0

No use of magic is needed.

Sample Input 4

4 5
1 2
2 5
#.###
####.
#..##
#..##

Sample Output 4

2

Solution in C# (.NET Core 3.1.201) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters;

public static class Ex
{
    public static bool IsNullOrEmpty(this string s) { return string.IsNullOrEmpty(s); }
    public static List<string> FastSort(this List<string> s) { s.Sort(StringComparer.OrdinalIgnoreCase); return s.ToList(); }
    public static void yesno(this bool b) { Console.WriteLine(b ? "yes" : "no"); }
    public static void YesNo(this bool b) { Console.WriteLine(b ? "Yes" : "No"); }
    public static void YESNO(this bool b) { Console.WriteLine(b ? "YES" : "NO"); }
    public static int PopCount(this int bits)
    {
        bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
        bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
        bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
        bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
        return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff);
    }
}



partial class Program
{
    public string GetStr() { return Console.ReadLine().Trim(); }
    public char GetChar() { return Console.ReadLine().Trim()[0]; }
    public int GetInt() { return int.Parse(Console.ReadLine().Trim()); }
    public long GetLong() { return long.Parse(Console.ReadLine().Trim()); }
    public double GetDouble() { return double.Parse(Console.ReadLine().Trim()); }
    public string[] GetStrArray() { return Console.ReadLine().Trim().Split(' '); }
    public string[][] GetStrArray(int N)
    {
        var res = new string[N][];
        for (int i = 0; i < N; i++) res[i] = Console.ReadLine().Trim().Split(' ');
        return res;
    }
    public int[] GetIntArray() { return Console.ReadLine().Trim().Split(' ').Select(int.Parse).ToArray(); }
    public int[][] GetIntArray(int N)
    {
        var res = new int[N][];
        for (int i = 0; i < N; i++) res[i] = Console.ReadLine().Trim().Split(' ').Select(int.Parse).ToArray();
        return res;
    }
    public long[] GetLongArray() { return Console.ReadLine().Trim().Split(' ').Select(long.Parse).ToArray(); }
    public long[][] GetLongArray(int N)
    {
        var res = new long[N][];
        for (int i = 0; i < N; i++) res[i] = Console.ReadLine().Trim().Split(' ').Select(long.Parse).ToArray();
        return res;
    }
    public char[] GetCharArray() { return Console.ReadLine().Trim().Split(' ').Select(char.Parse).ToArray(); }
    public double[] GetDoubleArray() { return Console.ReadLine().Trim().Split(' ').Select(double.Parse).ToArray(); }
    public double[][] GetDoubleArray(int N)
    {
        var res = new double[N][];
        for (int i = 0; i < N; i++) res[i] = Console.ReadLine().Trim().Split(' ').Select(double.Parse).ToArray();
        return res;
    }
    public char[][] GetGrid(int H)
    {
        var res = new char[H][];
        for (int i = 0; i < H; i++) res[i] = Console.ReadLine().Trim().ToCharArray();
        return res;
    }
    public T[] CreateArray<T>(int N, T value)
    {
        var res = new T[N];
        for (int i = 0; i < N; i++) res[i] = value;
        return res;
    }
    public T[][] CreateArray<T>(int H, int W, T value)
    {
        var res = new T[H][];
        for (int i = 0; i < H; i++)
        {
            res[i] = new T[W];
            for (int j = 0; j < W; j++) res[i][j] = value;
        }
        return res;
    }
    public T[][][] CreateArray<T>(int H, int W, int R, T value)
    {
        var res = new T[H][][];
        for (int i = 0; i < H; i++)
        {
            res[i] = new T[W][];
            for (int j = 0; j < W; j++)
            {
                res[i][j] = new T[R];
                for (int k = 0; k < R; k++) res[i][j][k] = value;
            }
        }
        return res;
    }

    Dictionary<int, List<int>> GetUnweightedAdjacencyList(int N, int M, bool isDirected, bool isNode_0indexed)
    {
        var dic = new Dictionary<int, List<int>>();
        foreach (var e in Enumerable.Range(0, N)) { dic.Add(e, new List<int>()); }
        for (int i = 0; i < M; i++)
        {
            var input = GetIntArray();
            var a = isNode_0indexed ? input[0] : input[0] - 1;
            var b = isNode_0indexed ? input[1] : input[1] - 1;
            dic[a].Add(b);
            if (isDirected == false) dic[b].Add(a);
        }
        return dic;
    }
    Dictionary<int, List<Edge>> GetWeightedAdjacencyList(int N, int M, bool isDirected, bool isNode_0indexed)
    {
        var dic = new Dictionary<int, List<Edge>>();
        foreach (var e in Enumerable.Range(0, N)) { dic.Add(e, new List<Edge>()); }
        for (int i = 0; i < M; i++)
        {
            var input = GetIntArray();
            var a = isNode_0indexed ? input[0] : input[0] - 1;
            var b = isNode_0indexed ? input[1] : input[1] - 1;
            var c = input[2];
            dic[a].Add(new Edge(b, c));
            if (isDirected == false) dic[b].Add(new Edge(a, c));
        }
        return dic;
    }

    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>() ? ct<T, int>(int.Parse(s))
                       : eq<T, long>() ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>() ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    void Multi<T>(out T a) => a = cv<T>(GetStr());
    void Multi<T, U>(out T a, out U b)
    {
        var ar = GetStrArray(); a = cv<T>(ar[0]); b = cv<U>(ar[1]);
    }
    void Multi<T, U, V>(out T a, out U b, out V c)
    {
        var ar = GetStrArray(); a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]);
    }
    void Multi<T, U, V, W>(out T a, out U b, out V c, out W d)
    {
        var ar = GetStrArray(); a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]);
    }
    void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
    {
        var ar = GetStrArray(); a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]);
    }
    void Multi<T, U, V, W, X, Y>(out T a, out U b, out V c, out W d, out X e, out Y f)
    {
        var ar = GetStrArray(); a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]); f = cv<Y>(ar[5]);
    }

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

class Pair : IComparable<Pair>
{
    public Pair(int node, long cost)
    {
        Node = node; Cost = cost;
    }
    public int Node { get; set; }
    public long Cost { get; set; }
    public int CompareTo(Pair p)
    {
        return p.Cost > Cost ? 1 : -1;
    }
}

class Edge
{
    public Edge(int to, long length)
    {
        To = to;
        Length = length;
    }
    public int To { get; set; }
    public long Length { get; set; }
}

class Comparable : IComparable<Comparable>
{
    public Comparable(int x, int id)
    {
        X = x;
        Id = id;
    }

    public int X;
    public int Id;
    public int CompareTo(Comparable c)
    {
        return X >= c.X ? -1 : 1;
    }
}

class Comparer<T> : IComparer<T>
{
    public int Compare(T t1, T t2)
    {
        return 1;
    }
}




partial class Program
{
    static void Main()
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        new Program().Solve();
        Console.Out.Flush();
        Console.Read();
    }

    public void Solve()
    {
        int H; int W;
        Multi(out H, out W);
        int sy, sx;
        Multi(out sy, out sx);
        sy--; sx--;
        int gy, gx;
        Multi(out gy, out gx);
        gy--; gx--;
        var map = GetGrid(H);
        var G = new Dictionary<int, List<Edge>>();
        var uf = new UnionFind(H * W);

        int pos1;
        int pos2;
        for (int y = 0; y < H; y++)
        {
            for (int x = 0; x < W; x++)
            {
                if (map[y][x] == '#') continue;
                for (int i = 0; i < 4; i++)
                {
                    var ny = y + dy[i];
                    var nx = x + dx[i];
                    if (ny < 0 || H <= ny || nx < 0 || W <= nx) continue;
                    if (map[ny][nx] == '#') continue;
                    uf.Union(ny * W + nx, y * W + x);
                    pos1 = y * W + x;
                    pos2 = ny * W + nx;
                    if (G.ContainsKey(pos1) == false) G.Add(pos1, new List<Edge>());
                    if (G.ContainsKey(pos2) == false) G.Add(pos2, new List<Edge>());
                    G[pos1].Add(new Edge(pos2, 0));
                    G[pos2].Add(new Edge(pos1, 0));
                }
            }
        }

        for (int y = 0; y < H; y++)
        {
            for (int x = 0; x < W; x++)
            {
                if (map[y][x] == '#') continue;
                pos1 = y * W + x;
                for (int dx = -2; dx <= 2; dx++)
                {
                    var nx = x + dx;
                    if (nx < 0 || W <= nx) continue;
                    for (int dy = 0; dy <= 2; dy++)
                    {
                        if (dx == 0 && dy == 0) continue;
                        var ny = y + dy;
                        if (H <= ny) continue;
                        if (map[ny][nx] == '#') continue;
                        if (uf.Same(y * W + x, ny * W + nx)) continue;
                        pos2 = ny * W + nx;
                        if (G.ContainsKey(pos1) == false) G.Add(pos1, new List<Edge>());
                        if (G.ContainsKey(pos2) == false) G.Add(pos2, new List<Edge>());
                        G[pos1].Add(new Edge(pos2, 1));
                        G[pos2].Add(new Edge(pos1, 1));
                    }
                }
            }
        }

        if (G.Count == 0)
        {
            Console.WriteLine(-1);
            return;
        }
        var dist = new long[H * W];
        for (int i = 0; i < H * W; i++) dist[i] = -1L;
        var pq = new LinkedList<Pair>();
        dist[sy * W + sx] = 0;
        pq.AddLast(new Pair(sy * W + sx, 0));
        while (pq.Count() > 0)
        {
            var now = pq.First();
            pq.RemoveFirst();
            if (now.Node == gy * W + gx)
            {
                Console.WriteLine(dist[now.Node]);
                return;
            }
            if (dist[now.Node] < now.Cost) continue;
            foreach (var next in G[now.Node])
            {
                var alt = now.Cost + next.Length;
                if (dist[next.To] != -1 && alt >= dist[next.To]) continue;
                dist[next.To] = alt;
                if (next.Length == 1) pq.AddLast(new Pair(next.To, alt));
                else pq.AddFirst(new Pair(next.To, alt));
            }
        }

        Console.WriteLine(dist[gy * W + gx]);
    }

    class UnionFind
    {
        // 親要素のインデックスを保持する
        // 親要素が存在しない(自身がルートである)とき、マイナスでグループの要素数を持つ
        int[] parents;
        public UnionFind(int n)
        {
            this.parents = new int[n];
            for (int i = 0; i < n; i++)
            {
                // 初期状態ではそれぞれが別のグループ(ルートは自分自身)
                // ルートなのでマイナスで要素数(1個)を保持する
                this.parents[i] = -1;
            }
        }

        // 要素xのルート要素はどれか
        public int Find(int x)
        {
            // 親がマイナスの場合は自分自身がルート
            if (this.parents[x] < 0) return x;
            // ルートが見つかるまで再帰的に探す
            // 見つかったルートにつなぎかえる
            this.parents[x] = Find(this.parents[x]);
            return this.parents[x];
        }

        /// <summary>
        /// 要素xの属するグループの要素数を取得する
        /// </summary>
        /// <param name="x"></param>
        public int Size(int x)
        {
            // ルート要素を取得して、サイズを取得して返す
            return -this.parents[this.Find(x)];
        }

        // 要素x, yが同じグループかどうか判定する
        public bool Same(int x, int y)
        {
            return this.Find(x) == this.Find(y);
        }

        // 要素x, yが属するグループを同じグループにまとめる
        public bool Union(int x, int y)
        {
            // x, y のルート
            x = this.Find(x);
            y = this.Find(y);
            // すでに同じグループの場合処理しない
            if (x == y) return false;

            // 要素数が少ないグループを多いほうに書き換えたい
            if (this.Size(x) < this.Size(y))
            {
                var tmp = x;
                x = y;
                y = tmp;
            }
            // まとめる先のグループの要素数を更新
            this.parents[x] += this.parents[y];
            // まとめられるグループのルートの親を書き換え
            this.parents[y] = x;
            return true;
        }
    }
}