4 mjj111

[mjj111]

🔗 문제 링크

프로그래머스 - 표편집
https://school.programmers.co.kr/learn/courses/30/lessons/81303

프로그래머스 - 양과늑대
https://school.programmers.co.kr/learn/courses/30/lessons/92343

✔️ 소요된 시간

표편집 1 시간 30분 (문제를 잘못 이해하고 접근했습니다 ㅠ)
양과 늑대 50분

✨ 간략한 코드 설명

프로그래머스 - 표편집
표편집 문제는 명령어에 따라 표를 갱신하는 것인데,
각 명령어에 따라 단순히 칸 이동만으로 문제를 해결할 수 있습니다.

        for (String c : cmd) {
            if (c.charAt(0) == 'U') {
                int value = Integer.parseInt(c.split(" ")[1]);
                now -= value;
                continue;
            }
            if (c.charAt(0) == 'D') {
                int value = Integer.parseInt(c.split(" ")[1]);
                now += value;
                continue;
            }
            if (c.charAt(0) == 'C') {
                cancels.push(now);
                totalRows--;
                if (now == totalRows) now--;
                continue;
            }
            if (c.charAt(0) == 'Z') {
                int cancelledRow = cancels.pop();
                if (cancelledRow <= now) now++;
                totalRows++;
            }
        }

각 명령어를 순회하며 처리합니다.

'U x': 현재 선택된 행을 x만큼 위로 이동 (now -= value).
'D x': 현재 선택된 행을 x만큼 아래로 이동 (now += value).
'C': 현재 선택된 행을 삭제하고, 스택에 저장. 행 개수를 줄임. 현재 선택된 행이 마지막 행이었다면 한 칸 위로 이동.
'Z': 마지막으로 삭제한 행을 복원. 삭제된 행이 현재 선택된 행보다 앞에 있으면 현재 선택된 행을 한 칸 아래로 이동. 행 개수를 늘림.

결과적으로,
StringBuilder를 사용하여 현재 상태를 나타내는 문자열을 생성합니다.
모든 남아있는 행에 대해 'O'를 추가하며 스택에서 삭제된 행의 인덱스를 꺼내 'X'를 해당 위치에 삽입합니다.

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < totalRows; i++) {
            sb.append("O");
        }
        
        while (!cancels.isEmpty()) {
            sb.insert(cancels.pop().intValue(), "X");
        }
        
        return sb.toString();
    }
}

---

프로그래머스 - 양과늑대
양과 늑대의 문제는 조건에 부합하여 가장 많은 양을 구하는 것인데,
DFS로 모든 경우의 수를 가져옵니다.

전형적인 DFS의 모습을 갖고 있어서.. 다들 아시겠지만..

private void dfs(int now, int sheepCnt, int wolfCnt, Set<Integer> nexts) {
dfs 메서드는 현재 노드(now), 현재까지의 양 수(sheepCnt), 늑대 수(wolfCnt), 그리고 다음에 탐색할 노드 목록(nexts)을 인자로 받습니다.

        if (info[now] == 0) sheepCnt++;
        else wolfCnt++;

        if (wolfCnt >= sheepCnt) return;
        maxSheepCnt = Math.max(sheepCnt, maxSheepCnt);

현재 노드가 양인지 늑대인지에 따라 sheepCnt 또는 wolfCnt를 증가시킵니다.
늑대 수가 양 수보다 많아지면 해당 경로 탐색을 중단합니다.
현재까지의 최대 양 수를 업데이트합니다.

        // 다음 탐색 위치 복사 
        Set<Integer> copySet = new HashSet<>(nexts);
        
        // 다음 탐색 목록중 현재 위치제외
        copySet.remove(now);
        
        for(int[] edge : edges) {
            int start = edge[0];
            int end = edge[1];
            if(start == now) copySet.add(end);
        }

현재 탐색 위치를 제외한 다음 탐색 위치를 복사합니다.
현재 노드와 연결된 자식 노드를 copySet에 추가합니다.

        for (int next : copySet) {
            dfs(next, sheepCnt, wolfCnt, copySet);
        }
    }
}

copySet에 있는 각 노드에 대해 재귀적으로 dfs를 호출하여 탐색을 계속합니다.

