Sponsored
Sponsored
This approach involves simulating the falling of each square by considering where each newly falling square intersects with squares that have already been dropped. We track the maximum heights over ranges and update them accordingly.
We use an array to maintain the maximum height for each position on the x-axis covered by the squares. For each square, we determine its position range on the x-axis, evaluate the highest point it will land on, update the height range, and then calculate the tallest height by comparing it to all other known heights.
Time Complexity: O(n^2), where n is the number of positions, due to checking each new square against all previous squares.
Space Complexity: O(n), for storing heights.
1def fallingSquares(positions):
2 heights = []
3 for left, size in positions:
4 right = left + size
5 base_height = 0
6 for l, s, h in heights:
7 if l < right and left < l + s: # overlap
8 base_height = max(base_height, h)
9 current_height = base_height + size
10 heights.append((left, size, current_height))
11 return [max(heights[i][2] for i in range(j+1)) for j in range(len(positions))]This solution defines a function fallingSquares that takes positions as input. For each square, it calculates the position, checks for overlaps with previously dropped squares, determines where it will land, updates the height, and maintains a list of tuples that record left position, size, and current height. The heights are calculated cumulatively, and the results are generated by iterating through the list of positions.
This approach optimizes the brute force simulation by utilizing a segment tree to efficiently manage and query intervals. The segment tree helps update and retrieve maximum heights for given x-ranges effectively.
We map the positions along the X-axis to a discrete set, construct a segment tree to cover those discrete positions, and then for each new square, we update the segment tree with the height of the square added to the current maximum height for its X-range. This is performed in logarithmic time due to the properties of the segment tree, enabling us to handle large input sizes more rapidly.
Time Complexity: O(n log n), due to the logarithmic operations with the segment tree.
Space Complexity: O(n), for storing distinct coordinates and segment tree data structures.
1import java.util.*;
2
3class
This approach involves using a hash map (or dictionary) to count the frequency of elements in the array. This will help us to easily keep track of the occurrences of each element, allowing us to efficiently determine if duplicates are present.
Time Complexity: O(n), Space Complexity: O(n)
1using System;
using System.Collections.Generic;
class Solution {
public bool ContainsDuplicate(int[] nums) {
HashSet<int> set = new HashSet<int>();
foreach (int num in nums) {
if (set.Contains(num)) {
return true;
}
set.Add(num);
}
return false;
}
static void Main(string[] args) {
Solution solution = new Solution();
int[] nums = new int[] { 1, 2, 3, 4 };
Console.WriteLine(solution.ContainsDuplicate(nums));
}
}This Java solution uses a segment tree to accomplish efficient range maximum queries and updates. The fallingSquares function first discretizes the x-coordinates for better management, then it processes each square's x-range to find the current maximum height via rangeQuery and updates this range using rangeUpdate. This allows determination of the highest structure after each square drops, maintaining optimal time complexity due to the segment tree structure.
This C# solution adopts a HashSet to quickly verify duplicates among the input numbers, adding each new element to the set as we proceed.
Sorting the list allows us to find duplicates by comparing each element to the next. If two adjacent elements are identical, a duplicate is present.