AndroidTeacher

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

문제 설명

N×N개의 수가 N×N 크기의 표에 채워져 있다. (x1, y1)부터 (x2, y2)까지 합을 구하는 프로그램을 작성하시오.

(x, y)는 x행 y열을 의미한다.

예를 들어, N = 4이고, 표가 아래와 같이 채워져 있는 경우를 살펴보자.

여기서 (2, 2)부터 (3, 4)까지 합을 구하면 3+4+5+4+5+6 = 27이고, (4, 4)부터 (4, 4)까지 합을 구하면 7이다.

표에 채워져 있는 수와 합을 구하는 연산이 주어졌을 때, 이를 처리하는 프로그램을 작성하시오.

풀이 과정

이 문제는 누적 합 으로 해결할 수 있다.

다음과 같은 표가 있다고 하자.

이제 표의 각각의 칸에는 그 칸까지의 누적합을 작성하자.

예를 들어, (2,2)에는 (0,0) ~ (2,2) 까지의 합을 더한 값이 들어간다.

누적합으로 작성한 표는 다음과 같다.

이 때, (1, 1) ~ (2, 2) 의 합계를 구하고 싶다면

(2,2)에 저장된 누적합에

(1,1)에 저장된 누적합을 빼주고

겹치는 부분인 (1,1)의 값(누적합이 아닌 고유의 그 값)을 더해주면 된다.

(1,1)칸은 두 번 뺐기 때문에 한 번 더해주어야 하는 것이다.

이를 파이썬 코드로 나타내면 다음과 같다.

import sys

input = sys.stdin.readline
n, m = map(int, input().split())

graph = []

for i in range(n):
  graph.append(list(map(int, input().split())))

acc = [[0]*(n+1) for _ in range(n+1)]

for i in range(1, n+1):
  for j in range(1, n+1):
    acc[i][j] = acc[i-1][j] + acc[i][j-1] - acc[i-1][j-1] + graph[i-1][j-1]

print(acc)

for i in range(m):
  x1,y1,x2,y2 = map(int, input().split())

  print(acc[x2][y2] - acc[x1-1][y2] - acc[x2][y1-1] + acc[x1-1][y1-1])

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

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

문제 설명

특정 문자열 S, 특정 알파벳 α와 문자열의 구간 [l,r]이 주어지면

S의 l번째 문자부터 r번째 문자 사이에 α가 몇 번 나타나는지 구하는 프로그램을 작성하자.

문자열의 문자는 0번째부터 세며, l번째와 r번째 문자를 포함해서 생각한다.

풀이 과정

이 문제는 누적 합 으로 풀어야 시간초과 없이 해결할 수 있다.

만약, 매번 l부터 r까지 모든 문자를 돌며 개수를 카운트하는식으로 하여

N번 계산한다면 시간초과 오류가 발생하기 때문에

누적합을 이용해야 한다.

즉, 누적해서 횟수를 쌓아가야 한다는 뜻이다.

예를 들어 kakaotistory 라는 문자열이 있고, k가 들어가는 횟수를 센다고 할때,

k가 등장하지 않는 인덱스에는

k[5] = k[4]

k[6] = k[5] 

...

처럼 그 전 인덱스의 횟수를 그대로 쌓아가고

k 문자가 나타날 때는 그 인덱스에 +1을 추가해주어 누적해서 쌓아가면 된다.

kakaotistory 같은 경우 k가 0번째와 2번째에 나타나기 때문에k[0] = 1, k[1] = 1, k[2] = 2 ... k[11] = 2 이런식으로 쌓아가면 된다.

이렇게 알파벳마다 누적합 횟수를 저장해놓으면,

0번째부터 6번째 문자 사이에 k가 몇개 들어있는지 알아보아야 할 때,

매번 카운트 할 필요 없이

k[6] - k[0] 의 값을 구해서 바로 횟수를 구할 수 있기 때문이다.

그래서, 가장 먼저 문자열을 입력받고 나서

a~z별로 누적합을 먼저 저장해놓고

매 질문이 들어올때는 저장해놓은 누적합의 계산을 통해서 바로 답을 구하면 된다.

이를 파이썬으로 구현한 코드는 다음과 같다.

import sys

input = sys.stdin.readline
s = list(input().rstrip())
n = int(input().rstrip())

cList = [[0] * len(s) for _ in range(26)]

for i in range(len(s)):
  cList[ord(s[i])-ord('a')][i] += 1

for i in range(26):
  for j in range(1, len(s)):
    cList[i][j] += cList[i][j-1]

