-

[SWEA_D4] 1226번 - 미로 1

asdklfjlasdlfkj — Mon, 16 Mar 2020 10:21:53 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV14vXUqAGMCFAYD&categoryId=AV14vXUqAGMCFAYD&categoryType=CODE&&&

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

dfs 알고리즘을 활용한 완전탐색 문제다.

주어진 조건대로 0이거나 목적지인 3인 경우만 갈 수 있게 설정하고, 방문하지 않은 곳에 대해서만 방문하도록 했다.

문자 -> 숫자 변환은 '0'을 빼는 것이므로 47번째 줄에서 처리해주었다.

아래는 코드

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 <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
vector<vector<int> > MAP;
vector<vector<bool> > check;
int r_s, c_s;
int answer = 0;
typedef struct dir{
    int dr, dc;
}dir;
dir direction[4] = { { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 } };
 
void dfs(int r, int c){
    if (MAP[r][c] == 3){
        answer = 1;
        return;
    }
    check[r][c] = true;
    for (int i = 0; i < 4; i++){
        int nr = r + direction[i].dr;
        int nc = c + direction[i].dc;
        if (nr >= 0 && nr < 16 && nc >= 0 && nc < 16){
            if ((MAP[nr][nc] == 0 || MAP[nr][nc] == 3) && !check[nr][nc]){
                dfs(nr, nc);
            }
        }
    }
}
 
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
 
    for (int tc = 1; tc <= 10; tc++){
        int t;
        cin >> t;
        answer = 0;
        MAP.assign(16, vector<int>(16, 0));
        check.assign(16, vector<bool>(16, false));
        for (int r = 0; r < 16; r++){
            string curRow;
            cin >> curRow;
            for (int c = 0; c < 16; c++){
                MAP[r][c] = curRow[c] - '0';
                if (MAP[r][c] == 2){
                    r_s = r;
                    c_s = c;
                }
            }
        }
        dfs(r_s, c_s);
        cout << "#" << t << " " << answer << '\n';
    }
    return 0;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[SWEA_D3] 1244번 - 최대 상금

asdklfjlasdlfkj — Sun, 15 Mar 2020 19:05:48 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV15Khn6AN0CFAYD&categoryId=AV15Khn6AN0CFAYD&categoryType=CODE

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

조건이 붙은 완전탐색 문제다.

dfs 알고리즘으로 풀 수 있다.

단, 단순히 뒤의 숫자가 앞의 숫자보다 같거나 큰 경우에 대해서 진행한다면 시간초과가 난다.

바꾼 뒤에 기준이 되는 베이스 포인트를 넘겨주고 2중 for문의 바깥 루프에서 이 값부터 기준으로 삼아 탐색을 하면 시간초과가 나지 않고 풀 수 있다.

