최고의 개발자 (목표)

문제

인하은행에는 ATM이 1대밖에 없다. 지금 이 ATM앞에 N명의 사람들이 줄을 서있다. 사람은 1번부터 N번까지 번호가 매겨져 있으며, i번 사람이 돈을 인출하는데 걸리는 시간은 Pi분이다.

사람들이 줄을 서는 순서에 따라서, 돈을 인출하는데 필요한 시간의 합이 달라지게 된다. 예를 들어, 총 5명이 있고, P1 = 3, P2 = 1, P3 = 4, P4 = 3, P5 = 2 인 경우를 생각해보자. [1, 2, 3, 4, 5] 순서로 줄을 선다면, 1번 사람은 3분만에 돈을 뽑을 수 있다. 2번 사람은 1번 사람이 돈을 뽑을 때 까지 기다려야 하기 때문에, 3+1 = 4분이 걸리게 된다. 3번 사람은 1번, 2번 사람이 돈을 뽑을 때까지 기다려야 하기 때문에, 총 3+1+4 = 8분이 필요하게 된다. 4번 사람은 3+1+4+3 = 11분, 5번 사람은 3+1+4+3+2 = 13분이 걸리게 된다. 이 경우에 각 사람이 돈을 인출하는데 필요한 시간의 합은 3+4+8+11+13 = 39분이 된다.

줄을 [2, 5, 1, 4, 3] 순서로 줄을 서면, 2번 사람은 1분만에, 5번 사람은 1+2 = 3분, 1번 사람은 1+2+3 = 6분, 4번 사람은 1+2+3+3 = 9분, 3번 사람은 1+2+3+3+4 = 13분이 걸리게 된다. 각 사람이 돈을 인출하는데 필요한 시간의 합은 1+3+6+9+13 = 32분이다. 이 방법보다 더 필요한 시간의 합을 최소로 만들 수는 없다.

줄을 서 있는 사람의 수 N과 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어졌을 때, 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 사람의 수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄에는 각 사람이 돈을 인출하는데 걸리는 시간 Pi가 주어진다. (1 ≤ Pi ≤ 1,000)

출력

첫째 줄에 각 사람이 돈을 인출하는데 필요한 시간의 합의 최솟값을 출력한다.

코드

import sys
def cumulativeSum(N,list):
    temp = []
    temp.append(list[0])
    for i in range(1,N):
        temp.append(temp[i-1] + list[i])
    timeSum = sum(temp)
    return timeSum
    
if __name__ == '__main__':
    N = int(sys.stdin.readline().rstrip())
    list = list(map(int, sys.stdin.readline().rstrip().split(" ")))

    list.sort()

    print(cumulativeSum(N,list))

풀이

돈을 인출하는데 오래 걸리는 사람이 먼저 인출하게 되면 뒷 사람들은 시간이 많이 걸린다. 따라서 돈을 인출하는데 짧게 걸리는 사람부터 인출할 수 있도록 한다. sort를 이용해서 돈을 인출하는데 걸리는 시간이 적은 사람 순으로 정렬한다. 즉 예제 입력 1을 기준으로, 현재 list에는 [1,2,3,3,4] 가 저장된다. 

그 후 cumulativeSum 함수를 이용해 각 사람이 걸리는 시간과 그 합을 계산한다.

각 사람에게 걸리는 시간은 temp = [1,3,6,9,13] 이다. 두 번째 사람은 첫 번째 사람이 걸린 시간과 자신이 인출하는 시간을 더한 만큼 시간이 걸린다. 세 번째 사람은 (두 번째 사람이 걸린 시간 + 자신이 인출하는 시간)만큼 시간이 걸린다.

따라서 세 번째 사람의 경우, 3 + 3 = 6 이 걸린 것이다. 

즉 temp[i] = temp[i-1] + list[i] 로 각 사람 별로 걸리는 시간을 구할 수 있다.

