GreedySnaker的博客

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。两个相邻元素间的距离为 1 。LeetCode链接我们可以从左上->右下遍历一次, 更新左, 上的最近距离, 再从右下->左上遍历一次, 更新右, 下最近距class Solution {public: vector<vector<int>> updateMatrix(vector<vector<int&gt

超级洗衣机假设有 n 台超级洗衣机放在同一排上。开始的时候，每台洗衣机内可能有一定量的衣服，也可能是空的。在每一步操作中，你可以选择任意 m (1 <= m <= n) 台洗衣机，与此同时将每台洗衣机的一件衣服送到相邻的一台洗衣机。给定一个整数数组 machines 代表从左至右每台洗衣机中的衣物数量，请给出能让所有洗衣机中剩下的衣物的数量相等的 最少的操作步数 。如果不能使每台洗衣机中衣物的数量相等，则返回 -1 。class Solution {public: int fin

预测赢家给你一个整数数组 nums 。玩家 1 和玩家 2 基于这个数组设计了一个游戏。玩家 1 和玩家 2 轮流进行自己的回合，玩家 1 先手。开始时，两个玩家的初始分值都是 0 。每一回合，玩家从数组的任意一端取一个数字（即，nums[0] nums[nums.length - 1]），取到的数字将会从数组中移除（数组长度减 1 ）。玩家选中的数字将会加到他的得分上。当数组中没有剩余数字可取时，游戏结束。如果玩家 1 能成为赢家，返回 true 。如果两个玩家得分相等，同样认为玩家 1 是游戏的赢家，

火柴拼正方形你将得到一个整数数组 matchsticks ，其中 matchsticks[i] 是第 i 个火柴棒的长度。你要用 所有的火柴棍 拼成一个正方形。你 不能折断 任何一根火柴棒，但你可以把它们连在一起，而且每根火柴棒必须 使用一次 。如果你能使这个正方形，则返回 true ，否则返回 false 。回溯，根据先决条件判断出变长，轮询，不满足则剪枝，减少判断次数class Solution {public: bool makesquare(vector<int>&am

根据字符出现频率排序给定一个字符串 s ，根据字符出现的 频率 对其进行 降序排序 。一个字符出现的 频率 是它出现在字符串中的次数。返回 已排序的字符串 。如果有多个答案，返回其中任何一个。示例 1:输入: s = “tree”输出: “eert”解释: 'e’出现两次，'r’和’t’都只出现一次。因此’e’必须出现在’r’和’t’之前。此外，"eetr"也是一个有效的答案。LeetCode链接统计字符数量后排序，再重组字符串class Solution {public: s

无重叠区间给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。示例 1:输入: intervals = [[1,2],[2,3],[3,4],[1,3]]输出: 1解释: 移除 [1,3] 后，剩下的区间没有重叠。LeetCode链接class Solution {public: int eraseOverlapIntervals(vector<vector<i

根据身高重建队列假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。LeetCode链接class Solution

字符串解码给定一个经过编码的字符串，返回它解码后的字符串。编码规则为: k[encoded_string]，表示其中方括号内部，encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。LeetCode链接class Solution{public: string dec

摆动序列如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。LeetCode链接用两个值记录趋势变化，而且只需要序列长度class Solution {public: int wiggleMaxLength(vector<int>& nums) { int nSize = nums.size(); if (nS

两整数之和给你两个整数 a 和 b ，不使用 运算符 + 和 - ​​​​​​​，计算并返回两整数之和。LeetCpde链接(位运算)异或运算相当于不进位的加法class Solution {public: int getSum(int a, int b) { while (b != 0) { unsigned int carry = (unsigned int)(a & b) << 1;

验证二叉树的前序序列化LeetCode链接一个槽位可以被看作「当前二叉树中正在等待被节点填充」的那些位置。class Solution {public: bool isValidSerialization(string preorder) { int n = preorder.length(); int i = 0; int slots = 1;//槽位 while (i < n) {

奇偶链表给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。LeetCode链接class Solution {public: ListNode* oddEvenList(ListNode* head) { if(!head || !head->next)

零钱兑换给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。你可以认为每种硬币的数量是无限的。LeetCode链接class Solution {public: int coinChange(vector<int>& coins, int amount) { vector<int> res(

搜索二维矩阵编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：每行的元素从左到右升序排列。每列的元素从上到下升序排列。LeetCode链接class Solution {public: bool searchMatrix(vector<vector<int>>& matrix, int target) { int m = matrix.size(), n = matri

给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。LeetCode链接比较常规的写法，计数，筛选class Solution {public: vector<int> majorityElement(vector<int>& nums) { int n = nums.size(); int nLength = n / 3; vector<int> vecAns;

课程表你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。LeetCode链接

打家劫舍你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。示例 1：输入：[1,2,3,1]输出：4LeetCode链接很经典的斐波那契问题，可以去看看官方简介。class Solution {public: int rob(vector&lt

最大数给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。示例 1：输入：nums = [10,2]输出：“210”LeetCode链接string 已经由比较大小方法，我们需要的就是组合class Solution {public: string largestNumber(vector<int>& nums) { sort(nums.b

比较版本号给你两个版本号 version1 和 version2 ，请你比较它们。版本号由一个或多个修订号组成，各修订号由一个 ‘.’ 连接。每个修订号由 多位数字 组成，可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号

寻找旋转排序数组中的最小值在一个预先按照升序排列，经由1到n次旋转后的数组中寻找最小值二分查找，因为他是“有序的”class Solution {public: int findMin(vector<int>& nums) { int left = 0; int right = nums.size() - 1; int index= 0; while (left < right)

LRU 缓存简单说就是删除最久没有访问的节点我们需要一个有序链表来记录节点，单向链表也可以，就是还要记录前驱后驱等，双向的可以省去很多中间变量。//定义链表节点struct Node{ int key, val; Node* pHead, * pTail; Node() : key(-1), val(-1), pHead(nullptr), pTail(nullptr) {} Node(int _key, int _val) : key(_key), val(_va

克隆图LeetCode链接啥意思呢，就是把图遍历一遍，然后每个节点new一遍，顺序不变。主要是就是BFS和DFS.深度优先/*// Definition for a Node.class Node {public: int val; vector<Node*> neighbors; Node() { val = 0; neighbors = vector<Node*>(); } Node(int

二叉树的层序遍历用队列class Solution {public: vector<vector<int>> levelOrder(TreeNode* root) { vector<vector<int>> ret={}; if(root==NULL) { return ret; } queue<TreeNode*

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。LeetCode链接去链接上看，讲的很详细了class Solution {public: int numTrees(int n) { if( n == 0 || n == 1) { return 1; } vector<int> G

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。你应当保留两个分区中每个节点的初始相对位置。LeetCode链接维护两个链表，再组合。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr)

删除有序数组中的重复项 II给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素最多出现两次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。双指针class Solution {public: int removeDuplicates(vector<int>& nums) { int len = nums.size(); if (len &lt

给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。始终以斜杠 ‘/’ 开头。两个目录名之间必须只有一个斜杠 ‘/’ 。最后一个目录名（如果存在）不能 以 ‘/’ 结尾。此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 ‘.’ 或 ‘…’）。// istringstream 和getline一般真想不到class Solution {public: string simplifyP

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。刚开始想的是根据移动个数找出新头，新尾，直接链接。后面发现环形链表可以少用很多变量记录节点前驱与后驱。class Solution {public: ListNode* rotateRight(ListNode* head, int k) { //不符合条件或者节点只有一个 if (head == NULL || head->next == NULL || k ==

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。class Solution {public: vector<int> spiralOrder(vector<vector<int>>& matrix) { vector <int> ans; if (matrix.empty()) { return ans; /

给你一个非负整数数组 nums ，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。假设你总是可以到达数组的最后一个位置。示例 1:输入: nums = [2,3,1,1,4]输出: 2解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。 示例 2:输入: nums = [2,3,0,1,4]输出: 2LeetCode 链

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。LeetCode 链接先上下反转，再对角反转class Solution {public: void rotate(vector<vector<int>>& matrix) { int nSize = matrix.size();

实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。必须 原地 修改，只允许使用额外常数空间。Leetcode链接class Solution {public: void nextPermutation(vector<int>& nums) { if (nums.size() < 2) {

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。返回被除数 dividend 除以除数 divisor 得到的商。整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2Leetcode链接暴力搜索法升级，加大步长， 由线性逼近改为指数逼近class Solution {public: int divide(int dividen

K 个一组翻转链表给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。递归class Solution {public: ListNode* reverse(ListNode* headHead, ListNode* tailTail) { // 参数是头前和尾后 ListNode* pre = headHead->next;

两两交换链表中的节点给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), nex

环形链表给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode *detectCycle(List

最接近的三数之和给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。示例：输入：nums = [-1,2,1,-4], target = 1输出：2解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)和15题是一样的，三指针。代码有空再写...

三数之和给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。示例 1：输入：nums = [-1,0,1,2,-1,-4]输出：[[-1,-1,2],[-1,0,1]]示例 2：输入：nums = []输出：[]三指针class Solution {public: vector<vector<int>> threeSum(vector<in

整数转罗马数字罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。字符 数值I 1V 5X 10L 50C 100D 500M 1000给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。示例 1:输入: 3输出: “III”示例 2:输入: 4输出: “IV

盛最多水的容器给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。示例 1：height = [1,1]输出：1示例 2：输入：height = [4,3,2,1,4]输出：16示例 3：输入：height = [1,2,1]输出：2双指针逼近class Solution {public: