10-yuyu0830

[yuyu0830]

🔗 문제 링크

비숍

✔️ 소요된 시간

1주일..?
틈틈히 풀었습니다

✨ 수도 코드

❓ 문제

n * n 크기의 체스판 이 주어진다! 체스 판은 기물을 둘 수 있는 칸(1) 과 기물을 둘 수 없는 칸(0) 으로 주어진다. 우리는 주어진 체스판 위에 최대한 많은 비숍을 서로 겹치지 않게 두려고 한다! 이 때 체스 판에 최대한 많은 비숍을 서로 겹치지 않게 배치했을 때, 몇 개의 비숍을 둘 수 있는지 구하자!

• 1 ≤ n ≤ 10
• 시간제한 10초

❗ 풀이

n-bishop 문제라고 볼 수 있다. 하지만 체스 판에서 기물을 둘 수 없는 공간이 있는 만큼 경우의 수가 조금 생긴다.

1️⃣ 첫번째 풀이

우선 기물을 둘 수 있는 칸이 별개로 주어지기 때문에 체스 판의 모양을 받을 때 기물을 둘 수 있는 칸의 위치를 벡터로 저장했다.

비숍은 대각선으로만 이동할 수 있다! 따라서 현재 위치 (x, y)에 대해서 대각선에 다른 비숍이 있는지만 확인하면 된다. 그래서 체스 보드를 대각선으로 기울여서 각 대각선에 위치한 비숍이 있는지 체크했다.

기존 체스판을 다루는 방식

기울여서 체스판을 다루는 방식

백트래킹 방식으로 탐색하는데 만약 현재 비숍을 두려고 하는 위치에 해당하는 l_arr, r_arr 이 둘 다 비어있으면 l_arr과 r_arr에 체크를 한 뒤 현재 탐색의 비숍 개수를 하나 늘리고 다음 위치를 탐색한다.

#include <iostream>
#include <vector>

using namespace std;

typedef pair<int, int> ii;

int leftArr[20] = {0, };
int rightArr[20] = {0, };
int map[11][11] = {0, };

int n, ans = 0, m = 0;
vector<ii> v;

void solve(int idx) {
    int x = v[idx].first;
    int y = v[idx].second;

    int rightPos = x + y;
    int leftPos = (n - x - 1) + y;

    if (map[x][y] && !rightArr[rightPos] && !leftArr[leftPos]) {
        rightArr[rightPos] = 1;
        leftArr[leftPos] = 1;

        m = max(m, ++ans);

        for (int i = idx + 1; i < v.size(); i++) {
            solve(i);
        }

        rightArr[rightPos] = 0;
        leftArr[leftPos] = 0;

        ans--;
    }
}

int main() {
    cin >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int t; cin >> t;
            map[i][j] = t;
            if (t) v.push_back(make_pair(i, j));
        }
    }

    for (int i = 0; i < v.size(); i++) {
        solve(i);
    }

    printf("%d\n", m);
}

이 풀이 방식은 결과적으로 시간 초과 코드였다. n의 최대치가 10이니 최대 칸 수는 100, 각 칸 별로 두거나 두지 않는 경우의 수가 있으니 2^100 만큼의 탐색 횟수를 가지게 된다. (실제로는 백트래킹 도중 순회하지 않는 경우의 수도 많아서 훨씬 작을 것 같다) 이거 때문에 시간 줄이려고 별의 별 방법을 다 써봤는데 안되더라..

2️⃣ 두번째 풀이

획기적으로 줄이는 방법이 없을까 하다가 비숍의 특성중 하나인 비숍은 같은 색 칸으로만 움직일 수 있다는 사실이 기억났다. 그러면 같은 색 비숍끼리만 비교하면 되지 않을까? 그렇게 된다면 탐색할 경우의 수가 확 줄게 된다. (2^50 + 2^50 (이 것도 백트래킹으로 순회하지 않는 경우의 수가 많아져 실제로는 2^(N * N / 4)가 된다고 한다. 참고) 그래서 같은 색끼리 비교할 수 있도록 코드를 조금 손보니 바로 해결!

#include <iostream>
#include <vector>

using namespace std;

typedef pair<int, int> ii;

int leftArr[2][11] = {0, };
int rightArr[2][11] = {0, };
int map[11][11] = {0, };

int n, ans[2] = {0, }, m[2] = {0, };
vector<ii> v[2];

void solve(int color, int idx) {
    int x = v[color][idx].first;
    int y = v[color][idx].second;

    int rightPos = (x + y) / 2;
    int leftPos = ((n - x - 1) + y) / 2;

    if (map[x][y] && !rightArr[color][rightPos] && !leftArr[color][leftPos]) {
        rightArr[color][rightPos] = 1;
        leftArr[color][leftPos] = 1;

        m[color] = max(m[color], ++ans[color]);

        for (int i = idx + 1; i < v[color].size(); i++) 
            solve(color, i);
        
        rightArr[color][rightPos] = 0;
        leftArr[color][leftPos] = 0;

        ans[color]--;
    }
}

int main() {
    cin >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int t; cin >> t;
            map[i][j] = t;
            if (t) v[i % 2 != j % 2].push_back(make_pair(i, j));
        }
    }

    for (int color = 0; color < 2; color++) {
        for (int i = 0; i < v[color].size(); i++) {
            solve(color, i);

            if (ans[color] + (v[color].size() - i - 1) < m[color]) break;
        }   
    }

    printf("%d\n", m[0] + m[1]);
}

