Submission #289782

#	Time	Username	Problem	Language	Result	Execution time	Memory
289782		Mercenary	Rectangles (IOI19_rect)	C++14	72 / 100	5084 ms	746952 KiB

rect

#include "rect.h"
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/trie_policy.hpp>

#define pb push_back
#define mp make_pair
#define taskname "A"

using namespace std;
using namespace __gnu_pbds;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef tree <int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;

const int maxn = 2505;
vector<int> valA[maxn][maxn] , valB[maxn][maxn];

int m , n;

int h[maxn][maxn];
int L[maxn][maxn] , R[maxn][maxn] , U[maxn][maxn] , D[maxn][maxn];

void init(int key){
    vector<int> s(maxn , 0);
    int sz = 0;
    for(int i = 1 ; i <= m ; ++i){
        sz = 0;
        for(int j = 1 ; j <= n ; ++j){
            while(sz > 0 && h[i][s[sz - 1]] + key <= h[i][j])sz--;
            if(sz > 0)L[i][j] = s[sz - 1];
            else L[i][j] = 0;
            s[sz++] = j;
        }
        sz = 0;
        for(int j = n ; j >= 1 ; --j){
            while(sz > 0 && h[i][s[sz - 1]] + key <= h[i][j])sz--;
            if(sz > 0)R[i][j] = s[sz - 1];
            else R[i][j] = n + 1;
            s[sz++] = j;
        }
        if(!key)continue;
        for(int j = 1 ; j <= n ; ++j){
            if(L[i][j] != 0)valA[L[i][j]][j].pb(i);
            if(R[i][j] != n + 1 && L[i][R[i][j]] != j)valA[j][R[i][j]].pb(i);
        }
    }
    for(int j = 1 ; j <= n ; ++j){
        sz = 0;
        for(int i = 1 ; i <= m ; ++i){
            while(sz > 0 && h[s[sz - 1]][j] + key <= h[i][j])sz--;
            if(sz > 0)U[i][j] = s[sz - 1];
            else U[i][j] = 0;
            s[sz++] = i;
        }
        sz = 0;
        for(int i = m ; i >= 1 ; --i){
            while(sz > 0 && h[s[sz - 1]][j] + key <= h[i][j])sz--;
            if(sz > 0)D[i][j] = s[sz - 1];
            else D[i][j] = m + 1;
            s[sz++] = i;
        }
        if(!key)continue;
        for(int i = 1 ; i <= m ; ++i){
            if(U[i][j] != 0)valB[U[i][j]][i].pb(j);
            if(D[i][j] != m + 1 && U[D[i][j]][j] != i)valB[i][D[i][j]].pb(j);
        }
    }
}
pair<ii,ii> val[maxn * maxn];

long long count_rectangles(std::vector<std::vector<int> > a) {
    m = a.size();n = a[0].size();
    for(int i = 1 ; i <= m ; ++i)for(int j = 1 ; j <= n ; ++j)h[i][j] = a[i - 1][j - 1];
    init(0);
    int sz = 0;
    for(int i = 2 ; i < m ; ++i){
        for(int j = 2 ; j < n ; ++j){
            if(L[i][j] && U[i][j] && R[i][j] <= n && D[i][j] <= m){
                auto cur = mp(mp(L[i][j] , R[i][j]) , mp(U[i][j] , D[i][j]));
                if(sz > 0 && val[sz - 1] == cur)continue;
                val[sz++] = cur;
            }
        }
    }
    init(1);
    sort(val,val+sz);
    int res = 0;
    for(int i = 0 ; i < sz ; ++i){
        if(i > 0 && val[i] == val[i - 1])continue;
        int L = val[i].first.first , R = val[i].first.second , U = val[i].second.first , D = val[i].second.second;
         auto checkA = [&](int L , int R , int U , int D)->bool{
            if(valA[L][R].size() < D - U + 1 || ::R[U][L] < R || ::L[U][R] > L)return 0;
            if(D - U <= 10){
                for(int i = U ; i <= D ; ++i){
                    if(::R[i][L] < R || ::L[i][R] > L){
                        return 0;
                    }
                }
                return 1;
            }
            auto it = lower_bound(valA[L][R].begin(),valA[L][R].end(),U)-valA[L][R].begin();
            if(it + D - U >= valA[L][R].size() || valA[L][R][it] != U || valA[L][R][it + D - U] != D)return 0;
            return 1;
        };
        auto checkB = [&](int L , int R , int U , int D)->bool{
            if(valB[L][R].size() < D - U + 1 || ::D[L][U] < R || ::U[R][U] > L)return 0;
            if(D - U <= 10){
                for(int i = U ; i <= D ; ++i){
                    if(::D[L][i] < R || ::U[R][i] > L){
                        return 0;
                    }
                }
                return 1;
            }
            auto it = lower_bound(valB[L][R].begin(),valB[L][R].end(),U)-valB[L][R].begin();
            if(it + D - U >= valB[L][R].size() || valB[L][R][it] != U || valB[L][R][it + D - U] != D)return 0;
            return 1;
        };
        if(checkA(L , R , U + 1 , D - 1) && checkB(U , D , L + 1 , R - 1)){
            res++;
        }
    }
    return res;
}

