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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 입력받은 4X4 배열에서 한 칸씩 시작한다.

2. 각 칸에서 갈 수 있는 4방향으로 계속 가면서 7자리의 숫자를 만든다.

3. 모든 칸에서의 탐색을 끝내고 결과를 출력한다.

<해법>

1. 7자리 숫자를 만드는 방법.

=> 이 문제를 처음에 만들어지는 수를 string으로 접근하였는데 시간 초과가 해결되지 않았습니다. 그래서 int로 접근하였습니다.

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
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
 
struct pos {
    int x, y;
};
 
int di[] = { -1,0,1,0 };
int dj[] = { 0,1,0,-1 };
 
int map[4][4];
bool words[10000000];
int res;
 
bool inner(int x, int y) {
    if (x < 0 || y < 0 || x >= 4 || y >= 4) {
        return false;
    }
    return true;
}
 
void go(pos cur, int word, int moveCnt) {
 
    //숫자 7개 완성 - 종료
    if (moveCnt == 7) {
        words[word] = true;
        return;
    }
 
    //기존 단어에 10을 곱해 한 자릿수 올려주고, 현재 좌표 값 더하기
    word *= 10;
    word += map[cur.x][cur.y];
 
    //4방향 중 갈 수 있는 곳으로 탐색
    for (int i = 0; i < 4; i++) {
        pos nxt = cur;
 
        nxt.x += di[i];
        nxt.y += dj[i];
 
        if (!inner(nxt.x, nxt.y)) {
            continue;
        }
 
        go(nxt, word, moveCnt + 1);
    }
}
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        memset(words, falsesizeof(words));
        res = 0;
 
        //입력
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                cin >> map[i][j];
            }
        }
 
        //각 칸마다 재귀함수
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                pos str = { i,j };
                go(str, 00);
            }
        }
 
        //결과 카운트 및 출력
        int res = 0;
        for (int i = 0; i < 10000000; i++) {
            if (words[i]) {
                res++;
            }
        }
        cout << "#" << test_case << " " << res << "\n";
    }
    return 0;
}
 

 

재귀함수에 대해 알아볼 수 있는 문제였습니다.

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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 암호코드가 포함된 2차원 배열을 입력받는다.

2. 입력받은 배열 중에서 암호코드를 찾는다.

3. 찾은 암호코드를 숫자 암호코드로 변환한다.

4. 숫자암호코드가 정상적인 암호코드인지 판별하고 출력한다.

<해법>

1. 2차원 배열에서 암호코드를 찾는 방법.

=> 2진수로된 암호코드 숫자들은 모두 '1'로 끝납니다. 따라서 주어진 2차원 배열을 뒤에서부터 검사하여 1을 찾은 후, 그 좌표부터 앞 56숫자는 모두 암호코드가 됩니다.

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
#include <iostream>
using namespace std;
 
