컴영의 기록지

[프로그래머스] 스티커 모으기(2)

컴영 — Fri, 2 Oct 2020 17:56:27 +0900

스티커 모으기(2)

문제) https://programmers.co.kr/learn/courses/30/lessons/12971

풀이)

dp를 이용해서 풀어야 하는 문제다

점화식

dp[i] = i번째 스티커를 뗄 경우, 지금까지 얻을 수 있었던 점수의 최대값

dp[i] = max(dp[i-2] + sticker[i], dp[i-1])

//i번째 스티커를 뗄 경우, i-2번째 스티커를 뜯어낸 후 합쳐왔던 점수에 i번째 스티커 점수 합침

i번째 스티커를 떼지 않을 경우, i-1번째 스티커를 뜯어낸 후 합쳐왔던 점수 가져옴

* 주의점 *

원형으로 연결되어 있기에, 첫번째 스티커를 뜯어낼 경우 마지막 스티커를 뜯지 못한다.

이를 위해 첫번째 스티커를 뜯었을 경우와 아닐 경우를 나눠서 계산해본다.

코드)

include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int result = 0;

int solution(vector<int> sticker)
{
    int answer = 0;

    if(sticker.size()== 1) return sticker[0];
    else if(sticker.size()==2) return max(sticker[0],sticker[1]);
    vector<int> dp(sticker.size(),0);

    //0번째 스티커 제거 -> 마지막 스티커 제거 못함
    dp[0] = sticker[0];
    dp[1] = sticker[0]; //0번째 제거 시 1번째는 제거 못함
    for(int i = 2; i < sticker.size()-1; i++){
        dp[i] = max(dp[i-2] + sticker[i] , dp[i-1]);//i번째 스티커를 제거할 경우, 제거하지 않을 경우
    }

    answer = dp[sticker.size() - 2];

    dp.resize(sticker.size()); //dp 배열 재사용

    //0번째 스티커 제거 안함 -> 마지막 스티커 제거 가능
    dp[0] = 0;
    dp[1] = sticker[1];
    for(int i = 2; i < sticker.size(); i++){
        dp[i] = max(dp[i-2] + sticker[i], dp[i-1]);
    }

    answer = max(answer, dp[sticker.size()-1]);

    return answer;
}

[프로그래머스] JadenCase 문자열 만들기

컴영 — Thu, 1 Oct 2020 16:47:20 +0900

JadenCase 문자열 만들기

문제) https://programmers.co.kr/learn/courses/30/lessons/12951

풀이)

A의 아스키 코드가 65, a의 아스키 코드가 97 임을 이용해서 소문자↔대문자를 바꿔줬는데

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <string>
#include <vector>
 
using namespace std;
 
string solution(string s) {
    string answer = "";
    
    //A 65 a 97
    if(s[0] >= 'a' && s[0] <= 'z'){
        answer += s[0] - 32;
    }
    else answer += s[0];
    
    for(int i=1;i<s.length();i++){
        if(s[i-1] == ' '){//공백다음 문자 -> 소문자일 경우 대문자로
            if(s[i] >= 'a' && s[i] <= 'z'){
                answer += s[i] - 32;
            }
            else answer += s[i];
        }
        else{//문자 내의 대문자일 경우 소문자로
            if(s[i] >= 'A' && s[i] <= 'Z'){
                answer += s[i] + 32;
            }
            else answer += s[i];
        } 
    }
    
    return answer;
}
Colored by Color Scripter
cs

tolower(), toupper()함수를 이용하면 더 쉽게 코드를 작성할 수 있었다.

#include <ctype.h>

int tolower(int C) // 대문자 C를 소문자로 바꿔준다.

int toupper(int c) //소문자 c를 대문자로 바꿔준다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <string>
#include <vector>
 
using namespace std;
 
