手撕代码相关

1. 用有锁的方式实现两个方法轮流输出：a1b2c3...z26。

# acquire()：尝试获取锁。如果锁处于未锁定状态，则立即获取并将其设置为锁定状态；如果锁已锁定，则当前线程会阻塞，直到其他线程调用 release() 释放锁。此方法用于确保同一时间仅有一个线程访问共享资源。

# release()：释放锁。仅在锁处于锁定状态时调用，将其状态改为未锁定，并唤醒等待该锁的其他线程。此方法用于允许其他线程继续执行。

import threading

#初始化两个锁，初始时lock_a未被锁定，lock_b被锁定
#lock_a为字母进程互斥锁，lock_b为数字进程互斥锁
lock_a = threading.Lock()
lock_b = threading.Lock()
lock_b.acquire()#确保thread2初始时无法立即执行

def print_letters():
    for i in range(26):
        lock_a.acquire()#等待lock_a被释放，释放后立即获取并将其设置为锁定状态
        print(chr(ord('a')+i),end='')
        lock_b.release()#释放lock_b，允许thread2执行


def print_numbers():
    for i in range(1,27):
        lock_b.acquire()#等待lock_b被释放，释放后立即获取并将其设置为锁定状态
        print(i,end='')
        lock_a.release()

thread1 = threading.Thread(target=print_letters)
thread2 = threading.Thread(target=print_numbers)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print()#插入一个换行符

2. 一个村庄，里面有许多房屋和土地，相邻的房屋是一个家族，计算有多少家族。

# 深度优先搜索

grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]

def dfs(grid,i,j):
    if not 0<=i<len(grid) or not 0<=j<len(grid[0]) or grid[i][j]=='0':
        return
    grid[i][j]='0'
    dfs(grid,i,j-1)
    dfs(grid,i,j+1)
    dfs(grid,i-1,j)
    dfs(grid,i+1,j)

count=0
for i in range(len(grid)):
    for j in range(len(grid[0])):
        if grid[i][j]=='1':
            dfs(grid,i,j)
            count+=1
print(count)

# 广度优先搜索

grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]

def bfs(grid,i,j):
    queue=[[i,j]]
    while queue:
        [i,j]=queue.pop()
        if 0<=i<len(grid) and 0<=j<len(grid[0]) and grid[i][j]=='1':
            grid[i][j]='0'
            queue += [[i,j+1],[i,j-1],[i-1,j],[i+1,j]]

count=0
for i in range(len(grid)):
    for j in range(len(grid[0])):
        if grid[i][j]=='1':
            bfs(grid,i,j)
            count+=1
print(count)

[探索路径] BFS：按层级逐层扩展，优先探索当前节点的所有相邻节点，再逐步深入下一层级。例如，在迷宫中，BFS会先检查所有距离起点一步的路径，再检查距离两步的路径。 DFS：优先深入某个分支到底，直到无法继续时再回溯，尝试其他路径。例如，在迷宫中，DFS会一直沿着一条路走到底，遇到死胡同时回退到最近的分叉点。

[数据结构] BFS：使用队列（FIFO，先进先出）管理待探索节点，确保同一层级的节点被优先处理。 DFS：使用栈（LIFO，后进先出）或递归实现，通过递归调用栈隐式维护探索路径。 3. 。 4. 。 5. 。