Java&C++题解与拓展——leetcode420.强密码检验器【“困难”模拟题】

最新推荐文章于 2023-01-19 13:46:36 发布

AnjaVon

最新推荐文章于 2023-01-19 13:46:36 发布

阅读量1k

点赞数 1

分类专栏： leetcode 文章标签： java c++ leetcode

本文链接：https://blog.csdn.net/sinat_41135487/article/details/123929097

版权

leetcode 专栏收录该内容

96 篇文章 1 订阅

订阅专栏

每日一题做题记录，参考官方和三叶的题解

题目要求

在这里插入图片描述

思路：模拟w(ﾟДﾟ)w

根据密码长度直接分情况讨论：

$n < 6$ ：长度不够，要增加长度所以用到增加操作，对三连串需要进行替换（删除+增加），最少操作次数就是单纯加够长度or种类，即 $m a x (6 - n, 3 - t y p)$ ；
$6\le n \le 20$ ：要破坏三连串，最佳的操作是进行替换，最少次数是当前三连串的长度除以三，即 $\lfloor \frac{len_i}{3} \rfloor$ ，最少操作次数就是消掉所有三连串或加（换）够种类，即 $max(\sum\lfloor \frac{len_i}{3} \rfloor, 3 - typ)$ ；
$n > 20$ ：要先把长度调整到合适长度，需要 $b a s e = n - 20$ 次删除操作，然后用替换破坏三连串，由于之前的删除操作可以破坏掉一定的三连串，具体规律是每删除三个字符就可以减少依次替换，那么根据 $l e n$ 模 $3$ 的值根据从小到大进行更新统计得到需替换操作数 $t o t$ ，最少操作次数就是调整至合适长度后消掉所有三连串或加（换）够种类，即 $b a s e + m a x (t o t, 3 - m)$ 。

Java

class Solution {
    public int strongPasswordChecker(String password) {
        char[] cs = password.toCharArray();
        int n = cs.length;
        int num = 0, low = 0, cap = 0;
        for(char c : cs) {
            if(c >= '0' && c <= '9')
                num = 1;
            else if(c >= 'a' && c <= 'z')
                low = 1;
            else if(c >= 'A' && c <= 'Z')
                cap = 1;
        }
        int typ = num + low + cap; //字符种类
        if(n < 6) { //增加、替换
            return Math.max(6 - n, 3 - typ);
        }
        else if(n <= 20) { //替换
            int tot = 0;
            for(int i = 0; i < n; ) { //统计三连串
                int j = i;
                while(j < n && cs[j] == cs[i])
                    j++;
                int len = j - i;
                if(len >= 3)
                    tot += len / 3;
                i = j;
            }
            return Math.max(tot, 3 - typ);
        }
        else {
            int tot = 0;
            int[] cnts = new int[3]; //三连串长度余数为i的数量
            for(int i = 0; i < n; ) { //统计三连串
                int j = i;
                while(j < n && cs[j] == cs[i])
                    j++;
                int len = j - i;
                if(len >= 3) {
                    tot += len / 3;
                    cnts[len % 3]++;
                }
                i = j;
            }
            int base = n - 20, cur = base; //至少需“删除”
            for(int i = 0; i < 3; i++) { //更新三连串，统计“替换”
                if(i == 2)
                    cnts[i] = tot;
                if(cnts[i] != 0 && cur != 0) {
                    int t = Math.min(cnts[i] * (i + 1), cur);
                    cur -= t;
                    tot -= t / (i + 1);
                }
            }
            return base + Math.max(tot, 3 - typ);
        }
    }
}

时间复杂度： $O (n)$
空间复杂度： $O (1)$

C++

class Solution {
public:
    int strongPasswordChecker(string password) {
        int n = password.size();
        int num = 0, low = 0, cap = 0;
        for(char c : password) {
            if(c >= '0' && c <= '9')
                num = 1;
            else if(c >= 'a' && c <= 'z')
                low = 1;
            else if(c >= 'A' && c <= 'Z')
                cap = 1;
        }
        int typ = num + low + cap; //字符种类
        if(n < 6) { //增加、替换
            return max(6 - n, 3 - typ);
        }
        else if(n <= 20) { //替换
            int tot = 0;
            for(int i = 0; i < n; ) { //统计三连串
                int j = i;
                while(j < n && password[j] == password[i])
                    j++;
                int len = j - i;
                if(len >= 3)
                    tot += len / 3;
                i = j;
            }
            return max(tot, 3 - typ);
        }
        else {
            int tot = 0;
            int cnts[3]{0}; //三连串长度余数为i的数量，记得初始化
            for(int i = 0; i < n; ) { //统计三连串
                int j = i;
                while(j < n && password[j] == password[i])
                    j++;
                int len = j - i;
                if(len >= 3) {
                    tot += len / 3;
                    cnts[len % 3]++;
                }
                i = j;
            }
            int base = n - 20, cur = base; //至少需“删除”
            for(int i = 0; i < 3; i++) { //更新三连串，统计“替换”
                if(i == 2)
                    cnts[i] = tot;
                if(cnts[i] != 0 && cur != 0) {
                    int t = min(cnts[i] * (i + 1), cur);
                    cur -= t;
                    tot -= t / (i + 1);
                }
            }
            return base + max(tot, 3 - typ);
        }
    }
};