Jayharvey

백준 6359 만취한 상범

jayharvey — Fri, 18 May 2018 22:41:20 +0900

<약수의 성질을 이용하는 법>



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
// 30분
// d[i] = 방의 갯수가 i개 일 때 열려있는 방의 갯수.
#include <cstdio>
using namespace std;
 
int a[101]; // i번째 약수의 갯수
int d[101];
 
int main() {
    int t;
    scanf("%d", &t);
    for (int i = 1; i <= 100; i++) {
        for (int j = 1; j * j <= i; j++) {
            if (i%j == 0) a[i] += 2;
            if (j*j == i) a[i] -= 1;
        }
    }
    for (int i = 1; i <= 100; i++)
        d[i] = d[i - 1] + (a[i] % 2 == 0 ? 0 : 1);
    while (t--) {
        int n;
        scanf("%d", &n);
        printf("%d\n", d[n]);
    }
    return 0;
}
 
Colored by Color Scripter
cs

DP 문제

먼저 1~100까지 각각의 약수의 갯수를 구해준뒤 문제를 해결하였다.

약수의 갯수를 구하는 시간을 줄이기 위해 제곱수를 이용하였다.

약수의 성질을 이용하면 약수란 나누었을 때 0이 되게 하는 수 이므로

14번 줄 if (i%j == 0) a[i] += 2;

즉, i의 약수는 나누었을 때 0이 되는 j 이다. 그리고 약수의 성질을 잘 살펴보면

제곱수를 제외하고는 항상 짝을 이룬다.

예를 들어

10의 약수는 1, 2, 5, 10 인데 1은 10과 짝을 이루고 2는 5와 짝을 이루므로

10과 같이 제곱수가 아닌 경우에는 sqrt(10)까지만 연산을 하되 2씩 더해주면 된다.

====================================

여기서 제곱수는 예외가 되는데

1에서 10까지 약수의 갯수를 나열해 보면 다음과 같다.

1 2 3 4 5 6 7 8 9 10

1 2 2 3 2 4 2 4 3 4

제곱수에 해당하는 1,4,9 만 약수의 갯수가 홀수 인 것을 알 수 있다.

그러므로 제곱수에 해당하는 수의 약수를 구한 뒤에는 다음과 같이 1을 빼준다.

15번 줄 if (j*j == i) a[i] -= 1;

각각의 약수의 갯수를 구한 이후 dp의 성질을 이용하면 다음과 같다.

19번 줄 d[i] = d[i - 1] + (a[i] % 2 == 0 ? 0 : 1);

d[i] = i-1번째 까지 열린방의 갯수 + 현재 방의 상태

※ 정리해보면, 1~10까지 직접 나열하여 방이 열려있는 유무를 확인해보면

최종적으로 "약수의 갯수"가 짝수일 때 닫혀있고, 홀수일 때 열려있다는 것을 알수 있다.

그리고 약수의 갯수가 짝수라는 것은 해당 수가 제곱수라는 뜻이다.

<DP를 이용한 일반적인 풀이법>

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
// 30분
// d[i] = 방의 갯수가 i개 일 때 열려있는 방의 갯수.
#include <cstdio>
using namespace std;
 
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n;
        scanf("%d", &n);
        int d[101] = { 0 }; // 모든 원소를 0으로 초기화 시킴.
        for (int i = 1; i <= n; i++) {
            for (int j = 1; i * j <= n; j++) {
                if (d[i*j]) d[i*j] = !d[i*j];
                else d[i*j] = !d[i*j];
            }
        }
        int sum = 0;
        for (int i = 1; i <= n; i++) sum += d[i];
        printf("%d\n", sum);
    }
    return 0;
}
 
 
Colored by Color Scripter
cs

백준 1309 동물원

jayharvey — Fri, 18 May 2018 19:05:27 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 다시 풀기(힌트 얻어서 품)
 
// d[i][0] = 2*i에 사자를 배치하되 마지막 칸에는 배치하지 않는 경우
// d[i][1] = 2*i에 사자를 배치하되 마지막 칸 왼쪽에 배치하는 경우
// d[i][2] = 2*i에 사자를 배치하되 마지막 칸 오른쪽에 배치하는 경우
 
#include <cstdio>
using namespace std;
 
int n, d[100001][3];
 
int main() {
    scanf("%d", &n);
    d[0][0] = 1;
    for (int i = 1; i <= n; i++) {
        d[i][0] = (d[i - 1][0] + d[i - 1][1] + d[i - 1][2]) % 9901;
        d[i][1] = (d[i - 1][0] + d[i - 1][2]) % 9901;
        d[i][2] = (d[i - 1][0] + d[i - 1][1]) % 9901;
    }
    printf("%d\n", (d[n][0] + d[n][1] + d[n][2]) % 9901);
    return 0;
}
 
Colored by Color Scripter
cs

백준 1965 상자넣기

jayharvey — Fri, 18 May 2018 18:06:51 +0900

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
// 다시 풀기
 
// D[i]를 뭘로 놓냐가 핵심 ! 
 
// 처음 접근할 때 D[i]를 A[i]까지 검사했을 때 가장 긴 부분 수열의 길이
// 로 설정했더니 안 풀림.
 
// D[i] = A[1], , , A[i] 까지 수열이 있을 때, A[i]을 마지막으로 하는
// 가장 긴 증가하는 부분 수열의 길이.
 
#include <cstdio>
#include <algorithm> // *max_element()를 이용하기 위함.
#include <vector>
using namespace std;
 
int main() {
    int n;
    scanf("%d", &n);
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    vector<int> d(n);
    for (int i = 0; i < n; i++) {
        d[i] = 1; // 자기자신만 있을 경우 1이므로. 최소 1이됨.
        for (int j = 0; j < i; j++) {
            // 현재 d[i]가 d[j] + 1보다 크거나 같다면 대치시킬 필요 x
            if (a[j] < a[i] && d[j] + 1 > d[i]) {
                d[i] = d[j] + 1;
            }
        }
    }
    printf("%d\n", *max_element(d.begin(), d.end()));
    return 0;
}
Colored by Color Scripter
cs

이 문제를 처음보자마자 든 생각은

" 11053 가장 긴 증가하는 부분 수열 문제와 똑같다 " 이다. 실제로 그렇다.

하지만 알고리즘을 한 달만에 다시 하려다 보니 접근법이 도저히 떠오르지 않고

오래 고민할 시간도 없어서 전에 풀었던 11053 문제 코드 보고 풀었다...

간단히 리뷰해보면,

DP 문제에서는 d[]를 뭘로 정의하느냐가 가장 핵심이다.

그리고 배열로 선언하지 않고 vector로 선언해야

*max_element(d.begin(), d.end())

위 함수를 이용하여 배열 원소들 중에 최댓값을 쉽게 찾을 수 있다.

백준 11051 이항 계수 2

jayharvey — Fri, 18 May 2018 17:22:01 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 18분
 
#include <cstdio>
using namespace std;
 
int d[1001][1001];
 
// nCr = n-1Cr + n-1Cr-1
int dp(int n, int k) {
    if (d[n][k] > 0) return d[n][k];
    if (n < k) return 0;
    else if (n == k || k == 0) return 1;
    else 
        return d[n][k] = (dp(n - 1, k) + dp(n - 1, k - 1)) % 10007;
}
 
int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    printf("%d\n", dp(n, k));
    return 0;
}
 
Colored by Color Scripter
cs

DP를 이용한 조합 문제 풀이

예외조건을 잘 처리해줄 것!

백준 4344 평균은 넘겠지

jayharvey — Fri, 18 May 2018 16:07:49 +0900

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
#include <cstdio>
#include <cstring>
using namespace std;
 
int score[1000];
 
int main() {
    int c;
    scanf("%d", &c);
    while (c--) {
        memset(score, 0, sizeof(score));
        int n , sum = 0;
        scanf("%d", &n);
        for (int i = 0; i < n; i++) {
            scanf("%d", &score[i]);
            sum += score[i];
        }
        double avg = (double)sum / n;
        int num = 0;
        for (int i = 0; i < n; i++)
            if (score[i] > avg)
                num += 1;
        printf("%.3f%%\n", (double)num / n * 100);
    }
    return 0;
}
 
Colored by Color Scripter
cs

자료형에 약해 항상 피해다녔는데 이번에 풀어보았다

매 테스트케이스마다 배열 공간을 새로이 할당하는 것보다는

0으로 초기화 시켜주는게 나을거 같아 memset()을 이용하였다.

(But, 둘 다 해본 결과 메모리 사용량이나 시간에 차이가 없다. 아마 새로이 할당하는 게 아니라 변수명으로 덮어씌우는 듯.)

핵심은

나누었을 때 소숫점이하 자리까지 얻으려면 다음과 같이 sum에 명시적 형변환을 해줘야 한다.

double avg = (double)sum / n;

그리고

소숫점 이하 셋째자리까지 출력하고 싶다면 %.3f 를 써줘야 하고

그 뒤에 % 문자를 출력하고 싶다면 %% 를 써줘야 한다.

printf("%.3f%%\n", (double)num / n * 100);

백준 9251 LCS

jayharvey — Fri, 18 May 2018 15:38:07 +0900

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
// 다시 풀기
 
#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
using namespace std;
 
string s1, s2;
int d[1001][1001] ;
 
int dp(int a, int b) {
    if (a < 0 || b < 0) return 0;
    if (d[a][b] != -1) return d[a][b];
    return d[a][b] = max({ dp(a - 1, b), dp(a, b - 1), dp(a - 1, b - 1) + (s1[a] == s2[b]) });
}
 
int main() {
    cin >> s1;
    cin >> s2;
    memset(d, -1, sizeof(d));
    printf("%d\n", dp(s1.size() - 1, s2.size() - 1));
    return 0;
}
 
 
Colored by Color Scripter
cs

내겐 상당히 까다로웠던 문제.

Top-Down 방식의 DP로 접근.

1. string으로 문자열 입력받기

string대신에 char s1[1001]로 입력받을 경우 문자열 길이를 구하기가 까다로워진다.

string을 사용하면

A. 문자열 입력받기 편하고 cin >> s1;

B. 배열처럼 인덱스로 접근할 수 있고 s1[a] == s2[b]

C. 길이를 쉽게 구할 수 있다. s1.size()

2. memoization을 0이 아닌 -1로 초기화하기.

int d[1001][1001] ;

memset(d, -1, sizeof(d));

cstring 라이브러리를 include하여 memset으로 -1로 초기화 해준다.

보통 배열을 0으로 초기화하지만 이 경우에는 d[i][j] 가 0인 경우가 필요하므로

한번도 참조하지 않았다는 의미에서 -1로 초기화 해준다.

3. max() 로 삼중 비교하기

max()는 두개의 인자를 받으므로 두 수만 비교가능한 것으로 알고 있다.

물론, max()를 겹쳐서 삼중 비교가 가능하지만 다음과 같이 {} 안에 써주면 삼중비교가 가능하다.

max({ dp(a - 1, b), dp(a, b - 1), dp(a - 1, b - 1) + (s1[a] == s2[b]) });

백준 2167 2차원 배열의 합

jayharvey — Fri, 18 May 2018 14:25:13 +0900

<DP를 적용하지 않고 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
#include <cstdio>
using namespace std;
 
int arr[301][301];
int n, m;
 
int main() {
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            scanf("%d", &arr[i][j]);
        }
    }
    int k;
    scanf("%d", &k);
    while (k--) {
        int a, b, x, y;
        scanf("%d %d %d %d", &a, &b, &x, &y);
        int sum = 0;
        for (int i = a; i <= x; i++) {
            for (int j = b; j <= y; j++) {
                sum += arr[i][j];
            }
        }
        printf("%d\n", sum);
    }
    return 0;
}
 
Colored by Color Scripter
cs

이렇게 답안을 제출해도 정답처리가 된다.

하지만 배열이 커지고 구해야 할 부분합의 갯수가 많아질 경우 시간초과가 날 것이다.

그러므로 이 문제를 DP를 이용하여 풀어보면 다음과 같다.

<DP를 적용하여 문제를 푼 경우>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <cstdio>
using namespace std;
 
int arr[301][301];
int d[301][301];
int n, m;
 
int main() {
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            scanf("%d", &arr[i][j]);
            d[i][j] = arr[i][j] + d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
        }
    }
    int k;
    scanf("%d", &k);
    while (k--) {
        int a, b, x, y;
        scanf("%d %d %d %d", &a, &b, &x, &y);
        printf("%d\n", d[x][y] - d[a - 1][y] - d[x][b - 1] + d[a - 1][b - 1]);
    }
    return 0;
}
Colored by Color Scripter
cs

걸린 시간을 비교해보면

DP로 풀었을 때 걸린 시간이 20분의 1로 줄었다는 것을 확인할 수 있다. (하지만 메모리를 더 씀..)

(중간에 시간초과는 코딩실수....)

백준 2163 초콜릿 자르기

jayharvey — Fri, 18 May 2018 13:48:36 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 12분
#include <cstdio>
using namespace std;
 
int d[301][301];
 
int dp(int n, int m) {
    if (d[n][m] > 0) return d[n][m];
    if (n == 1 && m == 1) return 0;
    if (n == 1)
        return d[n][m] = dp(n, m / 2) + dp(n, m - m / 2) + 1;
    else
        return d[n][m] = dp(n / 2, m) + dp(n - n / 2, m) + 1;
}
 
int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    printf("%d\n", dp(n, m));
    return 0;
}
 
Colored by Color Scripter
cs

다이나믹 프로그래밍 문제

이 문제는 정말 쉽다. 단순하게 n*m-1을 출력해도 정답 처리가 된다.

하지만 dp문제를 풀기로 했으므로 dp다운 접근을 하여 코드를 짰다.

백준 1010 다리 놓기

jayharvey — Fri, 18 May 2018 11:35:07 +0900

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
#include <cstdio>
using namespace std;
 
int d[31][31];
 
// nCr = n-1Cr + n-1Cr-1
int com(int n, int r) {
    if (d[n][r] > 0) return d[n][r];
    if (n == r || r == 0) return 1;
    else if (n < r) return 0;
    else {
        return d[n][r] = com(n - 1, r) + com(n - 1, r - 1);
    }
}
 
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n, m;
        scanf("%d %d", &n, &m);
        printf("%d\n", com(m, n));
    }
    return 0;
}
 
Colored by Color Scripter
cs

6번 줄의 // nCr = n-1Cr + n-1Cr-1 이것을 이용하는 것이 핵심이다.

일반적인 조합의 성질인

이 공식을 이용하여 코드를 짜는 경우 long long int 자료형으로도 29! 을 담을 수 없으므로 불가능한 방법이다.

DP로 풀기로 했으니 그 성질을 이용하여 위와 같이 풀었다.

22번 줄의 printf("%d\n", com(m, n));

com을 호출할 때 인자를 바꿔서 넣어주어야 하는 것을 잊지말 것.

백준 1003 피보나치 함수

jayharvey — Fri, 18 May 2018 10:47:59 +0900

<Bottom-Up> 방식

n은 최대 40까지이므로 for문을 돌려 40까지의 답을 구해 놓은 후 풀었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <cstdio>
using namespace std;
 
int d[41][2];
 
int main() {
    d[0][0] = d[1][1] = 1;
    d[0][1] = d[1][0] = 0;
 
    for (int i = 2; i <= 40; i++) {
        d[i][0] = d[i - 1][0] + d[i - 2][0];
        d[i][1] = d[i - 1][1] + d[i - 2][1];
    }
    int t;
    scanf("%d", &t);
    while (t--) {
        int n;
        scanf("%d", &n);
        printf("%d %d\n", d[n][0], d[n][1]);
    }
    return 0;
}
 
Colored by Color Scripter
cs

<Top-Down 방식>

규칙을 잘 살펴보면 n일 때의 0의 갯수는 n-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
#include <cstdio>
using namespace std;
 
int d[41];
 
int fibonacci(int n) {
    if (d[n] > 0) return d[n];
    if (n == 0) return 0;
    else if (n == 1) return 1;
    else {
        return d[n] = fibonacci(n - 1) + fibonacci(n - 2);
    }
}
 
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n;
        scanf("%d", &n);
        if (n == 0) printf("1 0\n");
        else printf("%d %d\n", fibonacci(n-1), fibonacci(n));
    }
    return 0;
}
 
Colored by Color Scripter
cs