for i in range(n):
  a, l, r = input().split()
  tmp = cList[ord(a)-ord('a')][int(r)] - cList[ord(a)-ord('a')][int(l)]

  if s[int(l)] == a:
    tmp+=1
    
  print(tmp)

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

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

문제 설명

그림과 함께 제공되는 문제이니 자세한 문제설명은 위 링크를 참조해주세요.

풀이 과정

이 문제는 누적 합 으로 푸는 문제이다.

누적합을 이용하지 않고 단순 합계를 이용한다면 시간초과 오류가 나게 된다.

한번 구간합을 구하는 시간복잡도는 O(n)이고 m번동안 수행을 하게 된다면

총 시간복잡도는 O(nm)이 되는데 데이터가 10만개가 되면 시간초과 오류가 나게 된다.

그래서 매번 구간합을 구하는 것이 아니라,

처음에 n개의 수를 입력받고 나면

길이 n짜리 리스트를 만들어 리스트의 각 자리에 그 자리까지의 누적합을 저장한 후에

각 자리의 누적합에서 빼주는 방식으로 구간합을 구하면 된다.

이를 파이썬으로 나타낸 코드는 다음과 같다.

import sys
input = sys.stdin.readline

n, m = map(int, input().split())
nums = list(map(int, input().split()))
pre = [0]
tmp_sum = []
mysum = 0

for i in range(n):
  mysum += nums[i]
  pre.append(mysum)


for i in range(n-m+1):
  tmp_sum.append(pre[i+m] - pre[i])

print(max(tmp_sum))

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

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

문제 설명

수 N개가 주어졌을 때, i번째 수부터 j번째 수까지 합을 구하는 프로그램을 작성하시오.

풀이 과정

이 문제는 

누적 합 으로 푸는 문제이다.

누적합을 이용하지 않고 단순 합계를 이용한다면 시간초과 오류가 나게 된다.

한번 구간합을 구하는 시간복잡도는 O(n)이고 m번동안 수행을 하게 된다면

총 시간복잡도는 O(nm)이 되는데 데이터가 10만개가 되면 시간초과 오류가 나게 된다.

그래서 매번 구간합을 구하는 것이 아니라,

처음에 n개의 수를 입력받고 나면

길이 n짜리 리스트를 만들어 리스트의 각 자리에 그 자리까지의 누적합을 저장한 후에

각 자리의 누적합에서 빼주는 방식으로 구간합을 구하면 된다.

예를 들어 2 ~ 4 구간합을 구한다면

4까지의 구간합에 2 이전 까지의 구간합을 빼면 되는 것이다.

이 때, 주의해야 할 점은

2 ~ 4 구간합이라고 하면 4까지의 구간합에 2 이전까지의 구간합이므로

맨 처음 리스트에 0을 넣어 인덱스를 맞춰주어야 한다.

맨 앞에 0을 붙여주자.

이를 파이썬코드로 나타내면 다음과 같다.

import sys
input = sys.stdin.readline

n, m = map(int, input().split())
nums = list(map(int, input().split()))
pre = [0]
mysum = 0

for i in range(n):
  mysum += nums[i]
  pre.append(mysum)


for i in range(m):
  a, b = map(int, input().split())
  print(pre[b] - pre[a-1])

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

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

문제 설명

평소에 질문을 잘 받아주기로 유명한 중앙대학교의 JH 교수님은 학생들로부터 재귀함수가 무엇인지에 대하여 많은 질문을 받아왔다.

매번 질문을 잘 받아주셨던 JH 교수님이지만 그는 중앙대학교가 자신과 맞는가에 대한 고민을 항상 해왔다.

중앙대학교와 자신의 길이 맞지 않다고 생각한 JH 교수님은 결국 중앙대학교를 떠나기로 결정하였다.

떠나기 전까지도 제자들을 생각하셨던 JH 교수님은 재귀함수가 무엇인지 물어보는 학생들을 위한 작은 선물로 자동 응답 챗봇을 준비하기로 했다.

JH 교수님이 만들 챗봇의 응답을 출력하는 프로그램을 만들어보자.

풀이 과정

이 문제는 재귀 구현 문제이다.

코드에 작성해야 하는 문자열은 위 링크의 예시답변을 참고해서 작성해야 한다.

예시답변의 구조를 보면 알 수 있듯이

마지막 "라고 답변하였지." 부분이 n의 개수에 맞춰 마지막에 한 번에 등장하는걸로 보아

질문과 답변 사이에 재귀로 동작해야 정상적으로 출력됨을 알 수 있다.

이를 고려한 파이썬 코드는 다음과 같다.

n = int(input())

print("어느 한 컴퓨터공학과 학생이 유명한 교수님을 찾아가 물었다.")
a = "____"

