Problem:
薄氷渡り

問題

冬の寒いある日，JOI太郎君は広場にはった薄氷を割って遊ぶことにした．広場は長方形で，東西方向に m 個，南北方向に n 個，つまり， m × n の区画に区切られている．また，薄氷が有る区画と無い区画がある． JOI太郎君は，次のルールにしたがって，薄氷を割りながら区画を移動することにした．

薄氷があるどの区画からも薄氷を割り始めることができる．

東西南北のいずれかの方向に隣接し， まだ割られていない薄氷のある区画に移動できる．

移動した先の区画の薄氷をかならず割る．

JOI太郎君が薄氷を割りながら移動できる区画数の最大値を求めるプログラムを作成せよ．ただし， 1 ≤ m ≤ 90，1 ≤ n ≤ 90 である．与えられる入力データでは，移動方法は20万通りを超えない．

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

入力はn+2行ある． 1 行目には整数 m が書かれている． 2 行目には整数 n が書かれている． 3 行目から n+2 行目までの各行には、0 もしくは 1 が， 空白で区切られて m 個書かれており，各区画に薄氷があるか否かを表している．北から i 番目，西からj番目の区画を (i,j) と記述することにすると (1 ≤ i ≤ n, 1 ≤ j ≤ m)，第 i+2 行目の j 番目の値は，区画 (i,j) に薄氷が存在する場合は 1 となり，区画 (i,j) に薄氷が存在しない場合は 0 となる．

m, n がともに 0 のとき入力の終了を示す. データセットの数は 5 を超えない．

出力

データセットごとに, 移動できる区画数の最大値を１行に出力せよ．

入出力例

入力例

3
3
1 1 0
1 0 1
1 1 0
5
3
1 1 1 0 1
1 1 0 0 0
1 0 0 0 1
0
0

出力例

5
5

1つ目の入力例に対して，最大値を与える移動方法の例　　

2つ目の入力例に対して，最大値を与える移動方法の例

2つ目の入力例に対して，最大値を与えない移動方法の例

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in C++ (judge verdict: Wrong Answer)

/************************************
 * ??±???????????¢?´¢ *
 ************************************/

#include <iostream>
#include <vector>
#include <stack>
#include <map>

#define LAND '1'  //??? char???
#define SEA  '0'   //??? char???

using namespace std;

/* ?????????*/
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};


/*8??????
int dx[] = {1,1,0,-1,-1,-1, 0, 1};
int dy[] = {0,1,1, 1, 0,-1,-1,-1};
*/

bool input(vector< vector<char> > &m);
void delete_island(vector< vector< char > > &m, int x, int y);
void output(vector< vector< char> > m);
void output(vector< vector< int > > m);
int depth(vector< vector< char> > m, int y, int x);
int max_value(vector< vector<int> > &memo);

int main(){
  int w, h;
  int max = 0;
    
  while(cin >> w >> h, w && h){
    vector< vector< char > > m(h+2, vector<char>(w+2));
    input(m);
    //output(m);
    
    for(int y = 0; y < m.size(); y++){
      for(int x = 0; x < m[y].size(); x++){
	if(m[y][x] == LAND){
	  int d = depth(m, y, x);
	  max = d > max ? d: max;
	}
      }
    }
    cout << max << endl;
  }
}


bool input(vector< vector<char> > &m){
  for(int y = 0; y < m.size(); y++){
    for(int x = 0; x < m[y].size(); x++){
      if(y == 0 || x == 0 ||
	 y == m.size()-1 || x == m[y].size()-1){
	m[y][x] = SEA;
      }else{
	if(!(cin >> m[y][x])) return false;
      }
    }
  }
  return true;
}


void delete_island(vector< vector< char > > &m, int x, int y){
   stack< pair< int, int > > s;
   s.push(make_pair(x,y));

   while(!(s.empty())){
     pair<int, int> cur = s.top();
     s.pop();
     if(m[cur.second][cur.first] == LAND){
       for(int i = 0; i < sizeof(dx)/sizeof(int); i++){
	 s.push(make_pair(cur.first+dx[i],cur.second+dy[i]));
       }
     }
   }
}

void output(vector< vector< char> > m){
  for(int y = 0; y < m.size(); y++){
    for(int x = 0; x < m[y].size(); x++){
      cout << m[y][x] << " ";
    }
    cout << endl;
  }
  cout << endl;
}

void output(vector< vector< int > > m){
  for(int y = 0; y < m.size(); y++){
    for(int x = 0; x < m[y].size(); x++){
      cout << m[y][x] << " ";
    }
    cout << endl;
  }
  cout << endl;
}


int depth(vector< vector< char> > m, int y, int x){
  stack< pair<int, int> > s;
  vector< vector<int> > memo(m.size(), vector<int>(m[0].size(), 0));
  s.push(make_pair(x,y));
  memo[y][x] = 1;
  while(!s.empty()){
    pair<int, int> cur;
    cur = s.top(); s.pop();
    m[cur.second][cur.first] = SEA;
    for(int i = 0; i < sizeof(dx)/sizeof(int); i++){
      pair<int, int> next;
      next = make_pair(cur.first+dx[i], cur.second+dy[i]);
      if(m[next.second][next.first] == LAND &&
	  memo[next.second][next.first] == 0){
	memo[next.second][next.first] =
	  max(memo[cur.second][cur.first] + 1, memo[next.second][next.first]);
	s.push(next);
      }
      //  output(memo);
    }
  }

  // cout << "======================" << endl;
  return max_value(memo);
}

int max_value(vector< vector<int> > &memo){
  int max = 0;
  for(int y = 0; y < memo.size(); y++){
    for(int x = 0; x < memo[y].size(); x++){
      if(max < memo[y][x]){
	max = memo[y][x];
      }
    }
  }
  return max;
}