#include <iostream>
#include <vector>
#include <queue>
#include <fstream>

using namespace std;

bool inside(const int row, const int col, const int rows, const int cols) {
    return row >= 0 && row < rows && col >= 0 && col < cols;
}

bool isFree(char c) {
    return c == '.' || c == 'I' || c == 'O';
}

vector<vector<int>> distances(const vector<pair<int, int>>& sources, const vector<string>& m) {
    static const int dr[] = {0, 0, -1, 1};
    static const int dc[] = {1, -1, 0, 0};
    const int rows = m.size();
    const int cols = m[0].size();

    vector<vector<int>> dist(rows, vector<int>(cols, -1));
    queue<pair<int, int>> q;

    for (const auto& source : sources) {
        if (isFree(m[source.first][source.second])) {
            dist[source.first][source.second] = 0;
            q.push(source);
        }
    }

    while (!q.empty()) {
        int row = q.front().first;
        int col = q.front().second;
        q.pop();
        for (int k = 0; k < 4; ++k) {
            int neighbor_row = row + dr[k];
            int neighbor_col = col + dc[k];
            if (inside(neighbor_row, neighbor_col, rows, cols) &&
                    dist[neighbor_row][neighbor_col] == -1 &&
                    isFree(m[neighbor_row][neighbor_col])) {
                dist[neighbor_row][neighbor_col] = dist[row][col] + 1;
                q.emplace(neighbor_row, neighbor_col);
            }
        }
    }

    return dist;
}

vector<string> forbidCells(const vector<string>& initial, const vector<vector<int>>& distance, int minDistance) {
    const int rows = initial.size();
    const int cols = initial[0].size();
    vector<string> result = initial;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            if (isFree(result[i][j]) && distance[i][j] < minDistance) {
                result[i][j] = '*';
            }
        }
    }
    return result;
}

bool canExit(const int minDistance, const pair<int, int>& entrance, const pair<int, int>& exit, const vector<string>& m, const vector<vector<int>>& dragonDistances) {
    vector<string> temp = forbidCells(m, dragonDistances, minDistance);
    return distances({entrance}, temp)[exit.first][exit.second] != -1;
}

int main() {
    int rows, cols;
#ifdef LOCAL
    ifstream cin("C:\\Users\\Cosmin\\Desktop\\in.txt");
    ofstream cout("C:\\Users\\Cosmin\\Desktop\\out.txt");
#else
    ifstream cin("barbar.in");
    ofstream cout("barbar.out");
#endif
    cin >> rows >> cols;
    vector<string> m(rows);
    for (int i = 0; i < rows; ++i) {
        cin >> m[i];
    }

    vector<pair<int, int>> dragons;
    pair<int, int> entrance;
    pair<int, int> exit;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            if (m[i][j] == 'D') {
                dragons.emplace_back(i, j);
            }
            if (m[i][j] == 'I') {
                entrance = make_pair(i, j);
            }
            if (m[i][j] == 'O') {
                exit = make_pair(i, j);
            }
        }
    }

    vector<vector<int>> dragonDistance = distances(dragons, m);
    int maxDistance = 0;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            if (dragonDistance[i][j] != -1) {
                maxDistance = max(maxDistance, dragonDistance[i][j]);
            }
        }
    }

    if (!canExit(0, entrance, exit, m, dragonDistance)) {
        cout << -1 << endl;
        return 0;
    }

    int left = 0, right = maxDistance;
    while (left < right) {
        int mid = (left + right + 1) / 2;
        if (canExit(mid, entrance, exit, m, dragonDistance)) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    cout << left << endl;
    return 0;
}