Skip to content

Commit fa419d6

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1589
No.1589.Maximum Sum Obtained of Any Permutation
1 parent 8d0f211 commit fa419d6

File tree

10 files changed

+256
-161
lines changed

10 files changed

+256
-161
lines changed

‎solution/1500-1599/1589.Maximum Sum Obtained of Any Permutation/README.md

Lines changed: 89 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,13 @@ requests[1] -> nums[0] + nums[1] = 3 + 5 = 8
5757

5858
<!-- 这里可写通用的实现逻辑 -->
5959

60-
“差分数组 + 贪心 + 排序”实现。
60+
**方法一：差分数组 + 排序 + 贪心**
61+
62+
我们观察发现，对于一次查询操作，会返回该查询区间 $[l, r]$ 中的所有元素之和。而题目要求的是所有查询操作的结果之和的最大值，也即是说，我们要累计所有查询操作的结果，使得这些结果之和最大。因此，如果一个下标 $i$ 在查询操作中出现的次数越多，那么我们就应该赋给下标 $i$ 一个较大的值，这样才能使得所有查询操作的结果之和最大。
63+
64+
因此，我们可以用差分数组的思想，统计每个下标在查询操作中出现的次数，然后对这些次数从小到大进行排序，然后对数组 $nums$ 也从小到大进行排序，这样就能保证每个下标 $i$ 在查询操作中出现的次数越多，该下标对应的值 $nums[i]$ 就越大。接下来，我们只需要将这些下标对应的值 $nums[i]$ 与其在查询操作中出现的次数相乘，然后累加起来，就是所有查询操作的结果之和的最大值。
65+
66+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
6167

6268
<!-- tabs:start -->
6369

@@ -68,21 +74,18 @@ requests[1] -&gt; nums[0] + nums[1] = 3 + 5 = 8
6874
```python
6975
class Solution:
7076
def maxSumRangeQuery(self, nums: List[int], requests: List[List[int]]) -> int:
71-
n = 100010
72-
delta = [0] * n
73-
for start, end in requests:
74-
delta[start] += 1
75-
delta[end + 1] -= 1
77+
n = len(nums)
78+
d = [0] * n
79+
for l, r in requests:
80+
d[l] += 1
81+
if r + 1 < n:
82+
d[r + 1] -= 1
7683
for i in range(1, n):
77-
delta[i] += delta[i - 1]
84+
d[i] += d[i - 1]
7885
nums.sort()
79-
delta.sort()
80-
i, j, res = n - 1, len(nums) - 1, 0
81-
while i > 0 and delta[i] > 0:
82-
res += delta[i] * nums[j]
83-
i -= 1
84-
j -= 1
85-
return res % 1000000007
86+
d.sort()
87+
mod = 10**9 + 7
88+
return sum(a * b for a, b in zip(nums, d)) % mod
8689
```
8790

