数据结构与算法之哈希表: LeetCode 1797. 设计一个验证系统 (Ts版)

设计一个验证系统

• https://leetcode.cn/problems/design-authentication-manager/description/

描述

• 你需要设计一个包含验证码的验证系统。每一次验证中，用户会收到一个新的验证码，这个验证码在 currentTime 时刻之后 timeToLive 秒过期。如果验证码被更新了，那么它会在 currentTime （可能与之前的 currentTime 不同）时刻延长 timeToLive 秒

• 请你实现 AuthenticationManager 类：

  • AuthenticationManager(int timeToLive) 构造 AuthenticationManager 并设置 timeToLive 参数
  • generate(string tokenId, int currentTime) 给定 tokenId ，在当前时间 currentTime 生成一个新的验证码
  • renew(string tokenId, int currentTime) 将给定 tokenId 且 未过期 的验证码在 currentTime 时刻更新。如果给定 tokenId 对应的验证码不存在或已过期，请你忽略该操作，不会有任何更新操作发生
  • countUnexpiredTokens(int currentTime) 请返回在给定 currentTime 时刻，未过期 的验证码数目
  • 如果一个验证码在时刻 t 过期，且另一个操作恰好在时刻 t 发生（renew 或者 countUnexpiredTokens 操作），过期事件 优先于 其他操作

示例 1

输入：
["AuthenticationManager", "renew", "generate", "countUnexpiredTokens", "generate", "renew", "renew", "countUnexpiredTokens"]
[[5], ["aaa", 1], ["aaa", 2], [6], ["bbb", 7], ["aaa", 8], ["bbb", 10], [15]]
输出：
[null, null, null, 1, null, null, null, 0]

解释：

AuthenticationManager authenticationManager = new AuthenticationManager(5); // 构造 AuthenticationManager ，设置 timeToLive = 5 秒。
authenticationManager.renew("aaa", 1); // 时刻 1 时，没有验证码的 tokenId 为 "aaa" ，没有验证码被更新。
authenticationManager.generate("aaa", 2); // 时刻 2 时，生成一个 tokenId 为 "aaa" 的新验证码。
authenticationManager.countUnexpiredTokens(6); // 时刻 6 时，只有 tokenId 为 "aaa" 的验证码未过期，所以返回 1 。
authenticationManager.generate("bbb", 7); // 时刻 7 时，生成一个 tokenId 为 "bbb" 的新验证码。
authenticationManager.renew("aaa", 8); // tokenId 为 "aaa" 的验证码在时刻 7 过期，且 8 >= 7 ，所以时刻 8 的renew 操作被忽略，没有验证码被更新。
authenticationManager.renew("bbb", 10); // tokenId 为 "bbb" 的验证码在时刻 10 没有过期，所以 renew 操作会执行，该 token 将在时刻 15 过期。
authenticationManager.countUnexpiredTokens(15); // tokenId 为 "bbb" 的验证码在时刻 15 过期，tokenId 为 "aaa" 的验证码在时刻 7 过期，所有验证码均已过期，所以返回 0 。

提示

• 1 <= timeToLive <= $10^8$
• 1 <= currentTime <= $10^8$
• 1 <= tokenId.length <= 5
• tokenId 只包含小写英文字母
• 所有 generate 函数的调用都会包含独一无二的 tokenId 值
• 所有函数调用中，currentTime 的值 严格递增
• 所有函数的调用次数总共不超过 2000 次

Typescript 版算法实现

1 ) 方案：哈希表

class AuthenticationManager {
    private timeToLive: number;
    private map: Map<string, number>;

    constructor(timeToLive: number) {
        this.timeToLive = timeToLive;
        this.map = new Map<string, number>();
    }

    /**
     * 生成一个新的 token 并设置其过期时间
     * @param {string} tokenId - 要生成的 token ID
     * @param {number} currentTime - 当前时间
     * @return {void}
     */
    generate(tokenId: string, currentTime: number): void {
        this.map.set(tokenId, currentTime + this.timeToLive);
    }