원하는 출력은 모든 사람이 필요한 시간의 합이므로, sum 함수로 temp의 합을 구한다. 

문제

한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.

입력

첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 231-1보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.

코드

import sys

if __name__ == '__main__':
    N = int(sys.stdin.readline().rstrip())

    list = []
    for i in range(N):
        a, b = map(int, sys.stdin.readline().rstrip().split(" "))
        list.append((a,b))

    list.sort(key=lambda x:(x[1],x[0]))
    
    cnt = 0
    end_time = 0

    for s,e in list:
        if end_time <= s:
            cnt += 1
            end_time = e
    
    print(cnt)

풀이

회의를 최대로 사용하기 위해서는 가장 빨리 끝나는 회의를 먼저 사용하면 된다. 중간에 회의를 같이 사용할 수 없어서 시작하는 시간보다는 끝나는 시간이 빠른 회의를 먼저 사용해야 한다. 따라서 sort 함수로 끝나는 시간 순으로 정렬시키고, 만약 끝나는 시간이 같은 회의라면 시작하는 시간이 빠른 회의 순으로 정렬할 수 있도록 했다.

cnt는 회의의 수, end_time은 현재 회의가 끝나는 시간을 저장하는 변수이다. list를 돌면서 현재 회의가 끝난 시간보다 회의의 시작시간이 같거나 뒤라면 이 회의를 다음 회의로 선정한다. 따라서 cnt를 1 올려주고 end_time을 선정된 회의의 끝나는 시간으로 바꾸어준다. 

문제

효빈이의 비밀 박스에는 조약돌이 N개 들어있다. 조약돌의 색상은 1부터 M까지 중의 하나이다.

비밀 박스에서 조약돌을 랜덤하게 K개 뽑았을 때, 뽑은 조약돌이 모두 같은 색일 확률을 구하는 프로그램을 작성하시오. 

입력

첫째 줄에 M (1 ≤ M ≤ 50)이 주어진다.

둘째 줄에는 각 색상의 조약돌이 몇 개 있는지 주어진다. 각 색상의 조약돌 개수는 1보다 크거나 같고 50보다 작거나 같은 자연수이다.

셋째 줄에는 K가 주어진다. (1 ≤ K ≤ N)

출력

첫째 줄에 뽑은 조약돌이 모두 같은 색일 확률을 출력한다. 정답과의 절대/상대 오차는 10-9까지 허용한다.

코드

import sys

def multi(n, k):
    result = n
    for i in range(k-1):
       result = result * (n-1)
       n = n-1
    return result

if __name__ == '__main__':
    M = int(sys.stdin.readline().rstrip()) # 조약돌 색상 수
    
    temp = sys.stdin.readline().rstrip().split() # 각 색상 별 조약돌 개수
    list = []
    for i in temp:
        list.append(int(i))

    K = int(sys.stdin.readline().rstrip())  # 뽑을 조약돌 수
    
    N = sum(list)	# 전체 돌 수
    numerator = 0   # 분자
    denominator = multi(N, K) #분모
   
    # 만약 뽑을 값보다 적은 조약돌의 개수를 가진 색상은 필요없음
    # 해당 색상의 조약돌 제거
    for i in list:
        if(i < K):
            list.remove(i)
                  
    for i in list:
        numerator += multi(i, K)
    
    print(numerator/denominator)

풀이

문제의 이해를 위해 예제 입력 4로 설명을 한다.

예제 입력 4에서 조약돌의 색상(M)이 5가지이고, 각 색상의 조약돌의 개수는 [12,2,34,13,17]이며 조약돌을 랜덤하게 4개(K) 뽑는다고 되어있다 .

분모는 N개의 조약돌 중 K개를 뽑는 경우의 수이다. 따라서 C(N, K)를 구하면 된다. 이때 N은 조약돌의 전체 개수이다.

N은 12+2+34+13+17 = 78이 된다. 즉 분모는 C(78, 4)가 된다. 

