#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;
char matrix[MAX_SIZE + 1][MAX_SIZE + 1];
int distances[MAX_SIZE + 1][MAX_SIZE + 1], goneThrough[MAX_SIZE + 1][MAX_SIZE + 1];
bool isWay;

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

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

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] == '*') {
                continue;
            }
            if (distances[nextI][nextJ] > curDist + 1) {
                distances[nextI][nextJ] = curDist + 1;
                positions.push(make_pair(distances[nextI][nextJ], make_pair(nextI, nextJ)));
            }
        }
    }
}

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];
    way.push(make_pair(distances[i][j], make_pair(i, j)));
    goneThrough[i][j] = 1;
    while (!way.empty()) {
        i = way.top().second.first;
        j = way.top().second.second;
        way.pop();
        maxDist = min(maxDist, distances[i][j]);
        if (matrix[i][j] == 'O') {
            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] || matrix[nextI][nextJ] == '*' || matrix[nextI][nextJ] == 'D') {
                continue;
            }
            goneThrough[nextI][nextJ] = 1;
            way.push(make_pair(distances[nextI][nextJ], make_pair(nextI, nextJ)));
        }
    }
    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;
            }
        }
    }
    findDragonsDistances();
    findMaxDist(startLine, startColumn);
}