반응형

10989번 수 정렬하기

n개의 수를 입력받고
n만큼 배열생성 후

오름차순출력 생각하고 같거나 높을 때 뒤로 내리는 정렬식
해봅시다

처음에는 순차정렬같은거로 해보고

두번째 구현때는 끝값기준으로 비교하는 정렬을 해보자.(이건 책에서 우연히 봄)

결국 시간초과됨ㅋㅋ
일단 대가리를 열심히 굴려서 구현한게 버블정렬 비스무리하게 만들었는데 완전한 버블이였으면 맞췄을거 버블을 제대로 구현하지 못해 시간초과가 계속 나왔다.

결국은 내장메서드 Arrays.sort()를 사용해서 해결...
이것도 나중엔 복수하러 온다.

--------

hint - 시간이 상당히 빡빡하니 속도최적화를 최우선시 해야한다
ex) BufferedReader, StringBuffer 등등 사용

--------
solution

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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
 
public class Main {
 
    public static void main(String[] args) throws NumberFormatException, IOException {// 순차정렬할것
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        
        int[] arrayInt = new int[n];
        
        for (int i = 0; i < n; i++) {
            arrayInt[i] = Integer.parseInt(br.readLine());
        }
        
        Arrays.sort(arrayInt);
        
        
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<arrayInt.length;i++){
            sb.append(arrayInt[i]+"\n");
        }
        System.out.println(sb);
    }
}
cs


실행시간 - 2700ms

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 2563번 색종이 자바로 풀어 본 짧은 글  (0) 2023.01.05
백준 17478번 재귀함수가 뭔가요? 자바로 풀어 본 짧은 글  (0) 2022.12.29
백준 2798번 블랙잭 자바로 풀어 본 짧은 글  (0) 2022.12.27
백준 2292번 벌집 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1712번 손익분기점 자바로 풀어 본 짧은 글  (0) 2022.12.20
반응형

2798번 블랙잭

첫째줄 입력 : n M
둘째줄 입력 : n의 갯수만큼의 넘버

알고리즘
해당 수 중에서 3개의 수 합이 M에 가장 가까운 합을 구해야한다 때문에 고민을 좀 했었는데 지금 생각나는건 전체탐색(브루트포스) 을 하는데 정답 값이 나왔을 때에만 종료조건을 달아서 해결하는 방식이다.

--------

hint

3중for문 이후 if(i != j && i != g && j != g)
3중for문으로 계속 탐색하는데 i,j,g가 서로 같을 때는 연산x
이후 만약에 정답 수가 나오면 그대로 중첩for문을 나오게끔해서 약간의 최적화 시도

--------

solution

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
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n, M;
        int a;
        int maxTmp = 0;
        int end = 0;
        
        n = sc.nextInt();
        M = sc.nextInt();
        
        
        int[] intArray = new int[n];
        
        for(int i = 0; i < n; i++) {
            intArray[i] = sc.nextInt();
        }
        //3중for문으로 확인작업
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                for(int g = 0; g < n; g++) {
                    if(i != j && i != g && j != g) {
                        
                        a = intArray[i] + intArray[j] + intArray[g];
                        
                        if(M >= a) {
                            if(maxTmp < a) {
                                maxTmp = a;
                            }
                            if(maxTmp == M) {
                                end = 1;
                                break;
                            }
                        }
                    }
                }
                if(end == 1){break;}
            }
            if(end == 1){break;}
        }
        System.out.println(maxTmp);
    }
}
cs

실행시간 - 232ms

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 17478번 재귀함수가 뭔가요? 자바로 풀어 본 짧은 글  (0) 2022.12.29
백준 10989번 수 정렬하기 자바로 풀어 본 짧은 글  (0) 2022.12.29
백준 2292번 벌집 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1712번 손익분기점 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1193번 분수찾기 자바로 풀어 본 짧은 글  (0) 2022.12.20
반응형

2292번 벌집

