Problem:
Score : 400 points

Problem Statement

Takahashi has a maze, which is a grid of H \times W squares with H horizontal rows and W vertical columns.

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

From a road square, you can move to a horizontally or vertically adjacent road square.

You cannot move out of the maze, move to a wall square, or move diagonally.

Takahashi will choose a starting square and a goal square, which can be any road squares, and give the maze to Aoki.

Aoki will then travel from the starting square to the goal square, in the minimum number of moves required.

In this situation, find the maximum possible number of moves Aoki has to make.

Constraints

1 \leq H,W \leq 20

S_{ij} is . or #.

S contains at least two occurrences of ..

Any road square can be reached from any road square in zero or more moves.

Input

Input is given from Standard Input in the following format:

H W
S_{11}...S_{1W}
:
S_{H1}...S_{HW}

Output

Print the maximum possible number of moves Aoki has to make.

Sample Input 1

3 3
...
...
...

Sample Output 1

4

If Takahashi chooses the top-left square as the starting square and the bottom-right square as the goal square, Aoki has to make four moves.

Sample Input 2

3 5
...#.
.#.#.
.#...

Sample Output 2

10

If Takahashi chooses the bottom-left square as the starting square and the top-right square as the goal square, Aoki has to make ten moves.

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
 
 public static class Program
 {
     private static readonly long INF = long.MaxValue / 2;
     private static readonly int MOD = 1000000007;
 
     struct Pair<T, U> : IComparable<Pair<T, U>>
         where T : IComparable<T>
         where U : IComparable<U>
     {
         public T first;
         public U second;
         private bool CompWithFirst;
 
         public Pair(T f, U s, int comp)
         {
             first = f;
             second = s;
             CompWithFirst = comp == 1;
         }
 
         public int CompareTo(Pair<T, U> other)
         {
             return CompWithFirst ? first.CompareTo(other.first) : second.CompareTo(other.second);
         }
     }
 
     public class PriorityQueue<T> where T : IComparable<T>
     {
 
         private List<T> Q;
         private readonly int r;
 
         public PriorityQueue(bool ascending)
         {
             if (ascending)
             {
                 r = 1;
             }
             else
             {
                 r = -1;
             }
 
             Q = new List<T>();
         }
 
 
         private void PushHeap(List<T> list, T item)
         {
             int n = list.Count();
             list.Add(item);
 
             while (n != 0)
             {
                 int pIndex = (n - 1) / 2;
 
                 if (list[n].CompareTo(list[pIndex]) * r > 0)
                 {
                     Swap(Q, n, pIndex);
                 }
                 else
                 {
                     break;
                 }
 
                 n = pIndex;
             }
         }
 
         private void PopHeap(List<T> list)
         {
             int n = list.Count() - 1;
             list[0] = list[n];
             list.RemoveAt(n);
 
             int cur = 0;
             int comp;
 
             while (2 * cur + 1 <= n - 1)
             {
                 int c1 = 2 * cur + 1;
                 int c2 = 2 * (cur + 1);
                 if (c1 == n - 1)
                 {
                     comp = c1;
                 }
                 else
                 {
 
                     comp = list[c1].CompareTo(list[c2]) * r > 0 ? c1 : c2;
                 }
 
                 if (list[cur].CompareTo(list[comp]) * r < 0)
                 {
                     Swap(Q, cur, comp);
                 }
                 else
                 {
                     break;
                 }
 
                 cur = comp;
             }
         }
 
         private void Swap(List<T> list, int a, int b)
         {
             T keep = list[a];
             list[a] = list[b];
             list[b] = keep;
         }
 
 
 
         public void Enqueue(T value)
         {
             PushHeap(Q, value);
         }
 
         public T Dequeue()
         {
             T ret = Q[0];
             PopHeap(Q);
             return ret;
         }
 
         public T Peek()
         {
             return Q[0];
         }
 
         public int CountItem()
         {
             return Q.Count();
         }
 
         public bool IsEmpty()
         {
             return !Q.Any();
         }
     }
 
     static long ModInv(long a, long m)
     {
         long b = m, u = 1, v = 0;
         while (b != 0)
         {
             long t = a / b;
             a -= t * b;
             long tmp = a;
             a = b;
             b = tmp;
             u -= t * v;
             tmp = u;
             u = v;
             v = tmp;
         }
 
         u %= m;
         if (u < 0) u += m;
         return u;
     }
 
     public static long CalcComb(long n, long m)
     {
         //条件チェック
         if (n < m) return 0;
         if (n < 0 || m < 0) return 0;
 
         //nＣm ＝ nＣm-1 ×（n-m+1）/ m 
 //         return CalcFact(n) / (CalcFact(m) * CalcFact(n - m));
         //MODで割ってbの逆元を求める
         return CalcFact(n) * ModInv((CalcFact(m) * CalcFact(n - m)) % MOD, MOD) % MOD;
     }
 
     /// <summary>
     /// 階乗を計算する。
     /// </summary>
     /// <param name="n">n</param>
     /// <returns>nの階乗（n!）</returns>
     public static long CalcFact(long n)
     {
         if (n <= 0)
         {
             return 1;
         }
 
         return n * CalcFact(n - 1) % MOD;
     }
 
 
     struct Pos
     {
         public int x;
         public int y;
 
         public Pos(int x, int y)
         {
             this.x = x;
             this.y = y;
         }
         
         public static Pos operator +(Pos p1, Pos p2)
         {
             var result = new Pos();
             result.x = p2.x + p1.x;
             result.y = p2.y + p1.y;
             return result;
         }
 
         public static Pos operator -(Pos p1, Pos p2)
         {
             var result = new Pos();
             result.x = p2.x - p1.x;
             result.y = p2.y - p1.y;
             return result;
         }
     }
     
     class Modular
     {
         private const int M = 1000000007;
         private long value;
 
         public Modular(long value)
         {
             this.value = value;
         }
 
         public static implicit operator Modular(long a)
         {
             var m = a % M;
             return new Modular((m < 0) ? m + M : m);
         }
 
         public static Modular operator +(Modular a, Modular b)
         {
             return a.value + b.value;
         }
 
         public static Modular operator -(Modular a, Modular b)
         {
             return a.value - b.value;
         }
 
         public static Modular operator *(Modular a, Modular b)
         {
             return a.value * b.value;
         }
 
         private static Modular Pow(Modular a, int n)
         {
             switch (n)
             {
                 case 0:
                     return 1;
                 case 1:
                     return a;
                 default:
                     var p = Pow(a, n / 2);
                     return p * p * Pow(a, n % 2);
             }
         }
 
         public static Modular operator /(Modular a, Modular b)
         {
             return a * Pow(b, M - 2);
         }
 
         private static readonly List<int> facs = new List<int> {1};
 
         private static Modular Fac(int n)
         {
             for (int i = facs.Count; i <= n; ++i)
             {
                 facs.Add((int) (Math.BigMul(facs.Last(), i) % M));
             }
 
             return facs[n];
         }
 
         public static Modular Ncr(int n, int r)
         {
             return (n < r) ? 0
                 : (n == r) ? 1
                 : Fac(n) / (Fac(r) * Fac(n - r));
         }
 
         public static explicit operator int(Modular a)
         {
             return (int) a.value;
         }
     }
     
     static class Permutation<T>
     {
         private static void Search(List<T[]> perms, Stack<T> stack, T[] a)
         {
             int N = a.Length;
             if (N == 0)
             {
                 perms.Add(stack.Reverse().ToArray());
             }
             else
             {
                 var b = new T[N - 1];
                 Array.Copy(a, 1, b, 0, N - 1);
                 for (int i = 0; i < a.Length; ++i)
                 {
                     stack.Push(a[i]);
                     Search(perms, stack, b);
                     if (i < b.Length) { b[i] = a[i]; }
                     stack.Pop();
                 }
             }
         }
         public static IEnumerable<T[]> All(IEnumerable<T> src)
         {
             var perms = new List<T[]>();
             Search(perms, new Stack<T>(), src.ToArray());
             return perms;
         }
     }
 
     public static int ReadLineToInt()
     {
         return int.Parse(ReadLine());
     }
     
     public static long ReadLineToLong()
     {
         return long.Parse(ReadLine());
     }
     
     public static int[] ReadLineToInts()
     {
         return ReadLine().Split(' ').Select(int.Parse).ToArray();
     }
     
     public static long[] ReadLineToLongs()
     {
         return ReadLine().Split(' ').Select(long.Parse).ToArray();
     }
     
     static int nibunn(int[] array, int target)
     {
         int L = 0;
         int R = array.Length; 
             
         while(R - L > 1)
         {
             int mid = (R + L) / 2;
             if (array[mid] > target) L = mid;
             else R = mid;
         }
         return L;
     }


     struct Testmony
     {
         public int To;
         public int IsHonest;

         public Testmony(int to, int isHonest)
         {
             To = to;
             IsHonest = isHonest;
         }
     }
     
     static int[] dx = {1,0,-1,0};
     static int[] dy = {0,1,0,-1};
     public static void Main(string[] args)
     {
         int[] input = ReadLineToInts();
         int h = input[0];
         int w = input[1];
         char[,] maze = new char[w,h];
         const int INF = 1001001001;
         for (int i = 0; i < h; i++)
         {
             char[] chars = ReadLine().ToCharArray();
             for (int j = 0; j < w; j++)
             {
                 maze[j, i] = chars[j];
             }
         }
         
         int ans = 0;
         for (int i = 0; i < h; i++)
         {
             for (int j = 0; j < w; j++)
             {
                 
                 if (maze[j, i] == '#')
                 {
                     continue;
                 }
                 int[,] dist = new int[w, h];
                 for (int a = 0; a < h; a++)
                 {
                     for (int b = 0; b < w; b++)
                     {
                         dist[b, a] = INF;
                     }
                 }
                 var q = new Queue<P>();
                 q.Enqueue(new P{first = j,second = i});
                 dist[j, i] = 0;
                 while (q.Count != 0)
                 {
                     var p = q.Dequeue();
                     for (int k = 0; k < 4; k++)
                     {
                         int nx = p.first + dx[k];
                         int ny = p.second + dy[k];
                         if (nx < 0 || ny < 0 || nx >= w || ny >= h)
                         {
                             continue;
                         }

                         if (maze[nx, ny] == '#')
                         {
                             continue;
                         }

                         if (dist[nx, ny] != INF)
                         {
                             continue;
                         }
                         
                         q.Enqueue(new P{first = nx,second = ny});
                         dist[nx, ny] = dist[p.first, p.second] + 1;
                     }
                 }

                 foreach (var e in dist)
                 {
                     if (e == INF) continue;
                     ans = Math.Max(ans, e);
                 }
             }
         }
         
         WriteLine(ans);

     }

     struct P
     {
         public int first;
         public int second;
     }
 }