string solution(string s) {
    string answer = "";
    
    answer += toupper(s[0]);
    
    for(int i=1;i<s.length();i++){
        if(s[i-1] == ' '){
            answer += toupper(s[i]);
        }
        else{
            answer += tolower(s[i]);
        } 
    }
    
    return answer;
}
Colored by Color Scripter
cs

[프로그래머스] 쿠키 구입

컴영 — Wed, 30 Sep 2020 17:37:32 +0900

쿠키구입

문제) https://programmers.co.kr/learn/courses/30/lessons/49995

풀이)

투포인터를 이용해서 푼 문제이다.

과정

1. for문을 통해 인덱스 0 ~ cookie.size() - 2 까지 차례로 시작 인덱스 start 로 정한다.

1.1. 시작인덱스 start + 1 을 마지막 인덱스 end 로 둔다.

1.2. (0 ~ 시작 인덱스 start) / (마지막 인덱스 end ~ cookie.size() - 1) 범위로 나눠

start와 end 두 인덱스 포인터를 이동시키며 두 쿠기 구간의 합을 비교한다.

*start 포인터는 왼쪽으로 이동, end 포인터는 오른쪽으로 이동한다.

*오른쪽 구간의 합이 크면, 왼쪽 구간을 늘린다 = start 포인터를 한칸 왼쪽으로 이동

*왼쪽 구간의 합이 크면, 오른쪽 구간을 늘린다 = end 포인터를 한칸 오른쪽으로 이동

코드)

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> cookie) {
    int answer = 0;
   for(int i=0;i<cookie.size()-1;i++){
       int start = i;
       int start_sum = cookie[start];
       int end = i+1;
       int end_sum = cookie[end];
       while(true){
           if(start_sum == end_sum && start_sum > answer){
               answer = start_sum;
           }
           else if(start_sum < end_sum && start > 0){
               start_sum += cookie[--start];
           }
           else if(start_sum >= end_sum && end < cookie.size() -1){
               end_sum += cookie[++end];
           }
           else break;
       }
   }
    return answer;
}

[프로그래머스] 캠핑

컴영 — Tue, 29 Sep 2020 14:57:20 +0900

캠핑

문제)

https://programmers.co.kr/learn/courses/30/lessons/1833#

풀이)

처음에 서로 대각선에 위치해 있는 쐐기들만 골라서 텐트를 쳐야하는지 착각해서 헤맸던 문제이다.

과정

1. 쐐기의 좌표들을 오름차순으로 정렬해준다.

2. 각 쐐기마다 다른 쐐기들과 비교하여 텐트를 칠 수 있는지 확인해준다.

=> 삼중포문을 이용해서 풀어줬다.

for(int i=0; i<data.size(); i++) //기준 쐐기 위치 {y,x}

for(int j=i+1; j<data.size(); j++) //비교할 쐐기 위치 {ty,tx}

for(int k=i+1; k<j; k++) //기준쐐기와 비교할 쐐기 사이에 존재하는 쐐기 위치 {ky,kx}

만약 중간에 존재하는 쐐기{ky,kx}가 기준쐐기와 비교할 쐐기가 이루는 직사각형 범위 내에 존재하면

기준 쐐기 {y,x}와 비교할 쐐기{ty,tx}는 쌍을 이루지 못한다.

코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
 
// 전역 변수를 정의할 경우 함수 내에 초기화 코드를 꼭 작성해주세요.
int solution(int n, vector<vector<int>> data) {
    int answer = 0;
    sort(data.begin(),data.end());
    for(int i=0;i<data.size();i++){
        int y = data[i][0];
        int x = data[i][1];
        //cout << "******확인 좌표 :" << y << " ," <<x << endl;
        for(int j=i+1;j<data.size();j++){
            int ty = data[j][0];
            int tx = data[j][1];
            if(ty == y || tx == x) continue;//같은 라인에 있으면 직사각형의 넓이 0
            //cout << " -" << ty << ", " << tx << endl;
             
            bool suc = true;
            
            for (int k = i + 1; k < j; k++){//{y,x} 와 {ty,tx}사이에 있으면서 같은 영역내에 있는가
                int ky = data[k][0];
                int kx = data[k][1];
               
                if ((y < ky && ky < ty)){
                    if(min(x,tx) < kx && kx < max(x,tx)) {
                        suc = false;
                        break;
                    }
                 }
            }
           
            if(suc) {
                //cout << "성공" << endl;
                answer++;
            }
        }
    }
    return answer;
}
Colored by Color Scripter
cs