    /**
     * 更新一个已存在的 token 的过期时间
     * @param {string} tokenId - 要更新的 token ID
     * @param {number} currentTime - 当前时间
     * @return {void}
     */
    renew(tokenId: string, currentTime: number): void {
        const expirationTime = this.map.get(tokenId);
        if (expirationTime && expirationTime > currentTime) {
            this.map.set(tokenId, currentTime + this.timeToLive);
        }
    }

    /**
     * 计算当前未过期的 token 数量
     * @param {number} currentTime - 当前时间
     * @return {number} - 返回未过期的 token 数量
     */
    countUnexpiredTokens(currentTime: number): number {
        let count = 0;
        for (const expirationTime of this.map.values()) {
            if (expirationTime > currentTime) {
                count++;
            }
        }
        return count;
    }
}

/**
 * Your AuthenticationManager object will be instantiated and called as such:
 * var obj = new AuthenticationManager(timeToLive)
 * obj.generate(tokenId,currentTime)
 * obj.renew(tokenId,currentTime)
 * var param_3 = obj.countUnexpiredTokens(currentTime)
 */

2 ）方案2：哈希表 + 双向链表

class Node {
    expire: number;
    key: string;
    prev: Node | null;
    next: Node | null;

    constructor(expire: number, key: string, prev: Node | null = null, next: Node | null = null) {
        this.expire = expire;
        this.key = key;
        this.prev = prev;
        this.next = next;
    }
}

class AuthenticationManager {
    private timeToLive: number;
    private head: Node;
    private tail: Node;
    private map: Map<string, Node>;

    constructor(timeToLive: number) {
        this.timeToLive = timeToLive;
        this.head = new Node(-1, '');
        this.tail = new Node(-1, '');
        this.head.next = this.tail;
        this.tail.prev = this.head;
        this.map = new Map<string, Node>();
    }

    /**
     * 生成一个新的 token 并设置其过期时间
     * @param {string} tokenId - 要生成的 token ID
     * @param {number} currentTime - 当前时间
     * @return {void}
     */
    generate(tokenId: string, currentTime: number): void {
        const node = new Node(currentTime + this.timeToLive, tokenId);
        this.map.set(tokenId, node);
        this.insertAtTail(node);
    }

    /**
     * 更新一个已存在的 token 的过期时间
     * @param {string} tokenId - 要更新的 token ID
     * @param {number} currentTime - 当前时间
     * @return {void}
     */
    renew(tokenId: string, currentTime: number): void {
        if (this.map.has(tokenId)) {
            const node = this.map.get(tokenId)!;
            if (node.expire > currentTime) {
                this.removeFromList(node);
                node.expire = currentTime + this.timeToLive;
                this.insertAtTail(node);
            }
        }
    }

    /**
     * 计算当前未过期的 token 数量
     * @param {number} currentTime - 当前时间
     * @return {number} - 返回未过期的 token 数量
     */
    countUnexpiredTokens(currentTime: number): number {
        while (this.head.next !== this.tail && this.head.next.expire <= currentTime) {
            const node = this.head.next!;
            this.map.delete(node.key);
            this.removeFromList(node);
        }
        return this.map.size;
    }

    /**
     * 将节点插入到链表尾部
     * @param {Node} node - 要插入的节点
     * @return {void}
     */
    private insertAtTail(node: Node): void {
        const last = this.tail.prev!;
        last.next = node;
        node.prev = last;
        node.next = this.tail;
        this.tail.prev = node;
    }

    /**
     * 从链表中移除节点
     * @param {Node} node - 要移除的节点
     * @return {void}
     */
    private removeFromList(node: Node): void {
        if (node.prev) node.prev.next = node.next;
        if (node.next) node.next.prev = node.prev;
        node.prev = null;
        node.next = null;
    }
}

/**
 * Your AuthenticationManager object will be instantiated and called as such:
 * var obj = new AuthenticationManager(timeToLive)
 * obj.generate(tokenId,currentTime)
 * obj.renew(tokenId,currentTime)
 * var param_3 = obj.countUnexpiredTokens(currentTime)
 */