처음 문제 마주했을 때 숨이 막혔는데 생각보다 난이도가 쉬워보인다.
첫번째 칸 기준으로 점차 늘어나는걸 잘 캐치해야할듯
분수찾기의 쉬운버전같음

 

--------
hint

답이 없는 줄 알았는데, 규칙이 생각보다 쉽다.
중앙 1 기준으로  첫번째 depth = 6
두번째 depth = 12
세번째 depth = 18
....
해당 범위에 맞게 하면 됨

규칙성을찾고
a + 1이 입력값 n을 넘겼을 때 종료 후 depth 출력

--------

Solution

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
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args){
        int n;
        Scanner sc = new Scanner(System.in);
        int a = 1;
        int b = 0;
        n = sc.nextInt();
        int count = 0; // depth대신 count사용
        if(n == 1) {
            System.out.println(1);
        }
        else {
            while(true) {
                a = a + b;
                b = b + 6;
                count++;
                if(n < a + 1) {
                    break;
                }
            }
            System.out.println(count);
        }
    }
}
cs

실행시간 - 204ms

break하는 위치를 찾는데 약간 애먹었다.

처음 1을 갖고 시작하기 때문에 n이 a+1보다 적어질 때의 카운트를 출력하면 된다.

아직도 상당히 범위도 잡기 어렵고 규칙을 코드로 구현하기에 헷갈리지만 계속 형태와 방식에 익숙해져야 한다...

수학부분 너무 어렵다

 

 

 

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 10989번 수 정렬하기 자바로 풀어 본 짧은 글  (0) 2022.12.29
백준 2798번 블랙잭 자바로 풀어 본 짧은 글  (0) 2022.12.27
백준 1712번 손익분기점 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1193번 분수찾기 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 2869번 달팽이는 올라가고 싶다 자바로 풀어 본 짧은 글  (0) 2022.12.18
반응형

1712번 문제 손익분기점


고정비용 : A
노트북 한대 가변비용 : B
노트북 판매가격 : C

A + B - C < 0이 되었을 때 끝남.
달팽이랑 비슷한거같은데?

조건 : 21억 이하 자연수면 int로 가능
분기점 존재하지않으면 -1 or 손익분기점 판매수

--------
hint
앞서 올린 달팽이와 상당히 유사함
조건만 잘 따져서 해보자

--------
Solution

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
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args){
        int A, B, C;
        Scanner sc = new Scanner(System.in);
        int sellmoney;
        int sonik;
        int count;
        
        A = sc.nextInt();
        B = sc.nextInt();
        C = sc.nextInt();
        
        //구현부
        if(B < C) {
            sellmoney = C - B; // 판매시 순 이익
            
            sonik = A / sellmoney;
            count = sonik + 1; // 마지막 하나 더 팔아야 분기점 돌파
            System.out.println(count);
        }else {
            System.out.println(-1);//손익분기점 미존재
        }
    }
}
cs

실행시간 - 204ms

고정비용 : A
노트북 한대 가변비용 : B
노트북 판매가격 : C

sellmoney = C - B; // 판매시 순 이익

sonik = A / sellmoney;

B < C 일 때는 -1출력

달팽이의 힘.... 정말 쉽게풀었따

 

 

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 2798번 블랙잭 자바로 풀어 본 짧은 글  (0) 2022.12.27
백준 2292번 벌집 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1193번 분수찾기 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 2869번 달팽이는 올라가고 싶다 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 2204번 도비의 난독증 테스트 자바로 풀어 본 짧은 글  (0) 2022.12.18
반응형

1193번 분수찾기 문제

생각

처음 시도한 방법 : 칸을 생각하지 않고 분자와 분모의 규칙성을 찾아내서 

1 - 1 - 2 - 3 - 2 - 1 - 1 - 2 - 3 - 4 - 5 - 4 - 3 - 2 – 1 - 1– 2 – 3 – 4 – 5 – 6 – 7 – 6 – 5 – 4 – 3 – 2 - 1