• 처음에는 그리디로 할까.. 다른 방법이 있지않을까... 고민하다가 시간을 좀 썼고,
  이후에는 다음 탐색 위치 복사 부분에서 헷갈려서 계속 틀렸었습니다 ㅎ

📚 새롭게 알게된 내용

문제를 너무 어렵게 해석하려 했던 것 같습니다.
문제 그대로 접근하고, 이후에 최적화를 했어야 했는데.. 먼저 최적화된 방법을 모색하는 실수가 잦네요
위 두 문제에서 뼈저리게 다시 느꼈고 고쳐야겠습니다 ㅠ

[9kyo-hwang]

1. 양과 늑대

트리 순회인데, 방문했던 지점을 "다시 방문"해야 하니까 Visited 리스트를 확장하는 아이디어까진 좋았는데...

늑대/양 카운팅은 1번만 일어나야 하니까, 방문했던 지점을 다시 방문할 땐 카운팅을 하지 않도록 하는 처리를 하는 과정에서 결국 못참고 블로그를 봐버렸네요...

제 경우엔

1. Visited 리스트를 [현재 노드][양 수][늑대 수] 3개를 동시에 확인하도록 3차원으로 만들었습니다.
2. 양/늑대 정보를 나타내는 Info 리스트에 "확인함"을 의미하는 '2' 값을 기록해, 백트래킹 과정에서 Info[node] == 2이면 카운팅 하지 않도록 했습니다.

전체 코드

#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

int solution(vector<int> Info, vector<vector<int>> Edges) 
{
    enum EInfo
    {
        Sheep = 0,
        Wolf = 1,
        Checked = 2
    };
    
    const int N = Info.size();

    vector<vector<int>> Tree(N);
    for(const auto& Edge : Edges)
    {
        Tree[Edge[0]].emplace_back(Edge[1]);
        Tree[Edge[1]].emplace_back(Edge[0]);
    }
    
    vector<vector<vector<bool>>> Visited(N, vector(N + 1, vector(N + 1, false)));
    Visited[0][1][0] = true;
    Info[0] = EInfo::Checked;
    
    int Answer = 0;
    function<void(int, int, int)> Backtracking = [&](int Src, int Sheep, int Wolf)
    {
        Answer = max(Answer, Sheep);
        for(int Dst : Tree[Src])
        {
            if(Info[Dst] == EInfo::Sheep && !Visited[Dst][Sheep + 1][Wolf])
            {
                Visited[Dst][Sheep + 1][Wolf] = true;
                Info[Dst] = EInfo::Checked;
                Backtracking(Dst, Sheep + 1, Wolf);
                Info[Dst] = EInfo::Sheep;
                Visited[Dst][Sheep + 1][Wolf] = false;
            }
            else if(Info[Dst] == EInfo::Wolf && Sheep > Wolf + 1 && !Visited[Dst][Sheep][Wolf + 1])
            {
                Visited[Dst][Sheep][Wolf + 1] = true;
                Info[Dst] = EInfo::Checked;
                Backtracking(Dst, Sheep, Wolf + 1);
                Info[Dst] = EInfo::Wolf;
                Visited[Dst][Sheep][Wolf + 1] = false;
            }
            else if(Info[Dst] == EInfo::Checked && !Visited[Dst][Sheep][Wolf])
            {
                Visited[Dst][Sheep][Wolf] = true;
                Backtracking(Dst, Sheep, Wolf);
                Visited[Dst][Sheep][Wolf] = false;
            }
        }
    }; Backtracking(0, 1, 0);
    
    return Answer;
}

2. 표 편집

생긴 게 뭔가 딱 연결 리스트 문제길래 C++의 "list" 라이브러리 써서 뚱땅뚱땅 코드 짰는데 냅다 시간 초과 나더라구요...?
뭐지... 하면서 질문 게시판 뒤져봤는데 리스트 쓰지 말고 vector(Java의 ArrayList)써라는 글이 있길래 바꿨는데 진짜로 되더라구요...?
뭔가뭔가한 일이었습니다...

전체 코드

#include <string>
#include <vector>

using namespace std;

struct FCell
{
    int Up, Index, Down;
    FCell(int InUp, int InIndex, int InDown) 
        : Up(InUp), Index(InIndex), Down(InDown)
        {

        }
};

