47-tgyuuAn

[tgyuuAn]

🔗 문제 링크

너 봄에는 캡사이신이 맛있단다

✔️ 소요된 시간

40분

(50점 까지 맞고 Large 케이스는 레퍼런스 참고)

• 해당 문제에 모듈러 연산, 분할 정복 제곱 과 같은 잡기술이 들어갑니다.
• 모를 경우 빠른 PR 정독 추천드립니다.

✨ 수도 코드

일단 이 코드로 모든 조합의 경우를 완전 탐색하게 될 경우 말도 안되는 경우의 수가 나오기 때문에 시도해보지도 않았다.

문제를 곰곰히 읽어보니, 결국 최소 값과 최대 값만 있으면 그 사이에 있는 수는 무엇이 들어있든 중요하지 않다라는 사실을 깨달았다.

즉, 아래와 같은 예제가 있을 경우,

6
1 4 5 5 6 10

최소값 1 최대값 10일 경우,

• 내부에 4가 있는 경우와 없는 경우,

• 첫 번째 5가 있는 경우와 없는 경우,

• 두 번째 5가 있는 경우와 없는 경우,

• 6이 있는 경우와 없는 경우

총 2의 4승개 만큼 존재할 수 있다.

최대값 10 - 최소값 1 = 9 가 16개 (2의 4승개) 있으므로 144가 쌓인다.

즉, 이러한 방법으로 아래와 같이 2개의 for문으로 완탐 돌리면 Small 케이스는 통과가 가능하다.

for start_idx in range(N-1):
    for end_idx in range(start_idx+1, N):
        # 상세 로직

하지만 위와 같이 풀 경우 $O(n^2)$ 의 시간 복잡도로 풀리게 되는데,

Large 케이스의 경우 n이 30만이기 때문에 시간 내로 들어오지 못하게 된다.

여기서 30분 정도 고민하며 뇌사가 왔는데,

말도 안되는 인사이트를 발견한다.

https://0902.tistory.com/60

홀리몰리..

그렇다.. 애초에 저 최소값 최대값이 쌍으로 있을 필요가 없고,

어차피 최소 값은 빼질거고 최대 값은 더해질 것이므로 하나의 for문 만으로도 구현이 가능하다.

뭔가 말이 어려운데...

아래와 같이 가장 앞에 있는 1은 뒤에 어떤 수가 있던 간에 총 $2^5 - 1$개 만큼 최소 값으로 동작할 것이다.

반면 10은 $2^5-1$개의 경우 동안 최대 값으로 동작할 것이다.

즉, 이런 식으로 한 번의 순회만으로 최소 값은 빼고 최대 값은 더해주면 Large 케이스도 해결 가능이다.

추가적으로 이 문제는 수의 범위가 최대 $2^31$ 까지 가므로,

수가 매우 크기 때문에 일반적인 사칙연산이더라도 시간이 매우 커진다.

그렇기 때문에 중간중간 수를 줄여주는 모듈러 연산을 적용시켜줘야 하는데,

아마 홍주님을 제외한 나머지 분들은 이미 아실테고,

홍주님을 위해서 짧게나마 링크를 남겨드리리다.

이건 외울 수 밖에 없어요.

근의 공식처럼...

https://sskl660.tistory.com/75

또 제곱의 수가 너무 커질 경우 제곱 연산에서 시간 복잡도가 터질 수 있으므로,

이것 또한 분할 정복 방법으로 시간을 단축시켜야하는데,,,

말로 설명하면 PR이 너무 길어질 것 같다.

일단 핵심은 2^1024를 한다 했을 때,

그냥 반복문으로 이를 계싼하면 1024번 계산해야 하지만,

1024
= 512 * 512
= 256 * 256 * 256 * 256
= ...

이런 식으로 계속 반씩 쪼개면 단 10번만으로 계산이 가능하다는 원리이다.

https://devlibrary00108.tistory.com/328

홍주님 머리가 터질 것 같다.

너무 죄송하다.

📚 새롭게 알게된 내용

근데 파이썬으로 알고리즘을 할 경우 큰 수 제곱 연산에 함수를 굳이 직접 만들 필요 없고,

# N을 K 제곱할 때 Q로 나눈 수
pow(N, K, Q)

로 이미 제공해주고 있었다.

즉, 내가 짠 코드보다 아래와 같이 기본적으로 제공해주는 메소드를 사용하면 시간이 반절이나 줄어든다.

import sys

DIV = 1_000_000_007

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

N = int(input())
numbers = sorted(list(map(int,input().split())))
DP = [-1 for _ in range(N)]
answer = 0

for start_idx in range(N):
    start_num = numbers[start_idx]
    end_num = numbers[N-start_idx-1]

    # 만약 캐싱이 되어있지 않을 경우 직접 계산
    if DP[N-start_idx-1] == -1: DP[N-start_idx-1] = pow(2, N-start_idx-1, DIV)
    
    # 한번이라도 계산  했으면 바로 이용
    answer += ((end_num % DIV) * (DP[N-start_idx-1] % DIV)) % DIV
    answer -= ((start_num % DIV) * (DP[N-start_idx-1] % DIV)) % DIV

