题目地址:
https://www.lintcode.com/problem/remove-dights/description
给定一个字符串表示的非负整数 s s s,再给定一个正整数 k k k,现在要求在 s s s中删去 k k k位,使得剩下来的数达到最小。返回这个最小值(返回字符串即可,要求不能有开头 0 0 0)。如果 k k k大于等于字符串的长度则规定答案是 0 0 0。题目保证给定的数没有开头 0 0 0(除非本身就是 0 0 0)。
思路是单调栈。先考虑如果只允许删除一个数字,那应该怎样做。设原数是 a n a n − 1 . . . a 0 a_na_{n-1}...a_0 anan−1...a0,如果 a n ≤ a n − 1 ≤ . . . ≤ a 0 a_n\le a_{n-1}\le ...\le a_0 an≤an−1≤...≤a0,那么我们可以证明要删掉的数就是 a 0 a_0 a0,所得数就是 s ′ = a n a n − 1 . . . a 1 ‾ s'=\overline{a_na_{n-1}...a_1} s′=anan−1...a1,不然的话,设删除的数是 a i a_i ai,其中 i ≠ 0 i\ne 0 i=0,那么得数 s ′ ′ = a n . . . a i + 1 a i − 1 . . . a 0 ‾ ≥ s ′ = a n a n − 1 . . . a i + 1 a i . . . a 1 ‾ s''=\overline{a_n...a_{i+1}a_{i-1}...a_0}\ge s'=\overline{a_na_{n-1}...a_{i+1}a_i...a_1} s′′=an...ai+1ai−1...a0≥s′=anan−1...ai+1ai...a1,所以 s ′ s' s′就是最优解;否则,设 k = min { k : a k > a k + 1 } k=\min\{k:a_k>a_{k+1}\} k=min{k:ak>ak+1},则用相同的证明方法可以证明要删除的数就是 a k a_k ak。
接下来考虑删除多个数字的情况。首先由上面只删除一个数字的方法,我们得到一个方案,即先从左到右遍历这个字符串,每次一遇到形如 a j > a j + 1 a_j>a_{j+1} aj>aj+1的情况就删除 a j a_j aj(如果没有这样的pair,就直接删掉尾端的 k k k个数)。接下来我们证明这种方法能得到最优解。可以用反证法。假设用上面的方案删除的数字分别是 a i 1 , a i 2 , . . . , a i k a_{i_1},a_{i_2},...,a_{i_k} ai1,ai2,...,aik所得新数为 s ′ s' s′,还有一个更好方案,删除的数字是 a j 1 , a j 2 , . . . , a j k a_{j_1},a_{j_2},...,a_{j_k} aj1,aj2,...,ajk所得新数为 s ′ ′ s'' s′′。取最小的 r r r使得 i r ≠ j r i_r\ne j_r ir=jr,如果 i r < j r i_r<j_r ir<jr,那么一定有 a i r > a i r + 1 a_{i_r}>a_{i_r+1} air>air+1,则 s ′ < s ′ ′ s'<s'' s′<s′′矛盾;如果 i r > j r i_r> j_r ir>jr,则一定有 a j r ≤ a j r + 1 a_{j_r}\le a_{j_r+1} ajr≤ajr+1,所以 s ′ ≤ s ′ ′ s'\le s'' s′≤s′′矛盾。综上所述按照上面的方案得到的就是最优解。
具体代码,其实就是一边从左到右遍历字符串,一边维护一个字典序单调上升的栈。代码如下:
public class Solution {
/**
* @param num: a number
* @param k: the k digits
* @return: the smallest number
*/
public String removeKdigits(String num, int k) {
// write your code here.
// 要把num删光的话,则直接返回0
if (k >= num.length()) {
return "0";
}
// 直接用一个StringBuilder来作为栈使用
StringBuilder sb = new StringBuilder();
for (int i = 0; i < num.length(); i++) {
char c = num.charAt(i);
// 只要遇到了比栈顶小的字符,就把栈顶pop出来,同时记还可以删除的数字个数减1
while (sb.length() > 0 && sb.charAt(sb.length() - 1) > c && k > 0) {
sb.setLength(sb.length() - 1);
k--;
}
sb.append(c);
}
// 此时sb已经单调了,如果还需要删除多于其长度个数的数字,则直接返回0
if (k >= sb.length()) {
return "0";
}
// 否则先把末尾的k个字符切掉,然后去掉开头0
sb.setLength(sb.length() - k);
int idx = 0;
while (idx < sb.length() && sb.charAt(idx) == '0') {
idx++;
}
return idx == sb.length() ? "0" : sb.substring(idx);
}
}
时空复杂度 O ( n ) O(n) O(n)。