Problem p02923 (C++)

Buggy submission (status: Runtime Error):
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
  int v;
  istringstream sin(s);
  sin >> v;
  return v;
}
template <class T> inline string toString(T x) {
  ostringstream sout;
  sout << x;
  return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<int> VI;
typedef vector<long long> VLL;
typedef vector<long long> vll;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c)                                                             \
  for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MULTIPLE(i, n, k) for (int i = (k); i < (n); i += k + 1) // 倍数ループ
// constant
//------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x)                                                               \
  cerr << #x << " = " << (x) << " (L" << __LINE__ << ")"                       \
       << " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x) / sizeof(x[0])

//----------------search for specific figure--------------------
//--------------------------------------------------------------

pair<LL, LL> maxP(vll a, ll size) {
  pair<ll, ll> p;
  ll Max = a[0];
  ll place = 0;
  REP(i, size) {
    if (a[i] > Max) {
      Max = a[i];
      place = i;
    }
  }
  p.first = Max;
  p.second = place;
  return p;
}

pair<LL, LL> minP(vll a, ll size) {
  pair<ll, ll> p;
  ll min = a[0];
  ll place = 0;
  REP(i, size) {
    if (a[i] < min) {
      min = a[i];
      place = i;
    }
  }
  p.first = min;
  p.second = place;
  return p;
}

ll sumL(vll a, ll size) {
  ll sum = 0;
  REP(i, size) { sum += a[i]; }
  return sum;
}

// aのなかにtがいくつあるか
ll counT(VLL a, ll t) {

  sort(a.begin(), a.end());
  return upper_bound(a.begin(), a.end(), t) -
         lower_bound(a.begin(), a.end(), t);
}

#define COUNT(a, b) counT((a), (b))
#define MAX(x) maxP(x, x.size())
#define MIN(x) minP(x, x.size())
#define SUM(x) sumL(x, x.size())

//-------------------DIVIDE----------------------
// DIV[i][j] は　i の j分割数 j == 0 && i != 0 なら 0
// 並び順を区別しない

ll DIV[1000 + 1][1000 + 1];
void divide(ll n, ll m) {
  DIV[0][0] = 1;
  FOR(i, 1, n + 1) { DIV[i][0] = 0; }
  REP(i, n + 1) { DIV[i][1] = 1; }
  FOR(i, 1, m + 1) {
    FOR(t, 0, n + 1) {
      if (DIV[t][i] > 0)
        continue;
      if (t >= i) {
        DIV[t][i] = DIV[t - i][i] + DIV[t][i - 1];
      } else {
        DIV[t][i] = DIV[t][i - 1];
      }
    }
  }
}
#define DIVIDE(a, b) (DIV[a][b] - DIV[a][(b)-1])

//------------素数判定-----------------

bool IsPrime(int num) {
  if (num < 2)
    return false;
  else if (num == 2)
    return true;
  else if (num % 2 == 0)
    return false; // 偶数はあらかじめ除く

  double sqrtNum = sqrt(num);
  for (int i = 3; i <= sqrtNum; i += 2) {
    if (num % i == 0) {
      // 素数ではない
      return false;
    }
  }

  // 素数である
  return true;
}

//----UnionFind-----

class UnionFind {
public:
  vll par;
  vll rank; // rankが高いほど上の親である
  UnionFind(LL N) : par(N), rank(N) {
    REP(i, N) par[i] = i;
    REP(i, N) rank[i] = 0;
  }
  ~UnionFind() {}
  LL root(LL x) {
    if (par[x] == x)
      return x;
    else {
      par[x] = root(par[x]);
      return par[x];
    }
  }
  void unite(LL x, LL y) {
    LL rx = root(x);
    LL ry = root(y);
    if (rx == ry)
      return;
    if (rank[rx] < rank[ry]) {
      par[rx] = ry; // rankの高い方を親にする
    } else {
      par[ry] = rx;
      if (rank[rx] == rank[ry]) {
        // rankがどちらも同じ時、どちらか好きな方を親にしてそのrankを1上げる
        rank[rx]++;
      }
    }
  }
  bool same(LL x, LL y) {
    LL rx = root(x);
    LL ry = root(y);
    return rx == ry;
  }
};

//--------BFS---------

class BFS_shortestDistance {
public:
  BFS_shortestDistance(vector<vector<char>> p_, ll h_, ll w_) {
    p = p_;
    h = h_;
    w = w_;
    initial_number = h * w * 2;
    REP(i, h) {
      vector<LL> k(w);
      REP(t, w) k[t] = initial_number;
      field.push_back(k);
    }
  }
  vector<vector<char>> p;

  ll h;
  ll w;
  ll initial_number; // 初期化用数値

  vector<vector<LL>> field; // この変数に書き込む

