12-mjj111

[mjj111]

🔗 문제 링크

치킨 배달

✔️ 소요된 시간

20분

✨ 수도 코드

해당 문제는 주어진 그래프에서 각 치킨집과 집간의 사이거리가 가장 적은 경우에 대한 거리를 반환을 요구합니다.
더불어 최대 M 값에 대한 치킨 집을 여는 것을 허용합니다.

이 문제를 풀기 위해서는 주어진 치킨 집중 M개를 택하여,
택함을 받은 치킨집과 각 집간의 거리를 계산하여 가장 적은 값을 반환해야합니다.

주어진 치킨 집에서 M개의 치킨집을 택하기 위해서 백트레킹을 사용합니다.

    public static void DFS(int start, int cnt) {
        if(cnt != M) {
            for (int i = start; i < chicken.size(); i++) {
                open[i] = true;
                DFS(i + 1, cnt + 1);
                open[i] = false;
            }
            return;
        }

만약 M개를 모두 택했을 경우,
열린 치킨집과 각 집의 거리를 계산하여 정답을 갱신합니다.

        int res = 0;
        for (int i = 0; i < person.size(); i++) {
            int minimum = Integer.MAX_VALUE;

            for (int j = 0; j < chicken.size(); j++) {
                if (open[j]) {
                    int distance = getDistance(i, j);
                    minimum = Math.min(minimum, distance);
                }
            }

            res += minimum;
        }
        answer = Math.min(answer, res);

📚 새롭게 알게된 내용

백트레킹으로 M개의 치킨집을 택하고,
그래프탐색으로 또 거리를 계산해야할까 했더니 처음 받은 값에서 치킨집과 집을 저장하면 그럴 필요가 없더군요!
문제를 자세히 봐야겠습니다 ㅋㅋㅋ ㅎ

[9kyo-hwang]

오호 1년도 더 전에 풀었었던 문제네요 :)
백트래킹을 기반으로, 치킨집을 하나씩 폐업해보며 M개만 남겼을 때의 거리 합을 구해 그 중 최소를 구하는 문제죠 :p

집들의 위치, 치킨집들의 위치, 현재 폐업한 치킨집 인덱스 <- 3가지 리스트를 캐치했다면 무난하게 풀 수 있는 문제였네요!

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

enum class EMap
{
    Empty = 0,
    House = 1,
    Chicken = 2,
};

#define EMPTY static_cast<int>(EMap::Empty)
#define HOUSE static_cast<int>(EMap::House)
#define CHICKEN static_cast<int>(EMap::Chicken)

constexpr int INF = 987654321;

int N, M;
vector<vector<int>> City;
vector<pair<int, int>> Houses, Chickens;
vector<bool> Closed;

int Backtracking(int Level, int Remain)
{
    if(Remain == 0)
    {
        int TotalDistance = 0;
        for(const auto& [hr, hc] : Houses)
        {
            int MinimumDistance = INF;
            for(int l = 0; l < Chickens.size(); ++l)
            {
                if(Closed[l]) continue;
                
                const auto& [cr, cc] = Chickens[l];
                MinimumDistance = min(MinimumDistance, abs(hr - cr) + abs(hc - cc));
            }
            
            TotalDistance += MinimumDistance;
        }
        
        return TotalDistance;
    }
    
    int MinimumDistance = INF;
    for(int l = Level; l < Chickens.size(); ++l)
    {
        if(Closed[l]) continue;
        
        Closed[l] = true;
        MinimumDistance = min(MinimumDistance, Backtracking(l, Remain - 1));
        Closed[l] = false;
    }
    
    return MinimumDistance;
}

int main()
{
    cin >> N >> M;
    City.assign(N, vector(N, 0));
    
    for(int r = 0; r < N; ++r)
    {
        for(int c = 0; c < N; ++c)
        {
            cin >> City[r][c];
            if(City[r][c] == HOUSE)
            {
                Houses.emplace_back(r, c);
            }
            else if(City[r][c] == CHICKEN)
            {
                Chickens.emplace_back(r, c);
            }
        }
    }
    
    Closed.assign(Chickens.size(), false);
    
    cout << Backtracking(0, Chickens.size() - M);

    return 0;
}