【算法和数据结构】单词翻译

描述

​ 小李的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。

​ 这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。

​ 假设内存中有 M 个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过 M−1，软件会将新单词存入一个未使用的内存单元；若内存中已存入 M 个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。

​ 假设一篇英语文章的长度为 N 个单词。给定这篇待译文章，翻译软件需要去外存查找多少次词典？假设在翻译开始前，内存中没有任何单词。

输入

​ 共 2行。每行中两个数之间用一个空格隔开。

​ 第一行为两个正整数 M,N代表内存容量和文章的长度。

​ 第二行为 N 个非负整数，按照文章的顺序，每个数（大小不超过 1000）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。

输出

​ 一个整数，为软件需要查词典的次数。

样例输入：

3 7
1 2 1 5 4 4 1

样例输出：

5

说明：

整个查字典过程如下：每行表示一个单词的翻译，冒号前为本次翻译后的内存状况：

空：内存初始状态为空。

1．1：查找单词1并调入内存。

2． 12：查找单词2并调入内存。

3． 12：在内存中找到单词1。

4． 125：查找单词5并调入内存。

5． 254：查找单词4并调入内存替代单词1。

6． 254：在内存中找到单词4。

7． 541：查找单词1并调入内存替代单词2。

共计查了5次词典。

关键词：

链表，缓存，哈希

分析：

缓存方式用链表的方式，最早进入的单词就是头结点的next指针指向的单词，后面进入的单词直接加到末尾。删除操作的复杂度O(1)。

哈希表在单词内容和单词节点指针之间建立对应，当需要删除最早进入的单词时，也需要从哈希表中删掉对应的单词，哈希保证找到的时间复杂度O(1)。

代码：

#include <iostream>
#include <vector>
#include <unordered_map>
#include <utility>

#include <memory>


using namespace std;

struct Word {
    int val;
    Word *next;

    Word(int v) : val(v), next(nullptr) { }
};

class Dic {
public:
    Dic(int n) : volume(n) { 
        head = new Word(-1);
        last = head;
    }

    void showDic() {
        Word *temp = head->next;
        while (temp) {
            temp = temp->next;
        }
    }

    bool checkDic(int word) {
        showDic();
        // if the word is in the dictionary
        if (hashDic.find(word) != hashDic.end()) {
            return true;
        }
        else {
            Word *newWord = new Word(word);
            last->next = newWord;
            last = newWord;

            hashDic.insert(make_pair(word, newWord));

            if (hashDic.size() > volume) {
                Word *temp = head->next;
                hashDic.erase(temp->val); // 在hashDic中把单词删除
                head->next = head->next->next;
                delete temp; // 在链表中把最早插入的单词删除
            }

            return false;
        }
    }

    ~Dic() {
        Word *ptr = head;
        while (ptr != nullptr) {
            Word *temp = ptr;
            ptr = ptr->next;
            delete temp;
        }
    }

private:
    Word *head, *last;
    int volume; // volume of dic
    unordered_map<int, Word*> hashDic;
};

int main() {
    int M, N;
    cin >> M >> N;

    Dic dic(M);

    int cnt = 0;

    for (int i = 0; i < N; i++) {
        int temp;
        cin >> temp;
        if (!dic.checkDic(temp)) {
            cnt++;
        }
    }
    cout << cnt << endl;
    return 0;
}