#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};

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

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

void findCosts(int i, int j) {
    int maxDist = distances[i][j];
    positions.push(make_pair(distances[i][j], make_pair(i, j)));
    while (!positions.empty()) {
        i = positions.top().second.first;
        j = positions.top().second.second;
        positions.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) {
                continue;
            }
            goneThrough[nextI][nextJ] = 1;
            positions.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') {
                dragons.push_back(make_pair(i, j));
            } else if (matrix[i][j] == 'I') {
                startLine = i;
                startColumn = j;
            } else if (matrix[i][j] == 'O') {
                exitLine = i;
                exitColumn = j;
            }
        }
    }
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (matrix[i][j] == '*' || matrix[i][j] == 'D' || matrix[i][j] == 'I') {
                distances[i][j] = -1; // nu se poate pe aici
            } else {
                for (int a = 0; a < dragons.size(); ++a) {
                    distances[i][j] = min(distances[i][j], abs(dragons[a].first - i) + abs(dragons[a].second - j));
                }
            }
        }
    }
    /*
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            cout << distances[i][j] << " ";
        }
        cout << '\n';
    }
     */
    findCosts(startLine, startColumn);
    /*
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            cout << goneThrough[i][j] << " ";
        }
        cout << '\n';
    }
     */
}

/*
 
 10 10
 ..........
 .I....D...
 ..........
 ..D...D...
 **********
 D*........
 *...D.....
 ..****....
 ...O......
 .......... -> -1
 
 10 10
 ..........
 .I....D...
 ..........
 ..D...D...
 .*........
 D*........
 *...D.....
 ..****....
 ...O......
 .......... -> 2
 
 
 
 */