Problem p00207 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
bool N[102][102];
int map[102][102], R, ga, gb, w, h, f = 0;
void block(int, int);
int main() {
  int i, n, c, d, X = 0, Y = 0, x, y;
  cin >> w >> h;
  while (w != 0 || h != 0) {
    memset(map, 0, sizeof(map));
    memset(N, false, sizeof(N));
    cin >> X >> Y;
    cin >> ga >> gb;
    cin >> n;
    for (i = 0; i < n; i++) {
      cin >> c >> d >> x >> y;
      if (d) {
        map[y][x] = c;
        map[y + 1][x] = c;
        map[y + 2][x] = c;
        map[y + 3][x] = c;
        map[y][x + 1] = c;
        map[y + 1][x + 1] = c;
        map[y + 2][x + 1] = c;
        map[y + 3][x + 1] = c;

      } else {
        map[y][x] = c;
        map[y + 1][x + 1] = c;
        map[y + 1][x + 2] = c;
        map[y + 1][x + 3] = c;
        map[y + 1][x] = c;
        map[y][x + 1] = c;
        map[y][x + 2] = c;
        map[y][x + 3] = c;
      }
    }
    R = map[Y][X];
    if (R == map[gb][ga] && R != 0) {
      block(Y, X);
      if (f == 1)
        cout << "OK" << endl;
      else
        cout << "NG" << endl;
    } else
      cout << "NG" << endl;
    // for(i=0;i<h;i++){
    // for(j=0;j<w;j++){
    //	cout<<map[i][j];
    // }

    //		cout<<endl;
    //}
    f = 0;
    cin >> w >> h;
  }
  return 0;
}
void block(int b, int a) {
  // if(f==1) return 1;
  N[b][a] = true;
  if (ga == a && gb == b)
    f = 1;
  if (map[b][a + 1] == R && N[b][a + 1] == false)
    block(b, a + 1); //???
  if (map[b + 1][a] == R && N[b + 1][a] == false)
    block(b + 1, a); //???
  if (map[b][a - 1] == R && N[b][a - 1] == false)
    block(b, a - 1); //???
  if (map[b - 1][a] == R && N[b - 1][a] == false)
    block(b - 1, a); //???
}

Error: TLE

Fixed submission:

// #include <iostream>
// #include <algorithm>
// using namespace std;
//
// int N;  // ??????????????° (1 <= N <= 100)
// int W;  // ??????????????????????????? (1 <= W <= 10000)
//
// struct Item {
//     int v;  // ??????????????? (1 <= v <= 1000)
//     int w;  // ??????????????? (1 <= w <= 1000)
// };
// Item items[101];    // ??????????????±
//
// int C[101][10001];  //
// ??????????????????????¨???????????????????????¬??????????
///*
//    C[i][w] :
//    ???????????????????????\\?????????or??\\???????????????i????????????????????§????????????
//    ??????????????????????¨????w????????£???????????????????????§??????????´??????????
//*/
//
// int maxv = 0;  // ?????????????¨?????????§???
//
//// ??????????????????????????°????????¢??°
// void debug_print(int i, int w)
//{
//     char key_wait;
//
//     cout << "  C[i][w] = max(C[i-1][w], C[i-1][w - items[i].w] +
//     items[i].v);" << endl; cout << "->C[" << i << "][" << w << "] = max(C["
//     << i - 1 << "][" << w << "], C[" << i - 1 << "][" << w << " - " <<
//     items[i].w << "] + " << items[i].v << ")" << endl;
//
//     for (int iii = 0; iii <= N; ++iii) {
//         for (int www = 0; www <= W; ++www) {
//             if (C[iii][www] == -1) {
//                 cout << " x";
//             }
//             else {
//                 cout << " " << C[iii][www];
//             }
//         }
//         cout << endl;
//     }
//
//     cin >> key_wait;
// }
//
//
// int main()
//{
//     int i, w;
//
//     cin >> N >> W;
//
//     // ?????? = 0, ?????? = 0 ???????????????????????\\???????????????
//     //
//     ?????????????????¨??§?????????????????????????°??????????????????????????????????
//     items[0].v = 0;
//     items[0].w = 0;
//     for (i = 1; i <= N; ++i) {
//         cin >> items[i].v >> items[i].w;
//     }
//
//     /*
//     ???????????°????????¨????????????-1??§?????????
//     ??????????§£??????????????£??????
//     ????????????????????????????????????????????????
//     */
//     for (i = 0; i <= N; ++i) {
//         for (w = 0; w <= W; ++w) {
//             C[i][w] = -1;
//         }
//     }
//
//     // ??¢????????????????????\\??£???????????´????????????0
//     for (w = 0; w <= W; ++w) {
//         C[0][w] = 0;
//     }
//
//     for (i = 1; i <= N; ++i) {
//         for (w = 0; w <= W; ++w) {
//             //
//             ?????????????????????i??????????????????????????\\???????????´???
//             if (w - items[i].w < 0) {
//                 C[i][w] = C[i - 1][w];
//             }
//             //
//             ?????????????????????i????????????????????\\??????????£????????????´??????
//             // i????????????????????\\???????????£??????????????????
//             //
//             i????????????????????\\???????????????w????????£??????????????????????????????
//             // ????????§????????????????´??????????
//             else {
//                 C[i][w] = max(C[i - 1][w], C[i - 1][w - items[i].w] +
//                 items[i].v);
//             }
//             maxv = max(maxv, C[i][w]);
//
//             // ???????????°????????¨??¢??°
//             //
//             ???????????????????????¢??????????????°AOJ??§Accepted??????????????????
//             debug_print(i, w);
//         }
//     }
//
//     cout << maxv << endl;
//
//     return 0;
// }
/*
#include <iostream>
#include <string>
using namespace std;

#define REP( i, a )     for( int i = 0; i < a; i++ )
#define RREP( i, a )    for( int i = a; i >= 0; i-- )
#define FOR( i, a, b )  for( int i = a; i < b; i++ )
#define RFOR( i, a, b ) for( int i = b; i >= a; i-- )
#define ALL( A ) (A).begin, (A).end()

template <typename T>
void debug( const T& outData ) {
        cout << outData << endl;
}

template <typename T>
void debugAr( const T& outData[], const int& loopNum ) {

        for( int i = 0; i < loopNum; i++ ) cout << outData[i] << endl;

}

int main()
{

        int a;
        string str;

        cin >> a >> str;

        debug( a );
        debug( str );

        return 0;

}
*/