분자 A 규칙 : 1 + 2의 기준 패턴으로 계속 더해졌다 빼졌다 반복

1 – 2 – 1 – 1 – 2 – 3 – 4 – 3 – 2 – 1 – 1 – 2 – 3 – 4 – 5 – 6 – 5 – 4 – 3 – 2 - 1

분모 규칙 : 0 + 2의 기준 패턴으로 계속 더해졌다 빼졌다 반복

이러한 패턴을  알게 돼서 구현만 하면 될줄 알았는데 나중에 확인해보니 시간제한이 0.5초였다.

또 내가 수학적 생각을 안하고 무대포로 풀 생각만 했구나 싶었다.

결과적으로 저렇게 연산을 했을 때 시간이 부족해서 필히 문제가 생겼을 것이다.

아무리 생각해도 정확한 정답이 나오지 않아 결국 다른 분들의 풀이를 봤다.

-------

hint

이걸 보면서 규칙성 확인

 

-------

Solution

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
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        
        int a = 0;
        int count = 1;
        int b = 0;
        int tmp = 0;
        int mother, child;
        
        while(true) {
            if( a >= n ) {
                b = a - n - 1;
                
                mother = n - tmp;
                child = count - mother;
                if(child < 0) {
                    child *= -1;
                }
                
                child = count - mother;
                if(count % 2 == 1) {
                    System.out.println(mother + "/" + child);
                }
                else {
                    System.out.println(child + "/" + mother);
                }
                break;
            }
            
            tmp = a;
            a += count;
            count++;
        }
    }
}
 
// 2 3 4  5  6  7  8
//1 3 6 10 15 21 28 36
cs

실행시간 - 224ms


위의 hint그림 처럼 대각선 기준으로 정방향 역방향으로 1부터 순차증가가 된다.
이 부분을 체크해서 각 대각라인 별 갯수가 1 - 3 - 6 - 10 - 15 - 21 순으로 증가하는데,
a(0) = a + 대각라인 으로 총 갯수를 파악 가능하며, 
child / mother라 했을 때 mother = n - tmp로 해당 번호의 순번, 즉 분자나 분모의 값 하나를 구할 수 있고
이후 count - mother를 통해 다른 분자나 분모의 값을 구할 수 있다.
count - mother가 가능한 이유는 각 대각라인 순번별로 2부터 시작해 합이 1씩 증가한다. 그 합은 child + mother 이다.

---
수학 문제는 난이도가 쉽게 나와도 정말 풀기 어려운 듯 하다 최적화를 떠나서 구현 자체가 너무 힘듦
이후에도 해당 문제는 계속 들여다볼 것 같다.

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 2292번 벌집 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1712번 손익분기점 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 2869번 달팽이는 올라가고 싶다 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 2204번 도비의 난독증 테스트 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 4447번 좋은놈 나쁜놈 자바로 풀어 본 짧은 글  (0) 2022.12.18
반응형

2869번 문제 달팽이는 올라가고 싶다

예전에 틀려놓고 버려뒀던 문제...
그냥 구현만 했더니 시간제한이 0.15초인걸 보고 답없겠다 싶었는데...
이번엔 한번 시간써서 풀어보려한다
답도 대충 훑어봤었는데 이젠 풀겠지

글이 적어서 단순해보이지만 이런 문제일수록 규칙을 잘 봐야지..
범위 10억이면 int형으로 커버 가능하고 이제 남은건 수학적 계산 뿐...

 

------

hint

V에서 마지막 미끄러지는 부분은 계산하면 안됨

실행시간을 잘 봐야함

 

 

------

Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int A, B, V;
        int tmp;
        
        A = sc.nextInt();
        B = sc.nextInt();
        V = sc.nextInt();
        
        //여기가 구현부
        tmp = (V - B)/(A - B);
        if((V - B)%(A - B)> 0) {
            tmp++;
        }
        System.out.println(tmp);
    }
}
cs

실행시간 - 108ms


