非科班菜鸡算法学习记录 | 代码随想录算法训练营完结!

这俩月终于结束了233333,之后就是反复复习和背八股了吧,然后整整项目春招再投投投,感觉大部分题都有思路了但是做过的题也会没思路,还是要复习

总结

数组:

        双指针用的很多,一般一个指向遍历位置,另一个指向插入位置

链表:

        也是双指针比较多,注意可以创造一个dummy节点指向头节点,从dummy开始遍历会比较方便;环形链表位置是快慢指针,快走2慢走1,它们肯定会在慢没走完环的一圈时相遇,此时把慢指针放在头节点,两个指针同步走,相等的位置即环入口

哈希:

          unordered_map; unordered_set;解决字母异位词,几数之和等;去重常用set;map一般key保存值,value保存下标

栈和队列:

        有效的括号,栈和队列互相实现

二叉树:

        两种,迭代(层序)和递归(深度);迭代时是用一个队列保存节点,记录每层节点数size,当pop节点时,size--(到0时该层结束),并把他的左右孩子进入队列;

        递归:

  1. 确定递归函数的参数和返回值: 确定哪些参数是递归的过程中需要处理的,那么就在递归函数里加上这个参数, 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。

  2. 确定终止条件: 写完了递归算法, 运行的时候,经常会遇到栈溢出的错误,就是没写终止条件或者终止条件写的不对,操作系统也是用一个栈的结构来保存每一层递归的信息,如果递归没有终止,操作系统的内存栈必然就会溢出。

  3. 确定单层递归的逻辑: 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

回溯:

       三要素

        回溯函数模板返回值以及参数

        回溯函数终止条件

        回溯搜索的遍历过程



void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
        处理节点;
        backtracking(路径,选择列表); // 递归
        回溯,撤销处理结果
    }
}

贪心:

       没有套路,大概就是局部最优可以推到全局最优

动规:

  1. 确定dp数组(dp table)以及下标的含义

  2. 确定递推公式

  3. dp数组如何初始化

  4. 确定遍历顺序

  5. 举例推导dp数组

最重要的还是01背包和完全背包,是指有物品i,重量为weight[i],价值为value[i],装满这个背包所能得到的最大价值;dp[i][j]为取【0,i】物品时[重量为j]的最大价值;

       01: dp[i][j] =max( dp[i-1][j]  , dp[i-1][j-weight[i]] + value[i] ) // 不取i但重量为j的价值和取i重量为j的最大值

压成一维数组
                dp[j] =max( [j]  , dp[j-weight[i]] + value[i] )// 每一层的dp是由上一层的dp来的,所以只需要一维就可以了,注意第二层for要从后往前遍历,保证物品i只被放入一次!

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

  完全背包:

// 先遍历物品,再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

单调栈:

主要是用来找左右第一个比自己大或者比自己小的元素,还不熟练具体看之前每日总结

最后!感谢卡哥!也感谢能坚持下来的自己,至少秋招面对昨天还能挣扎一下不至于直接寄!

轻舟已过万重山!!!

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
下面是Python实现的FP-growth算法代码: ```python # 定义节点类 class FPNode: def __init__(self, item, count, parent): self.item = item self.count = count self.parent = parent self.children = {} self.next = None def increment(self, count): self.count += count def display(self, ind=1): print(' ' * ind, self.item, ' ', self.count) for child in self.children.values(): child.display(ind + 1) # 构建FP树 def build_tree(item_list, min_sup): item_counts = {} for trans in item_list: for item in trans: item_counts[item] = item_counts.get(item, 0) + 1 freq_items = set(item for item in item_counts if item_counts[item] >= min_sup) if len(freq_items) == 0: return None, None for item in item_counts: if item not in freq_items: del item_counts[item] root = FPNode(None, None, None) for trans in item_list: sorted_items = [item for item in trans if item in freq_items] sorted_items.sort(key=lambda item: item_counts[item], reverse=True) if len(sorted_items) > 0: insert_tree(sorted_items, root, item_counts, 1) return root, item_counts def insert_tree(items, node, item_counts, count): if items[0] not in node.children: node.children[items[0]] = FPNode(items[0], 0, node) if item_counts is not None: item_counts[items[0]] += 1 child_node = node.children[items[0]] child_node.increment(count) if len(items) > 1: insert_tree(items[1:], child_node, item_counts, count) # 构建条件模式基 def get_paths(node): path = [] while node is not None: path.append(node) node = node.parent path.reverse() return path def find_prefix_path(base_path, node): cond_paths = [] while node is not None: if node.item is not None: path = get_paths(node) if len(path) > 1: cond_paths.append(path[1:] + base_path) node = node.next return cond_paths def mine_tree(root, item_counts, min_sup, pre_fix, freq_item_list): for item, count in item_counts.items(): new_freq_set = pre_fix.copy() new_freq_set.add(item) freq_item_list.append(new_freq_set) cond_pattern_bases = find_prefix_path(pre_fix, root.children[item]) cond_tree, cond_item_counts = build_tree(cond_pattern_bases, min_sup) if cond_item_counts is not None: mine_tree(cond_tree, cond_item_counts, min_sup, new_freq_set, freq_item_list) # 主函数 def fpgrowth(item_list, min_sup): root, item_counts = build_tree(item_list, min_sup) freq_item_list = [] mine_tree(root, item_counts, min_sup, set(), freq_item_list) return freq_item_list ``` 使用示例: ```python item_list = [['A', 'B', 'C', 'E'], ['B', 'D', 'E'], ['A', 'B', 'C', 'D'], ['A', 'B', 'D', 'E']] result = fpgrowth(item_list, 2) print(result) ``` 输出结果: ``` [{'B'}, {'B', 'E'}, {'B', 'D'}, {'A', 'B'}, {'A', 'B', 'C'}, {'A', 'B', 'D'}, {'A', 'B', 'C', 'E'}, {'A', 'B', 'D', 'E'}, {'C'}, {'C', 'A'}, {'E'}, {'D'}, {'D', 'E'}, {'C', 'A', 'B'}, {'C', 'A', 'B', 'E'}, {'C', 'A', 'B', 'D'}, {'C', 'B'}, {'C', 'B', 'E'}, {'C', 'B', 'D'}, {'C', 'A', 'B', 'D', 'E'}, {'C', 'A', 'B', 'E', 'D'}] ``` 其中,`item_list`表示数据集,`min_sup`表示最小支持度阈值,输出结果为频繁项集的列表。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值