CareerCup

void elements(int a[][N],int x,int y,int col,int *n)
{
     if(x<0 || x>=N || y<0 || y>=N || a[x][y]!=col || a[x][y]==-1)
        return;
     (*n)++;
     a[x][y]=-1;
     printmatrix(a);
     elements(a,x+1,y,col,n);
     elements(a,x-1,y,col,n);
     elements(a,x,y+1,col,n);
     elements(a,x,y-1,col,n);
}

// Assumptions:
// 1) Intensity is represented by an integer.
// 2) A pixel is reacable by another pixel if they are facing each other
//    vertically or horizontally, but not diagonally.
#include <iostream>
#include <stack>
#include <unordered_set>
using namespace std;

// Input format:
// i j
// n
// [n * n numbers]
//
// * (i, j) denotes the given pixel at (i + 1)th row, (j + 1)th column
// * n is the width and height of the screen
// * Each number is separated by whitespace characters.
//
// Sample input:
// 2 2
// 5
// 0 0 1 2 0
// 0 1 3 1 0
// 0 0 0 1 1
// 1 2 0 0 4
// 0 0 0 0 0
//
// Sample output:
// 13
int main() {
    int i, j, n;
    cin >> i >> j >> n;
    int index = i * n + j;
    int size = n * n;
    int* screen = new int[size];
    for (int i = 0; i < size; i++) {
        cin >> screen[i];
    }
    int target_intensity = screen[index];
    int count = 0;
    unordered_set<int> visited;
    stack<int> s;
    s.push(index);
    while (!s.empty()) {
        int cur = s.top();
        s.pop();
        if (visited.count(cur) != 0) continue;
        visited.insert(cur);
        if (screen[cur] != target_intensity) continue;
        count++;
        int cur_i = cur / n;
        int cur_j = cur % n;
        if (cur_i > 0) s.push(cur - n);
        if (cur_j > 0) s.push(cur - 1);
        if (cur_i < n - 1) s.push(cur + n);
        if (cur_j < n - 1) s.push(cur + 1);
    }
    cout << count << endl;
    delete[] screen;
}