string solution(int n, int k, vector<string> InCommand) {
    vector<FCell> Table;
    for(int i = 0; i <= n; ++i)
    {
        Table.emplace_back(i - 1, i, i + 1);
    }
    vector<FCell> PoppedCell;
    string Answer(n, 'O');
    
    auto CommandU = [&](int X)
    {
        while(X--)
        {
            k = Table[k].Up;
        }
    };
    
    auto CommandD = [&](int X)
    {
        while(X--)
        {
            k = Table[k].Down;
        }
    };
    
    auto CommandC = [&]()
    {
        PoppedCell.emplace_back(Table[k]);
        const auto& [Up, Index, Down] = Table[k];
        
        if(0 <= Up)
        {
            Table[Up].Down = Down;
        }
        if(Down < n)
        {
            Table[Down].Up = Up;
        }
        
        Answer[k] = 'X';
        
        k = (Down == n ? Up : Down);
    };
    
    auto CommandZ = [&]()
    {
        const auto& [Up, Index, Down] = PoppedCell.back();
        PoppedCell.pop_back();
        
        if(0 <= Up)
        {
            Table[Up].Down = Index;
        }
        if(Down < n)
        {
            Table[Down].Up = Index;
        }
        
        Answer[Index] = 'O';
    };
    
    for(const string& Command : InCommand)
    {
        switch(Command[0])
        {
            case 'U':
                CommandU(stoi(Command.substr(2)));
                break;
            case 'D':
                CommandD(stoi(Command.substr(2)));
                break;
            case 'C':
                CommandC();
                break;
            case 'Z':
                CommandZ();
                break;
            default: 
                break;
        }
    }
    
    return Answer;
}

아니 근데 우째 Stack 하나로 다 해결하셨대요...

---

양과 늑대 문제 관련해서 좀 검색해보니까, 원래 의도대로라면 "백트래킹을 이용한 완전 탐색은 시간 초과가 날 수 밖에 없다"라고 하네요.
다음과 같은 테스트 케이스가 존재한다면 무수히 많은 중복 케이스로 시간 초과가 난다고 합니다.

info = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
edges = [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6], [3, 7], [3, 8], [4, 9], [4, 10], [5, 11], [5, 12], [6, 13], [6, 14], [7, 15], [7, 16]]
Return = 17

질문은 아니지만,,, 원칙적으로 백트래킹(or 완전탐색)은 시간초과가 발생하는 잘못된 풀이입니다.

카카오 테스트케이스가 빈약해서 가능한 풀이라고 하네요...?
원칙대로면, 비트마스킹을 이용한 Flood Fill 알고리즘으로 풀어야 한다고 합니다.

정해 C++ 코드

#include <string>
#include <vector>
#include <functional>

using namespace std;

int solution(vector<int> Info, vector<vector<int>> Edges)
{
    const int N = Info.size();
    
    vector<bool> Visited(1 << N, false);
    vector<vector<int>> Graph(N);
    
    for(const auto& Edge : Edges)
    {
        Graph[Edge[0]].emplace_back(Edge[1]);
    }
    
    int Answer = 0;
    function<void(int)> DFS = [&](int Mask)
    {
        if(Visited[Mask]) return;
        
        Visited[Mask] = true;
        int Sheep = 0, Wolf = 0;
        for(int Node = 0; Node < N; ++Node)
        {
            if(Mask & (1 << Node))
            {
                Sheep += (Info[Node] == 0);
                Wolf += (Info[Node] == 1);
            }
        }
        
        if(Sheep <= Wolf) return;
        
        Answer = max(Answer, Sheep);
        for(int Parent = 0; Parent < N; ++Parent)
        {
            if(!(Mask & (1 << Parent))) continue;
            
            for(int Child : Graph[Parent])
            {
                DFS(Mask | (1 << Child));
            }
        }
    }; DFS(1);
    
    return Answer;
}

[xxubin04]

풀어보려고 노력했으나 너무 어려워서 못 풀었습니다...
저는 엄청 복잡한 문제라고 생각했었는데, 정말 간단하게 잘 푸셨네요👍🏻👍🏻
양과 늑대 문제에서 다시 방문하게 되는 노드는 어떻게 처리해야 할지 어려웠는데, 구현하신 코드를 한참 들여다봤네요😮
덕분에 많이 배워갑니다!!!