算法进阶篇 之 实用数据结构

于 2024-08-30 17:19:25 发布
阅读量721 收藏 5
点赞数 5
分类专栏： 算法 算法分析 文章标签： 算法 数据结构 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nndsb/article/details/141651725
版权

目录

一、并查集

1. HDU 1232: Game (Hangman)

2. POJ 1988: Catch the 'M'

3. POJ 1182: A Special Cake

4. POJ 1703: Calculation

二、优先队列

1. HDU 4006: Fractional Knapsack Problem

2. POJ 3253: Curves

3. POJ 2833: Hopscotch

4. POJ 2431: How Many Trees

一、并查集

1. HDU 1232: Game (Hangman)

问题概述： 玩家在有限的猜测次数内尝试猜出一个隐藏单词。每次猜测会给出当前已猜出的单词状态，并且玩家可以最多进行一定次数的错误猜测。

解题思路：

  1. 输入处理：读取隐藏单词和猜测序列。
  2. 状态初始化：
    • 使用字符数组来跟踪当前已猜出的字母状态。
    • 维护一个失败次数计数器。
  3. 猜测处理：
    • 遍历每个猜测字母，更新单词状态并检查是否达到失败次数上限。
  4. 结果判断：
    • 如果所有字母都被猜中，玩家获胜。
    • 如果失败次数超过上限，玩家失败。

Python 示例代码：

def hangman_game(secret_word, guesses, max_attempts):
    guessed_letters = set()
    incorrect_guesses = 0
    word_set = set(secret_word)
    current_state = ['_'] * len(secret_word)

    for guess in guesses:
        if guess in word_set:
            guessed_letters.add(guess)
            current_state = [ch if ch in guessed_letters else '_' for ch in secret_word]
        else:
            incorrect_guesses += 1
        
        if set(current_state) == word_set:
            return "You win."
        
        if incorrect_guesses >= max_attempts:
            return "You lose."
    
    return "You lose." if incorrect_guesses >= max_attempts else "You win."

# Example usage
t = int(input())
for _ in range(t):
    max_attempts = int(input())
    guesses = [input().strip() for _ in range(max_attempts)]
    secret_word = input().strip()
    print(hangman_game(secret_word, guesses, max_attempts))

2. POJ 1988: Catch the 'M'

问题概述： 在一个棋盘上放置最大数量的 'M'，满足一定的约束条件。

解题思路：

这个问题可以建模为最大流问题或最大匹配问题。棋盘被转换为一个流网络，在网络中寻找最大流。

Python 示例代码：

from collections import defaultdict, deque

def max_bipartite_matching(graph, left_nodes, right_nodes):
    match = {}
    def bfs():
        dist = {u: float('inf') for u in left_nodes}
        queue = deque()
        for u in left_nodes:
            if u not in match:
                dist[u] = 0
                queue.append(u)
        found_augmenting_path = False
        while queue:
            u = queue.popleft()
            for v in graph[u]:
                if v not in match:
                    found_augmenting_path = True
                elif dist.get(match[v], float('inf')) == float('inf'):
                    dist[match[v]] = dist[u] + 1
                    queue.append(match[v])
        return found_augmenting_path

    def dfs(u):
        for v in graph[u]:
            if v not in match or (dist[match[v]] == dist[u] + 1 and dfs(match[v])):
                match[v] = u
                return True
        dist[u] = float('inf')
        return False

    matching_size = 0
    while bfs():
        for u in left_nodes:
            if u not in match:
                if dfs(u):
                    matching_size += 1
    return matching_size

3. POJ 1182: A Special Cake

问题概述： 将一个蛋糕切割成特定形状或大小的块，以满足特定条件。

解题思路：

通常涉及几何计算或特殊的切割规则。你可以将其建模为几何问题或使用动态规划进行解决，具体取决于要求。

Python 示例代码：

def special_cake(cuts):
    # Example solution; details depend on the specific problem constraints
    # Use geometric calculations or dynamic programming
    return len(cuts)  # Placeholder for the actual calculation

# Example usage
cuts = [int(x) for x in input().split()]
print(special_cake(cuts))

4. POJ 1703: Calculation

问题概述： 计算给定数学表达式的值。表达式可能包含加、减、乘、除操作符。

解题思路：

  1. 解析表达式：使用逆波兰表示法（后缀表达式）来评估表达式。
  2. 实现算法：
    • 将表达式转换为逆波兰表示法。
    • 使用栈来评估逆波兰表达式。

Python 示例代码：