print(answer % DIV)

[H0ngJu]

친절한 수도코드 설명과 레퍼런스 참조까지 .. 😭
이해하는데 아주 도움이 정~말 많이 되었습니다..!!!!!!>!>!>

문제 재밌네요 ㄷㄷ 이런 아이디어를 떠올리기까지 얼마나 많은 문제를 풀어야할지 ..ㅎ

문제푸느라 수고많으셨슴다 !!!💪💪

[H0ngJu]

태규님 이 코드가 end_num과 start_num에 대하여 최댓값이 되는 경우의 합과 최솟값이 되는 경우의 합을 각각 answer에서 더하고 빼는 코드인 것 같은데 왜 %DIV를 계속 하는건지 설명해 주실 수 있을까요ㅠ? 이해가 될랑 말랑허네요 ..😅🤔

라고 질문하려고 했는데 첨부해주신 mod 연산보고 이해하고 갑니다. 허허

(end_num * DP[N-start_idx - 1]) % DIV를 하지 않는 이유가 end_num*DP가 표현 가능한 수를 넘어갈 수 있기 때문에 !! 맞을까요?

[tgyuuAn]

홍주님과 원만한 대화를 통해 해결하였씁니다 -

[pknujsp]

분할정복제곱은 살면서 이 문제 통해서 처음 봤네요
오래 생각해봤지만 도저히 답이 안나와서 태규님 풀이랑 다른 사람들 내용 보면서 풀어봤습니다
푸는 아이디어가 천재들인가 장난아니네요

MOD = 1_000_000_007

N = int(input())
scovilles = list(map(int, input().split()))
scovilles.sort()

total_pain_index = 0

for i, scoville in enumerate(scovilles):
    min_contribution = pow(2, N - i - 1, MOD)
    max_contribution = pow(2, i, MOD)
    contribution = (max_contribution - min_contribution) * scoville
    
    total_pain_index = (total_pain_index + contribution) % MOD
    
print(total_pain_index)

[tgyuuAn]

분할정복제곱은 살면서 이 문제 통해서 처음 봤네요 오래 생각해봤지만 도저히 답이 안나와서 태규님 풀이랑 다른 사람들 내용 보면서 풀어봤습니다 푸는 아이디어가 천재들인가 장난아니네요

MOD = 1_000_000_007

N = int(input())
scovilles = list(map(int, input().split()))
scovilles.sort()

total_pain_index = 0

for i, scoville in enumerate(scovilles):
    min_contribution = pow(2, N - i - 1, MOD)
    max_contribution = pow(2, i, MOD)
    contribution = (max_contribution - min_contribution) * scoville
    
    total_pain_index = (total_pain_index + contribution) % MOD
    
print(total_pain_index)

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ 저도 small 케이스밖에 못맞췄습니다. Large케이스는 진짜 천재들인 것 같아요..

[MunbinLee]

#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;

constexpr long long MOD = 1'000'000'007;
unordered_map<int, long long> memo{{0, 1}};

long long power(int x) { // NOLINT
  if (memo.contains(x))
    return memo[x];

  if (x % 2)
    return memo[x] = power(x - 1) * 2 % MOD;

  return memo[x] = power(x / 2) * power(x / 2) % MOD;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  int N;
  cin >> N;

  vector<int> foods(N);

  for (int &food : foods) {
    cin >> food;
  }

  ranges::sort(foods);

  long long answer = 0;

  for (int i = 0; i < N; i++) {
    answer += foods[i] * (power(i) - power(N - 1 - i));
    answer %= MOD;
  }

  cout << answer;

  return 0;
}

최댓값과 최솟값을 고정하면 같은 값이 나오므로 이를 응용해서 풀어보려 했으나 그렇게 분류를 하는 경우의 수가 많아서 두 번째 케이스는 풀기 실패했습니다.

이 부분 발상 지리는데요 ㅎㄷㄷㄷ

[tgyuuAn]

#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;

constexpr long long MOD = 1'000'000'007;
unordered_map<int, long long> memo{{0, 1}};

long long power(int x) { // NOLINT
  if (memo.contains(x))
    return memo[x];

  if (x % 2)
    return memo[x] = power(x - 1) * 2 % MOD;

  return memo[x] = power(x / 2) * power(x / 2) % MOD;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  int N;
  cin >> N;

  vector<int> foods(N);

  for (int &food : foods) {
    cin >> food;
  }

  ranges::sort(foods);

  long long answer = 0;

  for (int i = 0; i < N; i++) {
    answer += foods[i] * (power(i) - power(N - 1 - i));
    answer %= MOD;
  }

  cout << answer;

  return 0;
}

최댓값과 최솟값을 고정하면 같은 값이 나오므로 이를 응용해서 풀어보려 했으나 그렇게 분류를 하는 경우의 수가 많아서 두 번째 케이스는 풀기 실패했습니다.

이 부분 발상 지리는데요 ㅎㄷㄷㄷ

인정따리입니다...