분자는 각 색상별로 K를 뽑은 경우의 수를 더해주면 된다. 즉 C(한 색상의 조약돌 개수, K)를 모두 더해주면 된다.

따라서 C(12, 4)+C(2, 4)+C(34, 4)+C(13, 4)+C(17, 4)가 분자가 된다. 이때 C(2, 4)는 뽑을 조약돌 개수가 전체 조약돌 개수보다 적기 떄문에 불가능하다. 따라서 제외하면 C(12, 4)+C(34, 4)+C(13, 4)+C(17, 4) 가 분자가 된다.

∴ 확률값은 ${\frac{C(12, 4) + C(34,4) + C(13,4), C(17,4)}{C(78, 4)}}$ 가 된다.

계산을 해보자. 분자와 분모에 공통되는 수인 4!을 각각 분자와 분모에 곱해준다. 

분모의 경우는 78x77x76x75 = 34234200이 된다.

같은 방법으로 계산하면, 분자는 11880+1113029+17160+57120=1199184 가 된다.

따라서 분자/분모를 해주면 예시 출력 4와 같은 값이 나온다. 

이제 이걸 문제에 적용시키면 된다.

위에서 적었듯이, 분모는 C(N, K)가 되고 분자는 C(한 색상의 조약돌 개수, K)를 조약돌의 색상 개수별로 구해서 모두 더해주면 된다. 그리고 계산할 때는 K!을 곱했다고 생각하면 분모의 경우, K에 개수에 따라 Nx(N-1)x(N-2).. 이런식으로 구해주면 된다. 즉 K가 4면 Nx(N-1)x(N-2)x(N-3)을 해주면 되는 것이다.

코드에서 입력을 받은 후, N을 구해놓고 list를 돌아서 뽑을 조약돌의 개수보다 적은 조약돌의 개수를 가진 색상을 제거했다. 이는 분자에 포함되면 안되기 때문이다.

그리고 multi라는 함수에서 N과 K로 K!을 곱했다고 생각한 상황의 계산을 할 수 있게 했다. Combination 계산을 그냥 하고 싶다면 python의 라이브러리인 itertools에서 combinations을 import해 사용하면 된다.

문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 수 주어진다. 이 수는 절댓값이 1,000보다 작거나 같은 정수이다. 수는 중복되지 않는다.

출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

코드

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		ArrayList<Integer> array = new ArrayList();
		
		int N = sc.nextInt();
		
		for(int i = 0; i < N; i++) {
			array.add(sc.nextInt());
		}

		Collections.sort(array);
		
		for(int i = 0; i < array.size(); i++) {
			System.out.println(array.get(i));
		}
		
	}
}

풀이

scanner를 이용해서 입력을 받고, ArrayList에 add했다. 

Collections의 sort를 이용해 오름차순으로 정렬 후 출력했다.

문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 수가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;


public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

		int N = Integer.parseInt(br.readLine());
		
		int[] array = new int[10001]; // index => 해당숫자, 값  => 숫자의 갯수
		Arrays.fill(array, 0); // 배열 0으로 채우기
		
		for (int i = 0; i < N; i++) {
			array[Integer.parseInt(br.readLine())] += 1;
		}

		for(int i = 0; i < 10001; i++) {
			for(int j = 0; j < array[i]; j++) {
				bw.write(i + "\n");
			}
		}

		bw.flush();
		bw.close();
		br.close();
	}
}

풀이

시간을 최대한 줄이기 위해 bufferedReader와 bufferedWriter를 사용했다.

처음에는 Arraylist에 담고 Collections.sort()를 이용했는데 메모리 초과가 났다. 그래서 카운팅 정렬을 이용해 문제를 풀었다. 등장할 수 있는 수는 10000보다 작기 때문에 배열을 10001칸을 할당해주고 Arrays.fill을 이용해 0으로 채워준다. 잠깐 카운팅 정렬에 대해 얘기하자면,  index는 수가 되고 해당 index의 값은 수가 등장한 횟수가 된다. 즉 1이 한 번 나오면 array[1] = 1 이 되고, 1이 또 등장하면 array[1] = 2 가 된다.