#ifdef LOCAL
#include "rect.h"
#include <cstdio>
#include <unistd.h>
#include <cassert>
#include <string>

using namespace std;

class InputReader {
private:
	static const int SIZE = 4096;

	int inputFileDescriptor;
	char buf[SIZE];
	int curChar;
	int numChars;

public:

	inline InputReader(int _inputFileDescriptor):
		inputFileDescriptor(_inputFileDescriptor),
		curChar(0),
		numChars(0) {
	}

	inline void close() {
		::close(inputFileDescriptor);
	}

	inline char read() {
		assert(numChars != -1);
		if (curChar >= numChars) {
			curChar = 0;
			numChars = ::read(inputFileDescriptor, buf, SIZE);
			if (numChars == -1)
				return -1;
		}
		return buf[curChar++];
	}

	inline int readInt() {
		int c = eatWhite();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			assert(c >= '0' && c <= '9');
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	inline string readString() {
		char c = eatWhite();
		string res;
		do {
			res += c;
			c = read();
		} while (!isSpaceChar(c));
		return res;
	}

	inline string readLine() {
		string res;
		while (true) {
			char c = read();
			if (c == '\n' || c == '\r' || c == -1)
				break;
			res += c;
		}
		return res;
	}

	inline char eatWhite() {
		char c = read();
		while (isSpaceChar(c))
			c = read();
		return c;
	}

	static inline bool isSpaceChar(char c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
};


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    if(fopen(taskname".INP","r")){
		freopen(taskname".INP", "r",stdin);
		freopen(taskname".OUT", "w",stdout);
    }
	InputReader inputReader(STDIN_FILENO);
	int n, m;
	n = inputReader.readInt();
	m = inputReader.readInt();
	vector<vector<int>> a(n, vector<int>(m));
	for (int i = 0; i < n; i++)	{
		for (int j = 0; j < m; j++) {
			a[i][j] = inputReader.readInt();
		}
	}
	inputReader.close();

	long long result = count_rectangles(a);

	printf("%lld\n", result);
	fclose(stdout);
	return 0;
}

#endif // LOCAL

Compilation message (stderr)

rect.cpp: In lambda function:
rect.cpp:95:34: warning: comparison of integer expressions of different signedness: 'std::vector<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   95 |             if(valA[L][R].size() < D - U + 1 || ::R[U][L] < R || ::L[U][R] > L)return 0;
      |                ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~
rect.cpp:105:27: warning: comparison of integer expressions of different signedness: 'long int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  105 |             if(it + D - U >= valA[L][R].size() || valA[L][R][it] != U || valA[L][R][it + D - U] != D)return 0;
      |                ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~
rect.cpp: In lambda function:
rect.cpp:109:34: warning: comparison of integer expressions of different signedness: 'std::vector<int>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
  109 |             if(valB[L][R].size() < D - U + 1 || ::D[L][U] < R || ::U[R][U] > L)return 0;
      |                ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~
rect.cpp:119:27: warning: comparison of integer expressions of different signedness: 'long int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  119 |             if(it + D - U >= valB[L][R].size() || valB[L][R][it] != U || valB[L][R][it + D - U] != D)return 0;
      |                ~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~

• Subtask 1: 8 / 8
• Subtask 2: 7 / 7
• Subtask 3: 12 / 12
• Subtask 4: 22 / 22
• Subtask 5: 10 / 10
• Subtask 6: 13 / 13
• Subtask 7: 0 / 28