31-kangrae-jo

[kangrae-jo]

🔗 문제 링크

[두 배열의 합]

✔️ 소요된 시간

1h

✨ 수도 코드

이번주 토요일에 못올릴것 같아서 미리 올립니다...

오늘 문제는 누적합 관련 문제입니다.
이 문제도 방법을 알면 아하! 하고 번뜩이실겁니다.

저는 처음에 2차원 배열에 DP처럼 모든 부분 배열의 합을 더해놓으려고 했는데요.. 문제가 있습니다.
저장은 어떻게든 한다해도, 나중에 그 부분 배열의 합들을 조합하기가 쉽지 않다는 것이에요.

방법이 생각이 안나서 이리저리 찾아보던 중 제가 예전에 공부하면서 풀었던 문제가 떠오르더군요.
[합이 0인 네 정수]
이 문제랑 풀이가 똑같습니다.
바로 생각나지 않는걸 보니 저는 공부를 제대로 안했나봐요..

그래서 찾아낸 방법은 다음과 같아요.

1. 2차원 배열에 부분 합을 구해놓지 말고 1차원 배열에 쭉 늘어놓자.
2. 늘어놓은 부분 합들의 왼쪽 끝, 오른쪽 끝에서 시작하는 투포인터 탐색!
3. 탐색 중 T와 동일한 부분 합의 합을 발견하면 answer++;

아마 문제를 좀 오래 고민해보셨다면 위의 로직을 쉽게 이해할 수 있을 거에요.
이 문제 푸신 분들은 [합이 0인 네 정수]이것도 풀어보셔서 무한으로 즐기시길 바랍니다.
저처럼 방식을 까먹지 않도록 기록도 잘 하시길 바랍니다.

아 그리고 사용하는 언어에 upper_bound , lower_bound함수가 있는 사람들은 아래와 같은 풀이도 가능하니 참고 하시면 됩니다.

    long long answer = 0;
    for (int i = 0; i < subA.size(); i++) {
        int target = T - subA[i];
        auto lower = lower_bound(subB.begin(), subB.end(), target);
        auto upper = upper_bound(subB.begin(), subB.end(), target);
        answer += (upper - lower);
    }

두 부분 배열의 합이 T 일떄 while문으로 중복을 체크해주던 부분과 left++ , right-- 하던 로직을 최소화 할 수 있어요.
매번 이분 탐색을 하기 떄문에 제가 파일로 올려놓은 코드(투포인터)보다는 느립니다.

이분 탐색은 subB만 정렬 하면 돼서 좀 더 빠르지만, 메인 로직에서 O(N² log M) 입니다.
투 포인터는 O(N² + M²) 이죠.

이분탐색은 코드가 워낙 간결하니 충분히 장점이 있는것 같아요.

📚 새롭게 알게된 내용

2차원 배열에 부분합을 구해놓는다는 고정관념 꺠기
예전에 풀었던 문제 꼭꼭씹어먹기

[9kyo-hwang]

매 번 부분 배열 합을 구하는 건 무조건 시간초과 나니까 미리 캐싱을 해놓아겠다 -> 부분합
이 부분은 캐치했는데 그 다음은 어케 푸노.... 이러고 있었는데 '합이 0인 네 정수' 문제와 비슷하다는 코멘트를 보고 감을 잡았네요.

약간 어거지?라고 보일 수도 있는데, 투포인터나 이진 탐색 안쓰고 단순히 한 쪽 부분합 배열을 통해 만들 수 있는 모든 경우의 수를 map에 다 때려 박으면 됩니다. 그리고 나머지 한 쪽 부분합 배열을 통해 만들 수 있는 경우의 수를 확인하면서, T - (경우의 수)가 map에 존재하는 지 체크해서 그 개수만큼 더해주면 됩니다.