답을 한번 봐서 그런가? 이건 너무 쉽게 풀어버렸음...
자바의 시간초과문제는 Java11 > Java8로 제출하니까 바로 통과됨
BufferedReader를 사용하면 된다고 하긴 하는데 이건 진짜 최후의 최후보루 같은 느낌
일단 구현이 목적이라 저거까지 사용할 여유가 없다..
그리고 자바11이 스캐너를 사용할 때 오래걸리는 문제로 어쩔 수 없다고 하는데... 이정돈 넘어가도 되지 않을까...?

 

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 1712번 손익분기점 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 1193번 분수찾기 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 2204번 도비의 난독증 테스트 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 4447번 좋은놈 나쁜놈 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 13458 시험 감독 자바로 풀어 본 짧은 글  (0) 2022.12.16
반응형

2204번 문제 도비의 난독증 테스트

문제 난이도를 올렸더니 데이터 저장방식이 조금 더 까다로워진 듯 하다.
이번에도 ascii활용문제 조건 보고 데이터를 많이 저장할 필욘 없는 듯 하다. 최종적으로
사전상 가장 앞에 있는 단어 하나만 출력이니
종료조건 0을 잘 생각해서 구현해봐야겠다.
compare메서드 쓰면 편할거 같긴 한데 한번 직접 비교하는 코드 만들어서 해보기

 

-------


hint

while문 조건부에 입력받고 0이 아닐 때 반복 0을 입력 시 반복 종료
사전순인걸 기억해야함, 각 입력마다 사전순 앞의 값은 list에 add

-------

반응형

Solution

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
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args) {
        dicfirst dic = new dicfirst();
        Scanner sc = new Scanner(System.in);
        String first = new String();
        
        List<String> list = new ArrayList<String>(1000);
        int n;
        int count = 0;
        
        while((n = Integer.parseInt(sc.nextLine())) != 0) {
            
            String[] s = new String[n];
        
            for(int i = 0; i < n; i++) {
                s[i] = sc.nextLine();
            }
            first = s[0];
            //사전앞단어 구한 후 배열저장 or list저장
            //ascii A = 65 + 26(범위 65~90) / a = 95 + 26(범위 97~122)
            
            for(int i = 0; i < n; i++) {
                first = dic.go(first, s[i]);
            }
            
            list.add(first);//사전상 앞단어를 저장해둠
            count++;
        }
        for(int i = 0; i < count; i++) {
            System.out.println(list.get(i));
        }
 
    }
}
 
 
class dicfirst {
    
    String go(String a, String b){
        if(a != null) { // first문자열이 아직 저장되어있지 않다면 a는 null상태 - 바로 b return
            int count = 0;
            if(a.length() <= b.length()) {
                count = a.length();
            }
            else {
                count = b.length();
            }
            
            for(int i = 0; i < count; i++) {
                int compareOne = a.charAt(i);
                int compareTwo = b.charAt(i);
                if( 65 <= compareOne && compareOne <= 90) { // 대문자일 때 소문자로 변환 (+32)
                    compareOne += 32;
                }
                if( 65 <= compareTwo && compareTwo <= 90) { // 대문자일 때 소문자로 변환 (+32)
                    compareTwo += 32;
                }
                if(97 <= compareOne && compareOne <= 122 
                        && 97 <= compareTwo && compareTwo <= 122 ) {
                    if(compareOne < compareTwo) {return a;}
                    else if(compareOne > compareTwo) {return b;}//==미구현의도 : 같으면 다음 비교로 넘어가게끔 설계 
                }
            }
            if(a.length() <= b.length()) {
                return a;
            }
            else {
                return b;
            }
        }
        return b;
    }
}
cs

실행시간 - 264ms

구현 다했는데 사전순의 마지막 반례를 생각못해서 계속 틀렸다.

찾은 반례

 

2
aAab
aAa
0