8891
### **Java**
@@ -92,22 +95,26 @@ class Solution:
9295
```java
9396
class Solution {
9497
public int maxSumRangeQuery(int[] nums, int[][] requests) {
95-
int n = 100010;
96-
int[] delta = new int[n];
97-
for (int[] request : requests) {
98-
++delta[request[0]];
99-
--delta[request[1] + 1];
98+
int n = nums.length;
99+
int[] d = new int[n];
100+
for (var req: requests) {
101+
int l = req[0], r = req[1];
102+
d[l]++;
103+
if (r + 1 < n) {
104+
d[r + 1]--;
105+
}
100106
}
101107
for (int i = 1; i < n; ++i) {
102-
delta[i] += delta[i - 1];
108+
d[i] += d[i - 1];
103109
}
104110
Arrays.sort(nums);
105-
Arrays.sort(delta);
106-
long res = 0;
107-
for (int i = n - 1, j = nums.length - 1; i >= 0 && delta[i] > 0; --i, --j) {
108-
res += (long) delta[i] * nums[j];
111+
Arrays.sort(d);
112+
final int mod = (int) 1e9 + 7;
113+
long ans = 0;
114+
for (int i = 0; i < n; ++i) {
115+
ans = (ans + 1L * nums[i] * d[i]) % mod;
109116
}
110-
return (int) (res % 1000000007);
117+
return (int) ans;
111118
}
112119
}
113120
```
@@ -118,48 +125,80 @@ class Solution {
118125
class Solution {
119126
public:
120127
int maxSumRangeQuery(vector<int>& nums, vector<vector<int>>& requests) {
121-
int n = 100010;
122-
vector<int> delta(n);
123-
for (auto request : requests) {
124-
++delta[request[0]];
125-
--delta[request[1] + 1];
128+
int n = nums.size();
129+
int d[n];
130+
memset(d, 0, sizeof(d));
131+
for (auto& req : requests) {
132+
int l = req[0], r = req[1];
133+
d[l]++;
134+
if (r + 1 < n) {
135+
d[r + 1]--;
136+
}
126137
}
127138
for (int i = 1; i < n; ++i) {
128-
delta[i] += delta[i - 1];
139+
d[i] += d[i - 1];
129140
}
130141
sort(nums.begin(), nums.end());
131-
sort(delta.begin(), delta.end());
132-
long long res = 0;
133-
for (int i = n - 1, j = nums.size() - 1; i >= 0 && delta[i] > 0; --i, --j) {
134-
res += (long long)delta[i] * nums[j];
142+
sort(d, d + n);
143+
long long ans = 0;
144+
const int mod = 1e9 + 7;
145+
for (int i = 0; i < n; ++i) {
146+
ans = (ans + 1LL * nums[i] * d[i]) % mod;
135147
}
136-
return (int)(res % 1000000007);
148+
return ans;
137149
}
138150
};
139151
```
140152
141153
### **Go**
142154
143155
```go
144-
func maxSumRangeQuery(nums []int, requests [][]int) int {
145-
n := 100010
146-
delta := make([]int, n)
147-
for _, request := range requests {
148-
delta[request[0]]++
149-
delta[request[1]+1]--
156+
func maxSumRangeQuery(nums []int, requests [][]int) (ans int) {
157+
n := len(nums)
158+
d := make([]int, n)
159+
for _, req := range requests {
160+
l, r := req[0], req[1]
161+
d[l]++
162+
if r+1 < n {
163+
d[r+1]--
164+
}
150165
}
151166
for i := 1; i < n; i++ {
152-
delta[i] += delta[i-1]
167+
d[i] += d[i-1]
153168
}
154169
sort.Ints(nums)
155-
sort.Ints(delta)
156-
i, j, res := n-1, len(nums)-1, 0
157-
for i >= 0 && delta[i] > 0 {
158-
res += delta[i] * nums[j]
159-
i--
160-
j--
170+
sort.Ints(d)
171+
const mod = 1e9 + 7
172+
for i, a := range nums {
173+
b := d[i]
174+
ans = (ans + a*b) % mod
161175
}
162-
return res % 1000000007
176+
return
177+
```
178+
179+
### **TypeScript**
180+
181+
```ts
182+
function maxSumRangeQuery(nums: number[], requests: number[][]): number {
183+
const n = nums.length;
184+
const d = new Array(n).fill(0);
185+
for (const [l, r] of requests) {
186+
d[l]++;
187+
if (r + 1 < n) {
188+
d[r + 1]--;
189+
}
190+
}
191+
for (let i = 1; i < n; ++i) {
192+
d[i] += d[i - 1];
193+
}
194+
nums.sort((a, b) => a - b);
195+
d.sort((a, b) => a - b);
196+
let ans = 0;
197+
const mod = 10 ** 9 + 7;
198+
for (let i = 0; i < n; ++i) {
199+
ans = (ans + nums[i] * d[i]) % mod;
200+
}
201+
return ans;
163202
}
164203
```
165204

‎solution/1500-1599/1589.Maximum Sum Obtained of Any Permutation/README_EN.md

Lines changed: 83 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -61,44 +61,45 @@ Total sum: 11 + 8 = 19, which is the best that you can do.
6161
```python
6262
class Solution:
6363
def maxSumRangeQuery(self, nums: List[int], requests: List[List[int]]) -> int:
64-
n = 100010
65-
delta = [0] * n
66-
for start, end in requests:
67-
delta[start] += 1
68-
delta[end + 1] -= 1
64+
n = len(nums)
65+
d = [0] * n
66+
for l, r in requests:
67+
d[l] += 1
68+
if r + 1 < n:
69+
d[r + 1] -= 1
6970
for i in range(1, n):
70-
delta[i] += delta[i - 1]
71+
d[i] += d[i - 1]
7172
nums.sort()
72-
delta.sort()
73-
i, j, res = n - 1, len(nums) - 1, 0
74-
while i > 0 and delta[i] > 0:
75-
res += delta[i] * nums[j]
76-
i -= 1
77-
j -= 1
78-
return res % 1000000007
73+
d.sort()
74+
mod = 10**9 + 7
75+
return sum(a * b for a, b in zip(nums, d)) % mod
7976
```
8077

8178
### **Java**
8279

8380
```java
8481
class Solution {
8582
public int maxSumRangeQuery(int[] nums, int[][] requests) {
86-
int n = 100010;
87-
int[] delta = new int[n];
88-
for (int[] request : requests) {
89-
++delta[request[0]];
90-
--delta[request[1] + 1];
83+
int n = nums.length;
84+
int[] d = new int[n];
85+
for (var req: requests) {
86+
int l = req[0], r = req[1];
87+
d[l]++;
88+
if (r + 1 < n) {
89+
d[r + 1]--;
90+
}
9191
}
9292
for (int i = 1; i < n; ++i) {
93-
delta[i] += delta[i - 1];
93+
d[i] += d[i - 1];
9494
}
9595
Arrays.sort(nums);
96-
Arrays.sort(delta);
97-
long res = 0;
98-
for (int i = n - 1, j = nums.length - 1; i >= 0 && delta[i] > 0; --i, --j) {
99-
res += (long) delta[i] * nums[j];
96+
Arrays.sort(d);
97+
final int mod = (int) 1e9 + 7;
98+
long ans = 0;
99+
for (int i = 0; i < n; ++i) {
100+
ans = (ans + 1L * nums[i] * d[i]) % mod;
100101
}
101-
return (int) (res % 1000000007);
102+
return (int) ans;
102103
}
103104
}
104105
```
@@ -109,48 +110,81 @@ class Solution {
109110
class Solution {
110111
public:
111112
int maxSumRangeQuery(vector<int>& nums, vector<vector<int>>& requests) {
112-
int n = 100010;
113-
vector<int> delta(n);
114-
for (auto request : requests) {
115-
++delta[request[0]];
116-
--delta[request[1] + 1];
113+
int n = nums.size();
114+
int d[n];
115+
memset(d, 0, sizeof(d));
116+
for (auto& req : requests) {
117+
int l = req[0], r = req[1];
118+
d[l]++;
119+
if (r + 1 < n) {
120+
d[r + 1]--;
121+
}
117122
}
118123
for (int i = 1; i < n; ++i) {
119-
delta[i] += delta[i - 1];
124+
d[i] += d[i - 1];
120125
}
121126
sort(nums.begin(), nums.end());
122-
sort(delta.begin(), delta.end());
123-
long long res = 0;
124-
for (int i = n - 1, j = nums.size() - 1; i >= 0 && delta[i] > 0; --i, --j) {
125-
res += (long long)delta[i] * nums[j];
127+
sort(d, d + n);
128+
long long ans = 0;
129+
const int mod = 1e9 + 7;
130+
for (int i = 0; i < n; ++i) {
131+
ans = (ans + 1LL * nums[i] * d[i]) % mod;
126132
}
127-
return (int)(res % 1000000007);
133+
return ans;
128134
}
129135
};
130136
```
131137
132138
### **Go**
133139
134140
```go
135-
func maxSumRangeQuery(nums []int, requests [][]int) int {
136-
n := 100010
137-
delta := make([]int, n)
138-
for _, request := range requests {
139-
delta[request[0]]++
140-
delta[request[1]+1]--
141+
func maxSumRangeQuery(nums []int, requests [][]int) (ans int) {
142+
n := len(nums)
143+
d := make([]int, n)
144+
for _, req := range requests {
145+
l, r := req[0], req[1]
146+
d[l]++
147+
if r+1 < n {
148+
d[r+1]--
149+
}
141150
}
142151
for i := 1; i < n; i++ {
143-
delta[i] += delta[i-1]
152+
d[i] += d[i-1]
144153
}
145154
sort.Ints(nums)
146-
sort.Ints(delta)
147-
i, j, res := n-1, len(nums)-1, 0
148-
for i >= 0 && delta[i] > 0 {
149-
res += delta[i] * nums[j]
150-
i--
151-
j--
155+
sort.Ints(d)
156+
const mod = 1e9 + 7
157+
for i, a := range nums {
158+
b := d[i]
159+
ans = (ans + a*b) % mod
152160
}
153-
return res % 1000000007
161+
return
162+
}
163+
```
164+
165+
### **TypeScript**
166+
167+
```ts
168+
function maxSumRangeQuery(nums: number[], requests: number[][]): number {
169+
const n = nums.length;
170+
const d = new Array(n).fill(0);
171+
for (const [l, r] of requests) {
172+
d[l]++;
173+
if (r + 1 < n) {
174+
d[r + 1]--;
175+
}
176+
}
177+
for (let i = 1; i < n; ++i) {
178+
d[i] += d[i - 1];
179+
}
180+
nums.sort((a, b) => a - b);
181+
d.sort((a, b) => a - b);
182+
let ans = 0;
183+
const mod = 10 ** 9 + 7;
184+
for (let i = 0; i < n; ++i) {
185+
ans = (ans + nums[i] * d[i]) % mod;
186+
}
187+
return ans;
154188
}
155189
```
156190

0 commit comments

Comments
 (0)