[프로그래머스] 보석 쇼핑

컴영 — Mon, 28 Sep 2020 15:22:42 +0900

보석 쇼핑

풀이)

처음에는

인덱스 0부터 ~ 모든 보석을 포함하는 마지막 인덱스를 찾고, 그 안에서 구간을 줄여나가면서 풀었더니

틀렸던 문제다.

예외 존재) ["DIA","EM","EM","RUB","DIA"] 일경우

answer = [3, 5]

output = [1, 4] 가 나옴

그렇다고 2중 포문을 사용해서 구간을 찾기에는 보석 배열이 100,000 크기까지 될 수 있으므로 시간초과가 생긴다.

=> 투포인터 방법을 사용해서 풀어야 하는 문제이다.

unordered_map, 투 포인터 사용 풀이법

1. 먼저 보석의 총 개수를 unordered_map을 이용해서 구한다.

2. left, right 두 개의 인덱스 포인터를 이용해서 가장 짧은 구간을 찾는다.

-> left와 right 인덱스를 조건을 생각하며 한칸씩 이동시켜 모든 보석을 포함하는 구간을 찾는다.

(구간 내에 모든 보석이 포함되있는지는 unordered_map을 이용해서 판단한다.

unordered_map 사이즈가 보석의 총 개수와 같다면, 그 구간내에 모든 보석이 포함되어 있다는 뜻이다.)

코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <string>
#include <vector>
#include <unordered_map>
#include <iostream>
using namespace std;
 
vector<int> solution(vector<string> gems) {
    vector<int> answer;
    
    unordered_map <string,int> juwel;//맨 처음에는 보석 종류구하는 용도
                                    // 두번째에는 구간내에 보석 종류 빈도 구하는 용도
    int kind = 0;//보석 종류
    for(int i=0;i<gems.size();i++){
        if(juwel.find(gems[i])== juwel.end()){
            juwel[gems[i]] = 1;
            kind++;
        }
    }
   // cout << kind << endl;
    if(kind == 1){//보석이 한 종류뿐일때
         answer.push_back(1);
        answer.push_back(1);
        return answer;
    }
    else if(kind == gems.size()){//각각 모두 다른 보석일때
        answer.push_back(1);
        answer.push_back(gems.size());
        return answer;
    }
    
    juwel.clear();
    int left = 0 , right = 0;
    int result = 987654321;//나올 수 없는 구간 거리
    answer.push_back(0);
    answer.push_back(0);
    while(1){
         //cout << left << ", " << right << endl;
        if(juwel.size() >= kind){//보석이 모든 종류가 포함되어 있을 때
            juwel[gems[left]]--; //맨 왼쪽 인덱스의 보석 하나 제외
            if(juwel[gems[left]] == 0){
                //cout << gems[left] << "삭제 "<< endl;
                juwel.erase(gems[left]);
            }
            left++;
        }
        else if(right == gems.size()) break;
        else{
            juwel[gems[right]]++;//맨 오른쪽 인덱스 보석 포함
            right++;
        }
        if(juwel.size() == kind){
            int per = abs(right - left);
            if(result > per){
                result = per;
                answer[0] = left+1;
                answer[1] = right;
            }
        }
       
        
    }
    
    return answer;
}
Colored by Color Scripter
cs

[프로그래머스] 수식 최대화

컴영 — Sat, 26 Sep 2020 18:42:05 +0900

