Swift Coding Test Course, Interval Sum Calculation 1

Introduction

In today’s lecture, we will delve deep into the problem of calculating range sums. This problem frequently appears in various algorithmic challenges, and it’s essential to know efficient solutions.
In this article, we will define the problem, explain various approaches, and detail the process of finding the optimal solution.

Problem Definition

Given an array A and two integers L and R, calculate the value of
A[L] + A[L+1] + ... + A[R].
Assume that the index of A starts from 1.

Input

First line: Integer N (1 ≤ N ≤ 100,000) – Size of the array
Second line: N integers A[1], A[2], ..., A[N] (-1,000,000 ≤ A[i] ≤ 1,000,000)
Third line: Integer Q (1 ≤ Q ≤ 100,000) – Number of queries
Next Q lines: Each query contains two integers L and R

Output

For each query, output the range sum result line by line.

Problem Approach

There are several methods to solve this problem. A straightforward approach is to compute the sum directly for each query, but
this can be inefficient in terms of time complexity. Therefore, we will consider the following approach.

1. Approach through Simple Iteration

The most basic method is to use a loop to calculate the range sum for each query directly.
The time complexity of this method is O(N), and if there are Q queries, it becomes O(N*Q).
This would require up to a billion calculations in the worst-case scenario when both N and Q are at their maximum of 100,000, which is impractical.

2. Using a Cumulative Sum Array

Thus, using a cumulative sum array to solve the problem is much more efficient. With this approach,
the range sum can be resolved in O(1) time complexity. By creating a cumulative sum array and preprocessing the data linearly,
we can obtain results in O(1) time for each query.

Definition of Cumulative Sum Array

We will define the array p as follows:
p[i] = A[1] + A[2] + ... + A[i]
This way, the range sum A[L] + A[L+1] + ... + A[R] can be easily calculated as
p[R] - p[L-1].

Implementation

Now, let’s proceed with the actual implementation. I will write the algorithm using Swift.


    import Foundation

    // Input
    let n = Int(readLine()!)!
    let a = readLine()!.split(separator: " ").map { Int($0)! }
    let q = Int(readLine()!)!

    // Initialize cumulative sum array
    var p = [0] + a
    
    // Create cumulative sum array
    for i in 1..<n+1 {="" p[i]="p[i-1]" +="" a[i-1]="" }="" process="" each="" query="" for="" _="" in="" 0..<q="" let="" lr="readLine()!.split(separator:" "="" ").map="" int($0)!="" l="lr[0]" r="lr[1]" print(p[r]="" -="" p[l-1])="" <="" code=""></n+1>


<h2>Results and Analysis</h2>
<p>
        The above code constructs the cumulative sum array in O(N) time complexity and<br>
        prints the answer for each query in O(1) time.<br>
        In the worst-case scenario, considering the time spent on input, the overall time complexity is O(N + Q).
    </p>
<h3>Advantages of the Optimized Approach</h3>
<p>
        This method shows excellent performance, especially with large input data.<br>
        The use of cumulative sums allows for efficient handling of numerous queries.<br>
        Such problem-solving methods can be applied to other challenges and require a basic understanding of data structures.
    </p>
<h2>Conclusion</h2>
<p>
        Today, we explored an efficient problem-solving method using cumulative sum arrays through the problem of calculating range sums.<br>
        Many algorithmic problems practically utilize such techniques, so it is essential to grasp them.<br>
        In the next lecture, we will cover similar problems.<br>
        I hope this is helpful for your coding test preparation.
    </p>
<p></p>

<div id="jp-relatedposts" class="jp-relatedposts">
	<h3 class="jp-relatedposts-headline"><em>관련</em></h3>
</div>