#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#define infinite 99999999
using namespace std;
int n,m;
int parcurs[1010][1010];
int myDistance[1010][1010];
bool foundSolution;
bool solutionCertain;
int thisIsIt;
ifstream in("barbar.in");
ofstream out("barbar.out");
int cost;
int middle;
struct pos
{
    int i;
    int j;
}A,start,finish;
queue <pos> myQueue;
vector <pos> dragons;
int caseAvailable;

void surrounder()
{
    for(int i = 0; i <= m + 1; i++)
    {
        myDistance[0][i] = infinite;
        myDistance[n+1][i] = infinite;
        parcurs[0][i] = infinite;
        parcurs[n+1][i] = infinite;
    }

    for(int i = 0; i <= n; i++)
    {
        myDistance[i][0] = infinite;
        myDistance[i][m+1] = infinite;
        parcurs[i][0] = infinite;
        parcurs[i][m+1] = infinite;
    }
}

void read()
{
    char ch;
    in>>n>>m;
    surrounder();
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            myDistance[i][j] = infinite;
            in>>ch;
            if(ch == '.')
            {

            }
            else
            {
                if(ch == '*')
                {
                    parcurs[i][j] = infinite;
                }
                else
                {
                    if(ch == 'D')
                    {
                        A.i = i;
                        A.j = j;
                        dragons.push_back(A);
                        myDistance[i][j] = 0;
                        parcurs[i][j] = infinite;
                    }
                    else
                    {
                        if(ch == 'I')
                        {
                            start.i = i;
                            start.j = j;
                        }
                        else
                        {
                            finish.i = i;
                            finish.j = j;
                        }
                    }
                }
            }
        }
    }
}

void queueUp(int i, int j)
{
    if(parcurs[i-1][j] < caseAvailable)
    {
        parcurs[i-1][j] = caseAvailable;
        if((myDistance[i-1][j] > myDistance[i][j] + 1) || myDistance[i-1][j] == 0)
        {
            parcurs[i-1][j] = caseAvailable;
            A.i = i-1;
            A.j = j;
            myDistance[i-1][j] = myDistance[i][j] + 1;
            myQueue.push(A);
        }
    }
}

void queueMiddle(int i, int j)
{
    if(parcurs[i][j-1] < caseAvailable)
    {
        parcurs[i][j-1] = caseAvailable;
        if( myDistance[i][j-1] > myDistance[i][j] + 1 )
        {
            A.i = i;
            A.j = j-1;
            myQueue.push(A);
            parcurs[i][j-1] = caseAvailable;
            myDistance[i][j-1] = myDistance[i][j] + 1;
        }
    }

    if(parcurs[i][j+1] < caseAvailable )
    {
        if(myDistance[i][j+1] > myDistance[i][j] + 1)
        {
            A.i = i;
            A.j = j+1;
            myQueue.push(A);
            parcurs[i][j+1] = caseAvailable;
            myDistance[i][j+1] = myDistance[i][j] + 1;
        }
    }
}

void queueDown(int i, int j)
{
    if(parcurs[i+1][j] < caseAvailable)
    {
       if(myDistance[i+1][j] > myDistance[i][j] + 1)
        {
            parcurs[i+1][j] = caseAvailable;
            myDistance[i+1][j] = myDistance[i][j] + 1;
            A.i = i+1;
            A.j = j;
            myQueue.push(A);
        }
    }
}
void queueMyNeighbours(int i, int j)
{
    queueUp(i,j);
    queueMiddle(i,j);
    queueDown(i,j);
}

void setmyDistance()
{
    pos aux;
    while(myQueue.empty() == false)
    {
        aux = myQueue.front();
        myQueue.pop();
        queueMyNeighbours(aux.i,aux.j);
    }
}

void dragonIt()
{
    for(int i = 0; i < dragons.size(); i++)
    {
        caseAvailable++ ;
        myQueue.push(dragons[i]);
        setmyDistance();
    }
}

void df(int i, int j)
{
    parcurs[i][j] = caseAvailable;
    if(i == finish.i && j == finish.j)
    {
        foundSolution = true;
    }
    else
    {
        if(foundSolution == false)
        {
            if(parcurs[i-1][j] < caseAvailable && myDistance[i-1][j] >= middle)
            {
                df(i-1,j);
            }
            if(parcurs[i+1][j] < caseAvailable && myDistance[i+1][j] >= middle)
            {
                df(i+1,j);
            }
            if(parcurs[i][j-1] < caseAvailable && myDistance[i][j-1] >= middle )
            {
                df(i,j-1);
            }
            if(parcurs[i][j+1] < caseAvailable && myDistance[i][j+1] >= middle)
            {
                df(i, j+1);
            }
        }
    }
}

void bsc(int st, int dr)
{
    cout<<st<<" "<<dr<<endl;
    if(st > dr)
    {
        return;
    }
    foundSolution = false;
    middle = (st + dr) /2;
    df(start.i,start.j);
    if(foundSolution == false)
    {
        bsc(st ,middle - 1);
    }
    else
    {
        thisIsIt = middle;
        solutionCertain = true;
        bsc(middle + 1,dr);
    }
}

void writeMatrix()
{
    for(int i = 1 ; i<=n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(myDistance[i][j] == infinite)
            {
                out<<"* ";
            }
            else
            out<<myDistance[i][j]<<" ";
        }
        out<<endl;
    }
}
void solve()
{
    dragonIt();
    caseAvailable++;
    bsc(1,n);
    //middle = 3;
    //df(start.i,start.j);
    //cout<<foundSolution;
}

void write()
{
    if (solutionCertain == false)
    {
        out<<-1;
    }
    else
    {
        out<<thisIsIt;
    }
}

main()
{
    read();
    solve();
    write();
}