수식 최대화

문제)

https://programmers.co.kr/learn/courses/30/lessons/67257

풀이)

next_permutation으로 연산자의 우선순위를 바꿔주면서 푼 문제이다.

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

bool cardi[3];// + - *
long long solution(string expression) {
    long long answer = 0;
    vector <long long> number;
    vector <int> oper;
    string s;
    for (int i = 0; i < expression.length(); i++) {
        char ch = expression[i];
        if (ch == '+') {
            cardi[0] = true;
            oper.push_back(0);
            number.push_back(stoi(s));
            s = "";
        }
        else if (ch == '-') {
            cardi[1] = true;
            oper.push_back(1);
            number.push_back(stoi(s));
            s = "";
        }
        else if (ch == '*') {
            cardi[2] = true;
            oper.push_back(2);
            number.push_back(stoi(s));
            s = "";
        }
        else s += ch;
    }
    number.push_back(stoi(s));
    vector <int> priority;
    for (int i = 0; i < 3; i++) {
        if (cardi[i]) {
            priority.push_back(i);
        }
    }
    do {
        vector <long long> t_number = number;
        vector <int> t_oper = oper;
        long long temp;
        for (int i = 0; i < priority.size(); i++) {
            int o = priority[i];
            for (int j = 0; j < t_oper.size(); j++) {

                if (t_oper[j] == o) {

                    if (o == 0) {//+
                        t_number[j] = t_number[j] + t_number[j + 1];
                    }
                    else if (o == 1) {//-
                        t_number[j] = t_number[j] - t_number[j + 1];
                    }
                    else {//*
                        t_number[j] = t_number[j] * t_number[j + 1];
                    }
 t_number.erase(t_number.begin() + j + 1);
                    t_oper.erase(t_oper.begin() + j--);//j 줄여줌. 연산자 개수 하나줄었으므로
                }
            }

        }
        if (t_number[0] < 0) t_number[0] *= -1;
        if (answer < t_number[0]) answer = t_number[0];
    } while (next_permutation(priority.begin(), priority.end()));
    return answer;
}

+ 숫자와 연산자 저장할 때 substr을 이용한 간단한 방법

    int idx = 0;
    for(int i=0;i<expression.length();i++){
        char ch = expression[i];
        if(ch == '*' | ch == '+' | ch == '-'){
            oper.push_back(ch);
            number.push_back(stoi(expression.substr(idx,i-idx)));
            idx = i+1;
        }else if(i == expression.size()-1){
            number.push_back(stoi(expression.substr(idx,i-idx+1)));
        }
    }

+ next_permutation을 사용하지 말고 그냥 연산자 우선순위를 따로 저장해서 사용하는 방법(연산자 3개를 default로 둔다)

 string prior[6] = {
        "*+-", "*-+",
        "+*-", "+-*", 
        "-*+", "-+*",
    };

[프로그래머스] 경주로 건설

컴영 — Fri, 25 Sep 2020 18:01:02 +0900

경주로 건설

문제) https://programmers.co.kr/learn/courses/30/lessons/67259

풀이)

헤매다가 질문글을 보고 오류를 찾은 문제이다.

참고 질문글) https://programmers.co.kr/questions/12180

PQ와 DP를 이용하고, 새로운 비용이 작거나 같을 경우만 무조건 업데이트 시키면서 이동가능하게 했었는데

이동 방향에 따라 비용의 대소가 역전되는 경우가 있었다.

그래서 DP를 이용할 때 방향까지 저장해서 풀었다.

int dp[i][j][k] = (i,j)위치에 k방향으로 도달했을 때까지 든 최소 비용

과정

1. 비용을 Memoization할 배열을 모두 나올 수 없는 최대 비용으로 초기화.( INF = 987654321 )

2. 처음 출발할 칸 즉, (0,0)위치의 배열 값은 0으로 초기화.

