Niitty

input/code.cpp: In function 'void countSides(int, int, int, std::map<char, int>)':
input/code.cpp:17:36: warning: comparison of integer expressions of different signedness: 'std::__cxx11::basic_string<char>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   17 |                 if(missing.find(v) == -1) {
      |                    ~~~~~~~~~~~~~~~~^~~~~
input/code.cpp: In function 'int main()':
input/code.cpp:86:30: warning: comparison of integer expressions of different signedness: 'std::__cxx11::basic_string<char>::size_type' {aka 'long unsigned int'} and 'int' [-Wsign-compare]
   86 |             if(types.find(d) == -1) {
      |                ~~~~~~~~~~~~~~^~~~~

#include <bits/stdc++.h>
#define ln "\n"
using namespace std;
using ll = long long;
int n;
int ans = 0;
string types = "";
vector<string> vec;
vector<map<char,set<int>>> closestRow,closestCol;
void countSides(int side,int startY, int startX, map<char,int> table) {
        bool hasAll = true;
        string missing;
        pair<int,int> dif = {n-side-startX,n-side-startY};
        for(char v: types) {
            if(table[v] == 0) {
                hasAll = false;
                if(missing.find(v) == -1) {
                    missing += v;
                }
            }
        }
        if(hasAll) {
            ans++;
            ans += dif.first;
            ans += dif.second;
        } else {
            map<char,int> rows, cols;
            map<char,bool> rowsFound, colsFound;
            int maxRow = -1, maxCol = -1;
            for(char d : missing) {
                rowsFound[d] = false;
                colsFound[d] = false;
            }

                
            for(int i = startY; i < startY+side; i++) {
                for(char d : missing) {
                    auto val = closestRow[i][d].upper_bound(startX);
                    if(val != closestRow[i][d].end()) {
                        if(rowsFound[d] != true) rows[d] = *val;
                        rowsFound[d] = true;
                        rows[d] = min(*val,rows[d]);
                    } 
                }
            }

            for(int i = startX; i < startX+side; i++) {
                for(char d : missing) {
                    auto val = closestCol[i][d].upper_bound(startY);
                    if(val != closestCol[i][d].end()) {
                        if(colsFound[d] != true) cols[d] = *val;
                        colsFound[d] = true;
                        cols[d] = min(*val,cols[d]);
                    } 
                }
            }
            for(char d: missing) {
                maxRow = max(maxRow,rows[d]);
                maxCol = max(maxCol,cols[d]);
            }
            bool rc = true;
            for(auto [d,found]:rowsFound) {
                if(found == false) rc = false;
            }
            bool cc = true;
            for(auto [d,found]:colsFound) {
                if(found == false) cc = false;
            }
            if(rc) {
                ans += n-maxRow;
            }
            if(cc) {
                ans += n-maxCol;
            }
        }
}

int main() {
    cin >> n;
    vec.resize(n);
    for(int i = 0; i < n; i++) {
        cin >> vec[i];
    }
    for(int i = 0; i < n; i++) {
        for(char d:vec[i]) {
            if(types.find(d) == -1) {
                types += d;
            }
        }
    }


    closestCol.resize(n);
    closestRow.resize(n);
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            closestRow[i][vec[i][j]].insert(j);
            closestCol[j][vec[i][j]].insert(i);
        }
    }


    for(int side = n; side > 0; side--) {
        map<char,int> table;
        for(int i = 0; i < side; i++) {
            for(int j = 0; j < side; j++) {
                table[vec[i][j]]++;
            }
        }
        map<char,int> temp = table;
        for(int i = 0; i <= n-side; i++) {
            for(int j = 0; j <= n-side; j++) {
                countSides(side,i,j,temp);
                if(j < n-side) {
                    for(int v = i; v < side+i; v++) {
                        temp[vec[v][j]]--;
                    }
                    for(int v = i; v < side+i; v++) {
                        temp[vec[v][j+side]]++;
                    }
                }
            }
            if(i < n-side) {
                for(int j = 0; j < side; j++) {
                    table[vec[i][j]]--;
                }
                for(int j = 0; j < side; j++) {
                    table[vec[i+side][j]]++;
                }
                temp = table;
            }
        }

    }
    cout << ans << ln;
}

Test 1

Group: 1, 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 3

Group: 1, 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 4

Group: 1, 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 5

Group: 1, 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 6

Group: 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 7

Group: 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 8

Group: 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 9

Group: 2, 3, 4, 5, 6

Verdict: ACCEPTED

Test 10

Group: 3, 4, 5, 6

Verdict: ACCEPTED

Test 11

Group: 3, 4, 5, 6

Verdict: ACCEPTED

Test 12

Group: 3, 4, 5, 6

Verdict: ACCEPTED

Test 13

Group: 3, 4, 5, 6

Verdict: ACCEPTED

Test 14

Group: 4, 5, 6

Verdict: ACCEPTED

Test 15

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 4, 5, 6

Verdict: ACCEPTED

Test 17

Group: 4, 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 5, 6

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 6

Verdict: TIME LIMIT EXCEEDED

Test 23

Group: 6

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 6

Verdict: TIME LIMIT EXCEEDED

Test 25

Group: 6

Verdict: TIME LIMIT EXCEEDED