if (ans[color] + (v[color].size() - i - 1) < m[color]) break; 이 코드로 순회하면서 조금이라도 시간을 아껴보기 위해서 탐색 도중 남은 비숍을 전부 둘 수 있다고 해도 최대값이랑 비교했을 때 갱신할 수 있는 값이 아니면 탐색을 종료하게끔 만들었다.

📚 새롭게 알게된 내용

머리 꽁꽁 싸맨 어려운 문제였다... 2차원 배열을 기울여서 사용하는 건 새로운 접근이였다.

[InSange]

이동할 수 있는 공간을 담아넣는 배열에서 만약 대각선 4방향
dx[4] = {1, 1, -1, -1}, dy[4] = {1, -1, 1, -1}
요롷게 선정한 후
선정할 수 있는 공간에 넣었을 때
각 방향이 갈 수 있는 조건을 bool canGo[4]와 같이 선정한 후 값을 점점 늘려가면서 체크했다면 더 빠를까요?
저도 이론만 생각해본터라 될지는 모르겠지만 ㅎㅎ
두었을 때 대각선으로 갈 수 있는 모든 경로의 수를 1로 막아두는 것과 다 탐색하는 것 둘 다 시간 복잡도가 궁금해지네요..

대각선으로 푸는 방식.. 익숙치 않은 접근이다보니 분석하다가 이게 될까?라는 수많은 의혹심에 여러번 휩싸이는 것 같습니다.. 역시 여러 다방면으로 접근할 수 있다는 것은 그만큼 내공이 쌓인 고수가 아닐까요..? 좋은 문제 보고 갑니다.

[yuyu0830]

이동할 수 있는 공간을 담아넣는 배열에서 만약 대각선 4방향 dx[4] = {1, 1, -1, -1}, dy[4] = {1, -1, 1, -1} 요롷게 선정한 후 선정할 수 있는 공간에 넣었을 때 각 방향이 갈 수 있는 조건을 bool canGo[4]와 같이 선정한 후 값을 점점 늘려가면서 체크했다면 더 빠를까요? 저도 이론만 생각해본터라 될지는 모르겠지만 ㅎㅎ 두었을 때 대각선으로 갈 수 있는 모든 경로의 수를 1로 막아두는 것과 다 탐색하는 것 둘 다 시간 복잡도가 궁금해지네요..

사실 완전 처음 풀이는 탐색 가능 여부 확인용 2차원 배열을 따로 선언해 (x, y) 에 비숍을 둔다면 2차원 배열에서 (x, y)의 모든 대각선에 + 1을 해두고, 비숍을 뺄 때 모든 대각선에 -1을 하는 식으로 체크를 했습니다. 그렇게 하면 2차원 배열의 (a, b)가 0이면 비숍을 배치할 수 있고, 1 이상이면 비숍을 배치할 수 없습니다. 이렇게 해봤는데 시간 초과가 나오더라구요... 그런데 시간 초과의 가장 큰 원인이 흰색, 검은색 타일을 같이 확인하는 것인 만큼 이 풀이도 흰색, 검은색 타일을 따로 연산하면 해결 가능할까요?

대각선으로 푸는 방식.. 익숙치 않은 접근이다보니 분석하다가 이게 될까?라는 수많은 의혹심에 여러번 휩싸이는 것 같습니다.. 역시 여러 다방면으로 접근할 수 있다는 것은 그만큼 내공이 쌓인 고수가 아닐까요..? 좋은 문제 보고 갑니다.

이 풀이는 사실 n-Queen을 1차원 배열로 푸는 것에 영감을 받았습니다. 풀어보셨다면 아마 참고가 될 것이고, 안해보셨다면 n-Queen 1차원 배열로 풀어보시는걸 추천드립니다 :)

[seongwon030]

같은 색 칸으로만 움직일 수 있는 비숍의 특징을 잘 잡으신 것 같아요. 백트래킹에 대해 감을 못 잡고 있었는데 문제보고 리뷰하는 것만으로 슬슬 감이 잡히는 것 같아요. pr 잘 보고 갑니다 !

[dhlee777]

체스판을 기울여서 대각선별로 비숍의 위치를 체크하는 방법이 정말 참신한 접근인 것 같습니다.그리고 백트래킹 도중 최댓값 갱신 가능성이 없으면 탐색을 그만두면서 탐색시간을 아낄수 있다고 느꼈습니다. 잘 배워갑니다..!