3. PQ를 이용해서 비용을 갱신하며 이동.

* 코너 판단은 따로 bool 함수를 선언해서 해줬다.

방향이 상 0 하 1 인데 이동할 방향이 좌 2 , 우 3 이면 코너를 만들었다고 판단.

4. (n-1, n-1)위치의 배열 값 중 최소값을 answer에 저장하여 return.

코드)

#include <string>
#include <vector>
#include <queue>
using namespace std;
#define INF 987654321
int dp[25][25][4];
int n;
int dy[4] = {-1,1,0,0};
int dx[4] = {0,0,-1,1};

bool curve(int d1,int d2){
    if(d1 == 0 || d1 == 1){//상하
        if(d2 == 2 || d2 == 3) return true;
    }
    else{
        if(d2 == 0 || d2 == 1) return true;
    }
    return false;
}
struct Info {
    int y, x, dir, cost;
    Info() {}
    Info(int y, int x, int dir,int cost) {
        this->y = y;
        this->x = x;
        this->dir = dir;
        this->cost = cost;
    }

};
struct cmp {
    bool operator()(const Info &a,const Info &b) {
        if (a.cost == b.cost) {
            return a.y > b.y;
        }
        return a.cost > b.cost;
    }
};
int solution(vector<vector<int>> board) {
    int answer = INF;
    n = board.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for(int k=0; k<4; k++) dp[i][j][k] = INF;
        }
    }
    for (int k = 0; k < 4; k++) dp[0][0][k] = 0;

    priority_queue <Info,vector<Info>,cmp> qu;

    for (int i = 0; i < 4; i++) {
        qu.push({0,0,i,0});
    }
    while (!qu.empty()) {
        int y = qu.top().y;
        int x = qu.top().x;
        int dir = qu.top().dir;
        int cost = qu.top().cost + 100;
        qu.pop();

        for (int i = 0; i < 4; i++) {
            int ny = y + dy[i];
            int nx = x + dx[i];
            int next_cost = cost;

            if (ny < 0 || ny >= n || nx < 0 || nx >= n || board[ny][nx] == 1) continue;
            if (curve(dir, i)) {
                next_cost += 500;
            }
            if (dp[ny][nx][i] >  next_cost) {
                dp[ny][nx][i] = next_cost;
                qu.push({ ny,nx,i,next_cost });
            }
        }

    }
    for (int k = 0; k < 4; k++) {
        if(answer > dp[n-1][n-1][k]) answer = dp[n-1][n-1][k];
    }

    return answer;
}

[프로그래머스] 동굴 탐험

컴영 — Thu, 24 Sep 2020 15:46:40 +0900

동굴 탐험

문제) https://programmers.co.kr/learn/courses/30/lessons/67260

풀이)

처음에

dfs(방 탐색시 이용), before[]배열(이전에 꼭 방문해야하는 방 번호 저장), parent[]배열(트리 상에서 자식보다 먼저 방문해야하는 방 번호 저장) 을 이용해서 풀어보았지만 효율성면에서 떨어져서 다르게 풀어야했다.

효율성을 통과하지 못한 코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <string>
#include <vector>
#include <queue>
#include <string.h>
#include <iostream>
using namespace std;
vector <int> adj[200001];
int before[200001];
bool visited[200001];
int parent[200001];
int cnt = 0;
 
