Найти прямоугольную область белого цвета состоящую из наибольшего количества ячеек

#include <bits/stdc++.h>
using namespace std;
#define MAX 1000010
long long h[MAX];
int i, n, left, right;
long long area, res;
int main() {
    scanf("%d", &n);
    for (i = 1; i <= n; i++) cin >> h[i];
    res = 0;
    for (i = 1; i <= n; i++) {
        long long left = i, right = i;
        while (left > 1 && h[left - 1] >= h[i]) left--;
        while (right < n && h[right + 1] >= h[i]) right++;
        area = (right - left + 1) * h[i];
        if (area > res) res = area;
    }
    printf("%lld\n", res);
    return 0;
}

char counter[10]{};
   if(event)++counter[5];
if(event1)++counter[7];

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int maximalRectangle(vector<vector<char>>& matrix) {
    if (matrix.empty() || matrix[0].empty()) {
        return 0;
    }
 
    int m = matrix.size();
    int n = matrix[0].size();
    vector<int> left(n, 0);
    vector<int> right(n, n);
    vector<int> height(n, 0);
    int maxArea = 0;
 
    for (const auto& row : matrix) {
        int curLeft = 0, curRight = n;
 
        // Update height array
        for (int j = 0; j < n; j++) {
            if (row[j] == '1') {
                height[j]++;
            } else {
                height[j] = 0;
            }
        }
 
        // Update left boundary array
        for (int j = 0; j < n; j++) {
            if (row[j] == '1') {
                left[j] = max(left[j], curLeft);
            } else {
                left[j] = 0;
                curLeft = j + 1;
            }
        }
 
        // Update right boundary array
        for (int j = n - 1; j >= 0; j--) {
            if (row[j] == '1') {
                right[j] = min(right[j], curRight);
            } else {
                right[j] = n;
                curRight = j;
            }
        }
 
        // Calculate maximum area for each cell
        for (int j = 0; j < n; j++) {
            maxArea = max(maxArea, (right[j] - left[j]) * height[j]);
        }
    }
 
    return maxArea;
}
 
int main() {
    vector<vector<char>> matrix1 = {
        {'0', '1', '1', '0'},
        {'1', '1', '1', '1'},
        {'1', '1', '1', '1'},
        {'1', '1', '0', '0'}
    };
 
    cout << maximalRectangle(matrix1) << endl;
 
    return 0;
}

// '1',
// '0',
int main() {
    vector<vector<char>> matrix1 = {
        {'1','0','0','0','1','0'},
        {'0','0','0','0','1','0'},
        {'0','0','1','0','0','0'},
        {'0','0','0','0','0','0'},
        {'0','0','1','0','0','0'}
    };
 
cout << maximalRectangle(matrix1) << endl;
    getchar();
    return 0;
}

#include <iostream>
#include <cstdint>
#include <stack>
 
int main()
{
    size_t n, m, k;
    std::cin >> n >> m;
 
    uint64_t* h{ new uint64_t[m]{} }, s{};
    std::stack<std::pair<size_t, uint64_t>> st;
    auto maxS = [&](std::pair<size_t, uint64_t> h_) {
        while (!st.empty() && h_.second <= st.top().second) {
            k = st.top().first;
            s = std::max(s, (h_.first - k) * st.top().second);
            st.pop();
        }
        };
 
    for (size_t i{}; i != n; ++i) {
        for (size_t j{}, v; j != m; ++j) {
            std::cin >> v;
            h[j] = v ? 0 : h[j] + 1;
            k = j;
            maxS({ j, h[j] });
            if (h[j]) { st.push({ k, h[j] }); }
        }
        maxS({ m, 0 });
    }
    delete[] h;
 
    std::cout << "\n" << s;
 
}

#include <compare>
#include <vector>
#include <set>
#include <algorithm>
#include <iostream>
 
struct Rect
{
  unsigned h, w;
 
  unsigned area() const
    { return h * w; }
 
  friend auto operator <=>(const Rect&, const Rect&) = default;
};
 
struct Corner
{
  unsigned limit_w, limit_h;
  std::set<Rect> rects;
};
 
using Mtr = std::vector<std::vector<unsigned char>>;
 
int main()
{
  unsigned n = 0, m = 0;
  std::cin >> n >> m;
 
  Mtr mtr(n + 1);
  for (auto& row : mtr)
    row.resize(m + 1);
 
  for (unsigned i = 1; i <= n; ++i)
  {
    for (unsigned j = 1; j <= m; ++j)
    {
      std::cin >> mtr[i][j];
      mtr[i][j] = mtr[i][j] == '0';
      std::cout << 1 - (unsigned) mtr[i][j] << ' ';
    }
    std::cout << std::endl;
  }
  std::cout << std::endl;
 
  Rect r_max = { 0, 0 };
  unsigned i_max = 0, j_max = 0;
 
  std::vector<Corner> rows[2];
  rows[0].resize(m + 1);
  rows[1].resize(m + 1);
 
  for (unsigned i = 1; i <= n; ++i)
    for (unsigned j = 1; j <= m; ++j)
    {
      rows[0][j] = std::move(rows[1][j]);
      rows[1][j] = {};
 
      if (!mtr[i][j])
        continue;
 
      rows[1][j].limit_h = rows[0][j].limit_h + 1;
      rows[1][j].limit_w = rows[1][j - 1].limit_w + 1;
 
      for (const Rect& r_l : rows[1][j - 1].rects)
        rows[1][j].rects.insert({ std::min(r_l.h, rows[1][j].limit_h), r_l.w + 1 });
 
      for (const Rect& r_u : rows[0][j].rects)
        rows[1][j].rects.insert({ r_u.h + 1, std::min(r_u.w, rows[1][j].limit_w) });
 
      if (rows[1][j].rects.empty())
        rows[1][j].rects.insert({ 1, 1 });
 
      for (const Rect& r : rows[1][j].rects)
        if (r.area() > r_max.area())
        {
          r_max = r;
          i_max = i;
          j_max = j;
        }
    }
 
  if (r_max.area() > 0)
  {
    for (unsigned i = 1; i <= n; ++i)
    {
      for (unsigned j = 1; j <= m; ++j)
        if (i > i_max - r_max.h && i <= i_max &&
            j > j_max - r_max.w && j <= j_max)
          std::cout << "* ";
        else
          std::cout << 1 - (unsigned) mtr[i][j] << ' ';
      std::cout << std::endl;
    }
    std::cout << std::endl;
  }
 
  std::cout << r_max.area() << std::endl;
}