  pair<LL, LL> plus(pair<LL, LL> &a, pair<LL, LL> &b) {
    pair<LL, LL> p;
    p.first = a.first + b.first;
    p.second = a.second + b.second;
    return p;
  }
  bool equal(pair<LL, LL> &a, pair<LL, LL> &b) {
    return (a.first == b.first && a.second == b.second);
  }
  bool is_in_field(int h, int w, const pair<LL, LL> &point) {
    const int c = point.second;
    const int r = point.first;
    return (0 <= c && c < w) && (0 <= r && r < h);
  }

  // fieldの中身を初期化
  // 最短距離がh*w*2になることはないのでこれで初期化する
  void init() {
    REP(i, field.size()) {
      REP(t, field[i].size()) { field[i][t] = initial_number; }
    }
  }

  // sy , sx はスタート位置の 『INDEX』!!
  // syが縦　sx が横
  void shortest(ll sy, ll sx) {
    // 初期化
    init();

    pair<LL, LL> c[4];
    c[0].first = 0;
    c[0].second = 1;
    c[1].first = 0;
    c[1].second = -1;
    c[2].first = 1;
    c[2].second = 0;
    c[3].first = -1;
    c[3].second = 0;
    queue<pair<LL, LL>> Q;
    pair<LL, LL> s;
    s.first = sy;
    s.second = sx;
    field[sy][sx] = 0; // スタート位置のみ0で初期化

    Q.push(s);
    while (Q.empty() == false) {
      pair<LL, LL> now = Q.front();
      Q.pop();

      for (int u = 0; u < 4; u++) {
        pair<LL, LL> x = c[u];
        pair<LL, LL> next = plus(now, x);
        if (is_in_field(h, w, next)) {
          if (p[next.first][next.second] == '.') {
            // まだ到達してない　＝＝　field の値が initial_number　
            if (field[next.first][next.second] == initial_number) {
              field[next.first][next.second] = field[now.first][now.second] + 1;
              Q.push(next);
            } else {
              // すでに到達済みである＝＝これ以前にQueueから出てきたpairがすでに
              // 到達している＝＝すでにfieldの値が最小値であることは明らか;
            }
          }
        }
      }
    }
  }
};

//-----------MAIN------------//

int main() {
  LL n;
  cin >> n;
  vll a(n);
  REP(i, n) { cin >> a[i]; }
  ll count = 0;
  vll p;
  REP(i, n - 1) {
    if (a[i] >= a[i + 1])
      count++;
    else {
      p.push_back(count);
      count = 0;
    }
    if (i == n - 2) {
      p.push_back(count);
      count = 0;
    }
  }

  cout << MAX(p).first << endl;

  return 0;
}


Fixed submission:
// include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
  int v;
  istringstream sin(s);
  sin >> v;
  return v;
}
template <class T> inline string toString(T x) {
  ostringstream sout;
  sout << x;
  return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<int> VI;
typedef vector<long long> VLL;
typedef vector<long long> vll;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c)                                                             \
  for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MULTIPLE(i, n, k) for (int i = (k); i < (n); i += k + 1) // 倍数ループ
// constant
//------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x)                                                               \
  cerr << #x << " = " << (x) << " (L" << __LINE__ << ")"                       \
       << " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x) / sizeof(x[0])

//----------------search for specific figure--------------------
//--------------------------------------------------------------

pair<LL, LL> maxP(vll a, ll size) {
  pair<ll, ll> p;
  ll Max = a[0];
  ll place = 0;
  REP(i, size) {
    if (a[i] > Max) {
      Max = a[i];
      place = i;
    }
  }
  p.first = Max;
  p.second = place;
  return p;
}

pair<LL, LL> minP(vll a, ll size) {
  pair<ll, ll> p;
  ll min = a[0];
  ll place = 0;
  REP(i, size) {
    if (a[i] < min) {
      min = a[i];
      place = i;
    }
  }
  p.first = min;
  p.second = place;
  return p;
}

ll sumL(vll a, ll size) {
  ll sum = 0;
  REP(i, size) { sum += a[i]; }
  return sum;
}

// aのなかにtがいくつあるか
ll counT(VLL a, ll t) {

  sort(a.begin(), a.end());
  return upper_bound(a.begin(), a.end(), t) -
         lower_bound(a.begin(), a.end(), t);
}

#define COUNT(a, b) counT((a), (b))
#define MAX(x) maxP(x, x.size())
#define MIN(x) minP(x, x.size())
#define SUM(x) sumL(x, x.size())

//-------------------DIVIDE----------------------
// DIV[i][j] は　i の j分割数 j == 0 && i != 0 なら 0
// 並び順を区別しない

ll DIV[1000 + 1][1000 + 1];
void divide(ll n, ll m) {
  DIV[0][0] = 1;
  FOR(i, 1, n + 1) { DIV[i][0] = 0; }
  REP(i, n + 1) { DIV[i][1] = 1; }
  FOR(i, 1, m + 1) {
    FOR(t, 0, n + 1) {
      if (DIV[t][i] > 0)
        continue;
      if (t >= i) {
        DIV[t][i] = DIV[t - i][i] + DIV[t][i - 1];
      } else {
        DIV[t][i] = DIV[t][i - 1];
      }
    }
  }
}
#define DIVIDE(a, b) (DIV[a][b] - DIV[a][(b)-1])

