29-g0rnn

[g0rnn]

🔗 문제 링크

소문난 칠공주

✔️ 소요된 시간

1h

✨ 수도 코드

처음엔 골드3인 것 치고 쉬워서 빨리 풀고 다른 문제를 소개하려했습니다. 하지만 처음 접근이 너무나 잘못되다보니.. 시간을 많이 쓰게 되었고 또 그렇게 쉬운것 같지도 않아서 공유하게 되었습니다.

예전 테트리스 문제 기억하시나요? dfs로 5개의 테트리스 모형을 만들고 어쩌구 저쩌구 했던거.. 갑자기 이 문제를 보고 그 방법이 떠올랐습니다. dfs로 7개의 칸을 만들고 'S'의 개수가 4개 이상인지 체크했습니다. dfs로 인접한 칸을 접근했으니 당연히 연속하구요. 하지만 기본 테케도 통과 못했습니다... 기본 테스트 케이스의 힌트를 보니 아래의 경우가 있었는데 이건 dfs로는 절대로 만들 수 없는 모형이죠..^^; 이걸 납득하는데 시간이 좀 걸렸습니다.!

그렇다면 어떻게 풀어야할까요? 정답은 조합입니당 :)

아마 다들 접근은 조합일 거예요. 조합은 자주 만들었으니 넘어가고, 인접하면서 'S'가 4개 이상인지 확인해주면 됩니다.

저는 bfs로 내가 선택한 칸만 이동하면서 'S'가 4개 이상인지 확인했습니다. bfs로 하니까 연속적인건 당연하구요.

📚 새롭게 알게된 내용

제 풀이를 보면 select에 이상한 값을 넣고 있습니다. 이건 저번 리뷰하면서 썼던 방식인데 N * N 배열에 0부터 N*N - 1까지의 수를 채우고 배열의 값을 N으로 나누고 N으로 나머지를 구하면 행과 열의 index를 구할 수 있습니다.

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

[13] -> {3, 1}
13 / 4 = 3, 13 % 4 = 1 

실수하면 안되는건 0부터 시작해야합니다!!

[wnsmir]

5 by 5는 이미 정해진 사실이라 완전탐색의 방향으로 접근했습니다.

한칸에 대해 가능한 상하좌우의 모든 경우의수를 해보려고 했으나 잘못됐다는걸 깨달았습니다.

bfs를 결국 경우의수만큼 다 돌려봐야하기 때문입니다. 즉 반대로생각해보면

조합을 미리 만들어두고, bfs로 상하좌우로 이어져있는지 확인을 해주는 것입니다.

구현은 간단했습니다! 신선한 문제네요!!

from itertools import combinations
from collections import deque

board = [list(input().strip()) for _ in range(5)]
ans = 0
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

def is_connected(cands):
    q = deque([cands[0]])
    visited = set([cands[0]])
    cands_set = set(cands)
    while q:
        cur = q.popleft()
        x, y = cur // 5, cur % 5
        for d in range(4):
            nx, ny = x+dx[d], y+dy[d]
            if 0<=nx<5 and 0<=ny<5:
                nxt = nx*5+ny
                if nxt in cands_set and nxt not in visited:
                    visited.add(nxt)
                    q.append(nxt)
    return len(visited) == 7

