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


아이디어

  • 스택을 사용하여 (을 사용하면 나오는 위치를 우선 구해놓자
    • 재귀함수를 사용해서 (만나면 앞에 숫자에서 곱하기 사용

시간복잡도 계산

  • 스택사용해서 괄호 시작 및 끝나는 위치 매핑 : O(S)
    • 재귀함수 중 순회 : O(S)
  • 총합 : O(S)

자료구조

  • 괄호 시작 및 끝나는 위치 계산용 스택 : stack(int)
    • 스택안에 들어가는 값 : 각각 문자열 인덱스
    • 최대값 : 50 > INT 가능
      • 괄호 시작 및 끝나는 위치 기록 : map[60]
    • 들어가는 값 : 문자열 인덱스
    • 최대값 : 50 > INT 가능
      • 압축안된 문자열 길이 rs
    • 한번 괄호 쌍에 필요한 문자열 최소 3개
    • 그럼 최대 50/3 = 17번이 곱해질수 있음
    • 최대 9^17 > long long 사용

코드(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
#include <iostream>
#include <stack>
#include <string>
 
using namespace std;
typedef long long ll;
 
int map[60];
string s;
 
ll recur(int st, int en) {
    ll rs=0;
    for(int i=st; i<=en; i++) {
        
        // 만약 괄호 만나면 해당 괄호 끝에 해당하는 부분까지 곱해주기
        if(s[i] == '(') {
            // 이전글자 빼주기
            rs--;
            ll preChar = s[i-1]-'0';
            rs += preChar * recur(i+1,map[i]-1);
            // 괄호로 인덱스 이동
            i = map[i];
        } else {
            rs++;
        }
    }
    
    return rs;
}
 
int main() {
    fill(map, map+600);
    
    cin >> s;
    stack<char> st;
    
    // 괄호 끝나는 위치 기록함
    for(int i=0; i<s.size(); i++) {
        char ec = s[i];
        if(ec == '(') {
            st.push(i);
        } else if(ec==')') {
            int ei = st.top(); st.pop();
            // 괄호 끝나는 위치 기록
            map[ei] = i;
        }
    }
    
    cout << recur(0, s.size()-1<< '\n';
    
    return 0;
}
 
cs

문제유형

  • 시뮬레이션 - 스택 압축
    • 괄호 통해서 압축하는문제
    • 사전에 스택으로, 각각 괄호에서 끝나는 부분 구해놓은 뒤
    • 재귀함수 통해서 괄호 나올때마다 계산해주는 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 1300 내리막길  (0) 2021.03.18
백준 1920 수 찾기  (0) 2021.03.18
백준 2304 창고 다각형  (0) 2021.03.17
백준 14719 빗물  (0) 2021.03.17
백준 14499 주사위 굴리기  (0) 2021.03.17

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


아이디어

  • 오목하게 들어간 부분이 없으니까, 최대값까지 점점 증가해야함
  • 최대값을 기준으로 왼쪽에서는 계속 증가해야하고, 오른쪽에서는 계속 감소해야함
  • 맨 오른쪽부터 시작해서 최대값까지 점점 증가하면 됨

시간복잡도 계산

  • 최대값 인덱스 구하기 : O(N)
  • 왼쪽에서부터, 오른쪽에서부터 최대값까지 순회 : O(N)

자료구조

  • 기둥 높이 기록 : map[N]
    • 최대값 : 1000 > INT 가능
      • 왼쪽에서부터 최대값 int maxLeft
    • 최대값 : 1000 > INT 가능
      • 오른쪽에서부터 최대값 int maxRight
    • 최대값 : 1000 > INT 가능
      • 모두 더한값 rs
    • 1000 * 1000 > 1e6 > INT 가능

코드(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
#include <iostream>
 
using namespace std;
 
int map[1010];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int N; cin >> N;
    int maxv = 0;
    int maxi = 0;
    // 값 받으면서 최대값 인덱스 찾자
    for(int i=0; i<N; i++) {
        int a,b; cin >> a >> b;
        map[a] = b;
        if(map[a] > maxv ) {
            maxi = a;
            maxv = map[a];
        }
    }
    
    int rs=0;
    
    // 왼쪽에서부터 최대값 더함
    int maxLeft = 0;
    for(int i=0; i<maxi; i++) {
        maxLeft = max(maxLeft, map[i]);
        rs += maxLeft;
    }
    
    // 오른쪽쪽에서부터 최대값 더함
    int maxRight = 0;
    for(int i=1000; i>=maxi; i--) {
        maxRight = max(maxRight, map[i]);
        rs += maxRight;
    }
    
    cout << rs << '\n';
    return 0;
}
 
cs

문제유형

  • 시뮬레이션 - 히스토그램
    • 히스토그램 문제는 전체를 한번에 구하려면 어려워짐
    • 각각 위치에서 값을 더해주면 쉽게 할수있음

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 1920 수 찾기  (0) 2021.03.18
백준 1662 압축  (0) 2021.03.17
백준 14719 빗물  (0) 2021.03.17
백준 14499 주사위 굴리기  (0) 2021.03.17
백준 1062 가르침  (0) 2021.03.17

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


아이디어

  • 전체에서 빗물이 어떻게 담기는지 계산하는건 어려움
    • 이런 히스토그램에서는 x축에서 한칸한칸 계산해주는 것이 쉬움
    • 빗물이 담기는 기준 : 왼쪽에서 가장 큰값과 오른쪽에서 가장큰값 중 더 작은값까지 채워짐
    • 왼쪽과 오른쪽에서 최대값을 각각 구함
    • 각 x 칸에서, 왼쪽과 오른쪽값 중 더 작은값과, 현재 값을 비교해서 현재값이 더 작으면 그 차이만큼 더함

시간복잡도 계산

  • 왼쪽, 오른쪽 모두 최대값 구하기 : O(W)
    • 모든x축에 대해서 : O(W)
    • 차이구하기
    • 총합 : O(W + W) : O(W) > 가능

자료구조

  • int maxLeft[510] : 왼쪽중 최대값
    • 최대값 500이므로 INT 가능
      • int maxRight[510] : 오른쪽 중 최대값
    • 최대값 500이므로 INT 가능
      • int map[510] : 각 칸에서의 높이
      • 총합 : int cnt
    • 최대값 : 500*500 = 250000 > INT 가능

코드(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
#include <iostream>
 
using namespace std;
 
int map[510];
int maxLeft[510];
int maxRight[510];
 
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int H,W; cin >> H >> W;
    int maxv = 0;
    for(int i=0; i<W; i++) {
        // 값 기록하면서 왼쪽부터 최대값 등록하기
        cin >> map[i];
        maxv = max(maxv, map[i]);
        maxLeft[i] = maxv;
    }
    
    // 오른쪽에서부터 최대값 구하기
    maxv = 0;
    for(int i=W-1; i>=0; i--) {
        maxv = max(maxv, map[i]);
        maxRight[i] = maxv;
    }
    
    int cnt=0;
//    모든 위치순회
    for(int i=0; i<W; i++) {
        int minv = min(maxLeft[i], maxRight[i]);
        if(minv > map[i]) cnt += minv - map[i];
    }
    
    cout << cnt << '\n';
    return 0;
}
 
cs

문제유형

  • 시뮬레이션 - 히스토그램
    • 이런 히스토그램 문제 나올떄, 일정 구간 * 높일를 구하면 어려워짐
    • 각각 위치에서 값을 더해주면 쉽게 할수있음

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 1662 압축  (0) 2021.03.17
백준 2304 창고 다각형  (0) 2021.03.17
백준 14499 주사위 굴리기  (0) 2021.03.17
백준 1062 가르침  (0) 2021.03.17
백준 9663 N-Queen  (0) 2021.03.16

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


아이디어

  • 주사위 뼈대는 그대로 놓고, 주사위에 쓰인 숫자를 이동 시키자

시간복잡도 계산

  • 전체 명령에 대해 ; O(K)
  • 주사위 이동 : O(4)
  • 총합 : O(4K)

자료구조

  • 전체 지도 : map[30][30]
  • 주사위 : dice[4][3]

코드(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
#include <iostream>
 
using namespace std;
 
int map[30][30];
int dice[4][3];
int dy[] = {0,0,0,-1,1};
int dx[] = {0,1,-1,0,0};
 
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    // 주사위 처음에 모든면이 0이 적혀있음
    fill(&dice[0][0], &dice[3][3], 0);
    
    int N,M,y,x,K; cin >> N >> M >> y >> x >> K;
    
    for(int j=0; j<N; j++) {
        for(int i=0; i<M; i++cin >> map[j][i];
    }
    
    for(int k=0; k<K; k++) {
        int t; cin >> t;
        
        int ny = y + dy[t];
        int nx = x + dx[t];
        
        // 먼저 이동가능한지 먼저 확인
        if(!(ny>=0 && ny<&& nx>=0 && nx < M)) continue;
        
        y = ny;
        x = nx;
        
        // 주사위 이동
        if(t==1) {
            // 동쪽으로
            int tmp = dice[1][0];
            dice[1][0= dice[3][1];
            dice[3][1= dice[1][2];
            dice[1][2= dice[1][1];
            dice[1][1= tmp;
        } else if(t==2) {
            // 서쪽으로
            int tmp = dice[1][0];
            dice[1][0= dice[1][1];
            dice[1][1= dice[1][2];
            dice[1][2= dice[3][1];
            dice[3][1= tmp;
        } else if(t==3) {
            // 북쪽으로
            int tmp = dice[0][1];
            dice[0][1= dice[1][1];
            dice[1][1= dice[2][1];
            dice[2][1= dice[3][1];
            dice[3][1= tmp;
        } else if(t==4) {
            int tmp = dice[0][1];
            dice[0][1= dice[3][1];
            dice[3][1= dice[2][1];
            dice[2][1= dice[1][1];
            dice[1][1= tmp;
        }
        
        // 이동한 칸이 0인경우
        if(map[y][x] == 0) {
            map[y][x] = dice[3][1];
        } else {
            // 아닌경우
            dice[3][1= map[y][x];
            map[y][x] = 0;
        }
        
        cout << dice[1][1<< '\n';
        
    }
    return 0;
}
 
cs

문제유형

  • 시뮬레이션 - 주사위 굴리기
    • 주사위나 큐브나, 회전해야되는 물체 있을때, 실제로 회전하는 것이 아니라 값들을 회전시킴

'알고리즘 > 백준' 카테고리의 다른 글

백준 2304 창고 다각형  (0) 2021.03.17
백준 14719 빗물  (0) 2021.03.17
백준 1062 가르침  (0) 2021.03.17
백준 9663 N-Queen  (0) 2021.03.16
백준 2293 동전 1  (0) 2021.03.16

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


아이디어

  • 26개중에 K개 알파벳을 고를때 (백트래킹 조합),
    • N개의 문자열이 모두 통과하는지 확인
    • 최대 값을 구하는 문제이므로 모든 경우의 수에서 다 해보자

시간복잡도 계산

  • 백트래킹 O(N^N)
    • anta, tica에서 5개는 고정
    • 백트래킹으로 20개중 최대 20개 고를떄 > 20^20 > 시간초과
    • 그치만, 가지치기를 예상해서 한번 해보자.

자료구조

  • 문자열 리스트 : vector
  • 백트래킹 리스트 : vector
    • 리스트 내부 최대값 26이므로 가능
  • 알파벳 중복 체크 : bool[26]

코드(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
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
vector<string> s;
bool chk[26];
int N,K;
int maxv = 0;
vector<int> v;
 
void dfs(int num) {
    // 5개 제외하고 모두 고를경우
    if(num == K-5) {
        int cnt=0;
        for(string es : s) {
            bool sw = false;
            for(int i=0; i<es.size(); i++) {
                char ec = es[i];
                if(chk[ec-'a'== false) {
                    sw = 1;
                    break;
                }
            }
            if(sw==false) cnt++;
        }
        
        maxv = max(maxv, cnt);
        
        return;
    }
    
    // 알파벳 중복체크 후 추가
    // 조합이므로 리스트 맨 뒤에서 빼기
    int lastv = -1;
    if(!v.empty()) lastv = v.back();
    
    for(int i=lastv+1; i<26; i++) {
        if(chk[i]) continue;
        chk[i] = 1;
        v.push_back(i);
        
        dfs(num+1);
        
        chk[i] = 0;
        v.pop_back();
        
    }
    
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    fill(chk, chk+260);
    
    cin >> N >> K;
    
    // 문자열 잘라서 보관
    for(int i=0; i<N; i++) {
        string es; cin >>es;
        // 잘라서 보관
        s.push_back(es.substr(4,es.size()-8));
    }
    
    chk['a'-'a'= 1;
    chk['n'-'a'= 1;
    chk['t'-'a'= 1;
    chk['i'-'a'= 1;
    chk['c'-'a'= 1;
    
    // 5개 이하일경우 문자열 읽을 수 없음
    if(K<5) {
        cout << 0 << '\n';
        return 0;
    }
    
    dfs(0);
    
    
    cout << maxv << '\n';
    
    return 0;
}
 
cs

문제유형

  • 백트래킹 - 순열, 조합
    • 순열 : 재귀함수 내에서 순회할때 이전 중복값 체크
    • 조합 : 리스트 마지막 다음부터 순회
    • 값 중복되지 않도록 : 재귀함수 내 before 사용해서, 이전이랑 값 같을경우 넘김

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 14719 빗물  (0) 2021.03.17
백준 14499 주사위 굴리기  (0) 2021.03.17
백준 9663 N-Queen  (0) 2021.03.16
백준 2293 동전 1  (0) 2021.03.16
백준 15663 N과 M (9)  (0) 2021.03.15

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


아이디어

  • 퀸이 놓는 위치를 백트래킹 하자
  • 그냥 할 경우 시간복잡도가 어마어마하게 큼
    • O(N^2^(N^2)) : 225^225
    • 그래서 가지를 쳐가면서 백트래킹 시작
  • 퀸이기 때문에 한번에 한줄씩 밖에 안들어감
    • 한줄씩 백트래킹 수행
    • 세로의 경우 추후 별도 배열 만들어서 중복체크 해주자

시간복잡도 계산

  • 한줄에 하나씩 들어가는 백트래킹이므로
    • O(N^N) = 15^15
    • 시간초과 날것 같지만
    • 중간 중간 가지를 칠 것으로 예상하며 해보자

자료구조

  • bool column[15] : 해당 컬럼에 퀸 있는지 체크
  • 경우의 수 : cnt
    • 최대 15^15 될수도 있으므로, 혹시 모르니 long long으로 사용
  • 전체 맵 bool map[15][15]

코드(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
#include <iostream>
 
using namespace std;
typedef long long ll;
 
bool map[20][20];
bool column[20];
 
int N;
ll cnt;
 
bool diagonalChk(int y, int x) {
    // 왼쪽 대각선
    int j = y;
    int i = x;
    while(j>=0 && i >=0) {
        if(map[j][i]) return 1;
        j--;
        i--;
    }
    
    // 오른쪽 대각선
    j = y;
    i = x;
    while(j>=0 && i < N) {
        if(map[j][i]) return 1;
        j--;
        i++;
    }
    
    return 0;
    
}
void dfs(int y) {
    if(y==N) {
        // N개를 놓는 경우 cnt 증가
        cnt++;
        return;
    }
    
    for(int i=0; i<N; i++) {
        if(column[i]) continue;
        if(diagonalChk(y,i) == truecontinue;
        column[i] = 1;
        map[y][i] = 1;
        
        dfs(y+1);
        
        column[i] = 0;
        map[y][i] = 0;
    }
    
}
 
int main() {
    // 초기화
    fill(column, column+200);
    fill(&map[0][0], &map[19][20], 0);
    cnt=0;
    
    cin >> N;
    
    dfs(0);
    
    cout << cnt << '\n';
    
    return 0;
}
 
cs

문제유형

  • 백트래킹 - 2차원 경우의수

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 14499 주사위 굴리기  (0) 2021.03.17
백준 1062 가르침  (0) 2021.03.17
백준 2293 동전 1  (0) 2021.03.16
백준 15663 N과 M (9)  (0) 2021.03.15
백준 15652 N과 M (4)  (0) 2021.03.15

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


아이디어

  • 가치가 클수록, 앞에서 구한 값을 재활용할 수 있음 > DP
  • 접근 1. DP[K] : K원일떄 동전의 경우의 수
    • DP[K] = DP[K-동전1] + DP[K-동전2] + ...
    • 이때는 겹치는 경우의 수가 발생
    • 낮은 동전을 계산할때, 높은 동전의 경우의수가 들어가면 안됨
  • 접근 2. DP[N][K] : K원일떄, N개의 종류로 구할 수 있는 경우의 수
    • DP[N][K] = DP[N-1][K-coin[N]] + DP[N-1][K-coin[N]*2] + ...
    • N번쨰 코인의 가치를 뺀 이전 N-1개의 종류로 만든 경우의 수의 합
    • 그럼 DP[N][K] 의 크기가 1e4 * 1e2 > 1e6 의 INT 발생
    • 하지만 메모리 제한이 4MB > 4*1e6 일경우 비슷하지만, 다른 프로그램 돌리는데 메모리 있어서 초과 발생
  • 접근 3. DP[N] : N원일떄 경우의 수
    • 단 접근 2를 압축시켜 놓은 버전
    • K+1의 경우 K만 사용하고, 이전값을 사용하지 않음
    • 그럼 DP[N]만을 사용해서 재활용 가능
    • 단 이때, 코인을 여러번 뺴주지 말고 한번만 빼줘야함
      • 이미 한번 뺄경우, 뺀곳에 여러번 뺀 경우의 수가 담겨있음

시간복잡도 계산

  • 모든 가치에 대해 : O(K)
    • 모든 종류는 각각 이전 종류를 참고함
      • 이때 최대 N번 참고
      • O(N^2)
  • 총합 : O(K+N^2) = 2e4 > 가능

자료구조

  • DP값 : DP[N]
    • K 최대 : 1e4
    • N 최대 : 1e2
  • coin 가치 : int[]
    • 최대 1e5 > INT 가능

코드(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
#include <iostream>
 
using namespace std;
 
int coin[110];
int dp[10010];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int N,K; cin >> N >> K;
    for(int i=1; i<=N; i++cin >> coin[i];
    
    //dp값 초기화
    fill(dp, dp+100100);
    
    dp[0= 1;
    
    for(int j=1; j<=N; j++) {
        for(int i=0; i<=K; i++) {
            if(i-coin[j] >= 0) dp[i] += dp[i-coin[j]];
        }
    }
    
    cout << dp[K] << '\n';
    
    return 0;
}
 
cs

문제유형

  • DP - 이전 종류값 만을 포함
    • dp[N][K] = N개의 종류를 가지고있을때, K가치를 가질때의 dp 값
    • 단, 이전값만을 활용하는경우, dp[N]으로 줄여서 사용할 수 있음
      • 단 한번만 빼줘야함, 뺀곳에 여러번 뺀 경우의 수가 담겨있음
    • 대표문제 : knapsack
      • https://www.acmicpc.net/problem/12865
      • 여러 종류의 아이템을 한번씩 넣을수있을때, 한정된 비용에서의 최대가치 구하는 문제
      • dp[N][K] : N개의 종류를 들고, K만큼의 무게에서의 가질수 있는 최대 가치

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 1062 가르침  (0) 2021.03.17
백준 9663 N-Queen  (0) 2021.03.16
백준 15663 N과 M (9)  (0) 2021.03.15
백준 15652 N과 M (4)  (0) 2021.03.15
백준 15651 N과 M (3)  (0) 2021.03.15

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


아이디어

  • 인덱스를 가지고 순열을 구하되
  • 값이 중복되면 안됨
  • 순열이므로 중복값 체크한 후,
  • 재귀함수 내에서 이전값을 가지고 있다가, 같은값일경우 넘어감

시간복잡도 계산

  • O(10^M) : 10e8 > 가능

자료구조

  • 백트래킹 리스트 : vector
    • 최대값 : 8 > INT 가능
  • bool chk[10] : 중복값 체크

코드(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
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int N,M;
vector<int> v;
int nums[10];
bool chk[10];
 
void dfs() {
    if(v.size() == M) {
        // vector 안에 인덱스 저장
        for(int x : v) cout << nums[x] << ' ';
        cout << '\n';
        return;
    }
    
    int pre = -1;
    for(int i=0; i<N; i++) {
        // 이전값과 중복되면 건너뜀
        if(chk[i]) continue;
        if(pre == nums[i]) continue;
        chk[i] = 1;
        pre = nums[i];
        v.push_back(i);
        
        dfs();
        
        chk[i] = 0;
        v.pop_back();
    }
    
}
 
int main() {
    fill(chk, chk+100);
    cin >> N >> M;
    for(int i=0; i<N; i++cin >> nums[i];
    sort(nums, nums+N);
    dfs();
    return 0;
}
 
cs

문제유형

  • 백트래킹 - 순열, 조합
    • 순열 : 재귀함수 내에서 순회할때 이전 중복값 체크
    • 조합 : 리스트 마지막 다음부터 순회
    • 값 중복되지 않도록 : 재귀함수 내 before 사용해서, 이전이랑 값 같을경우 넘김

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 9663 N-Queen  (0) 2021.03.16
백준 2293 동전 1  (0) 2021.03.16
백준 15652 N과 M (4)  (0) 2021.03.15
백준 15651 N과 M (3)  (0) 2021.03.15
백준 15650 N과 M (2)  (0) 2021.03.15

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


아이디어

  • 중복이 가능한 조합
  • 기존 조합방법 : 리스트의 마지막값 다음부터 순회하며 백트래킹
  • 중복이 가능하므로, 마지막값 부터 순회하면서 수행

시간복잡도 계산

  • O(10^M) : 1e8 > 가능

자료구조

  • 백트래킹 리스트 : vector
    • 최대값 10 > INT 가능

코드(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
#include <iostream>
#include <vector>
 
using namespace std;
 
vector<int> v;
int N,M;
 
void dfs() {
    if(v.size() == M) {
        for(int x : v) cout << x << ' ';
        cout << '\n';
        return;
    }
    
    int last = 1;
    if(!v.empty()) last = v.back();
 
    for(int i=last; i<=N; i++) {
        v.push_back(i);
        dfs();
        v.pop_back();
    }
}
 
int main() {
    cin >> N >> M;
    dfs();
    return 0;
}
 
cs

문제유형

  • 백트래킹 - 순열, 조합
    • 순열 : 재귀함수 내에서 순회할때 이전 중복값 체크
    • 조합 : 리스트 마지막 다음부터 순회
    • 값 중복되지 않도록 : 재귀함수 내 before 사용해서, 이전이랑 값 같을경우 넘김

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 2293 동전 1  (0) 2021.03.16
백준 15663 N과 M (9)  (0) 2021.03.15
백준 15651 N과 M (3)  (0) 2021.03.15
백준 15650 N과 M (2)  (0) 2021.03.15
백준 15649 N과 M (1)  (0) 2021.03.15

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


아이디어

  • 백트래킹 - 순열,조합
    • 중복 순열이기 때문에, 중복값 체크해줄 필요없음
    • 순열처럼 풀되 중복값 체크해주지 않으면 됨

시간복잡도 계산

  • 10^M : 1e7 > 가능

자료구조

  • 백트래킹 리스트 : vector
    • 최대값 7 > INT 가능

코드(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
#include <iostream>
#include <vector>
 
using namespace std;
 
int N,M;
vector<int> v;
 
void dfs() {
    if(v.size() == M) {
        for(int x : v) cout << x << ' ';
        cout << '\n';
        return;
    }
    
    for(int i=1; i<=N; i++) {
        v.push_back(i);
        dfs();
        v.pop_back();
    }
}
 
int main() {
    cin >> N >> M;
    dfs();
    return 0;
}
 
cs

문제유형

  • 백트래킹 - 순열, 조합
    • 순열 : 재귀함수 내에서 순회할때 이전 중복값 체크
    • 조합 : 리스트 마지막 다음부터 순회
    • 값 중복되지 않도록 : 재귀함수 내 before 사용해서, 이전이랑 값 같을경우 넘김

비슷한 문제

'알고리즘 > 백준' 카테고리의 다른 글

백준 15663 N과 M (9)  (0) 2021.03.15
백준 15652 N과 M (4)  (0) 2021.03.15
백준 15650 N과 M (2)  (0) 2021.03.15
백준 15649 N과 M (1)  (0) 2021.03.15
백준 2579 계단 오르기  (0) 2021.03.14

+ Recent posts