따라서 입력을 받을 때 array[입력받은 수]에 1씩 더해준다. 그 후 array의 처음부터 출력해주면 된다.

만약 array[1] = 3이라면, 1이 3번 나왔다는 것이므로 출력할 때 1 + "\n" + 1 + "\n" + 1 이런 식으로 출력을 해야 한다.

따라서 이중 포문을 사용해서 첫 번째 포문으로는 array를 돌고, 두 번째 포문으로 각 인덱스에 저장된 값만큼 돌면서 현재 index를 bw에 저장한다. 그 후 마지막에 flush()를 이용해 한 번에 출력한다.

문제

666은 종말을 나타내는 숫자라고 한다. 따라서, 많은 블록버스터 영화에서는 666이 들어간 제목을 많이 사용한다. 영화감독 숌은 세상의 종말 이라는 시리즈 영화의 감독이다. 조지 루카스는 스타워즈를 만들 때, 스타워즈 1, 스타워즈 2, 스타워즈 3, 스타워즈 4, 스타워즈 5, 스타워즈 6과 같이 이름을 지었고, 피터 잭슨은 반지의 제왕을 만들 때, 반지의 제왕 1, 반지의 제왕 2, 반지의 제왕 3과 같이 영화 제목을 지었다.

하지만 숌은 자신이 조지 루카스와 피터 잭슨을 뛰어넘는다는 것을 보여주기 위해서 영화 제목을 좀 다르게 만들기로 했다.

종말의 숫자란 어떤 수에 6이 적어도 3개이상 연속으로 들어가는 수를 말한다. 제일 작은 종말의 숫자는 666이고, 그 다음으로 큰 수는 1666, 2666, 3666, .... 과 같다.

따라서, 숌은 첫 번째 영화의 제목은 세상의 종말 666, 두 번째 영화의 제목은 세상의 종말 1666 이렇게 이름을 지을 것이다. 일반화해서 생각하면, N번째 영화의 제목은 세상의 종말 (N번째로 작은 종말의 숫자) 와 같다.

숌이 만든 N번째 영화의 제목에 들어간 숫자를 출력하는 프로그램을 작성하시오. 숌은 이 시리즈를 항상 차례대로 만들고, 다른 영화는 만들지 않는다.

입력

첫째 줄에 숫자 N이 주어진다. N은 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 N번째 영화의 제목에 들어간 수를 출력한다.

코드

if __name__ == '__main__':
    N = int(input())
    temp = 0
    count = 0
    while True:
        count = count+1
        if str(count).find("666") != -1:
            temp = temp + 1
            if temp == N:
                answer = count
                break

    print(answer)

풀이

while이 돌아갈 때마다 count에 1씩 더해지고, count에 연속으로 666이 이어지는 게 존재하면 temp에 1을 더해준다. 즉 모든 수를 보면서 영화의 제목이 될 수 있는 666이 연속으로 있는 수를 찾고, 해당 수가 몇 번째 영화 제목인지를 temp에 저장한다. 이때 N이 영화의 제목에 들어간 수이므로 666이 연속으로 있는 수이고, 그 수의 제목의 순서가 N과 같다면 while문을 멈추고 출력한다.

문제

여러 개의 사과, 파인애플, 그리고 펜이 일렬로 세워져 있다. 이 물건들의 순서를 바꾸지 않고 옆에 있는 물건끼리 연결했을 때, 펜-파인애플-애플-펜을 몇 개나 만들 수 있을지 세어보자.