def evaluate_expression(expression):
    def apply_operation(op, a, b):
        if op == '+':
            return a + b
        elif op == '-':
            return a - b
        elif op == '*':
            return a * b
        elif op == '/':
            return a // b

    def precedence(op):
        if op in ('+', '-'):
            return 1
        if op in ('*', '/'):
            return 2
        return 0

    def infix_to_postfix(expression):
        output = []
        ops = []
        for char in expression:
            if char.isdigit():
                output.append(int(char))
            elif char in ('+', '-', '*', '/'):
                while (ops and precedence(ops[-1]) >= precedence(char)):
                    output.append(ops.pop())
                ops.append(char)
        while ops:
            output.append(ops.pop())
        return output

    def evaluate_postfix(postfix):
        stack = []
        for token in postfix:
            if isinstance(token, int):
                stack.append(token)
            else:
                b = stack.pop()
                a = stack.pop()
                stack.append(apply_operation(token, a, b))
        return stack[0]

    postfix_expr = infix_to_postfix(expression)
    return evaluate_postfix(postfix_expr)

# Example usage
expression = input().strip()
print(evaluate_expression(expression))

二、优先队列

1. HDU 4006: Fractional Knapsack Problem

问题概述： 这是一个经典的分数背包问题。给定一组物品，每个物品有一个重量和一个价值，背包有一个容量。目标是选择物品，以最大化背包的总价值，允许将物品分割成任意小的部分。

解题思路：

  1. 计算价值密度：每个物品的价值密度是其价值与重量的比值。
  2. 排序：根据价值密度从高到低对物品进行排序。
  3. 选择物品：从价值密度最高的物品开始，尽可能多地装入背包。如果当前物品不能完全放入背包，则将其部分放入。
  4. 累计价值：更新背包的总价值和剩余容量。

Python 示例代码：

def fractional_knapsack(weights, values, capacity):
    items = list(zip(weights, values))
    items.sort(key=lambda x: x[1] / x[0], reverse=True)
    
    total_value = 0.0
    for weight, value in items:
        if capacity == 0:
            break
        take_weight = min(weight, capacity)
        total_value += take_weight * (value / weight)
        capacity -= take_weight
    
    return total_value

# Example usage
n, capacity = map(int, input().split())
weights = []
values = []
for _ in range(n):
    weight, value = map(int, input().split())
    weights.append(weight)
    values.append(value)

print(fractional_knapsack(weights, values, capacity))

2. POJ 3253: Curves

问题概述： 给定一些曲线段，每条曲线段由两个点确定。任务是找到最短的路径，使得路径经过每条曲线段恰好一次，类似于最小生成树问题中的最小连接问题。

解题思路：

  1. 建图：将每条曲线段建成图的边。
  2. 计算最短路径：使用 Kruskal 算法或 Prim 算法来构建最小生成树。
  3. 输出结果：最小生成树的边权和即为解决方案。

Python 示例代码：

import heapq

def min_spanning_tree(n, edges):
    adj = [[] for _ in range(n)]
    for u, v, w in edges:
        adj[u].append((w, v))
        adj[v].append((w, u))
    
    total_weight = 0
    visited = [False] * n
    min_heap = [(0, 0)]  # Start with node 0
    while min_heap:
        weight, u = heapq.heappop(min_heap)
        if visited[u]:
            continue
        visited[u] = True
        total_weight += weight
        for w, v in adj[u]:
            if not visited[v]:
                heapq.heappush(min_heap, (w, v))
    
    return total_weight

# Example usage
n, m = map(int, input().split())
edges = [tuple(map(int, input().split())) for _ in range(m)]

print(min_spanning_tree(n, edges))

3. POJ 2833: Hopscotch

问题概述： 在一个矩阵中，每个单元格包含一个整数。任务是从矩阵的左上角到右下角找到一条路径，使得路径上的数字之和最大化，只能向下或向右移动。

解题思路：

  1. 动态规划：定义 dp[i][j] 为从 (0, 0) 到 (i, j) 的最大和。
  2. 状态转移：dp[i][j] 可以从 dp[i-1][j] 或 dp[i][j-1] 转移过来。
  3. 初始化：dp[0][0] 初始化为矩阵的起始值。
  4. 结果：dp[n-1][m-1] 是目标结果。

Python 示例代码：

def hopscotch(matrix):
    n = len(matrix)
    m = len(matrix[0])
    
    dp = [[0] * m for _ in range(n)]
    dp[0][0] = matrix[0][0]
    
    for i in range(n):
        for j in range(m):
            if i > 0:
                dp[i][j] = max(dp[i][j], dp[i-1][j] + matrix[i][j])
            if j > 0:
                dp[i][j] = max(dp[i][j], dp[i][j-1] + matrix[i][j])
    
    return dp[n-1][m-1]

# Example usage
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]

print(hopscotch(matrix))

4. POJ 2431: How Many Trees

问题概述： 给定一个无向图，任务是计算该图中可能的树的数量。树是一个无环的连通图，问题可以通过计算图的不同生成树来解决。

解题思路：

  1. 计算生成树数量：使用 Kirchoff 的矩阵树定理。
  2. 构造拉普拉斯矩阵：从图的邻接矩阵构造拉普拉斯矩阵。
  3. 计算行列式：计算拉普拉斯矩阵的任意子矩阵的行列式作为树的数量。