void get_parent(int here) { //트리상에서 부모번호를 저장하는 함수
 
    for (int i = 0; i < adj[here].size(); i++) {
        int next = adj[here][i];
        if (parent[next] == -1) {
            parent[next] = here;
            get_parent(next);
        }
    }
}
void dfs(int here) { //다음 정점을 방문처리하는 함수 
    visited[here] = true;;
    cnt++;
    for (int i = 0; i < adj[here].size(); i++) {
        int next = adj[here][i];
        if (visited[next] || !visited[before[next]]) continue;
        dfs(next);
 
    }
}
bool solution(int n, vector<vector<int>> path, vector<vector<int>> order) {
    bool answer = true;
    int a, b;
    for (int i = 0; i < path.size(); i++) {
        a = path[i][0];
        b = path[i][1];
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    for (int i = 0; i < order.size(); i++) {
        a = order[i][0];
        b = order[i][1];
        before[b] = a;
    }
   if(before[0] != 0) return false;
    memset(parent, -1, sizeof(parent));
    parent[0] = 0;
    get_parent(0);
    dfs(0);
    int result_cnt = cnt;
    while (true) {
        cnt = 0;
        for (int i = 0; i < n; i++) {
            if (!visited[i] && visited[before[i]] && visited[parent[i]]) {
                dfs(i);
            }
        }
        if (cnt == 0) break;
        result_cnt += cnt;
    }
    if (result_cnt == n) answer = true;
    else answer = false;
 
    return answer;
}
Colored by Color Scripter
cs

그래서 bfs 방법을 사용하고 before[]배열과 after[]배열(다음에 방문해야하는 방 번호)을 사용해줬다.

효율성 통과한 코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <string>
#include <vector>
#include <queue>
#include <string.h>
#include <iostream>
using namespace std;
vector <int> adj[200001];
int before[200001];
bool visited[200001];
int after[200001];
 
bool solution(int n, vector<vector<int>> path, vector<vector<int>> order) {
    bool answer = true;
    int a,b;
    for(int i=0;i<path.size();i++){
        a = path[i][0];
        b = path[i][1];
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    for(int i=0;i<order.size();i++){
        a = order[i][0];
        b = order[i][1];
        before[b] = a;
    }
    if(before[0] != 0) return false;
 
    queue<int> qu;
    visited[0] = true;
     for(int i=0;i<adj[0].size();i++){
            qu.push(adj[0][i]);
     }
 
    while(!qu.empty()){
        int here = qu.front();
        qu.pop();
        if(visited[here]) continue;
        if(!visited[before[here]]){//이전에 들려어야하는 곳을 아직 방문 안했다면
            after[before[here]] = here;
            continue;
        }   
        //cout << here << "-> ";
        visited[here] = true;
        for(int i=0;i<adj[here].size();i++){
            int next = adj[here][i];
            qu.push(next);
        }
        qu.push(after[here]);
    }
    for(int i=0;i<n;i++){
        if(!visited[i]){
            answer = false;
            break;
        }
    }
 
    return answer;
}
Colored by Color Scripter
cs

참고사항

자꾸 테스트케이스 30번 틀리는 경우!

-> 동굴을 들어가는 입구는 0번 방과 연결되어 있어서, 시작은 무조건 0번 방부터 해야하나

order배열 중에 0번 방으로 입장 전에 다른 방 번호를 먼저 방문해야한다는 케이스가 들어있을 수 있다.

이때는 바로 false를 return 해주도록 한다.

[프로그래머스] 단어 퍼즐

컴영 — Wed, 23 Sep 2020 17:25:46 +0900

단어 퍼즐

문제) https://programmers.co.kr/learn/courses/30/lessons/12983

풀이)

처음에 BFS를 이용해서 풀었으나 효율성을 통과하지 못했다.

효율성 통과 x 코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
 
bool cmp(const string &a, const string &b) {
    return a.length() > b.length();
}
 
int solution(vector<string> strs, string t)
{
    int answer = 0;
    sort(strs.begin(), strs.end(), cmp);
    queue <string> qu;
    vector <bool> check(t.length(), false);
    int cnt = 0;
    qu.push("");
    while (!qu.empty()) {
        int size = qu.size();
        while (size--)
        {
            string compare = qu.front();
            qu.pop();
            if (compare == t) return cnt;
 
            for (int i = 0; i < strs.size(); i++) {
                string next = compare + strs[i];
                if (check[next.length()])continue;
                if (next.length() <= t.length() && t.substr(0, next.length()) == next) {
                    check[next.length()] = true;
                    qu.push(next);
                }
            }
 
        }
 
        cnt++;
    }
 
    return -1;
}
Colored by Color Scripter
cs

