15 ljedd2

[LJEDD2]

🔗 문제 링크

백준 브루트포스 | BOJ 11502 세 개의 소수 문제

문제 설명
정수론(수학)에서, 세 개의 소수 문제(3-primes problem) 는 다음과 같은 추측을 말한다.
'5보다 큰 임의의 홀수는 정확히 세 개의 소수들의 합으로 나타낼 수 있다. 물론 하나의 소수를 여러 번 더할 수도 있다.'

예를 들면,
7 = 2 + 2 + 3
11 = 2 + 2 + 7
25 = 7 + 7 + 11
5보다 큰 임의의 홀수를 입력받아서, 그 홀수가 어떻게 세 소수의 합으로 표현될 수 있는지 알아보자.

✔️ 소요된 시간

1시간

✨ 수도 코드

에라토스테네스 공식을 까먹어서 .. 😭😭 풀 때는 좀 오래 걸린 것 같은데
정리하니 엄청 간단하게 풀 수 있는 비교적 쉬운 문제네요
이 다음차시에는 좀 더 어려운 문제를 들고 오겠습니다 .. !

이 문제를 풀기 위해서는 소수를 구하는 에라토스테네스의 체를 알아야 합니다!
전체 시간 복잡도는 O(n³)로
n이 1000이 아니라 1000까지의 소수의 개수라 대략 168개라고 치면
실제 연산 횟수는 약 168³ = 4,741,632회 정도가 되어 브루트포스로 충분히 계산할 수 있습니다.

에라토스테네스의 체 알고리즘을 사용하여 주어진 K보다 작은 소수들을 구한 후
3중 for문으로 모든 경우를 탐색해보는 브루트 포스(Brute Force) 알고리즘 기법을 사용하여 K를 만들 수 있는 세 개의 소수를 찾아내면 됩니다.

# 하나의 소수를 여러 번 더할 수 있다. -> 브루트포스 가능 
# 5보다 큰 임의의 홀수로 세 소수의 합이 되는지 
def search(n):
    for i in arr:
        for j in arr:
            for k in arr:
                if i+j+k == n:
                    return i, j, k

    else: # 안되면 0 
        return 0

# 에라토스테네스의 체 - 소수 판별 
prime = [True] * 1001

for i in range(2,101):
    if prime[i]:
        for j in range(i*2, 1001, i):
            prime[j] = False

# 소수 찾기 
arr = [i for i in range(2, 1001) if prime[i] == True]

t = int(input())
for _ in range(t):
    n = int(input())
    print(*search(n))

📚 새롭게 알게된 내용

[jung0115]

저도 전체적인 구현 방식은 비슷하게 풀어냈습니다! 소수는 구할 때마다 방법이 기억 나질 않는 거 같아요... 반복적으로 구현해보거나 아예 외워버리든 해야겠습니다 ㅜㅜ

이번 차시도 수고많으셨어요!

import java.io.BufferedReader
import java.io.InputStreamReader

fun main() {
  val br = BufferedReader(InputStreamReader(System.`in`))
  val sb = StringBuilder()

  val T = br.readLine().toInt()

  val nums = IntArray(T) { 0 }
  for(i: Int in 0..T-1) {
    nums[i] = br.readLine().toInt()
  }

  val primes = mutableListOf<Int>()

  for (i in 2..1000) {
    var isPrime = true
    for (p in primes) {
      if (p * p > i) break  // 이미 구한 소수로만 나눠서 확인
      if (i % p == 0) {
        isPrime = false
        break
      }
    }
    if (isPrime) {
      primes.add(i)  // 소수면 리스트에 추가
    }
  }

  for(i: Int in 0..T-1) {
    val result = searchThreeNum(nums[i], primes)

    if (result != null) {
      sb.append("${result.first} ${result.second} ${result.third}\n")
    } else {
      sb.append("0\n")
    }
  }

  print(sb)
}

fun searchThreeNum(n: Int, primes: List<Int>): Triple<Int, Int, Int>? {
  for (i in primes) {
    for (j in primes) {
      for (k in primes) {
        if (i + j + k == n) {
          return Triple(i, j, k)
        }
      }
    }
  }
  return null
}

[jung0115]

소수를 구할 때 저는 아래 코드처럼 구현했는데, 에라토스테네스의 체를 이용하면 숫자가 더 커졌을 때도 시간 복잡도 측면에서 유리하게 구현할 수 있겠네요! 제가 사용한 방식도 백준에서는 통과되기는 했지만, 숫자가 커질수록 나눗셈 연산이 늘어나서 좀 비효율적일 거 같네요 🥹

val primes = mutableListOf<Int>()

for (i in 2..1000) {
  var isPrime = true
  for (p in primes) {
    if (p * p > i) break  // 이미 구한 소수로만 나눠서 확인
    if (i % p == 0) {
      isPrime = false
      break
    }
  }
  if (isPrime) {
    primes.add(i)  // 소수면 리스트에 추가
  }
}

[janghw0126]

저도 에라토스테네스의 체로 구현해보았습니다!
코드가 거의 동일하네요 ㅎㅎ
이 알고리즘은 한번 보고 뒤돌면 까먹구,,,저에겐 그런 알고리즘이네요 ㅠ
정미님 말씀대로 외워버리든지 해야겠씁니다😂😂

def find_prime_sum(K, primes):
    for x in primes:
        for y in primes:
            for z in primes:
                if x + y + z == K:
                    print(x, y, z)
                    return
    print(0)

# 에라토스테네스의 체로 소수 구하기
is_prime = [True] * 1001
for i in range(2, int(1001 ** 0.5) + 1):
    if is_prime[i]:
        for j in range(i * i, 1001, i):
            is_prime[j] = False

primes = [i for i in range(2, 1001) if is_prime[i]]

for _ in range(int(input())):
    K = int(input())
    find_prime_sum(K, primes)

다음 PR도 팟팅입니다!