Solving LeetCode 1793: Maximum Score of a Good Subarray
Tags: leetcode, javascript, rust, python
Published: 2023-10-22 04:07:02



**Have you ever felt like a detective trying to crack a code when solving LeetCode problems?** If so, you're not alone. LeetCode offers a plethora of coding challenges that can truly put your problem-solving skills to the test. In this blog post, we're going to dive deep into one of these intriguing puzzles: **[LeetCode 1793 - Maximum Score of a Good Subarray](https://www.nileshblog.tech/leetcode-1793-maximum-score-of-a-good-subarray/)**. 

{% embed https://www.nileshblog.tech/leetcode-1793-maximum-score-of-a-good-subarray/ %}

## Introduction

[LeetCode 1793](https://www.nileshblog.tech/leetcode-1793-maximum-score-of-a-good-subarray/)is an exciting problem that requires you to think critically and develop an algorithm to maximize the score of a "good" subarray. But what exactly is a good subarray? Well, let's unravel the mystery step by step.

## The Prerequisites

Before we delve into the specifics of this LeetCode challenge, it's important to note that you should have a basic understanding of arrays and dynamic programming. If you're new to these concepts, a little background research might be helpful. 

## The Main Concept

So, what is a "good" subarray, and how can we maximize its score? A subarray is a contiguous set of elements from an array, and the score of a subarray is determined by multiplying the minimum value in the subarray by its length. In LeetCode 1793, our task is to find the maximum score among all "good" subarrays within the given array.


## Let's Break It Down

Now, let's take a look at an example to understand this concept better. Consider the following array:

```python
arr = [1, 4, 3, 2, 4, 5]
```

Our goal is to identify the "good" subarrays and calculate their scores. 

**Step 1:** We start by finding the minimum value within the array. In this case, the minimum value is 1.

**Step 2:** Next, we look for all subarrays with 1 as the minimum value. Here, we have subarrays `[1]`, `[1, 4, 3, 2]`, and `[1, 4, 3, 2, 4, 5]`.

**Step 3:** Calculate the score for each subarray by multiplying the minimum value by the length of the subarray. 

- Score for `[1]`: 1 x 1 = 1
- Score for `[1, 4, 3, 2]`: 1 x 4 = 4
- Score for `[1, 4, 3, 2, 4, 5]`: 1 x 6 = 6

**Step 4:** Identify the maximum score among these subarrays, which is 6.

## Example Implementation


```
If you want Leetcode Question codes : _https://bit.ly/maximum-score-of-a-good-subarray  _.**check out this link for all codes.(c++ , java , python , Rust, go , kotlin,more..)**
```


Here's a Python function to solve this problem:

```python
def maxScoreSightseeingPair(arr):
    max_score = 0
    min_element = arr[0]
    
    for i in range(1, len(arr)):
        max_score = max(max_score, min_element + arr[i] - i)
        min_element = min(min_element, arr[i] + i)
    
    return max_score
```

## Conclusion

In this blog post, we've unraveled the mystery of LeetCode 1793 - [Maximum Score of a Good Subarray](https://www.nileshblog.tech/leetcode-1793-maximum-score-of-a-good-subarray/). We learned how to identify "good" subarrays and calculate their maximum scores. Solving problems like this not only enhances your coding skills but also provides a sense of achievement as you crack the code.

Remember, the key to mastering LeetCode challenges is practice, practice, and more practice. So, go ahead, give LeetCode 1793 a try, and let's maximize those scores together! 🚀