그래서 다른 분의 글을 참고해서 재귀적 dp로 풀었다.(최단 비용 도로 개수 구하는 방법처럼)

효율성 통과 o 코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
#define INF 987654321
 
vector <int> dp;
bool cmp(const string &a, const string &b) {
    return a.length() > b.length();
}
int dfs(vector <string> &strs, string &t, int len) {
    if (len == t.length()) return 0;
    if (dp[len] != -1) return dp[len]; //이전에 계산한 값이 존재
 
    dp[len] = INF;
    for (int i = 0; i < strs.size(); i++) {
        if (strs[i].length() + len <= t.length()) {
            bool flag = true;
            for(int j = 0; j < strs[i].size(); j++) {
                if(t[len + j] != strs[i][j]) {
                    flag = false;
                    break;
                }
            }
            if(flag) {  
                dp[len] = min(dp[len], dfs(strs, t, strs[i].length() + len) + 1);
            }
        }
 
    }
    return dp[len];
}
 
int solution(vector<string> strs, string t)
{
    int answer = 0;
    sort(strs.begin(), strs.end(), cmp);
 
    dp.assign(t.length(), -1);
 
    return dfs(strs, t, 0) == INF ? -1 : dp[0];
}
Colored by Color Scripter
cs

[백준] 2842번 집배원 한상덕

컴영 — Fri, 18 Sep 2020 18:39:50 +0900

2842 집배원 한상덕

문제

상덕이는 언덕 위에 있는 마을의 우체국에 직업을 얻었다. 마을은 N×N 행렬로 나타낼 수 있다. 행렬로 나뉘어진 각 지역은 우체국은 'P', 집은 'K', 목초지는 '.' 중 하나로 나타낼 수 있다. 또, 각 지역의 고도도 알고 있다.

매일 아침 상덕이는 마을의 모든 집에 우편을 배달해야 한다. 배달은 마을에 하나밖에 없는 우체국 'P'가 있는 곳에서 시작한다. 상덕이는 현재 있는 칸과 수평, 수직, 대각선으로 인접한 칸으로 이동할 수 있다. 마지막 편지를 배달하고 난 이후에는 다시 우체국으로 돌아와야 한다.

상덕이는 이렇게 매일 아침 배달을 하는 것이 얼마나 힘든지 궁금해졌다. 상덕이가 배달하면서 방문한 칸 중 가장 높은 곳과 낮은 곳의 고도 차이를 피로도라고 하자. 이때, 가장 작은 피로도로 모든 집에 배달을 하려면 어떻게 해야 하는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (2 ≤ N ≤ 50)

다음 N개 줄에는 마을을 나타내는 행렬이 주어진다. 'P'는 한 번만 주어지며, 'K'는 적어도 한 번 주어진다.

다음 N개 줄에는 행렬로 나뉘어진 지역의 고도가 행렬 형태로 주어진다. 고도는 1,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 가장 작은 피로도를 출력한다.

풀이)

1981번 배열에서의 이동문제처럼

이분탐색을 이용해서 풀어보려했으나, 범위 값 설정의 어려움으로

계속 틀려서 결국 다른 분 풀이의 도움을 받았다.

두 개의 포인터와 bfs를 이용해서 풀 수 있다.(bfs말고 dfs를 이용해도 된다.)

과정

1. 고도 값들을 따로 저장한 다음에 그것들을 오름차순으로 정렬한 뒤, 중복된 고도 값은 없애준다.

2. 고도값을 저장한 벡터를 height[]라고 할때,

초기 left 와 right는 0으로 두고

상원이가 이동할 수 있는 고도 값의 범위를 height[left] ~ height[right]라고 한다.

