반응형

문제 링크: https://www.acmicpc.net/problem/1941

 

1941번: 소문난 칠공주

총 25명의 여학생들로 이루어진 여학생반은 5×5의 정사각형 격자 형태로 자리가 배치되었고, 얼마 지나지 않아 이다솜과 임도연이라는 두 학생이 두각을 나타내며 다른 학생들을 휘어잡기 시작

www.acmicpc.net

<문제 풀이> 백트랙킹

5X5 격자에서 7자리를 뽑아서(2차원 배열에서 조합) BFS로 연결 여부 확인 + S의 개수가 4 이상인지 확인하면 됩니다.

 

2차원 배열 조합

 for (int i = s; i < 25; i++) {
        int x = i / 5;
        int y = i % 5;
        res[x][y] = 1;
        dfs(i + 1, k + 1);
        res[x][y] = 0;
    }

<C++ 소스 코드>

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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
#include <cstdlib>
using namespace std;
 
#define X first
#define Y second
 
int res[5][5];
int dx[4= {001-1};
int dy[4= { -1100 };
bool visited[5][5];
vector<vector<char> > v(5);
int cnt = 0;
 
void dfs(int s, int k) {
    if (k == 7) {
        int temp = 0;
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (res[i][j] == 1 && v[i][j] == 'S') {
                    temp++;
                }
            }
        }
        if (temp >= 4) {
 
            int connected = 0;
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 5; j++) {
                    if (res[i][j] == 1 && !visited[i][j]) {
                        queue<pair<intint> > Q;
                        Q.push({ i, j });
                        visited[i][j] = true;
                        while (!Q.empty()) {
                            auto cur = Q.front(); Q.pop();
                            for (int dir = 0; dir < 4; dir++) {
                                int nx = cur.X + dx[dir];
                                int ny = cur.Y + dy[dir];
                                if (nx < 0 || ny < 0 || nx >= 5 || ny >= 5)continue;
                                if (visited[nx][ny] || res[nx][ny] == 0)continue;
                                Q.push({ nx, ny });
                                visited[nx][ny] = true;
                            }
                        }
                        connected++;
                    }
                }
            }
            if (connected == 1) cnt++;
        }
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                visited[i][j] = 0;
            }
        }
        return;
    }
 
    for (int i = s; i < 25; i++) {
        int x = i / 5;
        int y = i % 5;
        res[x][y] = 1;
        dfs(i + 1, k + 1);
        res[x][y] = 0;
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
   
    for (int i = 0; i < 5; i++) {
        string s; cin >> s;
        int s_len = s.length();
        v[i].resize(5);
        for (int j = 0; j < s_len; j++) {
            v[i][j] = s[j];
        }
    } 
    dfs(00);
    cout << cnt;
   
 
    return 0;
}
 
cs

 

반응형
반응형

문제 링크: https://www.acmicpc.net/problem/16987

 

16987번: 계란으로 계란치기

원래 프로그래머의 기본 소양은 팔굽혀펴기를 단 한 개도 할 수 없는 것이라고 하지만 인범이는 3대 500을 넘기는 몇 안되는 프로그래머 중 한 명이다. 인범이는 BOJ에서 틀린 제출을 할 때마다 턱

www.acmicpc.net

<문제 풀이>

  1. 가장 왼쪽의 계란을 든다.
  2. 손에 들고 있는 계란으로 깨지지 않은 다른 계란 중에서 하나를 친다. 단, 손에 든 계란이 깨졌거나 깨지지 않은 다른 계란이 없으면 치지 않고 넘어간다. 이후 손에 든 계란을 원래 자리에 내려놓고 3번 과정을 진행한다.
  3. 가장 최근에 든 계란의 한 칸 오른쪽 계란을 손에 들고 2번 과정을 다시 진행한다. 단, 가장 최근에 든 계란이 가장 오른쪽에 위치한 계란일 경우 계란을 치는 과정을 종료한다.

문제 조건을 그대로 dfs로 구현하면 된다.

<C++ 소스 코드> 백트랙킹

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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
#include <cstdlib>
using namespace std;
 