def recursive(cnt):
  question1(cnt)
  if cnt == n:
    answer2(cnt)
    answer3(cnt)
    return
    
  answer1(cnt)
  recursive(cnt+1)
  answer3(cnt)
  
def question1(cnt):
  print(a*cnt + "\"재귀함수가 뭔가요?\"")
  return

def answer1(cnt):
  print(a*cnt + "\"잘 들어보게. 옛날옛날 한 산 꼭대기에 이세상 모든 지식을 통달한 선인이 있었어.")
  print(a*cnt + "마을 사람들은 모두 그 선인에게 수많은 질문을 했고, 모두 지혜롭게 대답해 주었지.")
  print(a*cnt + "그의 답은 대부분 옳았다고 하네. 그런데 어느 날, 그 선인에게 한 선비가 찾아와서 물었어.\"")
  return

def answer2(cnt):
  print(a*cnt + "\"재귀함수는 자기 자신을 호출하는 함수라네\"")
  return

def answer3(cnt):
  print(a*cnt + "라고 답변하였지.")
  return

recursive(0)

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

문제 설명

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

자세한 문제 설명은 위 링크를 참고하시길 바랍니다.

풀이 과정

이 문제는 DP(다이나믹 프로그래밍)을 이용해 최대 증가 수열을 찾는 문제라고 할 수 있다.

전깃줄이 교차하지 않도록 하려면 어떻게 해야할지에 대해 먼저 생각해보자.

먼저, 위 그림에서 A의 1번과 B의 8번만 연결되어 있다고 가정해보자.

그리고 이 때, 아래의 ①번 상황과 ②번 상황을 각각 생각해보자.

① A의 2번과 B의 2번이 연결된다면 교차하게 된다. ( 1 - 8 / 2 - 2 )

② A의 3번과 B의 9번이 연결된다면 서로 교차하지 않는다. ( 1 - 8 / 3 - 9 )

위의 예시를 보면 다음과 같음을 알 수 있다.

전깃줄 두 개가 있을 때, A의 번호가 작은 순서대로 정렬을 하여 첫 번째, 두 번째 전깃줄이라고 순서를 매긴다면

두 번째 전깃줄의 B번호가 첫 번째 전깃줄의 B번호보다 작다면 교차하게 된다.

하지만 두 번째 전깃줄의 B번호가 첫 번째 전깃줄의 B번호보다 크거나 같으면 교차하지 않게 된다.

이를 그대로 연장하여 전깃줄 세개인 상황을 만들면

세 번째 전깃줄의 B번호가 앞의 두개의 전깃줄의 B번호보다 작다면 교차함을 알 수 있다.

즉, 우리가 원하는 그림은 다음과 같음을 알 수 있다.

이런 그림이 탄생하면 전깃줄이 서로 교차하지 않게 된다.

그래서 먼저,

① A의 번호가 작은 순서대로 정렬을 하고

② 앞순서의 B가 뒷순서의 B보다 작은 경우가 최대로 이어지는 경우를 찾는다.

이렇게 접근을 하기 위해 DP를 이용하면 된다.

앞순서의 B가 뒷순서의 B보다 작은 경우에만 DP 카운팅을 늘려서

최종적으로 최대의 DP카운트를 찾으면 정답을 찾게 된다.

이 때, 최대 연장부분을 찾기 위해서는 앞에서부터 하나씩 검사를 해야 하기 때문에

2중 for문을 이용해 DP를 갱신하였다.

이를 반영한 파이썬 코드는 다음과 같다.

n = int(input())
lists = []
dp = [1]*n

for i in range(n):
  a, b = map(int, input().split())
  lists.append([a, b])

lists.sort()

for i in range(1, n):
  for j in range(0, i):
    if lists[j][1] < lists[i][1]:
      dp[i] = max(dp[i], dp[j]+1)
      
print(n-max(dp))

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

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

문제 설명

n개의 정수로 이루어진 임의의 수열이 주어진다. 우리는 이 중 연속된 몇 개의 수를 선택해서 구할 수 있는 합 중 가장 큰 합을 구하려고 한다. 단, 수는 한 개 이상 선택해야 한다.

예를 들어서 10, -4, 3, 1, 5, 6, -35, 12, 21, -1 이라는 수열이 주어졌다고 하자. 여기서 정답은 12+21인 33이 정답이 된다.

풀이 과정

이 문제는 DP(다이나믹 프로그래밍)을 이용해 최댓값을 찾는 문제이다.

DP라는 리스트(배열)의 각 칸에는 그 칸까지 숫자들을 고려했을 때의 연속합의 최댓값을 담을 것이다.

