C++ 末端迭代器减量的应用及意义 int-get（int-key）{ 如果（m.count（key）==0）返回-1； 频率[m[键]。秒。擦除（iter[键]）； 频率[m[键].秒].向后推（键）； iter[key]=--freq[m[key].second].end（）； 如果（freq[minFreq].size（）=0）++minFreq； 返回m[key]。首先； } 私人： int cap，minFreq； 无序地图m； 无序映射频率； 无序图iter；

我在一个Leetcode问题上找到了这一系列解决方案代码。这让我想知道，在这种情况下，结束迭代器减量实际上意味着什么，以及在编写代码时何时使用这种格式。作为C++初学者，我认为如果它保持

会很棒。

iter[key]=freq[m[key].second].end（）

但是这真的让我很困惑。在上下文中，我们应该查找LFU缓存，并且该行应该查找频率列表中某个值的对应位置。

--
操作在实际语句之前执行


重要的

在进一步讨论
unordered_map
解决方案之前（顺便说一句，我也重新实现了该解决方案）：


//下面的代码块可能会稍微缩短执行时间；
//可以移除；
静态常数自动优化{
std:：ios:：与stdio同步（false）；
标准：cin.tie（无PTR）；
标准：：cout.tie（无PTR）；
返回0；
}();
//大多数标题已经包含在内；
//可以移除；
#包括
#包括
#包括
#包括
静态常量结构LFUCache{
内联LFUCache（常数整数容量）{
这->容量=容量；
尺寸=0；
}
内联常量int get（常量int键）{
if（values.find（key）=values.end（））{
返回-1；
}
更新（关键）；
返回值[键]。首先；
}
内联void put（常量int键，常量int值）{
如果（！容量）{
返回；
}
if（values.find（key）！=values.end（））{
值[键]。第一个=值；
更新（关键）；
}否则{
如果（大小=容量）{
const ValueType execit=键[使用的频率最少].front（）；
键[使用的频率最少].pop_front（）；
值。删除（逐出）；
擦除（逐出）；
}否则{
大小++；
}
值[键]={value，1}；
键[1]。向后放置（键）；
iters[key]=--key[1].end（）；
最小使用频率=1；
}
}
私人：
使用ValueType=std:：uint\u fast16\u t；
价值型能力；
值类型大小；
ValueType最小使用频率=0；
std：：无序映射键；
std：：无序的_映射值；
std：：无序映射器；
内联无效更新（常量整型键）{
常量值类型频率=值[键]。秒；
const auto&iter=iters[key]；
值[key].second++；
键[频率]。擦除（iter）；
键[Frequency+1]。向后放置（键）；
iters[key]=--key[frequency+1].end（）；
if（键[least\u freq\u used].empty（））{
最少使用频率++；
}
}
};

值得注意的是，双链表是实现LFU缓存的正确方法。以下是基于DLL的讨论板的工作解决方案之一：


// The following block might slightly improve the execution time;
// Can be removed;
static const auto __optimize__ = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    return 0;
}();

// Most of headers are already included;
// Can be removed;
#include <cstdint>
#include <unordered_map>
#include <list>
#include <utility>

