3081. Replace Question Marks in String to Minimize Its Value
Description
You are given a string s
. s[i]
is either a lowercase English letter or '?'
.
For a string t
having length m
containing only lowercase English letters, we define the function cost(i)
for an index i
as the number of characters equal to t[i]
that appeared before it, i.e. in the range [0, i - 1]
.
The value of t
is the sum of cost(i)
for all indices i
.
For example, for the string t = "aab"
:
cost(0) = 0
cost(1) = 1
cost(2) = 0
- Hence, the value of
"aab"
is0 + 1 + 0 = 1
.
Your task is to replace all occurrences of '?'
in s
with any lowercase English letter so that the value of s
is minimized.
Return a string denoting the modified string with replaced occurrences of '?'
. If there are multiple strings resulting in the minimum value, return the lexicographically smallest one.
Example 1:
Input: s = "???"
Output: "abc"
Explanation: In this example, we can replace the occurrences of '?'
to make s
equal to "abc"
.
For "abc"
, cost(0) = 0
, cost(1) = 0
, and cost(2) = 0
.
The value of "abc"
is 0
.
Some other modifications of s
that have a value of 0
are "cba"
, "abz"
, and, "hey"
.
Among all of them, we choose the lexicographically smallest.
Example 2:
Input: s = "a?a?"
Output: "abac"
Explanation: In this example, the occurrences of '?'
can be replaced to make s
equal to "abac"
.
For "abac"
, cost(0) = 0
, cost(1) = 0
, cost(2) = 1
, and cost(3) = 0
.
The value of "abac"
is 1
.
Constraints:
1 <= s.length <= 105
s[i]
is either a lowercase English letter or'?'
.
Solutions
Solution 1: Greedy + Priority Queue
According to the problem, we can find that if a letter $c$ appears $v$ times, then the score it contributes to the answer is $1 + 2 + \cdots + (v - 1) = \frac{v \times (v - 1)}{2}$. To make the answer as small as possible, we should replace the question marks with those letters that appear less frequently.
Therefore, we can use a priority queue to maintain the occurrence times of each letter, take out the letter with the least occurrence times each time, record it in the array $t$, then increase its occurrence times by one, and put it back into the priority queue. Finally, we sort the array $t$, and then traverse the string $s$, replacing each question mark with the letters in the array $t$ in turn.
The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the length of the string $s$.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
|