예를 들어, DP[2]는 2번째 인덱스 까지의 숫자를 고려했을 때의 최댓값이 저장될 것이다.

이 때, 만약 이전 인덱스 까지의 연속합이 음수라서 이전까지의 합에 현재 수를 더하는 것 보다

현재 수 만을 갖고있는게 더 큰 경우에는

이전까지 연속합을 끊어내고 현재 인덱스부터 새로운 구간합을 만들어가야 한다.

이러한 부분들을 고려하여 작성한 파이썬 코드는 다음과 같다.

n = int(input())
nums = list(map(int, input().split()))

INF = -int(1e9)
dp = [INF]*n

if n<2:
  dp[0] = nums[0]

else:
  dp[0] = nums[0]
  dp[1] = max(nums[1], dp[0]+nums[1])
  for i in range(2, n):
    dp[i] = max(dp[i-1]+nums[i], nums[i])

print(max(dp))

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !

문제 설명

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

수열 S가 어떤 수 Sk를 기준으로 S1 < S2 < ... Sk-1 < Sk > Sk+1 > ... SN-1 > SN을 만족한다면, 그 수열을 바이토닉 수열이라고 한다.

예를 들어, {10, 20, 30, 25, 20}과 {10, 20, 30, 40}, {50, 40, 25, 10} 은 바이토닉 수열이지만,  {1, 2, 3, 2, 1, 2, 3, 2, 1}과 {10, 20, 30, 40, 20, 30} 은 바이토닉 수열이 아니다.

수열 A가 주어졌을 때, 그 수열의 부분 수열 중 바이토닉 수열이면서 가장 긴 수열의 길이를 구하는 프로그램을 작성하시오.

풀이 과정

이 문제는 이 문제의 하위버전인 가장 긴 증가하는 부분수열 문제(https://www.acmicpc.net/problem/11053)를 풀었다면 쉽게 접근할 수 있는 문제이다.

먼저, 길이 10짜리 수열을 보자.

1 5 2 1 4 3 4 5 2 1

일단은, 감소하는 부분은 생각하지 말고 인덱스별로 증가하는 부분만을 생각해보자.

5는 1 -> 5 로 증가하기 때문에 길이 2짜리 부분수열이며

2는 1 -> 5 -> 2 가 될 수 없기 때문에 1 -> 2 로 2이다.

1은 증가할 수 없기 때문에 1이며

4는 1 -> 2 -> 4 이기 때문에 3이다.

이러한 식으로 부분증가 수열 중 최대 길이를 찾아내야 하는데,

이는 기준점(i)을 2번째 인덱스부터 끝점까지 반복문을 통해 이동해주며

그 안에서의 다른 기준점(j)을 세워 처음부터 i번째 인덱스 이전까지 돌며

i번째 수보다 작은 수를 만났을 경우에 그 수까지 부분수열의 길이에 +1을 해주면 된다.

즉, 2중 for문을 통해 i번째 인덱스에 대해 그 인덱스의 부분수열을 구해주면 된다.

참고로, 배열 길이는 1000이므로 2중 for문을 돌더라도 시간초과가 발생하지 않는다.

이를 그대로, 감소하는 수열에 적용해보자.

이번엔 기준점(i)을 처음 2번째 인덱스가 아닌 마지막에서 2번째 인덱스를 두어 감소하도록 하고

그 안의 기준점(j)을 끝점부터 i번째 인덱스 까지 돌며

i번째 수보다 작은 수를 만났을 경우에 그 수까지의 부분수열의 길이에 +1을 해주면 된다.

이를 코틀린 코드로 나타내면 다음과 같다.

import kotlin.collections.*
import kotlin.math.max

fun main(args: Array<String>) {
    val n = readLine()!!.toInt()
    val list = readLine()!!.split(" ").map { it.toInt() }

    val upDp = Array(1001){1}
    val downDp = Array(1001){1}

    for(i in 1 until n) {
        for(j in 0 until i) {
            if(list[i] > list[j]) {
                upDp[i] = max(upDp[i], upDp[j] + 1)
            }
        }

    }

    for(i in n-2 downTo 0) {
        for(j in n-1 downTo i+1) {
            if(list[i] > list[j]) {
                downDp[i] = max(downDp[i], downDp[j] + 1)
            }
        }
    }

    var max = 0
    for(i in 0 until n) {
       if(upDp[i] + downDp[i] > max) {
           max = upDp[i] + downDp[i]
       }
    }

    print(max-1)
}

https://github.com/HongEunho

전체 문제 & 코드는 위의 깃에 정리되어 있습니다.

팔로우 & 맞팔은 환영입니다 !