qq_53198408的博客

原创 yolov5（ODConv改进）

【代码】yolov5（ODConv改进）

原创 kafka

kafka配置

原创 最近最少使用缓存(来源力扣)

运用所掌握的数据结构，设计和实现一个 LRU (Least Recently Used，最近最少使用) 缓存机制 。实现 LRUCache 类：LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限

原创 字符串中的所有变位词(来源力扣)

给定两个字符串 s 和 p，找到 s 中所有 p 的 变位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。 变位词 指字母相同，但排列不同的字符串。 示例 1： 输入: s = “cbaebabacd”, p = “abc” 输出: [0,6] 解释: 起始索引等于 0 的子串是 “cba”, 它是 “abc” 的变位词。 起始索引等于 6 的子串是 “bac”, 它是 “abc” 的变位词。 示例 2： 输入: s = “abab”, p = “ab” 输出: [0,1,2] 解释: 起始

原创 剑指 Offer II 003. 前 n 个数字二进制中 1 的个数(来源力扣)

给定一个非负整数 n ，请计算 0 到 n 之间的每个数字的二进制表示中 1 的个数，并输出一个数组。 示例 1: 输入: n = 2 输出: [0,1,1] 解释: 0 --> 0 1 --> 1 2 --> 10 示例 2: 输入: n = 5 输出: [0,1,1,2,1,2] 解释: 0 --> 0 1 --> 1 2 --> 10 3 --> 11 4 --> 100 5 --> 101 动态规划+位运算 当i是奇数时：dp[i] =

原创 为高尔夫比赛砍树(来源力扣)

