Submission #36661568

---

Source Code Expand

#include <vector>
#include <array>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
#include <complex>

// #include <atcoder/all>

using namespace std;

// using Mint = atcoder::modint998244353;


// #define __LOCAL_DEBUG__ 0

//e.g., auto int_V567 = VECTOR<int>(0, 5, 6, 7)
template<typename T> auto VECTOR(const T& val, int sz) { return vector<T>(sz, val); }
template<typename T, typename... D> auto VECTOR(const T& val, int sz, D... ds) { return vector< decltype(VECTOR(val, ds...)) > (sz, VECTOR(val, ds...)); }


template<typename K, typename V> ostream& operator << (ostream& os, const pair<K, V>& p) {
    os << "(" << p.first << ": " << p.second << ")";
    return os;
}
template<typename T> ostream& operator << (ostream& os, const vector<T>& A) {
    int sz = A.size();
    os << "[";
    for (int i = 0; i < sz; ++i) { os<< A[i] << (i == sz - 1 ? "" : ", "); }
    os << "]";
    return os;
}
template<typename T, typename CMP> ostream& operator << (ostream& os, const set<T, CMP>& S) {
    os << "{";
    int rem = S.size();
    for (auto& x : S) { os << x << (--rem == 0 ? "" : ", ");}
    os << "}";
    return os;
}
template<typename T, typename CMP> ostream& operator << (ostream& os, const multiset<T, CMP>& S) {
    os << "{";
    int rem = S.size();
    for (auto& x : S) { os << x << (--rem == 0 ? "" : ", "); }
    os << "}";
    return os;
}
template<typename K, typename V, typename CMP> ostream& operator << (ostream& os, const map<K, V, CMP>& M) {
    os << "{";
    int rem = M.size();
    for (auto& x : M) { os << x << (--rem == 0 ? "" : ", "); }
    os << "}";
    return os;
}
template<typename K, typename V, typename CMP> ostream& operator << (ostream& os, const multimap<K, V, CMP>& M) {
    os << "{";
    int rem = M.size();
    for (auto& x : M) { os << x << (--rem == 0 ? "" : ", "); }
    os << "}";
    return os;
}

template<typename T> ostream& operator << (ostream& os, const unordered_set<T>& M) {
    os << "{";
    int rem = M.size();
    for (auto& x : M) { os << x << (--rem == 0 ? "" : ", "); }
    os << "}";
    return os;
}
template<typename K, typename V> ostream& operator << (ostream& os, const unordered_map<K, V>& M) {
    os << "{";
    int rem = M.size();
    for (auto& x : M) { os << x << (--rem == 0 ? "" : ", "); }
    os << "}";
    return os;
}


#ifdef __LOCAL_DEBUG__

const string COLOR_RESET = "\033[0m", BRIGHT_GREEN = "\033[1;32m", BRIGHT_RED = "\033[1;31m", BRIGHT_CYAN = "\033[1;36m", NORMAL_CROSSED = "\033[0;9;37m", RED_BACKGROUND = "\033[1;41m", NORMAL_FAINT = "\033[0;2m",
             RED="\033[0;31m", GREEN = "\033[0;32m", BLUE="\033[0;34m", /*ORANGE = "\033[0;33m",*/ YELLOW = "\033[1;33m", MAGENTA = "\033[1;35m", CYAN = "\033[0;36m", WHITE = "\033[0;37m", 
             WHITE_BACKGROUND = "\033[0;47m", UNDERLINED_YELLOW = "\033[0;4;33m", UNDERLINED_BLUE = "\033[0;4;34m", UNDERLINED_MAGENTA = "\033[0;4;35m", HIGHLIGHT1 = "\033[0;1;4;35m";
#define __dbg(x,y) cerr << COLOR_RESET << BRIGHT_CYAN << x << COLOR_RESET << " = " << (y) << " | "
// #define __dbgContext() cerr << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << endl
// #define __dbgContext() cerr << COLOR_RESET << NORMAL_FAINT << " (L" << RED << __LINE__ << NORMAL_FAINT << ") "  << __FILE__ << COLOR_RESET << endl
#define __dbgContext() cerr << COLOR_RESET << NORMAL_FAINT << " @(" << GREEN << __FILE__ << ":" << RED << __LINE__ << NORMAL_FAINT << ") " << COLOR_RESET << endl
// #define dbg(x) cerr << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << endl
#define dbg(x) cerr << COLOR_RESET << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) <<  NORMAL_FAINT << " (L" << RED << __LINE__ << NORMAL_FAINT << ") "  << __FILE__ << COLOR_RESET << endl