사전 순이라는 것은 다른 길이지만 바로 앞까지 길이와 알파벳이 같을 때 길이가 짧은 단어가 사전의 앞에 놓인다는 것을 말하는데, 이 부분을 놓쳤었다.
예를 들어, aaa aaaa가 있다고 가정했을 때 aaa와 aaaa는 세번째 자리까지는 같은 알파벳이지만, 뒤의 한글자로 단어의 길이가 나뉘는데 해당 부분을 해결하는 코드를 추가하자마자 문제해결이 되었다.
물론 코드는 그냥 돌아가게만 만들어둠..... 처리속도 등수 보니까 자바에서 거의 최하위권 ㅋㅋㅋ...

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 1193번 분수찾기 자바로 풀어 본 짧은 글  (0) 2022.12.20
백준 2869번 달팽이는 올라가고 싶다 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 4447번 좋은놈 나쁜놈 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 13458 시험 감독 자바로 풀어 본 짧은 글  (0) 2022.12.16
백준 15953 상금 헌터 자바로 풀어 본 짧은 글  (0) 2022.12.16
반응형

4447번 문제 좋은놈 나쁜놈

 

생각

ascii코드활용 65+ 26 / 97 + 26/
b와 g의 개수에 따라서 하면됨
예전에 했던 문제 1157이랑 비슷한 느낌으로 하면 될듯?
문자는 25자를 넘지않음.
nextline
String으로 받고

for문으로 배열들
charat을 통해 쭉 비교하면 되긴 하는데
이게 효율적일지는 모르겠음
일단구현부터!

 

----------

hint

 

nextInt() 이후 nextLine()을 사용한다면 입력의 오류에 주의할 것,

매 for문마다 good과 bad를 판단해 배열에 문자열을 추가해 저장

 

----------

Solution

 

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
import java.util.Scanner;
 
public class Main {
    
    public static void main(String[] args) {
        int[] goodAndBad = new int[2]; // 0 = good, 1 = bad
        Scanner sc = new Scanner(System.in);
        int n;
        n = Integer.parseInt(sc.nextLine());
        check c = new check();
        
        String[] s = new String[n];
    
        for(int i = 0; i < n; i++) {    
            s[i] = sc.nextLine(); //nextInt()를 사용 시 s[0]에 '' 저장 주의
        }
        
        for(int i = 0; i < n; i++) {
            goodAndBad[0] = 0;
            goodAndBad[1] = 0;
            for (int j = 0; j < s[i].length(); j++) {
                if((int)s[i].charAt(j) == 103) { // g == 103 , G == 71
                    goodAndBad[0]++;
                }
                else if((int)s[i].charAt(j) == 71) { 
                    goodAndBad[0]++;
                }
                else if((int)s[i].charAt(j) == 98) {// b == 98, B == 66
                    goodAndBad[1]++;
                }
                else if((int)s[i].charAt(j) == 66) { 
                    goodAndBad[1]++;
                }
            }
            s[i] = s[i].concat(c.goodOrBad(goodAndBad));
        }
        for(int i = 0; i < n; i++) {
            System.out.println(s[i]);
        }
    }
}
 
class check {
     String goodOrBad(int[] a) {
            if(a[0] > a[1]) {
                return " is GOOD";
            }
            else if(a[0] < a[1]) {
                return " is A BADDY";
            }
            else if(a[0] == a[1]) {
                return " is NEUTRAL";
            }
            return "error";
        }
}
cs

실행시간 - 200ms

 

전에 조금 더 어려웠던 문제(no.1157)를 풀어봐서 구현은 쉬웠다.

그런데 hint에 적었던 nextInt()사용 후 nextLine()을 사용했을 때 문제가 생겨서 해당 문제를 해결하는데 시간이 좀 걸렸고,

결과적으로 해결해서 지식이 늘어난 느낌도 좋고 좋은 경험 한거같다.

 