#include <bits/stdc++.h>
using namespace std;
using int64 = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int64 T; cin >> T;
    
    int n; cin >> n;
    vector<int64> A(n), prefixA(n + 1, 0);
    for(int i = 0; i < n; ++i) {
        cin >> A[i];
        prefixA[i + 1] = prefixA[i] + A[i];
    }
    
    int m; cin >> m;
    vector<int64> B(m), prefixB(m + 1, 0);
    for(int i = 0; i < m; ++i) {
        cin >> B[i];
        prefixB[i + 1] = prefixB[i] + B[i];
    }
    
    unordered_map<int, int64> numSubset;
    numSubset.reserve(n * n);
    
    for(int i = 0; i < n; ++i) {
        for(int j = i + 1; j <= n; ++j) {
            ++numSubset[prefixA[j] - prefixA[i]];
        }
    }
    
    int64 ans = 0;
    for(int i = 0; i < m; ++i) {
        for(int j = i + 1; j <= m; ++j) {
            int64 val = prefixB[j] - prefixB[i];
            if(numSubset.count(T - val)) {
                ans += numSubset.at(T - val);
            }
        }
    }
    
    cout << ans;

    return 0;
}

다만 자료형 때문에 4트 그냥 날려먹은건 안비밀... ㅎ

[kokeunho]

저도 배열 a, b 각각 이차원 배열을 만들어서 누적합을 저장해두고
이차원 배열을 탐색하면서 합이 T가 되는 조합을 찾으려 했습니다.
근데 그렇게 되면 시간 복잡도가 최악의 경우 O(n^2 * m^2)가 돼서 틀린 풀이였습니다.

좀 고민해보다 풀이를 참고했는데
생각보다 훨씬 간단한 풀이였습니다.

우선 강래님과 동일하게 배열 a, b의 범위별 나올 수 있는 누적합을 모두 저장합니다 (sumA, sumB).
그 다음부터는 저는 Map을 사용하였습니다.
sumB를 Map 자료구조를 활용하여 각 누적합 값마다 동일한 값이 몇 개가 나오는지 정리합니다.
->누적합의 값을 key로 동일한 값의 개수를 value로 Map에 저장합니다.

그리고 sumA를 순회하며 sumB에서 T-sumA_i에 해당하는 값들을
최종 답안 변수에 더해주었습니다.

좋은 문제 감사합니다. 수고하셨습니다!

Details

import java.util.*;

public class Main {
    static int T, n, m;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        T = sc.nextInt();
        n = sc.nextInt();
        int[] arrA = new int[n];
        for (int i = 0; i < n; i++) {
            arrA[i] = sc.nextInt();
        }
        m = sc.nextInt();
        int[] arrB = new int[m];
        for (int i = 0; i < m; i++) {
            arrB[i] = sc.nextInt();
        }

        List<Integer> sumA = findAllSums(arrA);
        List<Integer> sumB = findAllSums(arrB);

        Map<Integer, Integer> countB = new HashMap<>();
        for (int sum : sumB) {
            countB.put(sum, countB.getOrDefault(sum, 0) + 1);
        }

        long answer = 0;
        for (int sum : sumA) {
            answer += countB.getOrDefault(T-sum, 0);
        }

        System.out.print(answer);
    }
    static List<Integer> findAllSums(int[] arr) {
        List<Integer> response = new ArrayList<>();

        for (int i = 0; i < arr.length; i++) {
            int sum = 0;
            for (int j = i; j < arr.length; j++) {
                sum += arr[j];
                response.add(sum);
            }
        }

        return response;
    }
}

[g0rnn]

누적합 + 투포인터, 누적합 + 이진탑색으로 풀어야한다.! 는 느껴졌지만 직접적인 솔루션이 생각나지 않았습니다. 애초에 누적합을 1~i까지의 합만 생각하고 있었습니다. 어차피 내가 원하는 구간의 합은 누적합의 index 접근으로 상수 시간 내에 구할 수 있으니 문제없다고 생각해습니다. 모든 부분합을 구할 생각을 못했던거죠..