int code[10][7= {
    {0,0,0,1,1,0,1}, //0
    {0,0,1,1,0,0,1}, //1
    {0,0,1,0,0,1,1}, //2
    {0,1,1,1,1,0,1}, //3
    {0,1,0,0,0,1,1}, //4
    {0,1,1,0,0,0,1}, //5
    {0,1,0,1,1,1,1}, //6
    {0,1,1,1,0,1,1}, //7
    {0,1,1,0,1,1,1}, //8
    {0,0,0,1,0,1,1}  //9
};
 
int N, M;
int arr[50][100];
int codeBit[56];
int codeNum[8];
int res;
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        res = 0;
 
        //입력
        cin >> N >> M;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                scanf_s("%1d"&arr[i][j]);
            }
        }
 
        //비트코드 찾기
        bool codeFind = false;
        for (int i = 0; i < N; i++) {
            for (int j = M - 1; j >= 0; j--) {
                if (arr[i][j] == 1) {
                    codeFind = true;
                    for (int k = 0; k < 56; k++) {
                        codeBit[k] = arr[i][j - 55 + k];
                    }
                    break;
                }
            }
            if (codeFind) {
                break;
            }
        }
 
        //비트코드 숫자코드로 변환
        for (int i = 0; i < 8; i++) {
            for (int k = 0; k < 10; k++) {
                bool isSame = true;
                for (int j = 0; j < 7; j++) {
                    if (codeBit[(i * 7+ j] != code[k][j]) {
                        isSame = false;
                        break;
                    }
                }
                if (isSame) {
                    codeNum[i] = k;
                    break;
                }
            }
        }
 
        //숫자코드 계산
        int sum = (codeNum[0+ codeNum[2+ codeNum[4+ codeNum[6]) * 3 + codeNum[1+ codeNum[3+ codeNum[5+ codeNum[7];
 
        //정상적인 암호코드일 경우, 모든 숫자 더하기
        if (sum % 10 == 0) {
            for (int i = 0; i < 8; i++) {
                res += codeNum[i];
            }
        }
 
        //출력
        cout << "#" << test_case << " " << res << "\n";
    }
}
 

 

구현에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5Pq-OKAVYDFAUq

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 초기 배열을 입력받는다.

2. 90도 돌린 배열 = 초기 배열을 90도 돌린다.

3. 180도 돌린 배열 = 90도 돌린 배열을 90도 돌린다.

4. 270도 돌린 배열 = 180도 돌린 배열을 90도 돌린다.

5. 결과를 출력한다.

<해법>

1. 배열을 90도 돌리는 방법을 구하고, 90도 회전을 반복 진행하여 모든 결과를 구합니다.

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 <iostream>
using namespace std;
 
int N;
int tmp[7][7];
 
int res_90[7][7];
int res_180[7][7];
int res_270[7][7];
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //입력
        cin >> N;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> tmp[i][j];
            }
        }
 
        //입력받은 배열 90도 돌리기
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res_90[j][(N - 1- i] = tmp[i][j];
            }
        }
        //90도 돌린 배열 90도 돌리기
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res_180[j][(N - 1- i] = res_90[i][j];
            }
        }
        //180도 돌린 배열 90도 돌리기
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res_270[j][(N - 1- i] = res_180[i][j];
            }
        }
 
        //출력
        cout << "#" << test_case << "\n";
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cout << res_90[i][j];
            }
            cout << " ";
            for (int j = 0; j < N; j++) {
                cout << res_180[i][j];
            }
            cout << " ";
            for (int j = 0; j < N; j++) {
                cout << res_270[i][j];
            }
            cout << "\n";
        }
    }
}
 

 

2차원 배열에 대해 알아볼 수 있는 문제였습니다.

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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 각 빌딩들의 높이를 입력받는다.

2. 각 빌딩마다 조망에 영향을 주는 4개의 빌딩(왼쪽 두 개, 오른쪽 두 개)의 빌딩 중 가장 높은 빌딩 높이를 구한다.

3. 만약 가장 높은 빌딩의 높이보다 현재 빌딩의 높이가 더 높다면, 높이의 차이만큼 조망권이 확보되는 세대가 생긴다.

4. 위의 세대들을 합하여 결과를 출력한다.

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
#include <iostream>
#include <algorithm>
using namespace std;
 
int main() {
 
    int test_case;
    int T;
 
    T = 10;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        int N;
        int building[1000];
        int res = 0;
 
        //입력
        cin >> N;
        for (int i = 0; i < N; i++) {
            cin >> building[i];
        }
 
        //각 빌딩마다 탐색
        for (int i = 2; i < N - 2; i++) {
 
            //빌딩에 영향을 주는 4개 빌딩 중 가장 높은 높이
            int maxHeight = max(max(building[i - 2], building[i - 1]), max(building[i + 1], building[i + 2]));
 
            //빌딩이 가장 높은 높이보다 높다면, 결과 저장
            if (maxHeight < building[i]) {
                res += building[i] - maxHeight;
            }
        }
 
        //출력
        cout << "#" << test_case << " " << res << "\n";
    }
}
 

 

구현에 대해 알아볼 수 있는 문제였습니다.

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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 학생들의 점수 입력을 받음과 동시에, 그 점수에 해당하는 학생 수를 갱신한다.

2. 가장 많은 학생 수를 찾고, 그 index를 출력한다.

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
#include <iostream>
#include <cstring>
using namespace std;
 
