[Java] 1744 수 묶기 - ... 조건 처리?

https://www.acmicpc.net/problem/1744

1744번: 수 묶기

import java.io.*;
import java.util.*;
 
public class Main {
    
    static List<Integer> positive = new ArrayList<>();
    static boolean zero;
    static List<Integer> negative = new ArrayList<>();
    static int p_result = 0;
    static int n_result = 0;
    
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        for (int i = 0; i < N; i++) {
            int x = Integer.parseInt(br.readLine());
            if (x>0) positive.add(x);
            else if (x==0) zero = true;
            else negative.add(x);
        }
        
        Collections.sort(positive, Collections.reverseOrder()); //내림차순으로 정렬
        Collections.sort(negative); //오름차순으로 정렬
        
 
        /* Positive*/
        
        //양수가 짝수 개 있을 때.
        if(positive.size()%2==0) {
            for(int p=0;p<positive.size();p+=2) {
                if (positive.get(p)!=1 && positive.get(p+1)!=1)  { //1이 나오면 더해야 하므로 1이 없을 때 곱해줌.
                    p_result += positive.get(p) * positive.get(p+1);
                }
                else{
                    p_result += positive.get(p) + positive.get(p+1); //1이 나오면 더해줌.
                }
            }
        //양수가 홀수 개 있을 때.
        }else {
            if(positive.size()>1) { //size가 3이상.
                for(int p=0;p<positive.size()-1;p+=2) { //일단 짝수개 까지는 동일하게 진행.
                    if (positive.get(p)!=1 && positive.get(p+1)!=1) {
                        p_result += positive.get(p) * positive.get(p+1);
                    }
                    else p_result += positive.get(p) + positive.get(p+1);
                } //마지막 남은건 더해줌. 
                p_result += positive.get(positive.size()-1);
            }
            else { //size==1일 때.
                p_result += positive.get(0);
            }
        }
        
        /* Negative*/
        
        //음수가 짝수 개 있을 때
        if(negative.size()%2 ==0) { // 두개씩 곱한다.
            for(int p=0;p<negative.size();p+=2) {
                n_result += negative.get(p) * negative.get(p+1);
            }
        //음수가 홀수 개 있을 때
        }else {
            if(negative.size() >1) { //size3이상.
                for(int p=0;p<negative.size()-1;p+=2) {
                    n_result += negative.get(p) * negative.get(p+1);
                }//짝수개 까지는 일단 곱한다.
                if(!zero) { //0이 없으면 그냥 더하고 0이면 0이랑 곱해지니까 뭐 없음.
                    n_result += negative.get(negative.size()-1);
                }
            }
            else { //size==1일 때.
                if(!zero) n_result = negative.get(0);
            }
            
        }
        System.out.println(p_result + n_result);
    }
    
}

일정 숫자들에 괄호를 묶어 가장 큰 결과값이 나오도록 하게 하는 문제이다.

어떻게 해야 가장 큰 결과값이 나올까 생각하다가, 다음과 같이 구분을 나누어 보았다.

•  양수

1. 양수는 양수들끼리 더하고 곱한다.

2. 양수들은 언제나 곱한 값이 더한 값보다 크다. (단, 1은 제외한다.)

3. 양수임에도 불구하고 1이 들어간 경우는 더한 값이 곱한 값보다 크다. (N*1 < N+1)

4. 양수가 홀수개 있을 경우, 짝수개 까지는 2개씩 짝지어 곱하고 나머지 한개는 더한다.

(이 때, 양수가 1개 있을 경우는 그냥 더한다.)

5. 이것을 쉽게 하기 위해, 양수를 내림차순으로 정렬한 뒤 진행한다.

• 0

1. 0이 있는 경우, 음수를 제외시킬 수 있다. (0의 갯수보단 0의 유무가 중요하므로, boolean type 사용)

2. 단 음수가 홀수개인 경우에 한한다.

•  음수

1. 음수가 짝수 개 있는 경우, 음수x음수=양수 이므로 곱한다.

2. 음수가 홀수 개 있는 경우, 짝수개 까지는 곱하고, 나머지 한개는 더한다.

(이때, 음수가 한 개 있을 경우는 0의 유무를 확인한뒤 0이 있으면 0과 곱하고, 0이 없을 경우 더한다.)

3. 음수는 절댓값이 클 수록 작은 숫자이므로, 계산을 쉽게 하기 위하여 음수를 오름차순으로 정렬한 뒤 진행하였다.

 

 

이걸 그냥 코드로 구현함 !