#include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <algorithm>
#include <utility>
#include <cmath>
#include <map>
#include <deque>
#include <vector>
#include <set>
#include <climits>
#include <queue>
using namespace std;

ifstream fin("barbar.in");
ofstream fout("barbar.out");

const int MAX_SIZE = 1000;

int n, m, startLine, startColumn, exitLine, exitColumn;
char matrix[MAX_SIZE + 1][MAX_SIZE + 1];
int distances[MAX_SIZE + 1][MAX_SIZE + 1], goneThrough[MAX_SIZE + 1][MAX_SIZE + 1];
vector<pair<int, int>> dragons;
bool isWay = false;

int x[] = {1, -1, 0, 0};
int y[] = {0, 0, 1, -1};

queue<pair<int, pair<int, int>>> positions;

bool isInMatrix(int i, int j) {
    return i >= 1 && i <= n && j >= 1 && j <= m;
}

void findDragonsDistances() {
    while (!positions.empty()) {
        int curDist = positions.front().first;
        int i = positions.front().second.first;
        int j = positions.front().second.second;
        positions.pop();
        goneThrough[i][j] = 1;
        for (int a = 0; a <= 3; ++a) {
            int nextI = i + x[a];
            int nextJ = j + y[a];
            if (goneThrough[nextI][nextJ] || !isInMatrix(nextI, nextJ) || matrix[nextI][nextJ] == '*') {
                if (matrix[nextI][nextJ] == '*') {
                    distances[nextI][nextJ] = -1;
                }
                continue;
            }
            if (distances[nextI][nextJ] > curDist + 1) {
                distances[nextI][nextJ] = min(distances[nextI][nextJ], curDist + 1);
                positions.push(make_pair(distances[nextI][nextJ], make_pair(nextI, nextJ)));
            }
        }
    }
}

priority_queue<pair<int, pair<int, int>>> pos;

void findMaxDist(int i, int j) {
    for (int a = 1; a <= n; ++a) {
        for (int b = 1; b <= m; ++b) {
            goneThrough[a][b] = 0;
        }
    }
    int maxDist = distances[i][j];
    pos.push(make_pair(distances[i][j], make_pair(i, j)));
    goneThrough[i][j] = 1;
    while (!pos.empty()) {
        i = pos.top().second.first;
        j = pos.top().second.second;
        pos.pop();
        maxDist = min(maxDist, distances[i][j]);
        if (i == exitLine && j == exitColumn) { // daca am ajuns la destinatie
            fout << maxDist;
            isWay = true;
            break;
        }
        for (int a = 0; a < 4; ++a) {
            int nextI = i + x[a];
            int nextJ = j + y[a];
            if (!isInMatrix(nextI, nextJ) || goneThrough[nextI][nextJ] || distances[nextI][nextJ] == -1 || distances[nextI][nextJ] == 0) {
                continue;
            }
            goneThrough[nextI][nextJ] = 1;
            pos.push(make_pair(distances[nextI][nextJ], make_pair(nextI, nextJ))); // stocam in functie de valorile maxime.
        }
    }
    if (!isWay) {
        fout << -1;
    }
}

int main() {
    fin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            fin >> matrix[i][j];
            distances[i][j] = INT_MAX;
            if (matrix[i][j] == 'D') {
                positions.push(make_pair(0, make_pair(i, j)));
                distances[i][j] = 0;
            } else if (matrix[i][j] == 'I') {
                startLine = i;
                startColumn = j;
            } else if (matrix[i][j] == 'O') {
                exitLine = i;
                exitColumn = j;
            }
        }
    }
    if (startLine && startColumn && exitLine && exitColumn) {
        findDragonsDistances();
        findMaxDist(startLine, startColumn);
    }
}