해당 문제 관련 정리 : nextInt()입력 후 nextLine()사용 시 주의점

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 2869번 달팽이는 올라가고 싶다 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 2204번 도비의 난독증 테스트 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 13458 시험 감독 자바로 풀어 본 짧은 글  (0) 2022.12.16
백준 15953 상금 헌터 자바로 풀어 본 짧은 글  (0) 2022.12.16
백준 10886 0 = not cute / 1 = cute 자바로 풀어 본 짧은 글  (0) 2022.12.14
반응형

13458번 문제 시험 감독

 

생각
범위는 전부 백만
첫째줄 시험장의 개수N입력받고
둘째줄N을 통해 for문돌려서 시험장에 있는 응시자 수 입력받고
셋째줄 B와 C를 배열0,1에 입력받음
이후 알고리즘이 들어간다.

 

-----

hint

총 시험응시자 수를 나눠 몫과 나머지를 활용한다. / 입력조건을 잘 보고 자료형을 고민해야함

 

 

-----

Solution

반응형

 

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
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        int N;
        int[] testCapa = new int[1000000];
        int[] supervisor = new int[2]; // 감독관
        int tmp;
        int remainder; // 나머지
        int quotient; // 몫
        long count = 0;
        Scanner sc = new Scanner(System.in);
 
        N = sc.nextInt();
 
        for (int i = 0; i < N; i++) {
            testCapa[i] = sc.nextInt();
        }
 
        supervisor[0] = sc.nextInt(); // 총감독관
        supervisor[1] = sc.nextInt(); // 부감독관
 
        // 필요한 감독관 수의 최솟값을 만들기.
 
        for (int i = 0; i < N; i++) {
            tmp = testCapa[i];
            tmp -= supervisor[0];
            if (tmp < 1) { // tmp가 총감독관으로 끝날 때
                count++;
                continue;
            }
            else if (tmp > 0) { // tmp가 총감독관으로 안 끝날 때
                count++;
                remainder = tmp % supervisor[1];
                quotient = tmp / supervisor[1];
                
                count += quotient;
                
                if (remainder > 0) { // 나머지가 있으면 부감독관 한명 더 있어야함
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}
 
cs

구현 자체는 오래 생각해서 그런지 쉽게 구현했고,
이번에도 너무 생각을 짧게 하고 구현했는지, 조건 부분에서 두번이나 틀렸었다.

1트 - count를 남발 중복적용으로 인해 오답
2트 - 똑같이 조건이 아쉬움 count가 잘못적용됨
3트 - 모든 예제가 맞게끔 잘 적용 되었는데 자꾸틀림 질문게시판의 반례도 찾아봤지만, 모든 반례가 맞음
4트 - 바보같은 실수를 한 것을 깨달았음... 카운트 횟수는 100만*100만으로 int형의 42억으로는 감당을 하지 못해서 에러가 난 것이였음. 이후 count변수의 자료형을 long으로 변경 후 정답
실행시간 - 1712ms ///정답율 28.2%인게 다들 똑같은 실수 한거같음....

 

 

			if (tmp < 1) { // tmp가 총감독관으로 끝날 때
				count++;
				continue;
			}

5트 - 시간이 너무 오래걸림... 최대 100만번 for문을 돌리니 그럴 수밖에 없던 문제인듯함

때문에 조건을 달았었음 총 감독관으로 해당 시험장이 끝난다면 바로 종료되게끔 continue문을 넣어서 실행해봄 1712에서 아주아주 약간 줄었음.
실행시간 - 1688ms

 


그냥 내 효율적이지 못한 알고리즘이 문제인거 같다....
일단 구현에는 성공했으니 찝찝한 기분 안아두고 킵
당장 생각할 수 있는거는 BufferReader밖에 없는데 그거하나 넣는다고 드라마틱하게 바뀔거 같지 않음

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 2204번 도비의 난독증 테스트 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 4447번 좋은놈 나쁜놈 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 15953 상금 헌터 자바로 풀어 본 짧은 글  (0) 2022.12.16
백준 10886 0 = not cute / 1 = cute 자바로 풀어 본 짧은 글  (0) 2022.12.14
백준 10250 acm호텔 자바로 풀어 본 짧은 글  (0) 2022.12.14
반응형

15953번 문제 상금헌터


처음에 문제가 길어서 무서웠는데 생각보다 별거없던 문제
아직 티어가 낮아서 할만한거만 나오는듯

생각
1회 100명중 21명에게 상금부여
2회 64명중 31명에게 상금부여

각 등수에 맞는 명수로 조건걸고 조건에 따라서 상금을 더해 배열에 저장

 

-------

hint

 

배열은 [1000]
첫줄입력 : 가정횟수 t 1이상 1000이하
t의 갯수만큼 : 두개의 정수 100이하 / 64이하

1회차 : 1 3 6 10 15 21

2회차 : 1 3 7 15 31

--------

반응형

Solution

 

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
import java.util.Scanner;
 
public class Main {
 
    static int prize(int a, int b){
        int[] prizeOne = {5000000, 3000000, 2000000, 500000, 300000, 100000};
        int[] prizeTwo = {5120000, 2560000, 1280000, 640000, 320000};
        int prize = 0;
        
        if(a <= 21) {
            if(a == 1) {
                prize += prizeOne[0];
            }else if(a <= 3 && a > 1) {
                prize += prizeOne[1];
            }else if(a <= 6 && a > 3) {
                prize += prizeOne[2];
            }else if(a <= 10 && a > 6) {
                prize += prizeOne[3];
            }else if(a <= 15 && a > 10) {
                prize += prizeOne[4];
            }else if(a <= 21 && a > 15) {
                prize += prizeOne[5];
            }
        }
        if(b <= 31) {
            if(b == 1) {
                prize += prizeTwo[0];
            }else if(b <= 3 && b > 1) {
                prize += prizeTwo[1];
            }else if(b <= 7 && b > 3) {
                prize += prizeTwo[2];
            }else if(b <= 15 && b > 7) {
                prize += prizeTwo[3];
            }else if(b <= 31 && b > 15) {
                prize += prizeTwo[4];
            }
        }
        
        if(prize > 0) {
            return prize;
        }
        return 0;
    }
    
    public static void main(String[] args) {
        int[] arr = new int[1000];
        int count = 0;
        int t = 0;
        int a = 0;
        int b = 0;
        Scanner sc = new Scanner(System.in);
        
        t = sc.nextInt();
        
        for(int i = 0; i < t; i++) {
            a = sc.nextInt();
            b = sc.nextInt();
            
            arr[i] = prize(a, b);
            count++;
        }
        
        for(int i = 0; i < count; i++) {
            System.out.println(arr[i]);
        }    
    }
}
 
cs


첫번째 런타임에러 - 배열범위를 100으로 만들었었음. 조건 확인 잘하기
두번째 실패 - cashprize의 범위설정을 잘못했음. 범위 명확히 조절함
세번째 성공 - 속도 344ms 겁나느림.(클래스 생성해서 계산메소드를 만들었는데 이게 느린거같아 수정해봤음)
네번째 성공 - 속도 340ms 메서드를 같은 클래스 내에 지정해서 static선언 후 돌려봄 ㅋㅋㅋ이게 차이가 있는건지 모르겠음

 

 

 

 

 

 

이정도면 티어 한단계만 올려볼까..?

 

반응형
저작자표시 비영리 변경금지

'공부 > Algorithm' 카테고리의 다른 글

백준 2204번 도비의 난독증 테스트 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 4447번 좋은놈 나쁜놈 자바로 풀어 본 짧은 글  (0) 2022.12.18
백준 13458 시험 감독 자바로 풀어 본 짧은 글  (0) 2022.12.16
백준 10886 0 = not cute / 1 = cute 자바로 풀어 본 짧은 글  (0) 2022.12.14
백준 10250 acm호텔 자바로 풀어 본 짧은 글  (0) 2022.12.14

+ Recent posts

티스토리툴바