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

#include <algorithm>
#include <cmath>
#include <queue>
#include <stack>
#include <stdio.h>
#include <vector>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD NUM000007
#define EPS 0.0000001
#define NUM 1440
using namespace std;

enum HOUSE {
  L,
  R,
};

enum Type {
  Normal,
  Ladder,
  Slide,
};

struct Info {
  HOUSE house;
  int loc, count;
};

Type types[3] = {Normal, Ladder, Slide};

int main() {

  Type L_House[101], R_House[101];

  Info first_L, first_R;
  queue<Info> Q;

  int N, ans, tmp, next_loc;
  bool FLG, check[2][100];

  while (true) {
    scanf("%d", &N);
    if (N == 0)
      break;

    ans = BIG_NUM;

    for (int i = 0; i < N; i++) {
      scanf("%d", &tmp);
      L_House[i] = types[tmp];
    }

    for (int i = 0; i < N; i++) {
      scanf("%d", &tmp);
      R_House[i] = types[tmp];
    }

    L_House[N] = Normal; // N-1????¢?????????£?????´???
    R_House[N] = Normal;

    for (int i = 0; i < 2; i++) {
      for (int k = 0; k < N; k++) {
        check[i][k] = false;
      }
    }

    first_L.house = L;
    first_R.house = R;

    first_L.loc = 0;
    first_R.loc = 0;

    first_L.count = 0;
    first_R.count = 0;

    check[L][0] = true;
    check[R][0] = true;

    //??????????????°??????????????§????????´????????????
    if (L_House[0] == Ladder) {

      for (int i = 1; i <= N - 1; i++) {
        if (L_House[i] == Ladder) {
          first_L.loc++;
          check[L][i] = true;
        } else {
          break;
        }
      }
    }

    if (R_House[0] == Ladder) {

      for (int i = 1; i <= N - 1; i++) {
        if (R_House[i] == Ladder) {
          first_R.loc++;
          check[R][i] = true;
        } else {
          break;
        }
      }
    }

    while (!Q.empty())
      Q.pop();

    Q.push(first_L);
    Q.push(first_R);

    while (!Q.empty()) {

      if (Q.front().loc >= N - 1) {
        ans = Q.front().count;
        break;
      }

      if (Q.front().house == L) {

        for (int i = 0; i <= 2; i++) {
          next_loc = Q.front().loc + i;

          if (check[R][next_loc] == false) {
            Info info;

            info.count = Q.front().count + 1;
            check[R][next_loc] = true;
            info.house = R;

            switch (R_House[next_loc]) {
            case Normal:
              info.loc = next_loc;
              Q.push(info);
              break;
            case Ladder:
              FLG = true;
              for (++next_loc;; next_loc++) {

                if (R_House[next_loc] != Ladder) {
                  next_loc--;
                  break;
                } else { // R_House[nextl_loc] == Ladder

                  if (check[R][next_loc] ==
                      true) { //?????????????????£????????¨???????????´???
                    FLG = false;
                    break;
                  }
                  check[R][next_loc] =
                      true; // Q???push???????????´?????§???????????????????????????????????¨???????????°?¨????????????¨???????????????
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            case Slide:
              FLG = true;
              for (--next_loc;; next_loc--) {
                if (check[R][next_loc] == true) {
                  FLG = false;
                  break;
                }

                check[R][next_loc] = true;

                if (R_House[next_loc] != Slide) {
                  break;
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            }
          }
        }

      } else {

        for (int i = 0; i <= 2; i++) {
          next_loc = Q.front().loc + i;

          if (check[L][next_loc] == false) {
            Info info;

            info.count = Q.front().count + 1;
            check[L][next_loc] = true;
            info.house = L;

            switch (L_House[next_loc]) {
            case Normal: //????????????
              info.loc = next_loc;
              Q.push(info);
              break;
            case Ladder:
              FLG = true;
              for (++next_loc;; next_loc++) {

                if (L_House[next_loc] != Ladder) {
                  next_loc--;
                  break;
                } else { // L_House[nextl_loc] == Ladder

                  if (check[L][next_loc] ==
                      true) { //?????????????????£????????¨???????????´???
                    FLG = false;
                    break;
                  }
                  check[L][next_loc] =
                      true; // Q???push???????????´?????§???????????????????????????????????¨???????????°?¨????????????¨???????????????
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            case Slide:
              FLG = true;
              for (--next_loc;; next_loc--) {
                if (check[L][next_loc] == true) {
                  FLG = false;
                  break;
                }

                check[L][next_loc] = true;

                if (L_House[next_loc] != Slide) {
                  break;
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            }
          }
        }
      }
      Q.pop();
    }

    if (ans == BIG_NUM)
      printf("NA\\n");
    else {
      printf("%d\\n", ans);
    }
  }

  return 0;
}

Error: 0

Fixed submission:

#include <algorithm>
#include <cmath>
#include <queue>
#include <stack>
#include <stdio.h>
#include <vector>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD NUM000007
#define EPS 0.0000001
#define NUM 1440
using namespace std;

enum HOUSE {
  L,
  R,
};

enum Type {
  Normal,
  Ladder,
  Slide,
};

struct Info {
  HOUSE house;
  int loc, count;
  bool check[2][100];
};

Type types[3] = {Normal, Ladder, Slide};

int main() {

  Type L_House[100], R_House[100];
  Info first_L, first_R;
  queue<Info> Q;
  int N, ans, tmp, next_loc;
  bool FLG;

  while (true) {
    scanf("%d", &N);
    if (N == 0)
      break;

    ans = BIG_NUM;

    for (int i = 0; i < N; i++) {
      scanf("%d", &tmp);
      L_House[i] = types[tmp];
    }

    for (int i = 0; i < N; i++) {
      scanf("%d", &tmp);
      R_House[i] = types[tmp];
    }

    for (int i = 0; i < 2; i++) {
      for (int k = 0; k < N; k++) {
        first_L.check[i][k] = false;
        first_R.check[i][k] = false;
      }
    }

    first_L.house = L;
    first_R.house = R;

    first_L.loc = 0;
    first_R.loc = 0;

    first_L.count = 1;
    first_R.count = 1;

    first_L.check[L][0] = true;
    first_R.check[R][0] = true;

    while (!Q.empty())
      Q.pop();

    Q.push(first_L);
    Q.push(first_R);

    while (!Q.empty()) {

      if (Q.front().loc == N - 1) {
        ans = Q.front().count;
        break;
      }

      if (Q.front().house == L) {

        for (int i = 0; i <= 2; i++) {
          next_loc = Q.front().loc + i;

          if (Q.front().check[R][next_loc] == false) {
            Info info;

            for (int a = 0; a < 2; a++) {
              for (int b = 0; b < N; b++) {
                info.check[a][b] = Q.front().check[a][b];
              }
            }

            info.count = Q.front().count + 1;
            info.check[R][next_loc] = true;
            info.house = R;

            switch (R_House[next_loc]) {
            case Normal:
              info.loc = next_loc;
              Q.push(info);
              break;
            case Ladder:
              FLG = true;
              for (++next_loc;; next_loc++) {
                if (Q.front().check[R][next_loc] == true) {
                  FLG = false;
                  break;
                }

                info.check[R][next_loc] = true;

                if (R_House[next_loc] != Ladder) {
                  break;
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            case Slide:
              FLG = true;
              for (--next_loc;; next_loc--) {
                if (Q.front().check[R][next_loc] == true) {
                  FLG = false;
                  break;
                }

                info.check[R][next_loc] = true;

                if (R_House[next_loc] != Slide) {
                  break;
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            }
          }
        }

      } else {

        for (int i = 0; i <= 2; i++) {
          next_loc = Q.front().loc + i;

          if (Q.front().check[L][next_loc] == false) {
            Info info;

            for (int a = 0; a < 2; a++) {
              for (int b = 0; b < N; b++) {
                info.check[a][b] = Q.front().check[a][b];
              }
            }

            info.count = Q.front().count + 1;
            info.check[L][next_loc] = true;
            info.house = L;

            switch (L_House[next_loc]) {
            case Normal: //????????????
              info.loc = next_loc;
              Q.push(info);
              break;
            case Ladder:
              FLG = true;
              for (++next_loc;; next_loc++) {
                if (Q.front().check[L][next_loc] == true) {
                  FLG = false;
                  break;
                }

                info.check[L][next_loc] = true;

                if (L_House[next_loc] != Ladder) {
                  break;
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            case Slide:
              FLG = true;
              for (--next_loc;; next_loc--) {
                if (Q.front().check[L][next_loc] == true) {
                  FLG = false;
                  break;
                }

                info.check[L][next_loc] = true;

                if (L_House[next_loc] != Slide) {
                  break;
                }
              }

              if (FLG) {
                info.loc = next_loc;
                Q.push(info);
              }
              break;
            }
          }
        }
      }
      Q.pop();
    }

    if (ans == BIG_NUM)
      printf("NA\\n");
    else {
      printf("%d\\n", ans);
    }
  }

  return 0;
}