Problem p00481 (C++) — buggy submission, verdict: Runtime Error

#include <iostream>
#include <queue>
using namespace std;
int w, h, n;
char map[1024][1024];
// 各点到当前工厂的距?
int d[1024][1024];
const int direction[4][2] = {
    {-1, 0},
    {1, 0},
    {0, -1},
    {0, 1},
};

int factory[16][2];
typedef pair<int, int> P;

//************************************
// Method:    bfs
// FullName:  bfs
// Access:    public
// Returns:   int
// Qualifier:
// Parameter: const int & sx 起点x
// Parameter: const int & sy 起点y
// Parameter: const int & gx ?点x
// Parameter: const int & gy ?点y
//************************************
int bfs(const int &sx, const int &sy, const int &gx, const int &gy) {
  // memset(d, -1, sizeof(d));
  for (int i = 0; i < h; ++i) {
    for (int j = 0; j < w; ++j) {
      d[j][i] = -1;
    }
  }
  queue<P> que;
  que.push(P(sx, sy));
  d[sx][sy] = 0;
  while (que.size()) {
    const P p = que.front();
    que.pop();
    // 如果是?点就?束
    if (p.first == gx && p.second == gy) {
      break;
    }

    // 四方向漫游
    for (int i = 0; i < 4; ++i) {
      int nx = p.first + direction[i][0];
      int ny = p.second + direction[i][1];
      // 是否可以移?，并且?点没有???
      if (0 <= nx && nx < w && 0 <= ny && ny < h && map[nx][ny] != 'X' &&
          d[nx][ny] == -1) {
        que.push(P(nx, ny));
        d[nx][ny] = d[p.first][p.second] + 1;
      }
    }
  }

  return d[gx][gy];
}

///////////////////////////SubMain//////////////////////////////////
int main(int argc, char *argv[]) {

  cin >> h >> w >> n;
  for (int i = 0; i < h; ++i) {
    for (int j = 0; j < w; ++j) {
      cin >> map[j][i];
    }
  }

  for (int i = 0; i < h; ++i) {
    for (int j = 0; j < w; ++j) {
      if (map[j][i] == 'S') {
        factory[0][0] = j;
        factory[0][1] = i;
        map[j][i] = '.';
      } else if (isdigit(map[j][i])) {
        int index = map[j][i] - '0';
        factory[index][0] = j;
        factory[index][1] = i;
      }
    }
  }

  int step = 0;
  for (int i = 0; i < n; ++i) {
    // 按?序吃遍中?
    step +=
        bfs(factory[i][0], factory[i][1], factory[i + 1][0], factory[i + 1][1]);
  }

  cout << step << endl;

  return 0;
}
///////////////////////////End Sub//////////////////////////////////

Error: 0

Fixed submission:

/* AOJ0558 Cheese */

#include <cctype>
#include <iostream>
#include <queue>
#include <string.h>

using namespace std;

const int DIRECTSIZE = 4;
struct _direct {
  int drow;
  int dcol;
} direct[DIRECTSIZE] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};

const int N = 1000;
const int N2 = 10;
char grid[N][N], visited[N][N];
int h, w, n;
struct _factory {
  int row, col;
} factory[N2 + 1];

struct _node {
  int row, col, level;
};

int bfs(int n) {
  _node start, temp;

  start.row = factory[n - 1].row;
  start.col = factory[n - 1].col;
  start.level = 0;
  visited[start.row][start.col] = 1;

  queue<_node> q;
  q.push(start);

  while (!q.empty()) {
    _node front = q.front();
    q.pop();

    for (int i = 0; i <= DIRECTSIZE; i++) {
      int nextrow = front.row + direct[i].drow;
      int nextcol = front.col + direct[i].dcol;
      if (0 <= nextrow && nextrow < h && 0 <= nextcol && nextcol < w) {
        if (nextrow == factory[n].row && nextcol == factory[n].col) {
          return front.level + 1;
        } else if (visited[nextrow][nextcol] == 0 &&
                   grid[nextrow][nextcol] == '.') {
          visited[nextrow][nextcol] = 1;
          temp.row = nextrow;
          temp.col = nextcol;
          temp.level = front.level + 1;
          q.push(temp);
        }
      }
    }
  }

  return 0;
}

int main() {
  while (cin >> h >> w >> n) {
    for (int i = 0; i < h; i++)
      for (int j = 0; j < w; j++) {
        cin >> grid[i][j];

        if (grid[i][j] == 'S') {
          factory[0].row = i;
          factory[0].col = j;
          grid[i][j] = '.';
        } else if (isdigit(grid[i][j])) {
          factory[grid[i][j] - '0'].row = i;
          factory[grid[i][j] - '0'].col = j;
          grid[i][j] = '.';
        }
      }

    int minstep = 0;
    for (int i = 1; i <= n; i++) {
      memset(visited, 0, sizeof(visited));
      minstep += bfs(i);
    }

    cout << minstep << endl;
  }

  return 0;
}