23-SeongHoonC

[SeongHoonC]

🔗 문제 링크

소수의 연속합

✔️ 소요된 시간

40분

✨ 수도 코드

소수 리스트를 만들어서 head tail 옮겨가면서 해결하는건 쉽게 떠올랐습니다.

그러나 시간 초과에 봉착...

생각난 시간 초과 해결 방법

1. 누적합 리스트를 만들어 놓고 합 계산
2. 소수 구하는 시간 줄이기 (제곱근까지만 탐색하거나 에라토스테네스의 체 사용)

에라토스테네스는 문제풀 때 바로 생각 안나서 그냥 제곱근까지 탐색으로 우선 풀었습니당.. 그랬더니 해결!

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    var (head, tail) = 0 to 0
    val n = br.readLine().toInt()
    // 누적합 계산
    val primes = findPrimeNumbers(n)
    var count = 0

    // head tail
    while (head < primes.size && tail < primes.size) {
        val sum = primes.subList(head, tail + 1).sum()
        if (sum < n) {
            tail++
            continue
        }
        if (sum == n) {
            count++
        }
        head++
    }
    println(count)
}

// 최대 rangeMax 까지의 소수 리스트 구하기
private fun findPrimeNumbers(rangeMax: Int): List<Int> {
    return (2..rangeMax).filter {
        isPrime(it)
    }
}

소수인지 계산
private fun isPrime(num: Int): Boolean {
    for (i in 2..sqrt(num.toDouble()).toInt()) {
        if (num % i == 0) {
            return false
        }
    }
    return true
}

누적합을 적용하든 안하든 시간 차이가 얼마안나네요...

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    var (head, tail) = 1 to 1
    val n = br.readLine().toInt()
    val primes = listOf(0) + findPrimeNumbers(n)
    val summedPrimes = Array<Int>(n + 1) { 0 }
    for (i in 1 until primes.size) {
        summedPrimes[i] = summedPrimes[i - 1] + primes[i]
    }
    var count = 0

    while (head < primes.size && tail < primes.size) {
        val sum = summedPrimes[tail] - summedPrimes[head - 1]
        if (sum < n) {
            tail++
            continue
        }
        if (sum == n) {
            count++
        }
        head++
    }
    println(count)
}

📚 새롭게 알게된 내용

시간 초과를 어떻게 계산하는지 아직 잘몰라요 혹시 이 문제에서 시간초과 계산 방법을 알려주실 수 있나요?

[tgyuuAn]

시간 초과를 어떻게 계산하는지 아직 잘몰라요 혹시 이 문제에서 시간초과 계산 방법을 알려주실 수 있나요?

시간 복잡도 계산 말씀하시는 걸까요잉 ?!

[tgyuuAn]

def generatePrime(maximum):
    if maximum <= 1:
        return None

    prime_numbers = []
    
    for number in range(2,maximum+1):
        for i in range(2,int(number**0.5)+1):
            if number%i ==0:
                break
        
        else:
            prime_numbers.append(number)

    return prime_numbers

target = int(input())

if target <= 1:
    print("0")

else:
    primeNumbers = generatePrime(target)

    #print(primeNumbers)

    left, right = 0,0
    temp = 2
    count = 0

    while left<=right:
        if temp < target:
            right += 1
            if right >= len(primeNumbers): break
            temp += primeNumbers[right]

        elif temp > target:
            temp -= primeNumbers[left]
            left += 1

        else:
            right += 1
            count += 1
            if right >= len(primeNumbers): break
            temp += primeNumbers[right]

    print(count)

일단 올려 놓구 리뷰는 나즁에 키키

[SeongHoonC]

누적합도 쓸 필요가 없었군요 합 변수를 만들고 head tail 을 변수에 더해주면 되는거였네요

[9kyo-hwang]

이거랑 똑같은 로직으로 C++ 코드 제출해봤는데 코틀린이랑 시간 차이가 안나네요...?

#include <iostream>
#include <vector>
#include <numeric>

using namespace std;

bool IsPrime(int n)
{
    for(int i = 2; i * i <= n; ++i)
    {
        if(n % i == 0)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N; cin >> N;
    
    vector<int> Primes;
    for(int i = 2; i <= N; ++i)
    {
        if(IsPrime(i))
        {
            Primes.emplace_back(i);
        }
    }
    
    int Head = 0, Tail = 0;
    int Answer = 0, Sum = 0;
    while(Head < Primes.size() && Tail < Primes.size())
    {
        int Sum = accumulate(&Primes[Head], &Primes[Tail + 1], 0);
        if(Sum < N)
        {
            Tail++;
            continue;
        }
        
        if(Sum == N)
        {
            Answer++;
        }
        Head++;
    }
    
    cout << Answer;

    return 0;
}

신기하네요...

---

생각해보니 2 ~ 4,000,000 숫자에 대해 다 소수를 판별하다보니 시간이 오래걸릴 수 밖에 없네요... 여기서 시간이 오래 걸립니다.

에라토스테네스의 체를 사용하면 시간이 대폭 줄어듭니다. 제 경우엔 20ms 까지 줄어드네요 ㅋㅋ

[alstjr7437]

소수 문제를 보면 매번 생각나는 에라토스테네스의 체인데 인터넷을 참고하고 어떻게 구현하는지 이해는 했는데 다시 하려면 안되더라구요... 시간이 될때 블로그에 정리를 한번 해야할 것 같네요!!!

[H0ngJu]

소수 보고 바로 에라토스테네스의 체?! 하고 접근했습니다
근데 구현은 기억이 안나서 공부하고 다시 접근했습니다 ㅎ;; 덕분에 복습했습니다 (_ _)

흐음.. 근데 연속된 소수의 합을 처리하는 과정에서 쫌 오래 걸렸네요
성훈님 PR의 head, tail 부분 로직 짜다가 (제 코드의 while 문) IndexError가 자꾸 발생해서 겨우 처리했네용 ..

문제푸느라 수고많으셨슴다 ~~ 👍👍

import sys
import math

def input(): return sys.stdin.readline().rstrip()

N = int(input())
if N <= 1:
    print("0")
    sys.exit(0)

total = 0
result = 0
start = 0
end = 0

arr = [True for i in range(N+1)]
prime_arr = []


for i in range(2, int(math.sqrt(N)) + 1):
    if arr[i]:
        for j in range(i*i, N+1, i):
            arr[j] = False

for i in range(2, len(arr)):
    if arr[i] == True:
        prime_arr.append(i)

total = prime_arr[start]

while start<=end and end<=len(prime_arr):
    if total < N:
        if 0<end<len(prime_arr):
            total += prime_arr[end]
        end += 1
    elif total == N:
        result += 1
        total -= prime_arr[start]
        start += 1
    else:
        total -= prime_arr[start]
        start += 1


print(result)