4. Bomberman

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using namespace std;

vector<vector<int>> readInput()
{
    vector<vector<int>> matrix;
    int rows = 0;
    int cols = 0;
    cin >> rows >> cols;
    matrix.resize(rows);
    for (int i = 0; i < rows; ++i)
    {
        string line;
        cin >> line;
        matrix[i].resize(cols);
        for (int j = 0; j < cols; ++j)
        {
            int temp = (int)line[j] - '0';
            matrix[i][j] = temp;
        }
    }
    return matrix;
}

bool isInBound(vector<vector<int>>& matrix,
    const int row,
    const int col)
{
    if (row >= 0 &&
        row < (int)matrix.size() &&
        col >= 0 &&
        col < (int)matrix[row].size())
    {
        return true;
    }

    return false;
}

bool isMined(vector<vector<int>>& matrix, int row, int col, vector<pair<int, int>>& usedBombs)
{
    const int size = usedBombs.size();
    for (int i = 0; i < size; i++)
    {
        if (row == usedBombs[i].first && col == usedBombs[i].second)
        {
            return true;
        }
    }
    return false;
}

int getPoints(vector<vector<int>>& data, int row, int col, int power, vector<pair<int, int>>& bombs)
{
    int result = 0;
    if (power == 0)
    {
        if (!isMined(data, row, col, bombs))
        {
            result += data[row][col];
            bombs.push_back(pair<int, int>(row, col));
        }
        //result = data[row][col];
        //bombs.push_back(pair<int, int>(row, col));
    }
    else
    {
        for (int i = 1; i <= power; i++)
        {
            //left
            if (isInBound(data, row, col - i) && !isMined(data, row, col - i, bombs))
            {
                result += data[row][col - i];
                bombs.push_back(pair<int, int>(row, col - i));
            }

            //right
            if (isInBound(data, row, col + i) && !isMined(data, row, col + i, bombs))
            {
                result += data[row][col + i];
                bombs.push_back(pair<int, int>(row, col + i));
            }

            //top
            if (isInBound(data, row - i, col) && !isMined(data, row - i, col, bombs))
            {
                result += data[row - i][col];
                bombs.push_back(pair<int, int>(row - i, col));
            }

            //bottom
            if (isInBound(data, row + i, col) && !isMined(data, row + i, col, bombs))
            {
                result += data[row + i][col];
                bombs.push_back(pair<int, int>(row + i, col));
            }

            //center
            if (!isMined(data, row, col, bombs))
            {
                result += data[row][col];
                bombs.push_back(pair<int, int>(row, col));
            }
        }
    }
    return result;
}
int main()
{
    vector<vector<int>> matrix = readInput();

    int numberOfCommands;
    cin >> numberOfCommands;
    cin.ignore();
    int power = 0;

    vector<pair<int, int>> usedBombs;

    for (int i = 0; i < numberOfCommands; i++)
    {
        string command;
        getline(cin, command);

        if (command == "power up")
        {
            ++power;
            cout << "Increased bomb power to " << power << endl;
        }
        else if (command == "power down")
        {
            --power;
            if (power < 0)
            {
                power = 0;
            }
            cout << "Decreased bomb power to " << power << endl;
        }
        else
        {
            istringstream istr(command);
            string word, rowInStr, colInStr;
            istr >> word >> rowInStr >> colInStr;
            int row = stoi(rowInStr);
            int col = stoi(colInStr);
            int points = getPoints(matrix, row, col, power, usedBombs);
            cout << points << " points" << endl;
            points = 0;
        }
    }
    return 0;
}