机器翻译

#include <iostream>
using namespace std;
#include <vector>
#include <queue>
#include <algorithm>
int main(){
    int M, N;
    vector<int> v;
    vector<int> cache;
    cin >> M >> N;
    int num, count = 0;
    for(int i = 0; i < N; ++i){
        cin >> num;
        v.push_back(num);
    }
    for(const auto& val : v){
        vector<int>::const_iterator it = find(cache.begin(), cache.end(), val);
        if(it == cache.end()){
            if(cache.size() < M) cache.push_back(val);
            else{
                cache.erase(cache.begin());
                cache.push_back(val);
            }
            count++;
        }
    }
    cout << count << endl;
    return 0;
}

m, n = map(int, input().strip().split())
w, t, c = list(map(int, input().strip().split())), [], 0
for i in w:
    if i in t:
        continue
    else:
        if len(t) >= m:
            t.pop(0)
        c += 1
        t.append(i)
print(c)

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>
using namespace std;

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

    unordered_set<int> cache;        // 用于快速查找（O(1)时间复杂度）
    queue<int> fifo_queue;           // 用于维护FIFO顺序
    int miss_count = 0;

    for (int i = 0; i < N; i++) {
        int word;
        cin >> word;

        // 如果单词不在缓存中（缓存未命中）
        if (cache.find(word) == cache.end()) {
            miss_count++;

            // 如果缓存已满，需要移除最早进入的单词
            if (cache.size() >= M) {
                int oldest = fifo_queue.front();
                fifo_queue.pop();
                cache.erase(oldest);
            }

            // 将新单词加入缓存
            cache.insert(word);
            fifo_queue.push(word);
        }
        // 如果单词在缓存中（缓存命中），不需要任何操作
    }

    cout << miss_count << endl;
    return 0;
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int m,n;
        Queue<Integer> queue = new LinkedList<>();
        m = in.nextInt();
        n = in.nextInt();
        int ans = 0;
        while(n-->0){
            int temp = in.nextInt();
            if(!queue.contains(temp)){
                queue.offer(temp);
                if(queue.size()>m)queue.poll();
                ans++;
            }
        }
        System.out.println(ans);
    }
}

M, N = map(int, input().split())
queue = list(map(int, input().split()))
huancun_list = []
count = 0
for _ in range(N):
    if (queue[0] not in huancun_list) & (len(huancun_list) < M):
        huancun_list.append(queue[0])
        queue.pop(0)
        count += 1
    elif (queue[0] in huancun_list) & (len(huancun_list) < M):
        queue.pop(0)
        continue
    elif (queue[0] not in huancun_list) & (len(huancun_list) >= M):
        huancun_list.pop(0)
        huancun_list.append(queue[0])
        queue.pop(0)
        count += 1
    elif (queue[0] in huancun_list) & (len(huancun_list) >= M):
        queue.pop(0)
        continue
print(count)

#include <iostream>
using namespace std;
#include<deque>
#include<vector>
bool isInCache(int a,deque<int>d){
      for(int i=0;i<d.size();i++){
           if(a==d[i]){
               return 1;
           }
      }
      return 0;
}
int main() {
   int M,N;
   cin>>M>>N;
    vector<int>v;
   for(int i=0;i<N;i++){
        int a;
        cin>>a;
        v.push_back(a);
   }
   int miss=0;
   deque<int>d;
   for(int i=0;i<v.size();i++){
           if(isInCache(v[i],d)){
                 continue;
           }
           else if(!isInCache(v[i],d)){
            miss++;
                if(d.size()==M){
                    d.pop_front();
                    d.push_back(v[i]);
                }
                else{
                    d.push_back(v[i]);
                }
           }
         }
         cout<<miss;
   }

// 64 位输出请用 printf("%lld")

m,n = map(int,input().split())
w = list(map(int,input().split()))
list_w = []
cnt = 0
for i in w:
    if i not in list_w:
        cnt += 1
        if len(list_w) == m:
            list_w.pop(0)
            list_w.append(i)
        if len(list_w) < m:
            list_w.append(i)
    else:
        continue
print(cnt)

class Queue:
    def __init__(self):
        self.in_stack: list[int] = []
        self.out_stack: list[int] = []

    def push(self, x: int):
        self.in_stack.append(x)

    def _dump_if_needed(self):
        if not self.out_stack:
            while self.in_stack:
                self.out_stack.append(self.in_stack.pop())

    def pop(self) -> int:
        if self.isEmpty():
            raise IndexError("pop from an empty queue")

        self._dump_if_needed()

        return self.out_stack.pop()

    def query(self) -> int:
        if self.isEmpty():
            raise IndexError("pop from an empty queue")

        self._dump_if_needed()

        return self.out_stack[-1]

    @property
    def size(self) -> int:
        return len(self.in_stack) + len(self.out_stack)

    def isEmpty(self) -> bool:
        return not self.in_stack and not self.out_stack

    def __len__(self) -> int:
        return self.size
    
    def __contains__(self, x : int) -> bool:
        return x in self.in_stack&nbs***bsp;x in self.out_stack

def totalQuery(M : int, words : list[int]) -> int:
    vocab = Queue()
    total_number_of_query = 0
    for word in words:
        if word not in vocab:
            total_number_of_query += 1
            if vocab.size >= M:
                vocab.pop()
            vocab.push(word)

    return total_number_of_query

def main():
    M, N = map(int, input().split())
    words = list(map(int, input().split()))
    print(totalQuery(M, words))

if __name__ == "__main__":
    main()

# 小白版本

a,b = map(int, input().split())

nums = list(map(int,input().split()))
stack=[]
res = 0
for aaa in nums:
    if aaa in stack:
        # res+= 1
        continue
    elif len(stack)<a:
        res+=1
        stack.append(aaa)
    else:
        stack.pop(0)
        res+=1
        stack.append(aaa)
print(res)