#define S first
#define W second
 
int n;
vector<pair<intint> > egg;
int res = 0;
void dfs(int idx) { //idx번째 계란을 든다
    if (idx >= n) { //가장 최근에 든 계란이 가장 오른쪽에 위치한 경우
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            if (egg[i].S <= 0) cnt++//깨진 계란 카운트
        }
        res = max(res, cnt);
        return;
    }
    bool flag = false//idx번째 계란으로 다른 계란을 쳤는지 여부
    for (int i = 0; i < n; i++) {
        if (i == idx) continue// 자기 자신 무시
        if (egg[idx].S > 0 && egg[i].S > 0) { // 계란을 칠 수 있으면
            egg[idx].S -= egg[i].W;
            egg[i].S -= egg[idx].W;
            flag = true;
            dfs(idx + 1);
            egg[idx].S += egg[i].W;
            egg[i].S += egg[idx].W;
        }
    }
    if(!flag) dfs(idx + 1); //계란을 칠 수 없으면 넘어간다.
 
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    cin >> n;
 
    for (int i = 0; i < n; i++) {
        int s, w;
        cin >> s >> w;
        egg.push_back({ s,w });
    }
    dfs(0);
    cout << res;
    return 0;
}
 
cs

 

반응형

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

[백준 1799번] 비숍  (0) 2021.12.31
[백준 1941번] 소문난 칠공주  (0) 2021.12.31
[백준 2448번] 별 찍기 - 11  (0) 2021.12.27
[백준 2447번] 별 찍기 - 10  (0) 2021.12.27
[백준 1992번] 쿼드트리  (0) 2021.12.27
반응형

문제 링크: https://www.acmicpc.net/problem/2448

 

2448번: 별 찍기 - 11

첫째 줄에 N이 주어진다. N은 항상 3×2k 수이다. (3, 6, 12, 24, 48, ...) (0 ≤ k ≤ 10, k는 정수)

www.acmicpc.net

<문제 풀이> 재귀

위 그림처럼 3등분을 계속해서 n == 3일 때 (x, y)을 기준으로 별을 배열에 업데이트하면 됩니다.

 

 

<C++ 소스 코드>

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 <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
 
using namespace std;
 
char board[3072][6144];

//x,y에서 시작해서 높이가 n인 별 찍기
void solve(int x, int y, int n) {
    if (n == 3) {
        board[x][y] = '*';
        board[x+1][y-1] = '*';
        board[x + 1][y + 1] = '*';
        board[x + 2][y - 2] = '*';
        board[x + 2][y - 1] = '*';
        board[x + 2][y] = '*';
        board[x + 2][y + 1] = '*';
        board[x + 2][y + 2] = '*';
        return;
    }
    solve(x, y, n / 2);
    solve(x + n / 2, y - n / 2, n / 2);
    solve(x + n / 2, y + n / 2, n / 2);
 
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; cin >> n;
    fill(&board[0][0], &board[3071][6144], ' ');
    solve(0, n - 1, n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 2*n; j++) {
            cout << board[i][j];
        }
        cout << '\n';
    }
    return 0;
}
 
cs

 

 

반응형
반응형

문제 링크: https://www.acmicpc.net/problem/2447

 

2447번: 별 찍기 - 10

재귀적인 패턴으로 별을 찍어 보자. N이 3의 거듭제곱(3, 9, 27, ...)이라고 할 때, 크기 N의 패턴은 N×N 정사각형 모양이다. 크기 3의 패턴은 가운데에 공백이 있고, 가운데를 제외한 모든 칸에 별이

www.acmicpc.net

<C++ 소스 코드 > 재귀

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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
 
using namespace std;
 