int scores[101];
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //테스트 케이스 번호
        int case_num;
        cin >> case_num;
 
        //점수마다 사람 수 배열 초기화
        memset(scores, 0sizeof(scores));
 
        //학생 수 1000명만큼 반복
        for (int i = 0; i < 1000; i++) {
            int score;
            cin >> score;
            scores[score]++;
        }
 
        //사람이 가장 많은 점수 찾기
        int res = 0;
        int tmp = 0;
        for (int i = 1; i < 101; i++) {
            if (scores[i] >= tmp) {
                tmp = scores[i];
                res = i;
            }
        }
 
        //출력
        cout << "#" << case_num << " " << res << "\n";
    }
 
    return 0;
}
 

 

구현에 대해 알아볼 수 있는 문제였습니다.

'알고리즘 문제풀이 > SWEA' 카테고리의 다른 글

[C++] SWEA 1961 - 숫자 배열 회전  (0) 2020.05.03
[C++] SWEA 1206 - View  (0) 2020.05.03
[C++] SWEA 1210 - Ladder1  (0) 2020.05.03
[C++] SWEA 1238 - Contact  (0) 2020.05.03
[C++] SWEA 1219 - 길찾기  (0) 2020.05.03

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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 사다리 도착지점 부터 시작해서 위로 올라가서 출발 지점을 찾는 방식을 이용한다.

2. 위로 올라가면서 양 옆으로 갈 수 있는 길이 있다면, 옆 길로 갈 수 있을 때까지 가고 다시 올라간다.

3. 출발 지점을 찾았다면 출력한다.

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
#include <iostream>
using namespace std;
 
int map[100][102];
int res;
 
