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: Accepted)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters;
using System.Security.Permissions;
using System.Xml.Schema;

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<(int, long)>> GetWeightedAdjacencyList(int N, int M, bool isDirected, bool isNode_0indexed)
    {
        var dic = new Dictionary<int, List<(int, long)>>();
        foreach (var e in Enumerable.Range(0, N)) { dic.Add(e, new List<(int, long)>()); }
        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((b, c));
            if (isDirected == false) dic[b].Add((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;
    public long cost;
    public int CompareTo(Pair p)
    {
        return p.cost > cost ? 1 : -1;
    }
}

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--;
        var spos = sy * W + sx;

        int gy, gx;
        Multi(out gy, out gx);
        gy--; gx--;
        var gpos = gy * W + gx;

        var map = GetGrid(H);

        var G = new Dictionary<int, List<(int to, int length)>>();

        for (int y = 0; y < H; y++)
        {
            for (int x = 0; x < W; x++)
            {
                if (map[y][x] == '#') continue;
                G.Add(y * W + x, new List<(int to, int length)>());
            }
        }

        var par = CreateArray(H * W, -1);
        Queue<int> queue;
        int pos, npos, nx, ny;
        for (int y = 0; y < H; y++)
        {
            for (int x = 0; x < W; x++)
            {
                if (map[y][x] == '#') continue;
                pos = y * W + x;
                if (par[pos] != -1) continue;
                queue = new Queue<int>();
                par[pos] = pos;
                queue.Enqueue(pos);
                while (queue.Count > 0)
                {
                    var now = queue.Dequeue();
                    var yy = now / W;
                    var xx = now % W;
                    for (int i = 0; i < 4; i++)
                    {
                        nx = xx + dx[i];
                        ny = yy + dy[i];
                        if (ny < 0 || H <= ny || nx < 0 || W <= nx) continue;
                        if (map[ny][nx] == '#') continue;
                        npos = ny * W + nx;
                        if (par[npos] != -1) continue;
                        par[npos] = pos;
                        G[pos].Add((npos, 0));
                        G[npos].Add((pos, 0));
                        queue.Enqueue(npos);
                    }
                }
            }
        }

        for (int y = 0; y < H; y++)
        {
            for (int x = 0; x < W; x++)
            {
                if (map[y][x] == '#') continue;
                pos = y * W + x;
                for (int dy = 0; dy <= 2; dy++)
                {
                    ny = y + dy;
                    if (H <= ny) break;
                    for (int dx = -2; dx <= 2; dx++)
                    {
                        if (dy == 0 && dx <= 0) continue;
                        nx = x + dx;
                        if (nx < 0 || W <= nx) continue;
                        if (map[ny][nx] == '#') continue;
                        npos = ny * W + nx;
                        if (par[pos] == par[npos]) continue;
                        G[pos].Add((npos, 1));
                        G[npos].Add((pos, 1));
                    }
                }
            }
        }

        var dist = CreateArray(H * W, -1);
        var deque = new LinkedList<(int node, int cost)>();

        dist[spos] = 0;
        deque.AddFirst((spos, 0));
        while (deque.Count() > 0)
        {
            var now = deque.First();
            if (now.node == gpos)
            {
                Console.WriteLine(dist[gpos]);
                return;
            }
            deque.RemoveFirst();
            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) deque.AddLast((next.to, alt));
                else deque.AddFirst((next.to, alt));
            }
        }
        Console.WriteLine(-1);
    }

}