while(right < height.size()){

while(1){

//상원이가 height[left] ~ height[right] 범위의 고도들만 이동해서

모든 집에 우편을 배달할 수 있는지 체크

배달할 수 있을 경우 :

피로도를 계산(height[right] - height[left])

고도값 범위의 낮은 고도 가리키는 인덱스를 높여준다 left++;

없을 경우 :

break;

}

고도값 범위의 높은 고도 가리키는 인덱스를 높여준다. right++;

}

ex) 그림으로 예를 들어서 보면

3
K.P
...
K.K
3 3 4
9 5 9
8 3 7

이니깐,

초기 height와 left, right는 다음과 같다.

상원이가 고도 3~3일때만 이동 가능하면, 우체국에서 출발 자체가 불가능 => 결국 모든 집에 우편 배달불가능하니깐 right 이동

상원이가 고도 3~4 일때만 이동 가능하면 우편 배달 불가능 또 right 이동

불가능 -> 또 이동 -> 또 이동고도 3 ~ 8 일때는 가능

상원이가 3~8 고도 범위를 이동 가능하다고 하면 이 때는 모든 집에 우편 배달 가능하니깐 => 피로도 계산 8 - 3 = 5

그리고 left 이동시켜서 다시 반복..

조금 설명이 부족한듯 싶지만,, 이런식으로 고도 범위를 바꿔가며

피로도의 최소값을 찾으면 된다.

주의할 점

상원이가 현재 출발해야 하는 우체국의 고도가 범위안에 있을 때만 이동을 시작할 수 있다.

코드)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <stdio.h>
#include <vector>
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;
 
int n;
char map[50][50];
pair<int, int> sang;
int house;
int height[50][50];
bool visited[50][50];
int dy[8] = {-1,-1,0,1,1,1,0,-1};
int dx[8] = {0,1,1,1,0,-1,-1,-1};
 
bool bfs(int s, int e) {
    queue<pair<int, int>> qu;
    qu.push({ sang.first,sang.second });
    visited[sang.first][sang.second] = true;
    int temp = 0;
    
    while (!qu.empty())
    {
        int y = qu.front().first;
        int x = qu.front().second;
        qu.pop();
        if (map[y][x] == 'K') {
            temp++;
            if (temp == house) return true;
        }
        for (int i = 0; i < 8; i++) {
            int ny = y + dy[i];
            int nx = x + dx[i];
            if (nx <0 || nx>=n || ny <0 || ny>=n || visited[ny][nx])continue;
            if (height[ny][nx] < s || height[ny][nx] > e) continue;
            visited[ny][nx] = true;
            qu.push({ ny,nx });
        }
    }
    return false;
}
 
int main() {
    scanf("%d", &n);
    getchar();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            map[i][j] = getchar();
            if (map[i][j] == 'P') {
                sang.first = i;
                sang.second = j;
            }
            else if (map[i][j] == 'K') {
                house++;
            }
        }
        getchar();
    }
 
    
    vector <int> diff_height;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &height[i][j]);
            diff_height.push_back(height[i][j]);
        }
    }
 
    sort(diff_height.begin(), diff_height.end()); //고도 값들 오름차숨
    diff_height.erase(unique(diff_height.begin(), diff_height.end()), diff_height.end());//중복값 제외
 
    int answer = 987654321;
    int left = 0, right = 0;
 
    while (right < diff_height.size())
    {
        while (true) {
            bool suc = false;
            if (diff_height[left] <= height[sang.first][sang.second] && height[sang.first][sang.second] <= diff_height[right]) {
                suc = bfs(diff_height[left], diff_height[right]);
                memset(visited, 0, sizeof(visited));
            }
            
            if (!suc) break;
            
            int diff = diff_height[right] - diff_height[left];
            if (answer > diff) answer = diff;
            left++;
        }
        right++;
    }
    printf("%d", answer);
 
 
    return 0;
}
Colored by Color Scripter
cs