아래는 전체 코드.

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

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string num;
int answer, MaxChg;
void dfs(int idx, int change){
    if (change == MaxChg){
        answer = max(answer, stoi(num));
        return;
    }
    for (int i = idx; i < num.length(); i++){
        for (int j = i + 1; j < num.length(); j++){
            if (num[j] >= num[i]){
                swap(num[i], num[j]);
                dfs(i, change + 1);
                swap(num[i], num[j]);
            }
        }
    }
}
int main(){
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int tc;
    cin >> tc;
    for (int T = 1; T <= tc; T++){
        cin >> num >> MaxChg;
        answer = 0;
        dfs(0, 0);
        cout << "#" << T << " " << answer << '\n';
    }
    return 0;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[SWEA_모의SW역량테스트] 2105번 - 디저트 카페

asdklfjlasdlfkj — Thu, 27 Feb 2020 11:38:37 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5VwAr6APYDFAWu

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

SWEA 삼성 SW 역량테스트 모의 문제다.

이 문제는 작년 실제 기출 문제 '게리맨더링2(https://cpp-dev.tistory.com/51?category=852516)' 문제와 매우 유사하다. 하지만 그 문제보다는 처리할 코드가 적어 보다 쉽게 풀 수 있는 문제다.

이 문제는 시작점의 범위와 길이 1, 길이 2의 조합에 대해 그릴 수 있는 경우 해당 경로의 디저트 수를 구하는 완전탐색 문제다. 시뮬레이션 느낌도 좀 있다.

isPossible 함수는 주어진 시작점과 총 Map의 한 변의 길이, 그리고 길이 두 개가 주어졌을 때, 그 경로가 갈 수 있는 것인지 판별하는 함수다. 이 함수에서 true가 반환되면 해당 경로는 존재할 수 있는 것이므로, 경로를 따라가면서 디저트의 수를 구한 뒤, 중복이 없는지 조건을 따져 중복이 없다면 답을 갱신해준다.

아래는 소스코드.

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

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int T, N;
 
bool isPossible(int r, int c, int len1, int len2, int N){
    if ((0 <= (r - 1 + len1) && (r - 1 + len1) < N && (c + 1 - len1) >= 0 && (c + 1 - len1) < N) &&
        (0 <= (r + len1 + len2 - 2) && (r + len1 + len2 - 2) < N && 0 <= (c - len1 + len2) && (c - len1 + len2) < N) &&
        (0 <= (r + len2 - 1) && (r + len2 - 1) < N && 0 <= (c + len2 - 1) && (c + len2 - 1) < N)){
        return true;
    }
    return false;
}
 
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> T;
    for (int tc = 1; tc <= T; tc++){
        int answer = -1;
        cin >> N;
        vector<vector<int> > Map;
        Map.assign(N, vector<int>(N, 0));
        for (int r = 0; r < N; r++){
            for (int c = 0; c < N; c++){
                cin >> Map[r][c];
            }
        }
        for (int r = 0; r < N-2; r++){
            for (int c = 1; c < N; c++){
                for (int len1 = 2; len1 < N; len1++){
                    for (int len2 = 2; len2 < N; len2++){
                        if (!isPossible(r, c, len1, len2, N)) continue;
                        else{
                            vector<int> disserts;
                            int curr = r;
                            int curc = c;
                            for (int i = 1; i < len1; i++){
                                disserts.push_back(Map[curr + 1][curc - 1]);
                                curr++;
                                curc--;
                            }
                            for (int i = 1; i < len2; i++){
                                disserts.push_back(Map[curr + 1][curc + 1]);
                                curr++;
                                curc++;
                            }
                            for (int i = 1; i < len1; i++){
                                disserts.push_back(Map[curr - 1][curc + 1]);
                                curr--;
                                curc++;
                            }
                            for (int i = 1; i < len2; i++){
                                disserts.push_back(Map[curr - 1][curc - 1]);
                                curr--;
                                curc--;
                            }
                            //cout << curr << " " << curc << '\n';
                            int tot_category = disserts.size();
                            sort(disserts.begin(), disserts.end());
                            disserts.erase(unique(disserts.begin(), disserts.end()), disserts.end());
                            int erased_ = disserts.size();
                            if (tot_category == erased_){ // 중복 없다면
                                answer = max(answer, tot_category);
                            }
                        }
                    }
                }
            }
        }
        cout << "#" << tc << " " << answer << '\n';
    }
    return 0;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[SWEA_모의SW역량테스트] 1953번 - 탈주범 검거

asdklfjlasdlfkj — Wed, 26 Feb 2020 15:25:35 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5PpLlKAQ4DFAUq#;return%20false;

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

SWEA 삼성 SW 모의 역량테스트 문제다.

전형적인 BFS 문제로, 갈 수 있는 길을 가고, 가지 않은 길을 가면서 탈주범이 최대 갈 수 있는 지역의 수를 구하는 문제다.

Map을 단순히 숫자로 표현하기보다는 상하좌우 접근가능한 정보를 저장하는 것이 구현하기 용이하여 구조체 Open을 사용하였으며, 4방위 탐색을 BFS에서 활용할 때 가장 기본이 되는 dir 구조체를 선언해 활용했다.

그리고 단계별 탐색이 되어야하는 BFS 문제이기 때문에, 루프를 돌 때마다 큐의 크기만큼만 반복문을 돌고 time을 증가시킨 뒤, L과 비교해 무한루프를 빠져나왔다.

L이 1일경우, 맨홀 입구아래 부분만 있을 수 있으므로 답을 1로 하여 출력하도록 하였다.

아래는 소스코드.

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
int T, N, M, R, C, L;
typedef struct Open{
    bool up = false;
    bool down = false;
    bool left = false;
    bool right = false;
}Open;
 
typedef struct dir{
    int dr, dc;
}dir;
dir direction[4] = { { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 } };
vector<vector<bool> > check;
vector<vector<Open> > Map;
 
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
 
    cin >> T;
    for (int tc = 1; tc <= T; tc++){
        cin >> N >> M >> R >> C >> L;
        // L = 1일 때 맨홀 뚜껑 위치이며 지점 한 개에 있을 수 있는 것.
        Open tmp;
        Map.assign(N, vector<Open>(M, tmp));
        check.assign(N, vector<bool>(M, false));
        for (int r = 0; r < N; r++){
            for (int c = 0; c < M; c++){
                int ele;
                cin >> ele;
                if (ele > 0){
                    switch (ele){
                    case 1: // 상하좌우
                        Map[r][c].up = true;
                        Map[r][c].down = true;
                        Map[r][c].left = true;
                        Map[r][c].right = true;
                        break;
                    case 2: // 상하
                        Map[r][c].up = true;
                        Map[r][c].down = true;
                        break;
                    case 3: // 좌우
                        Map[r][c].left = true;
                        Map[r][c].right = true;
                        break;
                    case 4: // 상우
                        Map[r][c].up = true;
                        Map[r][c].right = true;
                        break;
                    case 5: // 하우
                        Map[r][c].down = true;
                        Map[r][c].right = true;
                        break;
                    case 6: // 좌하
                        Map[r][c].left = true;
                        Map[r][c].down = true;
                        break;
                    case 7: // 좌상
                        Map[r][c].left = true;
                        Map[r][c].up = true;
                        break;
                    }
                }
            }
        }
        int answer = 1;
        int time = 1;
        queue<pair<int, int> > q;
        q.push(make_pair(R, C));
        check[R][C] = true;
        int level;
        while (1){
            if (L == 1) break;
            int cnt = q.size();
            for (int k = 0; k < cnt; k++){
                pair<int, int> curPos = q.front();
                q.pop();
                int curR = curPos.first;
                int curC = curPos.second;
                for (int i = 0; i < 4; i++){ // 동 서 남 북
                    int nR = curR + direction[i].dr;
                    int nC = curC + direction[i].dc;
                    if (0 <= nR && nR < N && 0 <= nC && nC < M){
                        if (i == 0){
                            if (Map[curR][curC].right && Map[nR][nC].left && !check[nR][nC]){
                                check[nR][nC] = true;
                                answer++;
                                q.push(make_pair(nR, nC));
                            }
                        }
                        else if (i == 1){
                            if (Map[curR][curC].left && Map[nR][nC].right && !check[nR][nC]){
                                check[nR][nC] = true;
                                answer++;
                                q.push(make_pair(nR, nC));
                            }
                        }
                        else if (i == 2){
                            if (Map[curR][curC].down && Map[nR][nC].up && !check[nR][nC]){
                                check[nR][nC] = true;
                                answer++;
                                q.push(make_pair(nR, nC));
                            }
                        }
                        else if (i == 3){
                            if (Map[curR][curC].up && Map[nR][nC].down && !check[nR][nC]){
                                check[nR][nC] = true;
                                answer++;
                                q.push(make_pair(nR, nC));
                            }
                        }
                    }
                }
            }
            time++;
            if (time == L) break;
        }        
        cout << "#" << tc << " " << answer << '\n';
        Map.clear();
        check.clear();
    }
    return 0;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[KAKAO_2018] 캐시 (1차)

asdklfjlasdlfkj — Tue, 18 Feb 2020 18:02:42 +0900

카카오 2018 Blind recruitment 문제다.

레벨 2 문제로 프로그래머스 링크로 확인해볼 수 있다.

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

코딩테스트 연습 - [1차] 캐시 | 프로그래머스

3 [Jeju, Pangyo, Seoul, NewYork, LA, Jeju, Pangyo, Seoul, NewYork, LA] 50 3 [Jeju, Pangyo, Seoul, Jeju, Pangyo, Seoul, Jeju, Pangyo, Seoul] 21 2 [Jeju, Pangyo, Seoul, NewYork, LA, SanFrancisco, Seoul, Rome, Paris, Jeju, NewYork, Rome] 60 5 [Jeju, Pangyo, S

programmers.co.kr

이 문제는 LRU 알고리즘 기반으로 주어진 캐시 크기와 문자열 배열이 주어졌을 때 실행시간을 구하는 문제다.

먼저 대소문자 구분이 없으므로 모두 소문자로 바꿔주는 로직이 필요하며,

그 다음에 캐시의 크기에 따른 요소의 추가 및 시간 추가를 해주면 된다.

만일 캐시의 크기가 다 차지 않은 경우, cache hit이라면 해당 요소를 맨 앞으로 이동해주고 answer을 +1 해주어야 하며,

cache miss일 경우 꽉 차지 않은 경우와 꽉 찬 경우에 대해 나눠서 구현하면 된다.

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

#include <string>
#include <vector>
#include <deque>
using namespace std;
 
int solution(int cacheSize, vector<string> cities) {
    int answer = 0;
    int idx = -1;
    deque<string> cache(cacheSize, "");
    int diff = 'a'-'A';
    for(int i=0; i<cities.size(); i++){
        for(int j=0; j<cities[i].length(); j++){
            if('A' <= cities[i][j] && cities[i][j] <= 'Z') cities[i][j] += diff;
        }
    }
    for(int i=0; i<cities.size(); i++){
        string curstr = cities[i];
        bool found = false;
        for(int j=0; j <= idx; j++){
            if(cache[j].compare(curstr) == 0){ // cache hit
                answer++;
                for(int k=j; k>=1; k--){
                    cache[k] = cache[k-1];
                }
                cache[0] = curstr;
                found = true;
                break;
            }
        }
        if(!found){ // cache miss
            answer+=5;
            if(idx < cacheSize-1){ 
                for(int j=idx+1; j>=1; j--){
                    cache[j] = cache[j-1];
                }
                idx++;
                cache[0] = curstr;
            }
            else if(idx == cacheSize-1){
                for(int j=cacheSize-1; j>=1; j--){
                    cache[j] = cache[j-1];
                }
                cache[0] = curstr;
            }
        }
    }
    return answer;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[프로그래머스_레벨2] 가장 큰 정사각형 찾기

asdklfjlasdlfkj — Sat, 15 Feb 2020 11:41:04 +0900

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

코딩테스트 연습 - 가장 큰 정사각형 찾기 | 프로그래머스

[[0,1,1,1],[1,1,1,1],[1,1,1,1],[0,0,1,0]] 9

programmers.co.kr

처음에 for문으로 답을 찾으려 했다가 정확성은 맞았지만 효율성테스트에서 실패한 케이스다.

다시 문제를 분석하고 DP로 더 빠르게 풀 수 있는 것을 알게 된 뒤,

재설계해서 풀었다.

먼저 DP배열에 모두 0을 넣고, board에 1이 담겨있는 곳의 dp값을 1로 초기화 해주었다.

만약 board값을 확인하는 과정에서 1이 발견되지 않으면 0을 반환하고 종료하도록 했다. 그렇지 않은 경우 최소 1의 넓이를 가질 것이므로 answer의 초기값은 1로 설정했다. (answer은 제일 큰 정사각형의 한 변의 길이의 의미임.)

그 후, dp를 돌면서 좌상, 좌, 상 부분의 dp값을 보고 제일 작은 요소를 찾아 +1한 것이 현재 위치에서 얻을 수 있는 가장 긴 정사각형의 한 변의 길이이므로 루프를 돌며 제일 긴 길이를 answer에 담아두었다.

루프를 다 돌고 나서는 길이를 저장해둔 answer의 제곱을 반환하도록 했다.

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 <iostream>
#include <vector>
using namespace std;
 
int solution(vector<vector<int> > board)
{
    int answer = 1;
    vector<vector<int> > dp;
    int row = board.size(), col = board[0].size();
    dp.assign(row, vector<int>(col, 0));
    bool no_one = true;
    for(int r=0; r<row; r++){
        for(int c=0; c<col; c++){
            if(board[r][c]) {
                dp[r][c] = 1;
                no_one = false;
            }
        }
    }   
    if(no_one) return 0;
    for(int r=1; r<row; r++){
        for(int c=1; c<col; c++){
            if(dp[r][c] == 1){
                dp[r][c] = min(dp[r-1][c], min(dp[r-1][c-1], dp[r][c-1])) + 1;
                answer = (answer >= dp[r][c]) ? answer : dp[r][c];
            }
        }
    }
    answer = answer * answer;
    return answer;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[KAKAO_2018] 프렌즈 4블록

asdklfjlasdlfkj — Fri, 14 Feb 2020 15:02:33 +0900

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

코딩테스트 연습 - [1차] 프렌즈4블록 | 프로그래머스

프렌즈4블록 블라인드 공채를 통과한 신입 사원 라이언은 신규 게임 개발 업무를 맡게 되었다. 이번에 출시할 게임 제목은 프렌즈4블록. 같은 모양의 카카오프렌즈 블록이 2 ×2 형태로 4개가 붙어있을 경우 사라지면서 점수를 얻는 게임이다. 만약 판이 위와 같이 주어질 경우, 라이언이 2×2로 배치된 7개 블록과 콘이 2×2로 배치된 4개 블록이 지워진다. 같은 블록은 여러 2×2에 포함될 수 있으며, 지워지는 조건에 만족하는 2×2 모양이 여러 개 있다면

programmers.co.kr

2x2 크기의 동일 블록에 대한 블록게임을 구현하는 문제였다.

먼저 루프를 돌며 같은 모양을 갖는 블록들모임이 존재하는지 확인하고, 해당되는 갯수를 구해 정답에 더해주면 된다.

만약 그 갯수가 0이라면 지울 블록이 없다는 의미이므로 더이상 진행하지 않고 빠져나와 정답을 출력하면 된다.

핵심은 70번째 줄로 블록을 내려준 뒤에 다음 행 (바로 위 행) 부터 조사해주는 것이다. 저 break;를 안하면 통과하지 않는 테스트케이스 4건이 생긴다. 왜냐하면 기껏 갱신해놓은 r에 루프를 더 돌아 ' '가 아닌 것이 나오면 덮어써버리기 때문이다.

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

#include <string>
#include <vector>
using namespace std;
 
vector<vector<bool> > check;
int height, width;
typedef struct dir{
    int dr, dc;
}dir;
dir d[4] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
void falsing(){
    for(int r=0; r<height; r++){
        for(int c=0; c<width; c++){
            check[r][c] = false;
        }
    }
}
int solution(int R, int C, vector<string> board) {
    int answer = 0;
    height = R;
    width = C;
    check.assign(R, vector<bool>(C, false));
    while(1){
        int curErase = 0;
        // 1. erase
        for(int r=0; r<R-1; r++){
            for(int c=0; c<C-1; c++){
                char curCharacter = board[r][c];
                if(curCharacter == ' ') continue;
                bool allSame = true;
                for(int i=0; i<4; i++){
                    int nr = r + d[i].dr;
                    int nc = c + d[i].dc;
                    if(board[nr][nc] != curCharacter){
                        allSame = false;
                        break;
                    }
                }
                if(allSame){ // 4개 다 같으면
                    for(int i=0; i<4; i++){
                        int nr = r + d[i].dr;
                        int nc = c + d[i].dc;
                        if(!check[nr][nc]){
                            check[nr][nc] = true;
                            curErase++;
                        }
                    }
                }
            }
        }
        answer += curErase;
        if(curErase == 0) break; // 안지워진다면 끝. // 지워주기.
        
        for(int r=0; r<R; r++){
            for(int c=0; c<C; c++){
                if(check[r][c]){
                    board[r][c] = ' ';
                }
            }
        } 
        
        // 2. go down
        for(int c=0; c<C; c++){
            for(int r=R-1; r>=0; r--){
                if(board[r][c] == ' '){
                    for(int n_r = r-1; n_r >= 0 ; n_r--){
                        if(board[n_r][c] != ' '){
                            board[r][c] = board[n_r][c];
                            board[n_r][c] = ' ';
                            break;
                        }
                    }
                }
            }
        }        
        falsing();
    }
    return answer;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[2019_KAKAO] 매칭 점수 (프로그래머스 레벨 3)

asdklfjlasdlfkj — Wed, 12 Feb 2020 18:01:56 +0900

https://programmers.co.kr/learn/courses/30/lessons/42893?language=cpp

코딩테스트 연습 - 매칭 점수 | 프로그래머스

매칭 점수 프렌즈 대학교 조교였던 제이지는 허드렛일만 시키는 네오 학과장님의 마수에서 벗어나, 카카오에 입사하게 되었다. 평소에 관심있어하던 검색에 마침 결원이 발생하여, 검색개발팀에 편입될 수 있었고, 대망의 첫 프로젝트를 맡게 되었다. 그 프로젝트는 검색어에 가장 잘 맞는 웹페이지를 보여주기 위해 아래와 같은 규칙으로 검색어에 대한 웹페이지의 매칭점수를 계산 하는 것이었다. 한 웹페이지에 대해서 기본점수, 외부 링크 수, 링크점수, 그리고 매칭점수를

programmers.co.kr

괴랄한 문자열 문제다.

조건이 많아서 abc가 word로 주어졌을 때

abca abcabc 가 page에 있다면 기본 점수를 0으로 해야 하는 것을 간과했으며,

기본 URL 확인시 단순 content 뒤에만 보도록 짰었는데 4줄과 같이 META를 정의하고 확인해줬어야 했다.

그래서 첫 번째 문제를 해결해 기본 점수 문제를 해결하고,

두 번째 문제를 해결해 기본 URL을 잘 찾을 수 있었다.

다소 조건이 까다로운 문제였지만, string의 문자열 함수를 이용해 잘 풀 수 있었다.

(문자열 함수 정리 : https://cpp-dev.tistory.com/56?category=852537)

또한 사용자 정의 sort 함수에 들어갈 정렬 기준의 응용도 할 수 있는 기회였다.

(사용자 정의 정렬 기준 : https://cpp-dev.tistory.com/88?category=852537)

그리고 find 함수로 찾고자 하는 문자열이 없는 경우 string::npos 를 반환하는 것을 알 수 있었다.

아래는 소스코드 전체다. 다른 사람들의 풀이와 비교했을 때 꽤 짧은 길이의 코드다.

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

#include <string>
#include <vector>
#include <algorithm>
#define META "<meta property=\"og:url\" content=\""
#define ENDURL "\"/>"
#define LINKSTART "<a href="
#define LINKEND "\">"
using namespace std;
bool cmp(pair<int, double> a, pair<int, double> b){
    // 앞에 인덱스, 뒤에 점수라면
    if (a.second == b.second) return a.first < b.first;
    return a.second > b.second;
}
int solution(string word, vector<string> pages) {
    vector<string> URL;
    vector<double> BasePoint(pages.size(), 0), LinkPoint(pages.size(), 0);
    vector<vector<string> > OutLinks(pages.size());
 
    int toLower = 'a' - 'A';
    for (int i = 0; i<pages.size(); i++){
        for (int j = 0; j<pages[i].length(); j++){
            if ('A' <= pages[i][j] && pages[i][j] <= 'Z'){
                pages[i][j] += toLower;
            }
        }
    }
    for (int i = 0; i<word.length(); i++){
        if ('A' <= word[i] && word[i] <= 'Z') word[i] += toLower;
    }
    // 1. 기본점수
    for (int i = 0; i<pages.size(); i++){
        int index = 0;
        int cnt = 0;
        while (pages[i].find(word, index) != string::npos){
            int ele = pages[i].find(word, index);
            char next = pages[i][ele + word.length()];
            char before = pages[i][ele - 1];
            if (!('a' <= next && next <= 'z') && !('a' <= before && before <= 'z')) {
                cnt++; 
            }
            index = ele + 1;
        }
        BasePoint[i] = cnt;
    }
    // 2. URL 찾기
    for (int i = 0; i<pages.size(); i++){
        int url_start = pages[i].find(META, 0) + 33;
        int url_end = pages[i].find(ENDURL, url_start)-1;
        URL.push_back(pages[i].substr(url_start, url_end - url_start + 1));
    }
    // 연관 URL 찾기
    for (int i = 0; i<pages.size(); i++){
        int idx = 0;
        while (pages[i].find(LINKSTART, idx) != string::npos){
            int url_start = pages[i].find(LINKSTART, idx) + 9;
            int url_end = pages[i].find(LINKEND, url_start)-1;
            OutLinks[i].push_back(pages[i].substr(url_start, url_end - url_start + 1));
            idx = url_end + 1;
        }
    }
    vector<int> OutLinksNum(pages.size(), 0);
    for (int i = 0; i<OutLinks.size(); i++){
        OutLinksNum[i] = OutLinks[i].size();
    }
    
    for (int i = 0; i<pages.size(); i++){
        string cur_URL = URL[i];
        for (int j = 0; j<OutLinks.size(); j++){
            if (i == j) continue;
            if (OutLinks[j].size() == 0) continue;
            for (int k = 0; k<OutLinks[j].size(); k++){
                if (OutLinks[j][k].compare(cur_URL) == 0){
                    LinkPoint[i] = LinkPoint[i] + (double)(BasePoint[j] / OutLinksNum[j]);
                    break;
                }
            }
        }
    }
    vector<pair<int, double> > Result;
    for (int i = 0; i<pages.size(); i++){
        Result.push_back(make_pair(i, BasePoint[i] + LinkPoint[i]));
    }
    sort(Result.begin(), Result.end(), cmp);
    int answer = Result[0].first;
    return answer;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[프로그래머스_레벨2] 뉴스 클러스터링 (2018 KAKAO BLIND RECRUIT.)

asdklfjlasdlfkj — Tue, 11 Feb 2020 21:28:45 +0900

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

코딩테스트 연습 - [1차] 뉴스 클러스터링 | 프로그래머스

뉴스 클러스터링 여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다. Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브는 사용자들이 편리하게 다양한 뉴스를 찾아볼 수 있도록 문제점을 개선하는 업무를 맡게 되었다. 개발의 방향을 잡기 위해 튜브는 우선 최근 화제가 되고 있는 카카오 신입 개발자 공채 관련 기사를 검색해보았다. 카카오 첫 공채..'블라인드' 방식 채용 카카오, 합병 후 첫

programmers.co.kr

재밌는 문제다.

알파벳으로 이루어진 벡터 두 개에서 교집합과 합집합의 성질을 이용해 '자카드 유사도'라는 수치를 구하는 문제다.

C++ <map> 라이브러리를 활용해 풀었는데, 벡터에 길이가 2인 문자열들을 저장해두고 추후에 벡터를 루프돌면서 해당 문자열을 'key'삼아 'value'를 ++해주는 것이 중요하다.

이 과정을 거친 뒤 두 map 중 어느 하나를 잡아 순회하면서 상대 map에 동일 key의 value와 최소값을 구해 교집합에 들어갈 원소의 수를 더해주고 이를 반복하면 총 교집합의 원소의 수가 나오게 된다.

전체 집합의 크기에서 교집합의 수를 뺀 것이 합집합과 동일한 성질을 이용하면 위에서 구한 교집합을 이용해 합집합의 크기도 쉽게 구할 수 있고, 이를 통해 '자카드 유사도'를 계산할 수 있다.

최종적으로 mul 로 정의해둔 값과 '자카드 유사도'를 곱해 정수부를 반환하면 된다.

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

#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <iostream>
#define mul 65536
using namespace std;
 
int solution(string str1, string str2) {
    int answer;
    double jacard;
 
    vector<string> v1, v2;
    for (int i = 0; i<str1.length() - 1; i++){
        // 알파벳 아닌 것들 모두 제외.
        if (!(('a' <= str1[i] && str1[i] <= 'z') || ('A' <= str1[i] && str1[i] <= 'Z'))){
            continue;
        }
        else if (!(('a' <= str1[i + 1] && str1[i + 1] <= 'z') || ('A' <= str1[i + 1] && str1[i + 1] <= 'Z'))){
            continue;
        }
        // 모두 대문자로 바꿈
        string cur = str1.substr(i, 2);
        for (int j = 0; j<2; j++)
            if ('a' <= cur[j] && cur[j] <= 'z') cur[j] -= ('a' - 'A');
        v1.push_back(cur);
    }
 
    for (int i = 0; i<str2.length() - 1; i++){
        if (!(('a' <= str2[i] && str2[i] <= 'z') || ('A' <= str2[i] && str2[i] <= 'Z'))){
            continue;
        }
        else if (!(('a' <= str2[i + 1] && str2[i + 1] <= 'z') || ('A' <= str2[i + 1] && str2[i + 1] <= 'Z'))){
            continue;
        }
        // 모두 대문자로 저장
        string cur = str2.substr(i, 2);
        for (int j = 0; j<2; j++)
            if ('a' <= cur[j] && cur[j] <= 'z') cur[j] -= ('a' - 'A'); // 소문자면 대문자로.
        v2.push_back(cur);
    }
    if (v1.empty() && v2.empty()) return mul; // 아무것도 안들어간 경우.
 
    map<string, int> m1, m2;
    for (int i = 0; i<v1.size(); i++) m1[v1[i]]++;
    for (int i = 0; i<v2.size(); i++) m2[v2[i]]++;
    double gyo = 0, hap, whole;
    whole = (double)(v1.size() + v2.size());
    // gyo 구하기 -> 끝
    for (map<string, int>::iterator iter = m1.begin(); iter != m1.end(); iter++){
        string this_str = iter->first;
        int m1_cnt = iter->second;
        int m2_cnt = m2[this_str];
        int min_val = min(m1_cnt, m2_cnt);
        if (min_val > 0) gyo += (double)min_val;
    }
    hap = whole - gyo; // 3 = 5 - 2 (tc#3)
    //cout << gyo << " " << hap << " " << whole << '\n';
    jacard = gyo / hap;
    answer = (int)(jacard*mul);
    return answer;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs

[프로그래머스_레벨 3] 오픈채팅방(2019 KAKAO BLIND RECRUIT.)

asdklfjlasdlfkj — Tue, 11 Feb 2020 20:04:32 +0900

문자열과 <map>을 능숙하게 다루면 쉽게 해결할 수 있는 문제다.

먼저 answer에

id+"님이 들어왔습니다." 또는

id+"님이 나갔습니다."와 같은 형태로 저장하고, 이름 변경의 경우 (Change나 Enter에 기존 id의 다른 입력으로 입장) map의 해당 key의 value를 바꿔주는 식으로 answer을 저장했다.

참고로 map은 기존에 없는 key값에 대한 대입은 새로운 key,value 쌍의 입력을 하도록 동작하며,

기존에 있는 key값에 대해서는 value의 갱신을 수행해주는 기능이 있다. 이 덕분에 29행/35행과 같이 기존에 있건없건 동일한 코드로 동작시킬 수 있다. 간편한 기능이다.

마지막으로 answer에 uid+안내문의 형식을 다시 M[uid]+안내문의 형식으로 바꿔주면 된다.

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

#include <string>
#include <vector>
#include <map>
#include <sstream>
#define ENTER "님이 들어왔습니다."
#define OUT "님이 나갔습니다."
using namespace std;
 
vector<string> solution(vector<string> record) {
    vector<string> answer;
    map<string, string> M; // id, name
    for(int i=0; i<record.size(); i++){
        string empty;
        string order = "", id = "", name = "";
        stringstream ss(record[i]);
        while(ss >> empty){
            if(order.compare("") == 0){
                order = empty;
            }
            else if(id.compare("") == 0){
                id = empty;
            }
            else{
                name = empty;
            }
        }
        if(order.compare("Enter") == 0){
            answer.push_back(id+ENTER);
            M[id] = name;
        }
        else if(order.compare("Leave") == 0){ // 나가는 것 답에만 표시
            answer.push_back(id+OUT);
        }
        else if(order.compare("Change") == 0){ // id찾아서 해당 이름 변경
            M[id] = name;
        }
    }
    // answer에 id를 이름으로 변경시킨 뒤 반환.
    for(int i=0; i<answer.size(); i++){
        string cur = answer[i];
        int nim_idx = cur.find("님");        
        string ID = cur.substr(0, nim_idx);
        answer[i].replace(0, ID.length(), M[ID]);
    }
    return answer;
}
http://colorscripter.com/info#e" target="_blank" style="color:#4f4f4ftext-decoration:none">Colored by Color Scripter

http://colorscripter.com/info#e" target="_blank" style="text-decoration:none;color:white">cs