[c++] 배열을 복사하는 함수 (copy)

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

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

 

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

copy(복사할 배열의 시작지점, 복사할 배열의 끝나는 지점, 복사될 배열의 시작하는 지점)

 

예를 들어 arr[10]을 arr_copy[10]에 옮긴다고 하자

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

 

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

copy(&복사할 배열의 시작지점, &복사할 배열의 시작지점 + 데이터 수, &복사될 배열의 시작지점)

 

예를 들어 arr[10][10]을 arr_copy[10][10]에 옮긴다고 하자

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

 

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

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

 

위의 방식을 활용한 문제는 다음과 같다.

이 문제는 그 상황상황마다 계속해서 2차원 배열을 복사해야하는 상황이므로 copy함수가 사용될 수 밖에 없다.

#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;
}