Niitty

input/code.cpp: In function 'void printRows(int, int*)':
input/code.cpp:15:13: warning: variable 'prewOrTowerSpace' set but not used [-Wunused-but-set-variable]
   15 |         int prewOrTowerSpace = rowSpace;
      |             ^~~~~~~~~~~~~~~~
input/code.cpp: In function 'int main()':
input/code.cpp:138:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::__cxx11::basic_string<char>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  138 |         for (int k = 0; k < row.size(); k++) {
      |                         ~~^~~~~~~~~~~~

#include <bits/stdc++.h>
 
using namespace std;
typedef long long ll;

const int FIELD_SIZE = 500;
const int FIELD_ROW_OFFSET = FIELD_SIZE * (FIELD_SIZE + 1) / 2;

int containedFlowers = 0;

void printRows(int n, int* field)
{
    for (int y = 0; y < n; y++) {
        int rowSpace = y * FIELD_ROW_OFFSET;
        int prewOrTowerSpace = rowSpace;
        int offsetTriangle = 0;

        cout << "row:\n";

        for (int x = 0; x < n; x++) {

            int orTowerSpace = rowSpace + offsetTriangle;

            for (int len = 0; len < n - x; len++) {
                cout << field[orTowerSpace + len] << " at " << (orTowerSpace + len) << "   ";
            }

            prewOrTowerSpace = orTowerSpace;
            offsetTriangle += n - x;
            cout << "\n";
        }
    }
}

ll bruteForce(int n, int* field)
{
    ll ans = 0;
 
    for (int y = 0; y < n; y++) {
        int rowSpace = y * FIELD_ROW_OFFSET;
        int prewOrTowerSpace = rowSpace;
        int offsetTriangle = n;

        for (int x = 1; x < n; x++) { // loop or tower spaces

            int orTowerSpace = rowSpace + offsetTriangle;

            for (int len = 0; len < n - x; len++) { // loop over or tower
                int bitMaskCombination = field[prewOrTowerSpace + len] | field[prewOrTowerSpace + len + 1];
                field[orTowerSpace + len] = bitMaskCombination;

                if (bitMaskCombination == containedFlowers) {
                    ans += 1;
                }
            }

            prewOrTowerSpace = orTowerSpace;
            offsetTriangle += n - x;
        }
    }

    //printRows(n, field);

    for (int y = 0; y < n - 1; y++) { // loop rows
        int rowSpace = y * FIELD_ROW_OFFSET;

        for (int orRowIndex = y + 1; orRowIndex < n; orRowIndex++) { // loop other rows to add to main row

            int addRowSpace = orRowIndex * FIELD_ROW_OFFSET;
            int offsetTriangle = 0;
            
            for (int x = 0; x < n; x++) { // loop orTowers

                int mainOrTowerSpace = rowSpace + offsetTriangle;
                int addOrTowerSpace = addRowSpace + offsetTriangle;

                for (int len = 0; len < n - x; len++) { // loop orTower bitmasks
                    field[mainOrTowerSpace + len] |= field[addOrTowerSpace + len];

                    if (field[mainOrTowerSpace + len] == containedFlowers) {
                        ans += 1;
                    }
                }

                offsetTriangle += n - x;
            }
        }
    }

    return ans;
}
 
void randomTest(int n)
{
    for (int i = 0; i < n; i++) {
        for (int k = 0; k < n; k++) {
        }
    }
 
    for (int i = 0; i < 26; i++) {
    }
    for (int i = 0; i < n; i++) {
        for (int k = 0; k < n; k++) {
        }
    }
}


 
int main()
{
    //vector<string> testField = {"AAAAA", "AAAAA", "AABAA", "AAACA", "AAADA"};
    //vector<string> testField = {"BAA", "AAB", "AAA"};
    //vector<string> testField = {"Z"};
    //vector<string> testField = {"AZ", "ZA"};
    //vector<string> testField = {"AAAC", "ABAA", "ABAA", "AAAA"};
    //vector<string> testField = {"AAAAA", "AAAAA", "AAAAA", "AAAAA", "AAAAA"};
    //vector<string> testField = {"ZAAAA", "AAAAA", "AAAAA", "AAAAA", "AAAAK"};
    //vector<string> testField = {"AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA","AAAAAAAAAA",};
    //vector<string> testField = {"AUFCHGK","GXAPVWB","NUHYMEA","HSCSNSI","IMBMTJS","TPVRJUF","SIKDVWY"};

    int n;
    //n = testField.size();
    //n = testField.size();
    cin >> n;
    //auto begin = std::chrono::high_resolution_clock::now();
    
    // n * n(n+1) / 2
    int* field = new int[FIELD_SIZE * FIELD_ROW_OFFSET]{0};
    //auto end = std::chrono::high_resolution_clock::now();
 

    for (int i = 0; i < n; i++) {
        //string row = testField[i];
        string row;
        cin >> row;

        for (int k = 0; k < row.size(); k++) {

            int bitMask = 1 << (row[k] - 'A');
            field[i * FIELD_ROW_OFFSET + k] = bitMask;
            containedFlowers |= bitMask;
        }
    }
    ll ans = bruteForce(n, field);
    cout << ans;
    /*for (int i = 0; i < n; i++) {
        for (int k = 0; k < n; k++) {
            cout << field[i * FIELD_ROW_OFFSET + k] << " ";
        }
        cout << "\n";
    }*/

    //auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end-begin).count();
    //std::cout << " ms: " << duration << "\n";
}

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: WRONG ANSWER

Test 4

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

Verdict: ACCEPTED

Test 5

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

Verdict: WRONG ANSWER

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: WRONG ANSWER

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: WRONG ANSWER

Test 13

Group: 3, 4, 5, 6

Verdict: ACCEPTED

Test 14

Group: 4, 5, 6

Verdict: ACCEPTED

Test 15

Group: 4, 5, 6

Verdict: ACCEPTED

Test 16

Group: 4, 5, 6

Verdict: WRONG ANSWER

Test 17

Group: 4, 5, 6

Verdict: ACCEPTED

Test 18

Group: 5, 6

Verdict: ACCEPTED

Test 19

Group: 5, 6

Verdict: ACCEPTED

Test 20

Group: 5, 6

Verdict: WRONG ANSWER

Test 21

Group: 5, 6

Verdict: ACCEPTED

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