단, 펜, 파인애플, 사과, 펜 순서로 연결된 네 개의 물건만을 펜-파인애플-애플-펜으로 인정하며, 하나의 펜이 두 개의 펜-파인애플-애플-펜에 포함될 수 없다. 또한 펜, 사과, 파인애플, 펜 순서로 연결된 네 개의 물건은 펜-파인애플-애플-펜이 아니다.

입력

첫 번째 줄에 물건의 총 개수 n이 주어진다. (1 ≤ n ≤ 1,000,000)

두 번째 줄에 물체의 목록이 길이 n의 문자열로 주어진다. 사과는 A로, 파인애플은 P로, 펜은 p로 대소문자를 구분하여 표기한다.

출력

만들 수 있는 펜-파인애플-애플-펜의 최대 개수를 출력한다.

코드

import sys

if __name__ == '__main__':
    N = int(input())
    str = sys.stdin.readline().rstrip()

    answer = str.count("pPAp")
    print(answer)

풀이

sys.stdin.readline()으로 한 줄을 입력받고 rstrip()으로 뒤 개행을 제거해준다.

문자열 안에서 찾고 싶은 문자의 개수를 찾아주는 count 함수를 이용해 입력받은 string에서 pPAp의 개수를 세서 print한다.

문제

지민이는 자신의 저택에서 MN개의 단위 정사각형으로 나누어져 있는 M×N 크기의 보드를 찾았다. 어떤 정사각형은 검은색으로 칠해져 있고, 나머지는 흰색으로 칠해져 있다. 지민이는 이 보드를 잘라서 8×8 크기의 체스판으로 만들려고 한다.

체스판은 검은색과 흰색이 번갈아서 칠해져 있어야 한다. 구체적으로, 각 칸이 검은색과 흰색 중 하나로 색칠되어 있고, 변을 공유하는 두 개의 사각형은 다른 색으로 칠해져 있어야 한다. 따라서 이 정의를 따르면 체스판을 색칠하는 경우는 두 가지뿐이다. 하나는 맨 왼쪽 위 칸이 흰색인 경우, 하나는 검은색인 경우이다.

보드가 체스판처럼 칠해져 있다는 보장이 없어서, 지민이는 8×8 크기의 체스판으로 잘라낸 후에 몇 개의 정사각형을 다시 칠해야겠다고 생각했다. 당연히 8*8 크기는 아무데서나 골라도 된다. 지민이가 다시 칠해야 하는 정사각형의 최소 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 M이 주어진다. N과 M은 8보다 크거나 같고, 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 보드의 각 행의 상태가 주어진다. B는 검은색이며, W는 흰색이다.

출력

첫째 줄에 지민이가 다시 칠해야 하는 정사각형 개수의 최솟값을 출력한다.

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int N = sc.nextInt();
		int M = sc.nextInt();

		int[][] array = new int[50][50];

		// 1.  배열 입력
		for (int i = 0; i < N; i++) {
			String s = sc.next();
			for (int j = 0; j < M; j++) {
				if (s.charAt(j) == 'W') {
					array[i][j] = 1;
				} else {
					array[i][j] = 2;
				}

			}
		}
		
		// 2. 체스 정답 입력
		int[][] answer1 = new int[8][8];
		int[][] answer2 = new int[8][8];

		int[] pattern1 = { 1, 2, 1, 2, 1, 2, 1, 2 };
		int[] pattern2 = { 2, 1, 2, 1, 2, 1, 2, 1 };

		for (int i = 0; i < 8; i++) {
			if (i % 2 == 0) { // 짝수번째 인덱스
				answer1[i] = pattern1;
				answer2[i] = pattern2;
			} else {
				answer1[i] = pattern2;
				answer2[i] = pattern1;
			}
		}

		// 3. 체스판 찾기
		
		int row = N-7;
		int col = M-7;
		int mini = 64;
		
		for(int k = 0; k < row; k++) {
			for(int p = 0; p < col; p++) {
				
				int sum1 = 0;
				int sum2 = 0;
				for (int i = 0; i < 8; i++) {
					for (int j = 0; j < 8; j++) {
						if (array[i+k][j+p] != answer1[i][j]) {
							sum1 += 1;
							
						}
						if(array[i+k][j+p] != answer2[i][j]) {
							sum2 += 1;
						}
					}
				}
				int temp = Math.min(sum1, sum2);
				mini = Math.min(mini, temp);
			}
			
		}

		System.out.println(mini);

	}
}