Python 示例代码：

import numpy as np

def count_trees(n, edges):
    laplacian = np.zeros((n, n))
    for u, v in edges:
        laplacian[u][u] += 1
        laplacian[v][v] += 1
        laplacian[u][v] -= 1
        laplacian[v][u] -= 1
    
    # Remove last row and column
    minor = laplacian[:-1, :-1]
    
    # Calculate the determinant
    return int(round(np.linalg.det(minor)))

# Example usage
n, m = map(int, input().split())
edges = [tuple(map(int, input().split())) for _ in range(m)]

print(count_trees(n, edges))

战族狼魂
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【2024美赛】算法进阶之路：2024美赛智能算法实用技巧
Fanjufei的博客
09-11 823
智能算法模型汇总
算法与数据结构+一点点ACM从入门到进阶吐血整理推荐书单
yingduo5775博客
02-20 439
前言：技术书阅读方法论 一.速读一遍（最好在1~2天内完成） 人的大脑记忆力有限，在一天内快速看完一本书会在大脑里留下深刻印象，对于之后复习以及总结都会有特别好的作用。 对于每一章的知识，先阅读标题，弄懂大概讲的是什么主题，再去快速看一遍，不懂也没有关系，但是一定要在不懂的地方做个记号，什么记号无所谓，但是要让自己后面再看的时候有个提醒的作用，看看第二次看有没有懂了些。 二.精读一遍（在2周内看完...
数据结构 算法 进阶篇
qq_51533426的博客
08-19 243
数据结构算法进阶
《算法和数据结构》题海战术篇
热门推荐
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
「算法与数据结构」从入门到进阶吐血整理推荐书单
墨鱼菜鸡
09-09 1326
一.入门系列 这些书籍通过图片、打比方等通俗易懂的方法来讲述，让你能达到懂一些基础算法，线性表，堆栈，队列，树，图，DP算法，背包问题等，不要求会实现，但是看过以下这些书对于之后实现算法打下坚实的思维基础。 很适合在闲暇之余拿出来阅读一番。 1.1 《啊哈！算法》 阅读链接：https://book.douban.com/s...
学算法先学数据结构？是否是无稽之谈？
英雄哪里出来
03-02 2万+
头发没了
如何学好算法与数据结构，从普通开发者到专家的进阶之路
一个8年大数据开发工程师的碎碎念
07-19 840
学习算法和数据结构是一个终身的过程。通过构建条件化知识,培养问题驱动的学习方法,深入源码,培养算法直觉,并保持持续学习的态度,我们可以逐步从普通开发者成长为算法专家。真正的专家不仅知道如何使用工具,更知道何时使用以及为什么使用。让我们一起在这条充满挑战和乐趣的道路上前进吧!
hello-algo-数据结构与算法-zh-csharp.pdf
01-24
本书《Hello 算法》是一本实用的数据结构与算法入门书，能够帮助读者快速掌握数据结构与算法的知识，提高编程能力和解决问题的能力。 知识点： 1. 数据结构的定义和分类 2. 数组、链表、栈、队列、树、图等数据...
数组与排序算法：从基础到进阶
07-03
《数组与排序算法：从基础到进阶》是一本全面深入探讨数组基础知识和各种排序算法的实用指南。本书旨在为读者提供一个系统化的学习路径，从数组的基本概念开始，逐步深入到复杂的排序算法，帮助读者建立扎实的算法...
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 1137
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 631
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 594
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 576
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 795
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 3495
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
字节跳动（社招）三面算法原题
宫水三叶的刷题日记
08-29 794
但当招聘市场"供过于求"的时候，为了不让招聘过程显得突兀（距离招聘截止日期还有很久，但人已招满），这时候通常会卡住一些流程，尽量拖时间，此时越到后面要求越高，希望越少。当我们有了所有排好序的候选边集合之后，我们可以对边进行从前往后处理，每次加入一条边之后，使用并查集来查询「起点」和「终点」是否连通（并查集部分）。所以，虽然目前某些字节跳动的 BU 已经开始拖流程，但在下半年，必然会有新业务大量招兵买马，抓紧准备吧各位。你每次可以往「上，下，左，右」四个方向之一移动，你想要找到耗费体力最小的一条路径。
【算法】深入浅出聚类算法：原理、应用与Java实现
一个不断前行的程序者
08-26 2065
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
树上dp+分组背包类问题
最新发布
2301_80475191的博客
08-29 411
今天也是无意间看到了一个树上dp+分组背包类的问题，有些难度的，不好想的嘞，话不多说直接看题。
河南萌新2024第二场
2301_80281705的博客
08-25 549
将用户名和对应信息set映射到map中: map< string ,set< string > > 方便了存储。给两个整数a和b，输出a∗b 但是a,b非常大，0
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

战族狼魂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值