1class Solution {
2    public long minEnergy(int n, int brightness, int[][] intervals) {
3        // Sort intervals by their start position in ascending order
4        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
5
6        // List to hold the merged, non-overlapping intervals
7        List<int[]> mergedIntervals = new ArrayList<>();
8        // Seed the list with the first interval
9        mergedIntervals.add(intervals[0]);
10
11        // Iterate over the remaining intervals and merge overlapping ones
12        for (int i = 1; i < intervals.length; i++) {
13            int[] current = intervals[i];
14            // Reference to the last interval already placed in the merged list
15            int[] lastInterval = mergedIntervals.get(mergedIntervals.size() - 1);
16
17            if (lastInterval[1] < current[0]) {
18                // No overlap: the current interval starts after the last one ends,
19                // so add it as a new separate interval
20                mergedIntervals.add(current);
21            } else {
22                // Overlap exists: extend the last interval's end to cover the current one
23                lastInterval[1] = Math.max(lastInterval[1], current[1]);
24            }
25        }
26
27        // Accumulate the total energy required across all merged intervals
28        long totalEnergy = 0;
29        for (int[] interval : mergedIntervals) {
30            int start = interval[0];
31            int end = interval[1];
32            // Number of integer positions covered by this interval (inclusive)
33            int length = end - start + 1;
34            // Energy per position is ceil(brightness / 3), computed as (brightness + 2) / 3.
35            // Multiply by the interval length to get the energy for this interval.
36            totalEnergy += (brightness + 2L) / 3 * length;
37        }
38
39        return totalEnergy;
40    }
41}
42

1class Solution {
2public:
3    long long minEnergy(int n, int brightness, vector<vector<int>>& intervals) {
4        // Sort intervals by their start point (and end point as tiebreaker)
5        sort(intervals.begin(), intervals.end());
6
7        // Initialize the merged list with the first interval
8        vector<vector<int>> mergedIntervals = {intervals[0]};
9
10        // Merge overlapping or adjacent intervals
11        for (int i = 1; i < static_cast<int>(intervals.size()); ++i) {
12            const auto& current = intervals[i];
13            // If the current interval does not overlap with the last merged one,
14            // append it as a new separate interval
15            if (mergedIntervals.back()[1] < current[0]) {
16                mergedIntervals.push_back(current);
17            } else {
18                // Otherwise, extend the end of the last merged interval
19                mergedIntervals.back()[1] = max(mergedIntervals.back()[1], current[1]);
20            }
21        }
22
23        // Accumulate the total energy across all merged intervals
24        long long totalEnergy = 0;
25        for (const auto& interval : mergedIntervals) {
26            int start = interval[0];
27            int end = interval[1];
28
29            // Number of integer points covered by this interval (inclusive)
30            int length = end - start + 1;
31
32            // Energy per point is ceil(brightness / 3), computed as (brightness + 2) / 3.
33            // Use 2LL to force a 64-bit computation and avoid overflow.
34            totalEnergy += (brightness + 2LL) / 3 * length;
35        }
36
37        return totalEnergy;
38    }
39};
40

1/**
2 * Calculates the minimum energy required given a set of intervals.
3 *
4 * The algorithm works in two phases:
5 *   1. Merge all overlapping intervals so that each region is counted only once.
6 *   2. For every merged interval, compute its length and accumulate the energy
7 *      needed, where each unit of length costs ceil(brightness / 3) energy.
8 *
9 * @param n          The total number of positions (kept for signature compatibility).
10 * @param brightness The brightness value used to derive the per-unit energy cost.
11 * @param intervals  An array of [start, end] interval pairs.
12 * @returns          The minimum total energy required.
13 */
14function minEnergy(n: number, brightness: number, intervals: number[][]): number {
15    // Sort intervals by their starting position in ascending order
16    // so that overlapping intervals are adjacent and can be merged.
17    intervals.sort((a, b) => a[0] - b[0]);
18
19    // Initialize the merged list with the first interval.
20    const mergedIntervals: number[][] = [intervals[0]];
21
22    // Iterate through the remaining intervals and merge them as needed.
23    for (let i = 1; i < intervals.length; i++) {
24        const current = intervals[i];
25        const last = mergedIntervals[mergedIntervals.length - 1];
26
27        if (last[1] < current[0]) {
28            // No overlap with the last merged interval: add as a new interval.
29            mergedIntervals.push(current);
30        } else {
31            // Overlap detected: extend the end of the last merged interval.
32            last[1] = Math.max(last[1], current[1]);
33        }
34    }
35
36    // Per-unit energy cost derived from the brightness value.
37    const unitCost = Math.ceil(brightness / 3);
38
39    // Accumulate the total energy across all merged intervals.
40    let totalEnergy = 0;
41    for (const [start, end] of mergedIntervals) {
42        // Inclusive length of the interval.
43        const length = end - start + 1;
44        totalEnergy += unitCost * length;
45    }
46
47    return totalEnergy;
48}
49