D24-读论文D24&算法D24

最新推荐文章于 2024-09-27 14:28:55 发布

甄小胖

最新推荐文章于 2024-09-27 14:28:55 发布

阅读量98

点赞数

分类专栏：每日一题 python 文章标签：算法 python 开发语言

本文链接：https://blog.csdn.net/weixin_45252975/article/details/126047483

版权

python 同时被 2 个专栏收录

115 篇文章 0 订阅

订阅专栏

每日一题

40 篇文章 0 订阅

订阅专栏

这篇博客探讨了三种数据结构的模拟实现：散列表、堆和Trie字符串统计。通过Python代码展示了插入、查找和删除操作，以及在特定操作中的注意事项，如在堆中删除元素后需要调整结构。此外，还涉及了连通块中点数量的计算。这些内容对于理解数据结构和算法的实际应用非常有帮助。

摘要由CSDN通过智能技术生成

840模拟散列表

n = int(input())
N = 100010
null = 0x3f3f3f3f
s = [null]*N

def find(x):
    k = x%N
    while s[k]!=null and s[k]!=x:
        k += 1
        if k==N:
            k = 0
    return k

for _ in range(n):
    op, pt = input().split()
    if op=='I':
        x = int(pt)
        s[find(x)] = x
    else:
        x = int(pt)
        if s[find(x)]==x:
            print('Yes')
        else:
            print('No')```
## 839模拟堆
在堆里面进行删除操作的时候，要先删除，才能down；不然，则可能将最后一个元素换上来。

```bash
n = int(input())
N = 100010
hp,ph,h = [0]*N,[0]*N,[0]*N
idx,size=0,0

def insert(x):
    global idx,size
    idx+=1
    size+=1
    h[size] = x
    ph[idx] = size
    hp[size] = idx
    up(size)

def down(u):
    t = u
    if u*2<=size and h[u*2]<h[t]:
        t = u*2
    if u*2+1<=size and h[u*2+1]<h[t]:
        t = u*2+1
    if t!=u:
        swap(u,t)
        down(t)
        
def up(u):
    while u//2 and h[u//2]>h[u]:
        swap(u, u//2)
        u=u//2

def swap(a,b):
    ph[hp[a]],ph[hp[b]] = b,a
    hp[a],hp[b] = hp[b],hp[a]
    h[a],h[b] = h[b],h[a]

for _ in range(n):
    op, *pt = input().split()
    if op=='I':
        x = int(pt[0])
        insert(x)
    elif op=='PM':
        print(h[1])
    elif op=='DM':
        swap(1,size)
        # 同理，先要删除，才能down
        size -= 1
        down(1)
    elif op=='D':
        k = int(pt[0])
        k = ph[k]
        swap(k,size)
        # 交换完，先要删除，才能down
        size -= 1
        up(k)
        down(k)
    else:
        k,x = map(int,pt)
        k = ph[k]
        h[k] = x
        up(k)
        down(k)

837连通块中点的数量

n,m = map(int,input().split())
N = 100010
p = [x for x in range(N)]
cnt = [1]*N

def find(x):
    if p[x]!=x:
        p[x] = find(p[x])
    return p[x]

def merge(a,b):
    if find(a)!=find(b):
        cnt[find(b)] += cnt[find(a)]
        p[find(a)] = find(b)

for _ in range(m):
    op, *pt = input().split()
    if op=='C':
        a,b = map(int, pt)
        merge(a,b)
    elif op=='Q1':
        a,b = map(int, pt)
        if find(a)==find(b):
            print('Yes')
        else:
            print('No')
    else:
        a = int(pt[0])
        print(cnt[find(a)])```


## 835Trie字符串统计

```bash
n = int(input())
N = 100010
tree = [[0]*26 for _ in range(N)]
idx = 1
cnt = [0]*N
def insert(x):
# 不要忘记global
    global idx
    p = 0
    for i in x:
        u = ord(i)-ord('a')
        if not tree[p][u]:
            tree[p][u]=idx
            idx += 1
        p = tree[p][u]
    cnt[p] += 1

def query(x):
    p = 0
    for i in x:
        u = ord(i)-ord('a')
        if not tree[p][u]:
        # 不要忘记return
            print(0) 
            return
        else:
            p= tree[p][u]
    print(cnt[p])
    return
    

for _ in range(n):
    # 字符串接收，不要僵硬化地用*
    op, pt = input().split()
    if op=='I':
        insert(pt)
    else:
        query(pt)