leetcode 420. Strong Password Checker 密码强度检查器+找规律+实在不会做

一时失言乱红尘 2022-06-04 10:21 74阅读 0赞

A password is considered strong if below conditions are all met:

It has at least 6 characters and at most 20 characters.  
It must contain at least one lowercase letter, at least one uppercase letter, and at least one digit.  
It must NOT contain three repeating characters in a row (“…aaa…” is weak, but “…aa…a…” is strong, assuming other conditions are met).  
Write a function strongPasswordChecker(s), that takes a string s as input, and return the MINIMUM change required to make s a strong password. If s is already strong, return 0.

Insertion, deletion or replace of any one character are all considered as one change.

这道题肯定不会，下面是网上的分析：

首先我们来看非强密码串主要有的三个问题：

1.  长度问题，当长度小于6的时候，我们要通过插入字符来补充长度，当长度超过20时，我们要删除字符。
2.  缺失字符或数字，当我们缺少大写，小写和数字的时候，我们可以通过插入字符或者替换字符的方式来补全。
3.  重复字符，这个也是本题最大的难点，因为插入，删除，或者置换都可以解决重复字符的问题，比如有一个字符串”aaaaa”，我们可以用一次置换，比如换掉中间的字符’a’；或者两次插入字符，在第二个a和第四个a后面分别插入一个非a字符；或者可以删除3个a来解决重复字符的问题。由于题目要求我们要用最少的步骤，那么显而易见置换是最高效的去重复字符的方法。

我们通过举例观察可以知道这三种情况并不是相互独立的，一个操作有时候可以解决多个问题，比如字符串”aaa1a”，我们在第二个a后面增加一个’B’，变为”aaBa1a”,这样同时解决了三个问题，即增加了长度，又补充了缺失的大写字母，又去掉了重复，所以我们的目标就是尽可能的找出这种能解决多种问题的操作。由于情况三(重复字符)可以用三种操作来解决，所以我们分别来看能同时解决情况一和情况三，跟同时解决情况二和情况三的操作。对于同时解决情况一和情况二的操作如果原密码串长度小于6会有重叠出现，所以我们要分情况讨论：

当密码串长度小于6时，情况一和情况二的操作步骤可以完全覆盖情况三，这个不难理解，因为这种情况下重复字符个数的范围为\[3,5\]，如果有三个重复字符，那么增加三个字符的操作可以同时解决重复字符问题(“aaa” -> “a1BCaa”；如果有四个重复字符，那么增加二个字符的操作也可以解决重复问题(“aaaa” -> “aa1Baa”)；如果有五个重复字符，那么增加和置换操作也同时解决重复问题(“aaaaa” -> “aa1aaB”)。所以我们就专心看最少多少步能同时解决情况一和情况二，首先我们计算出当前密码串需要补几个字符才能到6，补充字符的方法只能用插入字符操作，而插入字符操作也可以解决情况二，所以当情况二的缺失种类个数小于等于diff时，我们不用再增加操作，当diff不能完全覆盖缺失种类个数时，我们还应加上二者的差值。

当密码串长度大于等于6个的时候，这种情况就比较复杂了，由于目前字符串的长度只可能超标不可能不达标，所以我们尽量不要用插入字符操作，因为这有可能会使长度超过限制。由于长度的不确定性，所以可能会有大量的重复字符，那么解决情况三就变得很重要了，由于前面的分析，替换字符是最高效的解法，但是这种方法没法解决情况一，因为长度超标了的话，再怎么替换字符，也不会让长度减少，但是我们也不能无脑删除字符，这样不一定能保证是最少步骤，所以在解决情况三的时候还要综合考虑到情况一，这里用到了一个trick (很膜拜大神能想的出来)，对于重复字符个数k大于等于3的情况，我们并不是直接将其删除到2个，而是先将其删除到最近的(3m+2)个，那么如果k正好被3整除，那么我们直接变为k-1，如果k除以3余1，那么变为k-2。这样做的好处是3m+2个重复字符可以最高效的用替换m个字符来去除重复。那么下面我们来看具体的步骤，首先我们算出超过20个的个数over，我们先把over加到结果res中，因为无论如何这over个删除操作都是要做的。如果没超过，over就是0，用变量left表示解决重复字符最少需要替换的个数，初始化为0。然后我们遍历之前统计字符出现个数的数组，如果某个字符出现个数大于等于3，且此时over大于0，那么我们将个数减为最近的3m+2个，over也对应的减少，注意，一旦over小于等于0，不要再进行删除操作。如果所有重复个数都减为3m+2了，但是over仍大于0，那么我们还要进一步的进行删除操作，这回每次直接删除3m个，直到over小于等于0为止，剩下的如果还有重复个数大于3的字符，我们算出置换字符需要的个数直接加到left中即可，最后我们比较left和missing，取其中较大值加入结果res中即可，

可以参考这个连接[\[LeetCode\] Strong Password Checker 密码强度检查器][LeetCode_ Strong Password Checker]

代码如下：

#include <iostream>
    #include <vector>
    #include <map>
    #include <set>
    #include <queue>
    #include <stack>
    #include <string>
    #include <climits>
    #include <algorithm>
    #include <sstream>
    #include <functional>
    #include <bitset>
    #include <cmath>
    
    using namespace std;
    
    
    class Solution
    {
    public:
        int strongPasswordChecker(string s) 
        {
            int deleteTarget = max(0, (int)s.length() - 20), addTarget = max(0, 6 - (int)s.length());
            int toDelete = 0, toAdd = 0, toReplace = 0, needUpper = 1, needLower = 1, needDigit = 1;
    
            for (int l = 0, r = 0; r < s.length(); r++) 
            {
                if (isupper(s[r])) 
                    needUpper = 0; 
                if (islower(s[r])) 
                    needLower = 0; 
                if (isdigit(s[r])) 
                    needDigit = 0; 
    
                if (r - l == 2) 
                {
                    if (s[l] == s[l + 1] && s[l + 1] == s[r]) 
                    {
                        if (toAdd < addTarget) { toAdd++, l = r; }
                        else { toReplace++, l = r + 1; }
                    }
                    else 
                        l++;
                }
            }
            if (s.length() <= 20) 
                return max(addTarget + toReplace, needUpper + needLower + needDigit);
    
            toReplace = 0;
            vector<unordered_map<int, int>> lenCnts(3);
            for (int l = 0, r = 0, len; r <= s.length(); r++)
            {
                if (r == s.length() || s[l] != s[r]) 
                {
                    if ((len = r - l) > 2) 
                        lenCnts[len % 3][len]++;
                    l = r;
                }
            }
    
            for (int i = 0, numLetters, dec; i < 3; i++)
            {
                for (auto it = lenCnts[i].begin(); it != lenCnts[i].end(); it++) 
                {
                    if (i < 2) 
                    {
                        numLetters = i + 1, dec = min(it->second, (deleteTarget - toDelete) / numLetters);
                        toDelete += dec * numLetters, it->second -= dec;
                        if (it->first - numLetters > 2) 
                            lenCnts[2][it->first - numLetters] += dec; 
                    }
                    toReplace += (it->second) * ((it->first) / 3);
                }
            }
    
            int dec = (deleteTarget - toDelete) / 3;
            toReplace -= dec, toDelete -= dec * 3;
            return deleteTarget + max(toReplace, needUpper + needLower + needDigit);
        }
    };

[LeetCode_ Strong Password Checker]: https://www.cnblogs.com/grandyang/p/5988792.html