풀이

1.  배열 입력

이 부분은 말 그대로 보드를 입력받는 부분이다. 이 코드 위에 N과 M을 입력받는 부분도 있다.

sc.next()를 이용해서 한 줄을 s에 저장하고 W면 1로, B면 2로 array에 저장해주었다.

2.  체스 정답 입력

이 문제는 무조건 확인할 때 8x8로 확인하고, 체스판이 될 수 있는 경우의 수가 2가지(맨 왼쪽 위 칸이 흰색인 경우, 하나는 검은색인 경우)이기 때문에 정답이 될 수 있는 경우를 answer1과 answer2로 나누어 저장해주었다.

즉 answer1은 아래와 같고, answer2는 맨 왼쪽 위 칸이 2로 시작할 것이다.

이렇게 저장한 answer1과 answer2를 가지고 입력받은 보드 위에 돌리면서 비교해 서로 다른 숫자의 개수를 세고 최솟값을 출력한다.

3. 체스판 찾기

만약 주어진 보드가 10x10 크기라면 8x8 크기인 answer1이 몇 개 돌릴 수 있을까?

간단하게 0~9까지 총 10칸이 있다고 생각하면 0~7, 1~8, 2~9 총 3개의 8칸을 돌릴 수 있다.

즉 10x10 크기로 생각하면 3 x 3 = 9 개의 체스판을 확인하게 된다.

만약 11x11이라면? 4x4 = 16 개의 체스판을 확인하게 된다. (이때 체스판은 문제에서 8x8로 자른다고 명시되어있다)

여기서 규칙을 알 수 있다. (주어진 보드 길이의 row - 3 ) x (주어진 보드 길이의 col - 3) 만큼의 체스판을 확인한다는 사실이다. 

주어진 보드판이 10x10이면 배열로 생각했을 때 [0][0]부터 [9][9]까지 존재한다. 

따라서 8x8인 answer1과 answer2와 보드를 8x8로 잘라서 비교하고, 틀린 것의 개수를 비교할 때마다 구해서 제일 작은 값을 출력한다. 10x10 보드를 8x8로 자른다면 위에 구했듯이 총 9번을 비교하게 될 것이다. 

[0][0]~[7][7]을 시작으로 [2][2]~[9][9]까지 이동할 것이다. (맨 왼쪽 위 ~ 맨 오른쪽 아래)

k와 p가 전체 8x8을 이동시키는 for문이 되고, i와 j가 8x8을 직접 탐색하는 for문이 된다.

i와 j의 이중 포문 안에서는 보드와 answer1을 비교해 값이 다르면 sum1에 1을 더해주고, 보드와 answer2를 비교해 값이 다르면 sum2에 1을 더해준다. 값이 다르다는 건 정답인 answer와 다른 부분인 것이고, 즉 체스판이 되기 위해서 다시 칠해야 하는 부분인 것이다. array에서 k과 p를 더해주는 이유는 처음에 입력받은 보드를 8x8 크기로 잘라줄 때 이동시키기 위해서이다.

이때 sum1과 sum2는 8x8 비교를 한 번 할 때마다 구하므로 i 포문 위에서 0으로 계속 초기화시켜준다. 한 번의 비교 후에는 최솟값을 구해준다. Math.min 함수는 괄호 안의 두 값 중 최솟값을 반환해준다. mini가 64인 이유는 최대로 체스판을 만들기 위해 색칠하는 횟수가 64이기 때문이다.