static const struct LFUCache {

    inline LFUCache(const int capacity) {
        this->capacity = capacity;
        size = 0;
    }

    inline const int get(const int key) {
        if (values.find(key) == values.end()) {
            return -1;
        }

        update(key);
        return values[key].first;
    }

    inline void put(const int key, const int value) {
        if (!capacity) {
            return;
        }

        if (values.find(key) != values.end()) {
            values[key].first = value;
            update(key);

        } else {
            if (size == capacity) {
                const ValueType evict = keys[least_freq_used].front();
                keys[least_freq_used].pop_front();
                values.erase(evict);
                iters.erase(evict);

            } else {
                size++;
            }

            values[key] = {value , 1};
            keys[1].emplace_back(key);
            iters[key] = --keys[1].end();
            least_freq_used = 1;
        }
    }

private:
    using ValueType = std::uint_fast16_t;
    ValueType capacity;
    ValueType size;
    ValueType least_freq_used = 0;
    std::unordered_map<ValueType, std::list<ValueType>> keys;
    std::unordered_map<ValueType, std::pair<ValueType, ValueType>> values;
    std::unordered_map<ValueType, std::list<ValueType>::iterator>iters;

    inline void update(const int key) {
        const ValueType freqency = values[key].second;
        const auto& iter = iters[key];
        values[key].second++;
        keys[freqency].erase(iter);
        keys[freqency + 1].emplace_back(key);
        iters[key] = --keys[freqency + 1].end();

        if (keys[least_freq_used].empty()) {
            least_freq_used++;
        }
    }
};