그렇게 솔루션을 생각하다가 재귀함수로 양끝의 범위를 줄여가자! 이런 생각까지 했지만.. 문제를 보니 두 배열의 부분합을 모두 사용하라고 되어있어.. 그냥 답을 봤습니다.

강래님의 설명을 듣고도 이해되지 않아 코드로 이해했습니다. 부분합 구하기 + 정렬 + 범위 줄이기 이렇게 큰 로직으로 보니 솔루션이 단번에 생각나더군요

(while로 중복되는 부분합을 처리해야 한다는 사실은 실제 문제풀이 때 절대 생각해내지 못했을거 같네요..허허)

고생하셨습니다~

package beakjoon;

import java.util.*;
import java.io.*;

public class Sol2143 {
    static int T, n, m;
    static int[] a, b;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        T = Integer.parseInt(br.readLine());
        n = Integer.parseInt(br.readLine());
        a = new int[n];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(st.nextToken());
        }

        m = Integer.parseInt(br.readLine());
        b = new int[m];

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < m; i++) {
            b[i] = Integer.parseInt(st.nextToken());
        }
        br.close();

        List<Integer> partialA = allPartialSum(a, n);
        List<Integer> partialB = allPartialSum(b, m);

        partialA.sort(Integer::compareTo);
        partialB.sort(Integer::compareTo);

        long answer = 0;
        int left = 0, right = partialB.size() - 1;
        while (left < partialA.size() && 0 <= right) {
            int sum = partialA.get(left) + partialB.get(right);
            if (sum == T) {
                long cntA = 1, cntB = 1;
                while (left < partialA.size() - 1 && partialA.get(left).equals(partialA.get(left + 1))) {
                    cntA++;
                    left++;
                }
                while (0 < right && partialB.get(right).equals(partialB.get(right - 1))) {
                    cntB++;
                    right--;
                }
                answer += cntA * cntB;
                left++;
                right--;
            } else if(sum < T) {
                left++;
            } else {
                right--;
            }
        }
        System.out.println(answer);
    }

    private static List<Integer> allPartialSum(int[] arr, int size) {
        List<Integer> tmp = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            int sum = 0;
            for (int j = i; j < size; j++) {
                sum += arr[j];
                tmp.add(sum);
            }
        }
        return tmp;
    }
}

[wnsmir]

음 앞에 두문제 세그먼트트리를 풀고 이문제를 보니
뭔가 또 세그먼트트리문제인가? 하고 생각했습니다 ㅋㅋㅋㅋ

결국 모든합을 구해야하기 때문에 DP처럼 누적합으로 미리 계산해두는 방식을 풀 수 있었습니다.

여기까지는 강래님과 같았는데
저는 T-a를 투포인터가 아닌 카운터로 찾았습니다.

from collections import Counter

c = Counter([1,2,2,3,3,3])
print(c)   # Counter({3: 3, 2: 2, 1: 1})

이런 식으로 사용하는 라이브러리입니다.

from collections import Counter

T = int(input())
n = int(input())
A = list(map(int, input().split()))
m = int(input())
B = list(map(int, input().split()))

# 누적합 구하기
def prefix_sums(arr):
    prefix = [0]
    for x in arr:
        prefix.append(prefix[-1] + x)
    return prefix

prefixA = prefix_sums(A)
prefixB = prefix_sums(B)

# 부 배열 합 리스트 만들기
def subarray_sums(prefix):
    sums = []
    n = len(prefix)-1
    for i in range(1, n+1):
        for j in range(i, n+1):
            sums.append(prefix[j] - prefix[i-1])
    return sums

subA = subarray_sums(prefixA)
subB = subarray_sums(prefixB)

# subB 빈도 세기
countB = Counter(subB)

# 정답 구하기
answer = 0
for a in subA:
    answer += countB[T - a]

print(answer)