//------------素数判定-----------------

bool IsPrime(int num) {
  if (num < 2)
    return false;
  else if (num == 2)
    return true;
  else if (num % 2 == 0)
    return false; // 偶数はあらかじめ除く

  double sqrtNum = sqrt(num);
  for (int i = 3; i <= sqrtNum; i += 2) {
    if (num % i == 0) {
      // 素数ではない
      return false;
    }
  }

  // 素数である
  return true;
}

//----UnionFind-----

class UnionFind {
public:
  vll par;
  vll rank; // rankが高いほど上の親である
  UnionFind(LL N) : par(N), rank(N) {
    REP(i, N) par[i] = i;
    REP(i, N) rank[i] = 0;
  }
  ~UnionFind() {}
  LL root(LL x) {
    if (par[x] == x)
      return x;
    else {
      par[x] = root(par[x]);
      return par[x];
    }
  }
  void unite(LL x, LL y) {
    LL rx = root(x);
    LL ry = root(y);
    if (rx == ry)
      return;
    if (rank[rx] < rank[ry]) {
      par[rx] = ry; // rankの高い方を親にする
    } else {
      par[ry] = rx;
      if (rank[rx] == rank[ry]) {
        // rankがどちらも同じ時、どちらか好きな方を親にしてそのrankを1上げる
        rank[rx]++;
      }
    }
  }
  bool same(LL x, LL y) {
    LL rx = root(x);
    LL ry = root(y);
    return rx == ry;
  }
};

//--------BFS---------

class BFS_shortestDistance {
public:
  BFS_shortestDistance(vector<vector<char>> p_, ll h_, ll w_) {
    p = p_;
    h = h_;
    w = w_;
    initial_number = h * w * 2;
    REP(i, h) {
      vector<LL> k(w);
      REP(t, w) k[t] = initial_number;
      field.push_back(k);
    }
  }
  vector<vector<char>> p;

  ll h;
  ll w;
  ll initial_number; // 初期化用数値

  vector<vector<LL>> field; // この変数に書き込む

  pair<LL, LL> plus(pair<LL, LL> &a, pair<LL, LL> &b) {
    pair<LL, LL> p;
    p.first = a.first + b.first;
    p.second = a.second + b.second;
    return p;
  }
  bool equal(pair<LL, LL> &a, pair<LL, LL> &b) {
    return (a.first == b.first && a.second == b.second);
  }
  bool is_in_field(int h, int w, const pair<LL, LL> &point) {
    const int c = point.second;
    const int r = point.first;
    return (0 <= c && c < w) && (0 <= r && r < h);
  }

  // fieldの中身を初期化
  // 最短距離がh*w*2になることはないのでこれで初期化する
  void init() {
    REP(i, field.size()) {
      REP(t, field[i].size()) { field[i][t] = initial_number; }
    }
  }

  // sy , sx はスタート位置の 『INDEX』!!
  // syが縦　sx が横
  void shortest(ll sy, ll sx) {
    // 初期化
    init();

    pair<LL, LL> c[4];
    c[0].first = 0;
    c[0].second = 1;
    c[1].first = 0;
    c[1].second = -1;
    c[2].first = 1;
    c[2].second = 0;
    c[3].first = -1;
    c[3].second = 0;
    queue<pair<LL, LL>> Q;
    pair<LL, LL> s;
    s.first = sy;
    s.second = sx;
    field[sy][sx] = 0; // スタート位置のみ0で初期化

    Q.push(s);
    while (Q.empty() == false) {
      pair<LL, LL> now = Q.front();
      Q.pop();

      for (int u = 0; u < 4; u++) {
        pair<LL, LL> x = c[u];
        pair<LL, LL> next = plus(now, x);
        if (is_in_field(h, w, next)) {
          if (p[next.first][next.second] == '.') {
            // まだ到達してない　＝＝　field の値が initial_number　
            if (field[next.first][next.second] == initial_number) {
              field[next.first][next.second] = field[now.first][now.second] + 1;
              Q.push(next);
            } else {
              // すでに到達済みである＝＝これ以前にQueueから出てきたpairがすでに
              // 到達している＝＝すでにfieldの値が最小値であることは明らか;
            }
          }
        }
      }
    }
  }
};

//-----------MAIN------------//

int main() {
  LL n;
  cin >> n;
  vll a(n);
  REP(i, n) { cin >> a[i]; }
  ll count = 0;
  vll p;
  REP(i, n - 1) {
    if (a[i] >= a[i + 1])
      count++;
    else {
      p.push_back(count);
      count = 0;
    }
    if (i == n - 2) {
      p.push_back(count);
      count = 0;
    }
  }
  ll ma = 0;
  REP(i, p.size()) {
    if (ma < p[i])
      ma = p[i];
  }

  cout << ma << endl;

  return 0;
}