[c++] 배열에서 해당 원소의 갯수를 찾는 함수 (count)

일단, count함수는 algorithm에 존재하므로

사용하기 위해서는 상단부에 #include <algorithm>을 반드시 적어야 한다.

 

일차원 배열일 경우에는 되게 단순하게 하면 된다.

count(배열의 시작지점, 배열의 끝나는 지점, 원하는 숫자)

 

예를 들어 arr[10]에서 3의 숫자를 센다고 하자

그러면 count(arr, arr + 10, 3)를 사용하면 된다.

 

단, 다차원배열의 경우에는 이와는 조금 사용법이 다른데

count(&배열의 시작지점, &배열의 시작지점 + 데이터 수, 원하는 숫자)

 

예를 들어 arr[10][10]에서 3의 숫자를 센다고 하자

그러면 count(&arr[0][0], &arr[0][0] + 100, 3)를 사용하면 된다.

 

벡터의 경우에는 너무 간단한데

그냥 count(r.begin(), r.end(), 3)을 사용하면 된다. (벡터가 훨씬 쉽다..)

위를 사용한 간단한 문제를 살펴보면 다음과 같다

바이러스를 전파 시킨 뒤 남아있는 공간을 세기 위해서는 배열 안에 0의 갯수를 세야한다.

이 상황에서 count함수가 사용되게 된다.

 

해당하는 내용을 코드로 구현한 결과는 다음과 같다.

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cstring>

using namespace std;

int data_store[8][8];
int check_array[8][8];
vector <pair<int, int> > zero_store;
int n, m;
int max_result_store = -1;

void dfs(int i, int j, int (&visited)[8][8]){
    if(i < 0 || i >= n || j < 0 || j >= m){
        return;
    }
    if(check_array[i][j] == 1) return;
    else{
        if(check_array[i][j] == 2){
            if(visited[i][j]) return;
            else{
                visited[i][j] = true;
                if(i + 1 < n){
                    if(check_array[i + 1][j] != 1){
                        check_array[i + 1][j] = 2;
                        dfs(i + 1, j, visited);
                    }         
                }
                if(i - 1 >= 0){
                    if(check_array[i - 1][j] != 1){
                        check_array[i - 1][j] = 2;
                        dfs(i - 1, j, visited);
                    }
                }
                if(j + 1 < m){
                    if(check_array[i][j + 1] != 1){
                        check_array[i][j + 1] = 2;
                        dfs(i, j + 1, visited);
                    }
                }
                if(j - 1 >= 0){
                    if(check_array[i][j - 1] != 1){
                        check_array[i][j - 1] = 2;
                        dfs(i, j - 1, visited);
                    }
                }
                return;
            }
        }
    }
}

int main(void){
    cin >> n >> m;
    fill(&data_store[0][0], &data_store[7][8], -1);

    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            int temp;
            cin >> temp;
            data_store[i][j] = temp;
            if(temp == 0){
                pair<int, int> zero_temp;
                zero_temp.first = i;
                zero_temp.second = j;
                zero_store.push_back(zero_temp);
            } // Store seperately if value is zero
        }
    } // data_store

    // Brute force (Search all condition)

    int zero_size = zero_store.size();

    for(int i = 0; i < zero_size; i++){
        for(int j = i + 1; j < zero_size; j++){
            for(int k = j + 1; k < zero_size; k++){
                copy(&data_store[0][0], &data_store[0][0] + 64, &check_array[0][0]); 
                check_array[zero_store[i].first][zero_store[i].second] = 1;
                check_array[zero_store[j].first][zero_store[j].second] = 1;
                check_array[zero_store[k].first][zero_store[k].second] = 1; // initializing array

                int visited[8][8] = {false};

                for(int i = 0; i < n; i++){  
                    for(int j = 0; j < m; j++){
                        dfs(i, j, visited);
                    }
                }
                
                // count 0 value and storing max value

                int current_value = count(&check_array[0][0], &check_array[0][0] + 64, 0);
                max_result_store = max(current_value, max_result_store);

            }
        }
    }

    cout << max_result_store << "\n";
    return 0;
}