for cands in combinations(range(25), 7):
    S_cnt = sum(1 for idx in cands if board[idx//5][idx%5]=='S')
    if S_cnt >= 4 and is_connected(cands):
        ans += 1

print(ans)

[kangrae-jo]

처음에 저도 균호님처럼 dfs 로 접근했습니다.
골드 3 문제를 20분만에?? 하면서 제출했는데...
틀렸습니다. 가 뜨더라구요.

균호님 말대로 테케에서 주어진 답 2개도 dfs로는 만들 수 없는 형태더군요.
그래서 저도 bfs로 25개중 7개를 뽑고, 그 7개 자리가 연결되었는지, 그리고 이다솜씨의 파가 4인 이상 인지를 검사했습니다.

조합은 저희가 워낙 많이해서 빠르게 했지만, 조건검사가 생각보다 까다롭더군요.

간단히 하고 싶은 마음에 visited나 selected 검사도 하지 않고 그냥 dir을 통해 이동한 y_, x_가 candi에 있으면 연결되었다고 판단했어요.
근데 이 방식은 두명 두명 세명 이렇게 떨어져있는 경우에도 true를 반환하는 오류가 있었습니다.

그래서 저도 균호님이랑 거의 같은 방식으로 구현을 한 것 같아요.
장보고갑니다.

#include <iostream>
#include <queue>
#include <string>
#include <vector>

using namespace std;

const int N = 5;
const int M = 5;
const int OFFSET[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

vector<string> board(N);

bool isVaild(vector<int>& candi) {
    vector<bool> visited(7, false);
    queue<int> q;
    q.push(0); 
    visited[0] = true;

    int Y = 0, cnt = 0;
    while (!q.empty() && ++cnt) {
        int now = q.front(); 
        q.pop();

        int y = candi[now] / N;
        int x = candi[now] % M;

        if (board[y][x] == 'Y') Y++;

        for (int dir = 0; dir < 4; dir++) {
            int y_ = y + OFFSET[dir][0];
            int x_ = x + OFFSET[dir][1];
            for (int i = 0; i < 7; i++) {
                if (!visited[i] && y_ == candi[i] / N && x_ == candi[i] % M) {
                    visited[i] = true;
                    q.push(i);
                }
            }
        }
    }
    return cnt == 7 && Y < 4;
}

int comb(vector<int>& candi, int k) {
    if (candi.size() == 7) {
        if (isVaild(candi)) return 1;
        return 0;
    }

    int cnt = 0;
    for (int index = k; index < N * M; index++) {
        candi.push_back(index);
        cnt += comb(candi, index + 1);
        candi.pop_back();
    }
    return cnt;
}

int main() {
    for (int y = 0; y < N; y++) {
        cin >> board[y];
    }

    vector<int> candi;
    cout << comb(candi, 0) << '\n';

    return 0;
}

[9kyo-hwang]

대충 보고 "음 백트래킹 딸깍하면 되겠네"하고 두다다다 10분 코드 짜고 제출했는데 11% 철퇴 ㅋㅋ 저만 그런 게 아니여서 안도...

다시 문제 예시를 보니까,

.....
SYSYS
.Y...
.S...
.....

이 경우는 백트래킹으로 만들어질 수 없는 모양이더군요. 왜 테트리스 조각 얘기 하셨는지 딱 깨달았습니다.

재귀 탐색을 하면서 조건에 맞는 크기가 7인 연결 요소를 만드는 게 아니라, 거꾸로 가능한 연결 요소를 다 훑어본 뒤 조건에 부합하는 경우의 수를 카운팅하는 식으로 접근했습니다.

원래는 next_permutation을 써서 코드를 금방 짰는데 시간이 너무 오래 걸려서 짱구를 더 굴려봤습니다. 최초에 한 번 각 칸마다 "인접한 칸" 정보를 미리 캐싱하면 되겠더라구요. 그래서 인접칸 검사 부분이 간결해졌네요 ㅎ

#include <bits/stdc++.h>

using namespace std;

array<char, 25> board;
vector<int> adj[25];
array<bool, 25> selected;

bool IsConnectedComponent() {
    queue<int> q;
    array<bool, 25> visited = {false, };
    
    for(int i = 0; i < 25; ++i) {
        if(selected[i]) {
            q.emplace(i);
            visited[i] = true;
            break;
        }
    }
    
    int count = 1;
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        
        for(int v : adj[u]) {
            if(selected[v] && !visited[v]) {
                visited[v] = true;
                q.emplace(v);
                ++count;
            }
        }
    }
    
    // 과반임은 Combination 함수에서 여기로 들어올 때 이미 보장된 상태. 따라서 7개 칸이 연결됐는지만 확인
    return count == 7;
}

int Combination(int index = 0, int student = 0, int dasom = 0) {
    if(dasom + (7 - student) < 4) {  // 남은 모든 학생이 이다솜 파가 되어도 과반이 안되는 경우
        return 0;
    }
    
    if(student == 7) {
        return IsConnectedComponent();
    }
    
    int ans = 0;
    for(int i = index; i < 25; ++i) {
        selected[i] = true;
        ans += Combination(i + 1, student + 1, dasom + (board[i] == 'S'));
        selected[i] = false;
    }
    
    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    for(int i = 0; i < 5; ++i) {
        string row; cin >> row;
        for(int j = 0; j < 5; ++j) {
            board[i * 5 + j] = row[j];
        }
    }
    
    for (int i = 0; i < 25; i++) {
        int r = i / 5, c = i % 5;
        
        // 상하좌우 인접한 칸
        if (r > 0) adj[i].emplace_back(i-5);
        if (r < 4) adj[i].emplace_back(i+5);
        if (c > 0) adj[i].emplace_back(i-1);
        if (c < 4) adj[i].emplace_back(i+1);
    }
    
    cout << Combination();

    return 0;
}

[kokeunho]

스포 당해서 조합한 후에 bfs로 푸는 것을 알아버렸습니다.

만약 몰랐더라면 저도 dfs로 시도해보다 실패했을 것 같습니다.
입출력 예시의 경로를 dfs로 찾을 수 없다는 것을 생각하지 못하고 있었기 때문입니다.

조합으로 우선 7명을 고르고
bfs 시작 지점(가장 첫번째 selected 지점)을 찾은 뒤
해당 지점에서 bfs를 호출하여 selected 된 지점들 경로로 확인하면서
경로가 총 7칸인지, 이다솜파가 4명 이상인지 체크하였습니다.

수고하셨습니다~

Details

import java.util.*;

public class Main {
    static char[][] map = new char[5][5];
    static boolean[][] selected = new boolean[5][5];
    static boolean[][] visited = new boolean[5][5];
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};
    static int totalCount = 0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < 5; i++) {
            String line = sc.nextLine();
            for (int j = 0; j < 5; j++) {
                map[i][j] = line.charAt(j);
            }
        }
        sevenPrincesses(0, 0, 0);

        System.out.print(totalCount);
    }
    static void sevenPrincesses(int row, int col, int count) {
        if (row == 5 || count == 7) {
            if (count == 7) startBfs();
            return;
        }
        int newCol = (col + 1) % 5;
        int newRow = row;
        if (newCol == 0) newRow++;

        selected[row][col] = true;
        sevenPrincesses(newRow, newCol, count+1);
        selected[row][col] = false;
        sevenPrincesses(newRow, newCol, count);
    }
    static void startBfs() {
        for (int i = 0; i < 5; i++) {
            Arrays.fill(visited[i], false);
        }
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if(selected[i][j]) {
                    bfs(i, j);
                    return;
                }
            }
        }
    }
    static void bfs(int x, int y) {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{x, y});
        visited[x][y] = true;
        int sCount = 0, yCount = 0;

        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int cx = current[0], cy = current[1];
            if (map[cx][cy] == 'S') {
                sCount++;
            } else yCount++;

            for (int i = 0; i < 4; i++) {
                int nx = cx + dx[i];
                int ny = cy + dy[i];
                if (nx >= 0 && nx < 5 && ny >= 0 && ny < 5
                        && !visited[nx][ny] && selected[nx][ny]) {
                    visited[nx][ny] = true;
                    queue.add(new int[]{nx, ny});
                }
            }
        }
        if (sCount+yCount==7 && sCount >= 4) totalCount++;
    }
}