#define dbgif(cond, x) ((cond) ? cerr << COLOR_RESET << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << endl : cerr)

template<typename T> void __print(const char* name, T&& x) {
    __dbg(name, x);
}

template<typename T, typename... D> void __print(const char* name, T&& value, D&&... d) {
    auto p = strchr(name, ',');
    __dbg(string(name, p - name).c_str(), value);
    __print(p + 1, d...);
}

#define print(...) __print(#__VA_ARGS__, __VA_ARGS__), __dbgContext();


//Be careful! For highlighting the output.
// #define cout cout << HIGHLIGHT1

#define write std::cout << HIGHLIGHT1

#else
#define __dbg(x, y) 
#define __dbgContext() 
#define dbg(x) 
#define dbgif(cond, x) 
#define print(...) 

#define write std::cout 

#endif


template<typename T>
struct Rect {
    Rect(T _t = INF, T _b = -INF, T _l = INF, T _r = -INF) : t(_t), b(_b), l(_l), r(_r) {
    }
    void add(int x, int y) {
        t = min(t, x), b = max(b, x);
        l = min(l, y), r = max(r, y);
    }

    bool empty() {
        return !(t <= b && l <= r);
    }

    T t, b, l, r;

    static const T INF = numeric_limits<T>::max();
};

int main(int argc, char** argv) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(12);


    int H, W, N, h, w;
    cin >> H >> W >> N >> h >> w;

    vector<vector<int>> A(H, vector<int>(W, 0));
    for (int i = 0; i < H; ++i) {
        for (int j = 0; j < W; ++j) {
            cin >> A[i][j];
            --A[i][j];
        }
    }



    vector<Rect<int>> rects(N + 1);
    for (int i = 0; i < H; ++i) {
        for (int j = 0; j < W; ++j) {
            rects[A[i][j]].add(i, j);
        }
    }

    int total = 0;
    for (auto& r : rects) {
        if (!r.empty()) {
            ++total;
        }
    }
    print(total);
    vector<vector<int>> acc(H + 2, vector<int>(W + 2, 0));

    for (auto& rect : rects) {
        if (rect.empty()) {
            continue;
        }
        int t = rect.t, b = rect.b, l = rect.l, r = rect.r;
        print(t, b, l, r);
        int minX = max(0, b - (h - 1));
        int maxX = min(t, H - h);
        int minY = max(0, r - (w - 1));
        int maxY = min(l, W - w);
        print(minX, maxX, minY, maxY);
        if (minX <= maxX && minY <= maxY) {
            acc[minX + 1][minY + 1] += 1;
            acc[minX + 1][maxY + 1 + 1] -= 1;
            acc[maxX + 1 + 1][minY + 1] -= 1;
            acc[maxX + 1 + 1][maxY + 1  + 1] += 1;
        }
    }

    for (int i = 1; i <= H; ++i) {
        for (int j = 1; j <= W; ++j) {
            acc[i][j] += acc[i][j - 1] + acc[i - 1][j] - acc[i - 1][j - 1];
        }
    }
    // for (auto& V : acc) {
    //     print(V);
    // }


    for (int i = 0; i + h <= H; ++i) {
        for (int j = 0; j + w <= W; ++j) {
            auto ans = total - acc[i + 1][j + 1];
            write << ans << (j + w == W ? '\n' : ' ');
        }
    }

    return 0;
}

Submission Info

Compile Error

./Main.cpp: In function ‘int main(int, char**)’:
./Main.cpp:159:14: warning: unused parameter ‘argc’ [-Wunused-parameter]
  159 | int main(int argc, char** argv) {
      |          ~~~~^~~~
./Main.cpp:159:27: warning: unused parameter ‘argv’ [-Wunused-parameter]
  159 | int main(int argc, char** argv) {
      |                    ~~~~~~~^~~~

Judge Result