char board[6561][6561];
//x, y에서 시작해서 가로 세로의 크기가 각각 n
void solve(int x, int y, int n) {
    if (n == 3) {
        board[x][y] = '*';
        board[x][y+1= '*';
        board[x][y+2= '*';
        board[x + 1][y] = '*';
        board[x + 1][y + 1= ' ';
        board[x + 1][y + 2= '*';
        board[x + 2][y] = '*';
        board[x + 2][y + 1= '*';
        board[x + 2][y + 2= '*';
        return;
    }
    solve(x, y, n / 3);
    solve(x, y + n/3, n / 3);
    solve(x, y + 2*n/3, n / 3);
 
    solve(x + n/3, y, n / 3);
    solve(x + n/3, y + 2*n/3, n / 3);
  
    solve(x + 2*n/3, y, n / 3);
    solve(x + 2*n/3, y + n/3, n / 3);
    solve(x + 2*n/3, y + 2*n/3, n / 3);
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; cin >> n;
    fill(&board[0][0], &board[6560][6561], ' ');
    solve(00, n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << board[i][j];
        }
        cout << '\n';
    }
 
    
    return 0;
}
 
cs
반응형
반응형

문제 링크: https://www.acmicpc.net/problem/1992

 

1992번: 쿼드트리

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또

www.acmicpc.net

<C++ 소스 코드> 재귀

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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
 
using namespace std;
 
char board[64][64];
int res[2];
// x,y에서 시작해서 가로 세로 길이가 각각 n인 영상
void solve(int x, int y, int n) {
    if (n == 1) {
        cout << board[x][y];
        return;
    }
 
    char flag = board[x][y];
    bool run = false;
    for (int i = x; i < x + n; i++) {
        for (int j = y; j < y + n; j++) {
            if (flag != board[i][j]) run = true;
        }
    }
    if (!run) {
        cout << board[x][y];
        return;
    }
    cout << "(";
    solve(x, y, n / 2);
    solve(x, y + n / 2, n / 2);
    solve(x + n / 2, y, n / 2);
    solve(x + n / 2, y + n / 2, n / 2);
    cout << ")";
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n; cin >> n;
    for (int i = 0; i < n; i++) {
        string s; cin >> s;
        int s_len = s.length();
        for (int j = 0; j < s_len; j++) {
            board[i][j] = s[j];
        }
    }
    solve(00, n);
 
 
    
    return 0;
}
 
cs

 

반응형

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

[백준 2448번] 별 찍기 - 11  (0) 2021.12.27
[백준 2447번] 별 찍기 - 10  (0) 2021.12.27
[백준 2630번] 색종이 만들기  (0) 2021.12.27
[백준 1780번] 종이의 개수  (0) 2021.12.27
[백준 1766번] 문제집  (0) 2021.12.20
반응형

문제 링크:https://www.acmicpc.net/problem/2630

 

2630번: 색종이 만들기

첫째 줄에는 전체 종이의 한 변의 길이 N이 주어져 있다. N은 2, 4, 8, 16, 32, 64, 128 중 하나이다. 색종이의 각 가로줄의 정사각형칸들의 색이 윗줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다.

www.acmicpc.net

<C++ 소스 코드> 재귀

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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
 
using namespace std;
 
int board[128][128];
int res[2];
// x,y에서 시작해서 가로 세로 길이가 각각 n인 종이
void solve(int x, int y, int n) {
    if (n == 1) {
        res[board[x][y]]++;
        return;
    }
    int flag = board[x][y];
    bool run = false;
    for (int i = x; i < x + n; i++) {
        for (int j = y; j < y + n; j++) {
            if (flag != board[i][j]) run = true;
        }
    }
    if (!run) {
        res[board[x][y]]++;
        return;
    }
    solve(x, y, n / 2);
    solve(x, y + n / 2, n / 2);
    solve(x + n / 2, y, n / 2);
    solve(x + n / 2, y + n / 2, n / 2);
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n; cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> board[i][j];
        }
    }
    solve(00, n);
 
    for (int i = 0; i < 2; i++)cout << res[i] << '\n';
 
    
    return 0;
}
 
cs

 

반응형

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

[백준 2447번] 별 찍기 - 10  (0) 2021.12.27
[백준 1992번] 쿼드트리  (0) 2021.12.27
[백준 1780번] 종이의 개수  (0) 2021.12.27
[백준 1766번] 문제집  (0) 2021.12.20
[뱍쥰 1005번] ACM Craft  (0) 2021.12.20
반응형

문제 링크:https://www.acmicpc.net/problem/1780

 

1780번: 종이의 개수

N×N크기의 행렬로 표현되는 종이가 있다. 종이의 각 칸에는 -1, 0, 1 중 하나가 저장되어 있다. 우리는 이 행렬을 다음과 같은 규칙에 따라 적절한 크기로 자르려고 한다. 만약 종이가 모두 같은 수

www.acmicpc.net

 

<C++ 소스 코드> 재귀

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 <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <cmath>
#include <deque>
 
using namespace std;
 
int board[2187][2187];
int res[3];

// x,y에서 시작해서 가로 세로 길이가 각각 n인 종이
void solve(int x, int y, int n) {
    if (n == 1) {
        res[board[x][y] + 1]++;
        return;
    }
    int flag = board[x][y];
    bool run = false;
    for (int i = x; i < x + n; i++) {
        for (int j = y; j < y + n; j++) {
            if (flag != board[i][j]) run = true;
        }
    }
    if (!run) {
        res[board[x][y] + 1]++;
        return;
    }
    solve(x, y, n / 3);
    solve(x, y + n / 3, n / 3);
    solve(x, y + 2 * n / 3, n / 3);
 
    solve(x + n / 3, y, n / 3);
    solve(x + n / 3, y + n / 3, n / 3);
    solve(x + n / 3, y + 2 * n / 3, n / 3);
 
    solve(x + 2 * n / 3, y, n / 3);
    solve(x + 2 * n / 3, y + n / 3, n / 3);
    solve(x + 2 * n / 3, y + 2 * n / 3, n / 3);
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n; cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> board[i][j];
        }
    }
    solve(00, n);
 
    for (int i = 0; i < 3; i++)cout << res[i] << '\n';
 
    
    return 0;
}
 
cs

 

반응형

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

[백준 1992번] 쿼드트리  (0) 2021.12.27
[백준 2630번] 색종이 만들기  (0) 2021.12.27
[백준 1766번] 문제집  (0) 2021.12.20
[뱍쥰 1005번] ACM Craft  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
반응형

문제 링크:https://www.acmicpc.net/problem/1766

 

1766번: 문제집

첫째 줄에 문제의 수 N(1 ≤ N ≤ 32,000)과 먼저 푸는 것이 좋은 문제에 대한 정보의 개수 M(1 ≤ M ≤ 100,000)이 주어진다. 둘째 줄부터 M개의 줄에 걸쳐 두 정수의 순서쌍 A,B가 빈칸을 사이에 두고 주

www.acmicpc.net

<문제 풀이> 위상 정렬, 우선순위 큐

indegree가 0인 정점 중에서 가장 번호가 낮은 정점을 먼저 방문해야 되기 때문에 위상 정렬을 우선순위 큐로 구현하면 됩니다.

 

<C++ 소스 코드>

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
#include <iostream>
#include <string>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <utility>
#include <climits>
#include <deque>
 
using namespace std;
 
int n, m;
vector<int> adj[32001];
int indegree[32001];
 
class cmp {
public:
    bool operator()(int a, int b) {
        return a > b;
    }
};
 
void bfs() {
    priority_queue<intvector<int>, cmp > pq;
    for (int i = 1; i <= n; i++) {
        if (indegree[i] == 0) {
            pq.push(i);
        }
    }
    while (!pq.empty()) {
        int u = pq.top(); pq.pop();
        cout << u << ' ';
        for (auto& v : adj[u]) {
            indegree[v]--;
            if (indegree[v] == 0) {
                pq.push(v);
            }
            
        }
    }
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int a, b; 
        cin >> a >> b;
        adj[a].push_back(b);
        indegree[b]++;
    }
    bfs();
 
    return 0;
}
 
cs

 

반응형

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

[백준 2630번] 색종이 만들기  (0) 2021.12.27
[백준 1780번] 종이의 개수  (0) 2021.12.27
[뱍쥰 1005번] ACM Craft  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20
[백준 1516번] 게임 개발  (0) 2021.12.20

+ Recent posts