Given two arrays A[] and B[] of length N. Then your task is to choose a range [L, R] in such a way that both the conditions are met, Then the task is to output the Maximum possible sum of such B[L, R].
- A[L, R] contains unique elements.
- Sum of B[L, R] is the maximum possible.
Examples:
Input: N = 5, A[] = {0, 1, 2, 0, 2}, B[] = {5, 6, 7, 8, 2}
Output: 21
Explanation: If we took the range [L, R] as [2, 4]. It gives A[2, 4] = {1, 2, 0} and B[2, 4] = {6, 7, 8}. The sum of B[2, 4] is 6+7+8 = 21. All the elements of A[2, 4] are unique and B[2, 4] is maximum 21. Both the conditions are satisfied. Therefore, output is 21.Input: N = 3, A[] = {1, 1, 1}, B[] = {3, 4, 5}
Output: 5
Explanation: If we took range [L, R] as [3, 3]. It gives A[3, 3] = {1} and B[3, 3] = {5}. Then sum of B[3, 3] is 5. which is maximum possible according to the given constraints. Therefore, output is 5.
Approach: Implement the idea below to solve the problem
The problem is observation based and can be implemented easily. The problem requires using HashSet Data – Structure.
Steps were taken to solve the problem:
- Create a HashSet let say Set to store the unique elements.
- Declare three variables let say J, Sum and Max, initialize them all equal to 0.
-
Run a loop for i = 0 to i < N and follow below mentioned steps under the scope of loop:
- Num = A[i]
-
If (Set is Empty)
- Add Num into Set
- Add B[i] into Sum
-
Else
-
If (Set not contains Num)
- Add num into Set
- Add B[i] into Sum
-
Else
-
While (A[j] != Num)
- Remove A[j] from Set
- Sum -= B[j]
- Increment J
- Subtract B[j] from Sum
- Increment j
- Sum += B[i]
-
While (A[j] != Num)
- Update Max with Sum if Sum is greater than Max.
-
If (Set not contains Num)
- Output the value stored in Max.
Code to implement the approach:
//code by flutterfly #include <iostream> #include <unordered_set> #include <climits> #include <vector> using namespace std;
// Method to output the max possible sum void Max_sum( int N, vector< int >& A, vector< int >& B) {
// HashSet for counting unique sets
unordered_set< int > set;
// Variable to hold max sum
long long maxSum = LLONG_MIN;
int j = 0;
// variable to hold current sum
long long sum = 0;
// Loop for iterating over A
for ( int i = 0; i < N; i++) {
// Current element
int num = A[i];
// If set is empty then add the current element
// into both sum and set
if (set.empty()) {
set.insert(num);
sum += B[i];
} else {
// If the current element is not repeated
// Then add it to both sum and set
if (set.find(num) == set.end()) {
set.insert(num);
sum += B[i];
} else {
// Remove the elements from set and sum
// until the set contains a unique element
while (A[j] != num) {
set.erase(A[j]);
sum -= B[j];
j++;
}
sum -= B[j];
j++;
sum += B[i];
}
}
// Updating max with the current sum
maxSum = max(maxSum, sum);
}
// Printing out the maximum possible sum
cout << maxSum << endl;
} // Driver Function int main() {
// Inputs
int N = 5;
vector< int > A = {0, 1, 2, 0, 2};
vector< int > B = {5, 6, 7, 8, 2};
// Function call
Max_sum(N, A, B);
return 0;
} |
// Java code to implement the approach import java.util.*;
// Driver Class class Main {
// Driver Function
public static void main(String[] args)
{
// Inputs
int N = 5 ;
int [] A = { 0 , 1 , 2 , 0 , 2 };
int [] B = { 5 , 6 , 7 , 8 , 2 };
// Functionc call
Max_sum(N, A, B);
}
// Method to output the max possible sum
public static void Max_sum( int N, int [] A, int [] B)
{
// HashSet for counting unique sets
HashSet<Integer> set = new HashSet<>();
// Variable to hold max sum
long max = Integer.MIN_VALUE;
int j = 0 ;
// variable to hold current sum
long sum = 0 ;
// Loop for iterating over A
for ( int i = 0 ; i < N; i++) {
// Current elemment
int num = A[i];
// If set is empty then add current element
// into both sum and set
if (set.isEmpty()) {
set.add(num);
sum += B[i];
}
// Else block will exexute when set will have at
// least one element Formally, not empty.
else {
// If current element is not repeated
// Then add in both sum and set
if (!set.contains(num)) {
set.add(num);
sum += B[i];
}
// Else remove the elements from set and
// sum until the set contains unique element
else {
while (A[j] != num) {
set.remove(A[j]);
sum -= B[j];
j++;
}
sum -= B[j];
j++;
sum += B[i];
}
}
// Updating max with current sum
max = Math.max(max, sum);
}
// Printing out the maximum possible sum
System.out.println(max);
}
} |
# code by flutterfly def max_sum(N, A, B):
# Set for counting unique elements
unique_set = set ()
# Variables to hold max sum and current sum
max_sum = float ( '-inf' )
j = 0
current_sum = 0
# Loop for iterating over A
for i in range (N):
# Current element
num = A[i]
# If set is empty, add the current element
# into both sum and set
if not unique_set:
unique_set.add(num)
current_sum + = B[i]
else :
# If the current element is not repeated,
# add it to both sum and set
if num not in unique_set:
unique_set.add(num)
current_sum + = B[i]
else :
# Remove elements from set and sum
# until the set contains a unique element
while A[j] ! = num:
unique_set.remove(A[j])
current_sum - = B[j]
j + = 1
current_sum - = B[j]
j + = 1
current_sum + = B[i]
# Updating max with the current sum
max_sum = max (max_sum, current_sum)
# Printing out the maximum possible sum
print (max_sum)
# Driver Function if __name__ = = "__main__" :
# Inputs
N = 5
A = [ 0 , 1 , 2 , 0 , 2 ]
B = [ 5 , 6 , 7 , 8 , 2 ]
# Function call
max_sum(N, A, B)
|
using System;
using System.Collections.Generic;
class Program
{ // Method to output the max possible sum
static void MaxSum( int N, int [] A, int [] B)
{
// HashSet for counting unique sets
HashSet< int > uniqueSet = new HashSet< int >();
// Variables to hold max sum and current sum
long maxSumValue = long .MinValue;
int j = 0;
long currentSum = 0;
// Loop for iterating over A
for ( int i = 0; i < N; i++)
{
// Current element
int num = A[i];
// If set is empty, add the current element
// into both sum and set
if (uniqueSet.Count == 0)
{
uniqueSet.Add(num);
currentSum += B[i];
}
else
{
// If the current element is not repeated,
// add it to both sum and set
if (!uniqueSet.Contains(num))
{
uniqueSet.Add(num);
currentSum += B[i];
}
else
{
// Remove elements from set and sum
// until the set contains a unique element
while (A[j] != num)
{
uniqueSet.Remove(A[j]);
currentSum -= B[j];
j++;
}
currentSum -= B[j];
j++;
currentSum += B[i];
}
}
// Updating max with the current sum
maxSumValue = Math.Max(maxSumValue, currentSum);
}
// Printing out the maximum possible sum
Console.WriteLine(maxSumValue);
}
// Driver Function
static void Main()
{
// Inputs
int N = 5;
int [] A = { 0, 1, 2, 0, 2 };
int [] B = { 5, 6, 7, 8, 2 };
// Function call
MaxSum(N, A, B);
}
} |
// Method to output the max possible sum function maxSum(N, A, B) {
// Set for counting unique elements
const uniqueSet = new Set();
// Variables to hold max sum and current sum
let maxSumValue = Number.NEGATIVE_INFINITY;
let j = 0;
let currentSum = 0;
// Loop for iterating over A
for (let i = 0; i < N; i++) {
// Current element
const num = A[i];
// If set is empty, add the current element
// into both sum and set
if (uniqueSet.size === 0) {
uniqueSet.add(num);
currentSum += B[i];
} else {
// If the current element is not repeated,
// add it to both sum and set
if (!uniqueSet.has(num)) {
uniqueSet.add(num);
currentSum += B[i];
} else {
// Remove elements from set and sum
// until the set contains a unique element
while (A[j] !== num) {
uniqueSet. delete (A[j]);
currentSum -= B[j];
j++;
}
currentSum -= B[j];
j++;
currentSum += B[i];
}
}
// Updating max with the current sum
maxSumValue = Math.max(maxSumValue, currentSum);
}
// Printing out the maximum possible sum
console.log(maxSumValue);
} // Driver Function // Inputs const N = 5; const A = [0, 1, 2, 0, 2]; const B = [5, 6, 7, 8, 2]; // Function call maxSum(N, A, B); |
21
Time Complexity: O(N)
Auxiliary space: O(N), As HashSet is used to store unique elements.