int go(int x, int y) {
    while (true) {
 
        //종료조건
        if (x == 0) {
            return y - 1;
        }
 
        //왼쪽으로 갈 수 있는 사다리가 있다면
        if (map[x][y - 1== 1) {
            //왼쪽으로 갈 수 없을 때까지 이동
            while (true) {
                if (map[x][y - 1== 0) {
                    break;
                }
                y--;
            }
        }
        //오른쪽으로 갈 수 있는 사다리가 있다면
        else if (map[x][y + 1== 1) {
            //오른쪽으로 갈 수 없을 때까지 이동
            while (true) {
                if (map[x][y + 1== 0) {
                    break;
                }
                y++;
            }
        }
 
        //한 칸 위로
        x--;
    }
}
 
int main() {
    
    int test_case;
    int T;
 
    T = 10;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        int case_num;
        cin >> case_num;
 
        //입력
        for (int i = 0; i < 100; i++) {
            for (int j = 1; j < 101; j++) {
                cin >> map[i][j];
                //도착지점부터 시작
                if (map[i][j] == 2) {
                    res = go(i, j);
                }
            }
        }
 
        //출력
        cout << "#" << case_num << " " << res << "\n";
    }
 
    return 0;
}
 

 

시뮬레이션에 대해 알아볼 수 있는 문제였습니다.

'알고리즘 문제풀이 > SWEA' 카테고리의 다른 글

[C++] SWEA 1206 - View  (0) 2020.05.03
[C++] SWEA 1204 - 최빈수 구하기  (0) 2020.05.03
[C++] SWEA 1238 - Contact  (0) 2020.05.03
[C++] SWEA 1219 - 길찾기  (0) 2020.05.03
[C++] SWEA 1209 - Sum  (0) 2020.05.03

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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 입력으로 주어지는 데이터를 배열로 만든다.

2. 배열을 탐색하며 방문 배열에 연락을 몇 번 거쳤는지를 저장한다.

3. 가장 많은 연락을 거친 사람 중 숫자가 가장 큰 사람을 출력한다.

<해법>

1. 입력으로 주어지는 데이터를 배열로 만드는 방법.

=> 연락하는 사람, 연락받는 사람을 기준으로 나눕니다.

2. 방문 배열에 연락이 몇 번 거쳤는지 저장하는 방법.

=> ( 연락 받는 사람의 거친 연락 수 = 연락 하는 사람의 거친 연락 수 + 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
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
 
const int MAX = 101;
 
bool map[MAX][MAX];
int visited[MAX];
 
void bfs(int st) {
    queue<int> q;
    q.push(st);
    visited[st] = 0;
 
    while (!q.empty()) {
        int cur = q.front();
        q.pop();
 
        for (int i = 1; i < MAX; i++) {
            int nxt = i;
            if (map[cur][nxt] && visited[nxt] < 0) {
                q.push(nxt);
                visited[nxt] = visited[cur] + 1;
            }
        }
    }
    return;
}
 
int main() {
 
    int test_case;
    int T;
 
    T = 10;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 전역변수 초기화
        memset(map, falsesizeof(map));
        memset(visited, -1sizeof(visited));
 
        int data_cnt, START;
        cin >> data_cnt >> START;
 
        //a->b로 연락 가능
        for (int i = 0; i < data_cnt / 2; i++) {
            int a, b;
            cin >> a >> b;
            map[a][b] = true;
        }
 
        //당번부터 탐색 시작
        bfs(START);
 
        //연락된 사람들 중 숫자가 가장 큰 사람 저장
        int cnt = -1;
        int res = 0;
        for (int i = 0; i < MAX; i++) {
            if (visited[i] >= cnt) {
                cnt = visited[i];
                res = i;
            }
        }
 
        //출력
        cout << "#" << test_case << " " << res << "\n";
    }
}
 

 

BFS에 대해 알아볼 수 있는 문제였습니다.

'알고리즘 문제풀이 > SWEA' 카테고리의 다른 글

[C++] SWEA 1204 - 최빈수 구하기  (0) 2020.05.03
[C++] SWEA 1210 - Ladder1  (0) 2020.05.03
[C++] SWEA 1219 - 길찾기  (0) 2020.05.03
[C++] SWEA 1209 - Sum  (0) 2020.05.03
[C++] SWEA 1954 - 달팽이 숫자  (0) 2020.05.03

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

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 두 도시를 연결하는 도로 입력값들로 배열을 만든다.

2. 맵을 탐색하며 도착점에 갈 수 있는지 판단하여 출력한다.

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
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
 
int map[2][100];
bool visited[100];
int START = 0, END = 99;
 
int bfs(int st) {
    queue<int> q;
    q.push(st);
    visited[st] = true;
 
    while (!q.empty()) {
        int cur = q.front();
        q.pop();
 
        //현재 도시가 도착점일 경우 1 반환
        if (cur == END) {
            return 1;
        }
 
        //현재 도시와 연결되어있는 다음 도시 큐에 담기
        for (int i = 0; i < 2; i++) {
            int nxt = map[i][cur];
            if (nxt >= 0 && !visited[nxt]) {
                q.push(nxt);
                visited[nxt] = true;
            }
        }
    }
 
    //도착점에 방문한 적이 없는 경우 0 반환
    return 0;
}
 
int main() {
    
    int test_case;
    int T;
 
    T = 10;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //케이스마다 사용할 전역변수 초기화
        memset(map, -1sizeof(map));
        memset(visited, falsesizeof(visited));
 
        //입력
        int case_num, road_cnt;
        cin >> case_num >> road_cnt;
 
        for (int i = 0; i < road_cnt; i++) {
            int a, b;
            cin >> a >> b;
 
            //연결되어 있는 길 저장
            if (map[0][a] < 0) {
                map[0][a] = b;
            }
            else {
                map[1][a] = b;
            }
        }
 
        //탐색
        int res = bfs(START);
 
        //출력
        cout << "#" << case_num << " " << res << "\n";
    }
}
 

 

BFS에 대해 알아볼 수 있는 문제였습니다.

'알고리즘 문제풀이 > SWEA' 카테고리의 다른 글

[C++] SWEA 1210 - Ladder1  (0) 2020.05.03
[C++] SWEA 1238 - Contact  (0) 2020.05.03
[C++] SWEA 1209 - Sum  (0) 2020.05.03
[C++] SWEA 1954 - 달팽이 숫자  (0) 2020.05.03
[C++] SWEA 1974 - 스도쿠 검증  (0) 2020.05.03

+ Recent posts