思路： class Solution { int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; public int cutOffTree(List<List<Integer>> forest) { List<int[]> trees = new ArrayList<int[]>(); int row = forest.size(); int ...

原创 寻找右区间(来源力扣)

给你一个区间数组 intervals ，其中 intervals[i] = [starti, endi] ，且每个 starti 都 不同 。 区间 i 的 右侧区间 可以记作区间 j ，并满足 startj >= endi ，且 startj 最小化 。 返回一个由每个区间 i 的 右侧区间 在 intervals 中对应下标组成的数组。如果某个区间 i 不存在对应的 右侧区间 ，则下标 i 处的值设为 -1 。 示例 1： 输入：intervals = [[1,2]] 输出：[-1] 解释：集合

原创 最少移动次数使数组元素相等 II(来源力扣)

给你一个长度为 n 的整数数组 nums ，返回使所有数组元素相等需要的最少移动数。 在一步操作中，你可以使数组中的一个元素加 1 或者减 1 。 示例 1： 输入：nums = [1,2,3] 输出：2 解释： 只需要两步操作（每步操作指南使一个元素加 1 或减 1）： [1,2,3] => [2,2,3] => [2,2,2] 示例 2： 输入：nums = [1,10,2,9] 输出：16 思路：显然数组中每个数比较的对象是中间的数nums[n / 2]，得出中间的数，进而

原创 乘法表中第k小的数(来源力扣)

几乎每一个人都用 乘法表。但是你能在乘法表中快速找到第k小的数字吗？ 给定高度m 、宽度n 的一张 m * n的乘法表，以及正整数k，你需要返回表中第k 小的数字。 例 1： 输入: m = 3, n = 3, k = 5 输出: 3 解释: 乘法表: 1231\quad2\quad3123 2462\quad4\quad6246 3693\quad6\quad9369 第5小的数字是 3 (1, 2, 2, 3, 3). 其中第iii行小于等于k的个数为 min(⌊xi⌋,n)min(\lfloor

原创 电影评论文本分类

import tensorflow as tf from tensorflow import keras import numpy as np print(tf.__version__) imdb = keras.datasets.imdb (train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000) print("Training entries: {}, labels: {}".forma.

原创 验证外星语词典(来源力扣)

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。 给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。 示例 1： 输入：words = [“hello”,“leetcode”], order = “hlabcdefgijkmnopqrstuvwxyz” 输出：true 解释：在该语言的字母表中，‘h’ 位于 ‘l’ 之前，所以单词序列是按字

原创 最小覆盖子串(来源力扣)

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。 注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。 如果 s 中存在这样的子串，我们保证它是唯一的答案。 示例 1： 输入：s = “ADOBECODEBANC”, t = “ABC” 输出：“BANC” 示例 2： 输入：s = “a”, t = “a” 输出：“a” 示例 3: 输入: s = “a”

原创 滑动窗口最大值(来源力扣)

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。 用优先队列（大顶堆）来存储每一个窗口中的值，堆顶即为最大的元素，需要注意的有两点：优先队列的cell需要设计成数组，来存放每一个元素和其下标的对应，存元素是为了对窗口中的值进行排序；存下标是为了判断所取的堆顶元素是不是该窗口中的值，因为其有可能是窗口之前的值。 class Solution { public i

原创 基本计算器 II(来源力扣)

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。 整数除法仅保留整数部分。 你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。 注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。 示例 1： 输入：s = “3+2*2” 输出：7 示例 2： 输入：s = " 3/2 " 输出：1 示例 3： 输入：s = " 3+5 / 2 " 输出：5 class Solution { public in

原创 寻找重复数（来源力扣）

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。 假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。 你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。 示例 1： 输入：nums = [1,3,4,2,2] 输出：2 示例 2： 输入：nums = [3,1,3,4,2] 输出：3 思路（借鉴力扣）：本题的巧妙之处是用到了循环链表，快慢指针，如果数组中没有重复的数，以数

原创 环形链表 II(来源力扣)

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有

原创 生成对抗网路（GAN）：生成手写数字集MNIST

import tensorflow as tf print(tf.__version__) import glob import imageio import matplotlib.pyplot as plt import numpy as np import os import PIL from tensorflow.keras import layers import time from IPython import display (train_images, train_labels), (_,

原创 缺失的第一个正数(来源力扣)

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。 请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。 示例 1： 输入：nums = [1,2,0] 输出：3 示例 2： 输入：nums = [3,4,-1,1] 输出：2 本题的思路是将每个cell的值和该值对应的下标联系起来，cell的值<=0直接赋值nums.length+1，即不予考虑，接着遍历每一个cell并取其绝对值，满足cell的值<=nums.length则将该值对应的下标位置

原创 最长连续序列(来源力扣)

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。 示例 1： 输入：nums = [100,4,200,1,3,2] 输出：4 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。 示例 2： 输入：nums = [0,3,7,2,5,8,4,6,0,1] 输出：9 class Solution { public int longestConsecutive(int[

原创 谷粒商城部署

原创 生命游戏（来源力扣）

根据 百度百科 ， 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。 给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律： 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡； 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活； 如果活细胞周围八个.

原创 盛最多水的容器(来源力扣)

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 返回容器可以储存的最大水量。 说明：你不能倾斜容器。 输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。 这个思想太神奇了，l和r之间的范围代表着能作.

原创 四数相加 II(来源力扣)

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足： 0 <= i, j, k, l < n nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0 示例 1： 输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2] 输出：2 解释： 两个元组如下： (0, 0, 0, 1) -&g.

原创 Trie(字典树)

每个节点存储可以用哈希映射Map<Character, Trie> map， 也可以用数组Trie[] children class Trie { private Map<Character, Trie> map; private boolean endFlag; public Trie() { map = new HashMap<>(); endFlag = false; } publi

原创 SQL编程

#员工系列 #员工表 create table `employees` ( `emp_no` int(11) not null, `birth_data` date not null, `first_name` varchar(14) not null, `last_name` varchar(16) not null, `gender` char(1) not null, `hire_date` date not null, primary key (`

原创 两整数之和（来源力扣）

给你两个整数 a 和 b ，不使用 运算符 + 和 - ​​​​​​​，计算并返回两整数之和。 示例 1： 输入：a = 1, b = 2 输出：3 示例 2： 输入：a = 2, b = 3 输出：5 在不考虑进位的情况下，其无进位加法结果为a⊕b。 而所有需要进位的位为 a & b，进位后的进位结果为(a & b) << 1。 class Solution { public int getSum(int a, int b) { while(

原创 分数到小数(来源力扣)

给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以 字符串形式返回小数 。 如果小数部分为循环小数，则将循环的部分括在括号内。 如果存在多个答案，只需返回 任意一个 。 对于所有给定的输入，保证 答案字符串的长度小于 104 。 示例 1： 输入：numerator = 1, denominator = 2 输出：“0.5” 示例 3： 输入：numerator = 4, denominator = 333 输出：“0.(012)” class Solution

原创 基本分类：对服装图像进行分类（tensorflow）

# TensorFlow and tf.keras import tensorflow as tf from tensorflow import keras # Helper libraries import numpy as np import matplotlib.pyplot as plt print(tf.__version__) fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_i

原创 两数相除(来源力扣)

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 返回被除数 dividend 除以除数 divisor 得到的商。 整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2 示例 1: 输入: dividend = 10, divisor = 3 输出: 3 解释: 10/3 = truncate(3.33333…) = truncate(3)

原创 x 的平方根(来源力扣)

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。 示例 1： 输入：x = 4 输出：2 示例 2： 输入：x = 8 输出：2 解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。 class Solution { public int mySqrt(int x) {

原创 Pow(x, n)(来源力扣)

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即xnx^nxn ）。 示例 1： 输入：x = 2.00000, n = 10 输出：1024.00000 示例 3： 输入：x = 2.00000, n = -2 输出：0.25000 解释：2-2 = 1/22 = 1/4 = 0.25 注意：n需要换成long型，当−231-2^{31}−231转换成整数时，int型会溢出。 方法一：（快速幂+递归） class Solution { public double myPow(d

原创 墨墨背单词

原创 阶乘后的零（来源力扣）

给定一个整数 n ，返回 n! 结果中尾随零的数量。 提示 n! = n * (n - 1) * (n - 2) * … * 3 * 2 * 1 进阶：你可以设计并实现对数时间复杂度的算法来解决此问题吗？ 思路： 尾数0由因子5和2构成，显然因子5的个数少于2，所以只需考虑n！中因子5的个数。 class Solution { public int trailingZeroes(int n) { int sum = 0; while(n != 0) {

原创 快乐数（来源力扣）

编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为： 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。 示例 1： 输入：n = 19 输出：true 解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1 方法一：

原创 常数时间插入、删除和获取随机元素（来源力扣）

实现RandomizedSet 类： RandomizedSet() 初始化 RandomizedSet 对象 bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。 bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。 int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概.

原创 最长递增子序列（来源力扣）

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：nums = [7,7,7,7,

原创 零钱兑换(来源力扣)

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。 你可以认为每种硬币的数量是无限的。 示例 1： 输入：coins = [1, 2, 5], amount = 11 输出：3 解释：11 = 5 + 5 + 1 示例 2： 输入：coins = [2], amount = 3 输出：-1 假设dp[i]为组成金额i所需最少的硬币数量，假设dp[i]之前

原创 跳跃游戏（来源力扣）

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标。 示例 1： 输入：nums = [2,3,1,1,4] 输出：true 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。 示例 2： 输入：nums = [3,2,1,0,4] 输出：false 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下

原创 搜索二维矩阵 II(来源力扣)

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性： 每行的元素从左到右升序排列。 每列的元素从上到下升序排列。 一种方法是遍历完所有的数进行判断，但时间复杂度不能接受；另一种方法是对每一行进行二分查找，但时间复杂度仍很高（O（mlogn））； 要充分利用行和列都是递增的条件，则考虑从左下角开始搜索（从右上角同理）： 若matrix[x][y] == target 则返回； 若matrix[x][y] > target 则x–，去上一行搜索，

原创 xdm进来看看

http://http://124.222.191.66/