/*#ifndef DEBUG_H
#define DEBUG_H

#include <iostream>

#define REP( i, a )  for( int i = 0; i < a; i++ )
#define RREP( i, a ) for( int i = a; i >= 0; i-- )
#define FOR( i, a, b )  for( int i = a; i < b; i++ )
#define RFOR( i, a, b ) for( int i = b; i >= a; i-- )
#define ALL( A ) (A).begin(), (A).end()

template <typename T>
void prt( T outData )
{

std::cout << outData << endl;

}



#endif


??£????????????
*/

/*
#include<algorithm>
#include <iostream>
using namespace std;

static const int N=100;

int main(){
int i,n,j,p[N+1],m[N+1][N+1],k;
cin>>n;
for(i=1;i<=n;i++){
cin>>p[i-1]>>p[i];
}
for(i=1;i<=n;i++) m[i][i]=0;
for(i=2;i<=n;i++){
for(i=1;i<=n;i++){
int j=i+i-1;
m[i][j]=(i<<21);
for(k=10;k<=j-1;j++){
}
}
}
m[i][j]=min(m[i][j]=

*/
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
bool N[101][101];
int map[101][101], R, ga, gb, f = 0;
int block(int, int);
int main() {
  int i, j, a, n, L, b, c, d, X = 0, Y = 0, w, h, x, y;
  cin >> w >> h;
  while (w != 0 || h != 0) {
    memset(map, 0, sizeof(map));
    memset(N, 0, sizeof(N));
    cin >> a >> b;
    cin >> ga >> gb;
    cin >> n;
    for (i = 0; i < n; i++) {
      cin >> c >> d >> x >> y;
      if (d) {
        map[x][y] = c;
        map[x][y + 1] = c;
        map[x][y + 2] = c;
        map[x][y + 3] = c;
        map[x + 1][y] = c;
        map[x + 1][y + 1] = c;
        map[x + 1][y + 2] = c;
        map[x + 1][y + 3] = c;

      } else {
        map[x][y] = c;
        map[x + 1][y] = c;
        map[x + 2][y] = c;
        map[x + 3][y] = c;
        map[x + 1][y + 1] = c;
        map[x + 2][y + 1] = c;
        map[x + 3][y + 1] = c;
      }
    }
    R = map[a][b];
    if (block(a, b))
      cout << "OK" << endl;
    else
      cout << "NG" << endl;
    f = 0;
  }
  return 0;
}
int block(int a, int b) {
  // if(f==1) return 1;
  N[a][b] = 1;
  if (ga == a && gb == b)
    f = 1;
  return 1;
  if (map[a + 1][b] == R && N[a + 1][b] == 0)
    return block(a + 1, b);
  if (map[a][b + 1] == R && N[a][b + 1] == 0)
    return block(a, b + 1);
  if (map[a - 1][b] == R && N[a - 1][b] == 0)
    return block(a - 1, b);
  if (map[a][b - 1] == R && N[a][b - 1] == 0)
    return block(a, b - 1);
  return 0;
}