struct-DListNode{
int键；
int值；
国际频率；
DListNode*prev；
DListNode*下一步；
DListNode（整数k，整数v）{
key=k；
值=v；
频率=1；
prev=next=nullptr；
}
};
结构列表{
DListNode*哨兵；
整数大小；
DList（）{
尺寸=0；
sentinel=新的DListNode（-1，-1）；
哨兵->上一个=哨兵->下一个=哨兵；
}
无效预结束（DListNode*节点）{
节点->下一步=哨兵->下一步；
节点->上一个=哨兵；
sentinel->next->prev=节点；
哨兵->下一步=节点；
++大小；
}
DListNode*pop（DListNode*node=nullptr）{
如果（大小==0）{
返回空ptr；
}
if（node==nullptr）{
node=sentinel->prev；
}
节点->上一个->下一个=节点->下一个；
节点->下一步->上一步=节点->上一步；
--大小；
返回节点；
}
};
结构LFUCache{
无序的映射节点；
无序地图频率；
国际能力；
int min_freq；
LFUCache（内部容量）{
这->容量=容量；
最小频率=0；
}
void\u更新（DListNode*节点）{
if（freqs.find（node->freq）=freqs.end（）{
freqs[node->freq]=新数据列表（）；
}
if（freqs.find（节点->频率+1）=freqs.end（））{
freqs[node->freq+1]=new-DList（）；
}
freqs[node->freq]->pop（node）；
if（min_freq==node->freq&&freqs[node->freq]->size==0）{
++最小频率；
}
++节点->频率；
freqs[节点->频率]->前置（节点）；
}
int get（int键）{
if（nodes.find（key）=nodes.end（））{
返回-1；
}
DListNode*节点=节点[键]；
_更新（节点）；
返回节点->值；
}
无效放置（int键，int值）{
如果（容量==0）{
返回；
}
if（nodes.find（key）！=nodes.end（））{
DListNode*节点=节点[键]；
_更新（节点）；
节点->值=值；
}否则{
if（nodes.size（）=容量）{
if（freqs.find（min_freq）==freqs.end（））{
freqs[min_freq]=新数据列表（）；
}
DListNode*node=freqs[min_freq]->pop（）；
如果（节点）{
节点。擦除（节点->键）；
}
}
DListNode*node=新的DListNode（键，值）；
节点[键]=节点；
if（freqs.find（1）=freqs.end（））{
freqs[1]=新数据列表（）；
}
freqs[1]->prepend（节点）；

// The following block might slightly improve the execution time;
// Can be removed;
static const auto __optimize__ = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    return 0;
}();

// Most of headers are already included;
// Can be removed;
#include <cstdint>
#include <unordered_map>
#include <list>
#include <utility>

static const struct LFUCache {

    inline LFUCache(const int capacity) {
        this->capacity = capacity;
        size = 0;
    }

    inline const int get(const int key) {
        if (values.find(key) == values.end()) {
            return -1;
        }

        update(key);
        return values[key].first;
    }

    inline void put(const int key, const int value) {
        if (!capacity) {
            return;
        }

        if (values.find(key) != values.end()) {
            values[key].first = value;
            update(key);

        } else {
            if (size == capacity) {
                const ValueType evict = keys[least_freq_used].front();
                keys[least_freq_used].pop_front();
                values.erase(evict);
                iters.erase(evict);

            } else {
                size++;
            }

            values[key] = {value , 1};
            keys[1].emplace_back(key);
            iters[key] = --keys[1].end();
            least_freq_used = 1;
        }
    }

private:
    using ValueType = std::uint_fast16_t;
    ValueType capacity;
    ValueType size;
    ValueType least_freq_used = 0;
    std::unordered_map<ValueType, std::list<ValueType>> keys;
    std::unordered_map<ValueType, std::pair<ValueType, ValueType>> values;
    std::unordered_map<ValueType, std::list<ValueType>::iterator>iters;

    inline void update(const int key) {
        const ValueType freqency = values[key].second;
        const auto& iter = iters[key];
        values[key].second++;
        keys[freqency].erase(iter);
        keys[freqency + 1].emplace_back(key);
        iters[key] = --keys[freqency + 1].end();

        if (keys[least_freq_used].empty()) {
            least_freq_used++;
        }
    }
};

struct DListNode {
    int key;
    int value;
    int freq;
    DListNode* prev;
    DListNode* next;

    DListNode(int k, int v) {
        key = k;
        value = v;
        freq = 1;
        prev = next = nullptr;
    }
};

struct DList {
    DListNode* sentinel;
    int size;

    DList() {
        size = 0;
        sentinel = new DListNode(-1, -1);
        sentinel->prev = sentinel->next = sentinel;
    }

    void prepend(DListNode* node) {
        node->next = sentinel->next;
        node->prev = sentinel;
        sentinel->next->prev = node;
        sentinel->next = node;
        ++size;
    }

    DListNode* pop(DListNode* node = nullptr) {
        if (size == 0) {
            return nullptr;
        }

        if (node == nullptr) {
            node = sentinel->prev;
        }

        node->prev->next = node->next;
        node->next->prev = node->prev;
        --size;
        return node;
    }
};

struct LFUCache {
    unordered_map<int, DListNode*> nodes;
    unordered_map<int, DList*> freqs;
    int capacity;
    int min_freq;

    LFUCache(int capacity) {
        this->capacity = capacity;
        min_freq = 0;
    }

    void _update(DListNode* node) {
        if (freqs.find(node->freq) == freqs.end()) {
            freqs[node->freq] = new DList();
        }

        if (freqs.find(node->freq + 1) == freqs.end()) {
            freqs[node->freq + 1] = new DList();
        }

        freqs[node->freq]->pop(node);

        if (min_freq == node->freq && freqs[node->freq]->size == 0) {
            ++min_freq;
        }

        ++node->freq;
        freqs[node->freq]->prepend(node);
    }

    int get(int key) {
        if (nodes.find(key) == nodes.end()) {
            return -1;
        }

        DListNode* node = nodes[key];

        _update(node);

        return node->value;
    }

    void put(int key, int value) {
        if (capacity == 0) {
            return;
        }

        if (nodes.find(key) != nodes.end()) {
            DListNode* node = nodes[key];
            _update(node);
            node->value = value;

        } else {
            if (nodes.size() == capacity) {
                if (freqs.find(min_freq) == freqs.end()) {
                    freqs[min_freq] = new DList();
                }

                DListNode* node = freqs[min_freq]->pop();

                if (node) {
                    nodes.erase(node->key);
                }
            }

            DListNode* node = new DListNode(key, value);
            nodes[key] = node;

            if (freqs.find(1) == freqs.end()) {
                freqs[1] = new DList();
            }

            freqs[1]->prepend(node);
            min_freq = 1;
        }
    }
};


list<int> li;
li.push_back(1);
li.push_back(2);
li.push_back(3);