#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';
}
// Returneaza matricea de distante minime fata de orice sursa din sources a celulelor din matricea m.
// Celulele libere sunt identificate folosind functia isFree de mai sus.
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) {
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;
}
// Returneaza o copie a matricii initiale unde celulele libere care au distanta mai mica
// decat minDistance sunt inlocuite cu '*' pentru a le considera inaccesibile in Lee.
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;
}
// Returneaza true daca se poate ajunge de la entrance la exit mergand doar prin celule
// care au distanta fata de cel mai apropiat dragon mai mare sau egala cu minDistance.
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);
if (temp[entrance.first][entrance.second] == '*') {
return false;
}
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];
}
// Salvez pozitiile dragonilor, a intrarii si a iesirii
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);
}
}
}
// Salvez distantele de la dragoni la orice celula.
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]);
}
// Pot fi celule libere care sunt inaccesibile dragonilor. Lee-ul va intoarce distanta
// -1 pentru aceste celule, dar eu am nevoie ca distanta fata de ele sa fie foarte mare,
// deci o setez la rows * cols + 1, care e garantat mai mare decat orice distanta din matrice.
if (isFree(m[i][j]) && (dragonDistance[i][j] == -1)) {
dragonDistance[i][j] = rows * cols + 1;
}
}
}
// Daca nu putem ajunge de la intrare la iesire cu distanta minima fata de un dragon egala cu 0
// inseamna ca nu avem solutie.
if (!canExit(0, entrance, exit, m, dragonDistance)) {
cout << -1 << endl;
return 0;
}
// Observam ca daca avem solutie pentru distanta D1, atunci avem solutie pentru orice alta
// distanta D < D1, ceea ce inseamna ca canExit este o functie monotona cu 2 valori, 1 si 0.
// Sirul valorilor ei este : 1 1 1 1 1 ... 1 0 0 .. 0. Pe noi ne intereseaza unde este ultimul 1,
// acesta fiind cea mai mare distanta minima fata de un dragon posibila.
int left = 0, right = maxDistance;
while (left < right) {
int mid = (left + right + 1) / 2;
// Daca avem solutie pentru distanta mid, avem solutie pentru orice distanta <= mid,
// deci putem muta capatul din stanga al intervalului la mid. De observat ca NU se muta la mid + 1
// ca in cautarea binara normala, deoarece vrem sa patram mid in solutie, el putand fi chiar
// valoarea cautata de noi.
if (canExit(mid, entrance, exit, m, dragonDistance)) {
left = mid;
} else {
// Daca nu avem solutie pentru distanta mid, e clar ca nu vom avea solutie pentru nicio
// distanta mai mare decat ea din monotonia functiei, deci mutam capatul din dreapta la mid - 1.
right = mid - 1;
}
}
// Cand se ajunge aici inseamna ca left = right, deci putem afisa left.
cout << left << endl;
return 0;
}