Ealiser-CSDN博客

原创 Linux环境下，Nginx+Naocs远程访问碰到的若干问题

我有很长时间都在思考是不是我的电脑与服务器之间的连接有问题，但是明明能ping通端口也打开了，我一度以为闹鬼了。，该项目中需要的是1111(Nginx)端口，3333、4444、5555（Nacos）端口，要么就关闭防火墙，要么就依次开启各个端口。配置正确的情况下，尝试换一个正常网站如百度进行跳转测试，我这里是跳转通过了。所以我去**/nacos/conf/cluster.conf查看了我的配置**，进行了修改，直接成功，具体如下。，启动成功后我尝试了一下直接进入，但是仍然无法进入。

2023-07-16 23:17:18 526

原创 LeetCode第309题最佳买卖股票时机含冷冻期

算法动态规划核心思想1）做了几个动态方程的题，觉得第一步是先找当前有哪几种状态。在本题中，共分为三种状态：（1）不持有：有两种情况导致不持有①i-1天不持有股票；②i-1天有股票且当天出货（2）持有：①昨天持有股票；②今天买入前提是昨天没出货（3）不持有因为当天出货，此状态两个目的：满足（1）不持有状态下第二种情况；确保昨天没有出货。2）接着确定初始状态： dp[0][0] = 0; dp[0][1] = -1 * prices[0]; dp.

2022-05-03 11:22:47 254

原创 LeetCode第669题修剪二叉搜索树

算法深度优先搜索核心思想主要还是如何减枝比较重要。代码class Solution { public TreeNode trimBST(TreeNode root, int low, int high) { if (root == null) return null; if(root.val > high || root.val < low) { root = del(root); root .

2022-04-25 11:08:48 1948

原创 LeetCode第114题二叉树展开为链表

算法核心思想代码class Solution { public void flatten(TreeNode root) { if (root == null) return; List<TreeNode> temp = new ArrayList<>(); dfs(root,temp); for (int i = 1; i < temp.size(); ++i) { ..

2022-04-16 11:51:03 2943

原创 LeetCode第113题路径总和II

算法回溯和深度优先搜索核心思想二叉树很适合用深度优先搜索去做，简单快捷。这道题值得注意点是必须从根到叶子，同时没必要减枝，减枝的条件也有点复杂。代码class Solution { List<List<Integer>> res = new LinkedList<>(); public List<List<Integer>> pathSum(TreeNode root, int targetSum) { .

2022-04-15 16:14:03 1835

原创 LeetCode第105题从前序与中序遍历序列构造二叉树

算法分治算法核心思想可以根据前序遍历找到每一颗树的根节点，将中序遍历分为两个部分，分别定义左子树方法和右子树方法。代码class Solution { int num = 0; public TreeNode buildTree(int[] preorder, int[] inorder) { TreeNode root = new TreeNode(preorder[0]); int i = 0; for(;i < in.

2022-04-15 08:31:28 2638

原创 LeetCode第102题二叉树的层序遍历

算法广度优先遍历核心思想代码class Solution { List<List<Integer>> res = new LinkedList<>(); public List<List<Integer>> levelOrder(TreeNode root) { if(root == null) return new LinkedList<>(); List<..

2022-04-11 16:00:59 924

原创 LeetCode第144.94.145题二叉树的三种遍历

算法回溯法、深度优先搜索核心思想三者在代码上的区别就是在哪里保存根的值。代码//先序遍历class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new LinkedList<>(); if(root == null) return res; dfs(root,res); .

2022-04-11 14:05:23 992

原创 LeetCode第22题括号生成

算法回溯法核心思想简单的回溯，这几天做了几个回溯的类型题，简单做个总结，不一定对，还需要验证：使用回溯的题目，基本和二叉树和图有关系，使用的方法很多事深度优先遍历。对于二叉树的题目做好画好一个二叉树，做好模拟，想好减枝的条件，操作即可。代码class Solution { List<String> res = new LinkedList<>(); public List<String> generateParenthesis(int n).

2022-04-07 14:15:29 1137

原创 LeetCode第200题岛屿数量

算法深度优先搜索核心思想简单的深度优先搜索，每次搜索就发现一个岛屿。这个解法是岛屿题的通解题。代码class Solution { public int numIslands(char[][] grid) { int nums = 0; int m = grid.length; int n = grid[0].length; for(int i = 0;i < m;++i){ for(int .

2022-04-06 15:50:54 1197

原创 LeetCode第51题八皇后问题

算法回溯核心思想八皇后问题是回溯的经典问题。首先建议把模板备好，照着模板开始写。List<Value> result;void backtrack(路径，选择列表）{if(满足结束条件){result.add(路径);return;}for(选择：选择列表）{做选择；backtrack(路径，选择列表)；撤销选择;}}此外，对于使用java做这个道题，需要考虑java的字符处理太复杂了，建议先使用数组，然后进行转换。另外U1S1，笔试碰到这种题大概率要GG，.

2022-04-05 16:07:21 1985

原创 LeetCode第46题全排列

算法回溯算法核心思想这是做的第一道回溯算法题目。回溯的主要是通过穷举解决组合问题，这种思想非常适合处理面试的问题。因为此方法虽然占有大量的时间复杂度，但是却能很快给出解答。给出一个回溯法的万能公式List<Value> result;void backtrack(路径，选择列表）{if(满足结束条件){result.add(路径);return;}for(选择：选择列表）{做选择；backtrack(路径，选择列表)；撤销选择;}}代码class So.

2022-04-04 16:39:02 738

原创 LeetCode第137题只出现一次的数字II

算法数学核心思想最开始想用桶排序的思路，但是JAVA数组的最长长度是31位，所以作罢。后来采用老办法，统计每个位置1的个数num & 1//确定最后一位是不是1res |= ans[31-i] % m;//复原位置代码class Solution { public int singleNumber(int[] nums) { int[] ans = new int[32]; for(int num:nums){ .

2022-04-02 15:31:44 1236

原创 LeetCode第338、191题比特位计数位1的个数

算法数学，逻辑与核心思想计算1比特数应该怎么做？Brian Kernighan 算法对于任意整数 xx，令 x=x & (x−1)，该运算将 xx 的二进制表示的最后一个 11 变成 00。因此，对 xx 重复该操作，直到 xx 变成 00，则操作次数即为 xx 的「一比特数」。针对第二题，只需要将while条件变为！=0即可while x > 0{int nums = 0;x = x &(x-1);nums++;}代码class Solution .

2022-04-01 13:06:09 891

原创 LeetCode第231题 2的幂

算法位运算核心思想两种思路①一种是直接左移，这里需要注意即便使用long型结构保存数据，1的左移32位仍然是负数，因为1是32位保存的数据.②第二种方法为考虑2的倍数的特点，必定是只存在一个2，所以令n与（n-1）进行逻辑与即可。代码class Solution { public boolean isPowerOfTwo(int n) { int x = 0; long temp = 0; while(temp <= n){ .

2022-04-01 10:39:52 1013

原创 LeetCode第268题丢失的数字

算法位运算 --> 异或核心思想异或专注于寻找缺少的数字或者出现一次的数，利用的是异或和。神奇，不知道原理。代码class Solution { public int missingNumber(int[] nums) { int xor = 0; int n = nums.length; for(int i = 0;i<n;i++){ xor ^= nums[i]; } .

2022-03-31 14:40:07 650

原创 LeetCode第367题有效的完全平方数

算法二分查找核心思想简单的二分查找问题。还是注意范围问题代码class Solution { public boolean isPerfectSquare(int num) { if(num == 1) return true; int left = 1; int right = num; while(left <= right){ int mid = left + (right - left.

2022-03-31 12:45:03 526

原创 LeetCode第278题第一个错误的版本

算法二分查找核心思想本文是很常见的寻找左边界的问题，直接往里套就可。值得说明的是二分查找求mid的方法，第一种方法存在溢出的问题，使用第一种方法要使用long类型数据，第二种方法不存在溢出的问题，可以直接用int类型。//第一种mid = (left+right)/2;//第二种mid = left+(right - left)/2代码public class Solution extends VersionControl { public int firstBadVe.

2022-03-31 10:58:38 466

原创 LeetCode第162题寻找峰值暨二分总结（1）

算法二分查找核心思想二分查找的边界问题代码class Solution { public int findPeakElement(int[] nums) { if(nums.length == 1) return 0; if(nums.length == 2) return nums[0] > nums[1] ? 0:1; int left = 0; int right = nums.length - 1; .

2022-03-30 14:46:00 1159

原创 LeetCode第611题有效三角形的个数

算法贪心，二分查找核心思想排序完成后，遍历a+b，找出所有符合a+b>c的值。代码class Solution { public int triangleNumber(int[] nums) { if(nums.length < 3) return 0; Arrays.sort(nums); int res = 0; for(int i = 0;i < nums.length;++i){ .

2022-03-29 18:40:41 625

原创 LeetCode第74题搜索二维矩阵

算法二分查找核心思想将整个过程分为两个部分，第一个部分为判定在哪行，然后对当前行进行二分查找。代码class Solution { public boolean searchMatrix(int[][] matrix, int target) { int m = matrix.length; int n = matrix[0].length; int webM = -1; for(int i = 0; i < m;.

2022-03-29 14:20:33 347

原创 LeetCode第33题搜索旋转排序数组

算法二分查找核心思想1）首先想到的是双指针，分别找到两个有序数列的起点，根据target与数字第一个数字对比，选择哪个指针移动。2)另外一个思路就是二分查找法。第一种效果更好。代码//方法一class Solution { public int search(int[] nums, int target) { if(nums.length == 1 && nums[0] == target) return 0; int first.

2022-03-29 13:54:49 1224

原创 LeetCode第34题在排序数组中查找元素的第一个和最后一个位置

算法递归、二分法核心思想最开始打算使用双指针的二分方法进行处理，结果发现没有办法解决找到第一个后，下一步界限的确定，压倒我这个思路的最后一根稻草是【1,1,1】，查找1.最后选择了递归法解决，觉得比较复杂的就是最后结果的迭代，我处理的不好。代码class Solution { public int[] search(int[] nums, int target,int left,int right){ System.out.println("left:"+left);.

2022-03-28 16:20:43 1113

原创 LeetCode第35题搜索插入位置

算法二分查找核心思想和二分查找，没有什么区别，注意当target大于mid的时候，更新位置加上left。代码class Solution { public int searchInsert(int[] nums, int target) { int left = 0; int right = nums.length - 1; while(left <= right){ int mid = left + (ri.

2022-03-28 13:02:33 371

原创 LeetCode第704题二分查找

算法递归核心思想LeetCode给的解答是利用双指针进行解题，感觉也不是太二分，我选择二分到底，用的递归。代码class Solution { public int search(int[] nums, int target) { int len = nums.length; int i = len / 2; int result = -1; if(target == nums[i]) return .

2022-03-28 12:12:58 809

原创 LeetCode第56题合并区间

算法贪心核心思想这道题类似于第452题用最少数量的箭引爆气球，不断扩大自己的边界，如果无法扩大就保存至结果中。代码class Solution { public int[][] merge(int[][] intervals) { if(intervals.length == 1) return intervals; Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0])).

2022-03-26 12:48:57 875

原创 LeetCode第134题加油站

算法贪心核心思想这道题第一反应就是计算差值，然后根据最大值进行选取起点。但是这里存在一个问题：选取最高点还是选取最长连续的起点，最后我选择暴力遍历。但是在每次油量为负数时，下次从当前位置的下一点开始。不然会超时。后来看了解析，发现大方向没有错误，问题出在了应该找最小值，如果最小值为小于0，则直接返回-1；不然就返回下一个位置。代码class Solution { public int canCompleteCircuit(int[] gas, int[] cost) { .

2022-03-26 10:29:37 855

原创 LeetCode第16题最接近的三数之和

算法双指针核心思想我们需要实现a1+a2+a3无限逼近target，所以整个公式可以换为sum = a1+a2+a3-target。最终实现sum无限逼近于0。我选择固定a1-target，然后令一个指针从a2开始，另一个指针从尾开始，不断筛选最小值。代码class Solution { public int threeSumClosest(int[] nums, int target) { if(nums.length == 3) return nums[0]+num.

2022-03-25 16:01:07 1121

原创 LeetCode第122题买卖股票的最佳时间II

算法贪心、动态规划核心思想只要挣钱我就买，两两做差，如果大于0，我就买，小于0我就留着。实际上总利润就是所有大于0的差值的和。代码class Solution { public int maxProfit(int[] prices) { int[] temp = new int[prices.length - 1]; int total = 0; for(int i = 1,j = 0;i < prices.length;i++,j.

2022-03-24 15:19:32 821

原创 LeetCode第376题摆动序列

算法贪心也可以用动态规划核心思想我主要采用的是贪心的做法，对于任意开始，如果前一组数是>，那后一组只要是<即可，不是就换下一个数。代码class Solution { public int wiggleMaxLength(int[] nums) { if(nums.length == 1) return 1; int total = 0; int sign = 0; for(int i = 1;i < n.

2022-03-24 14:40:16 866

原创 LeetCode第55题跳跃游戏

算法贪心核心思想根据当前数组a[i]的大小，对当前可以到达的位置（即小于i+a[i]）进行遍历，选择一个最大的作为下一步，但是这里注意一点是如果当前的点即便是最大的，但所能到达的范围也在（i+a[i]）的范围内。则应该选择另一个点。代码class Solution { public boolean canJump(int[] nums) { if(nums.length == 1) return true; if(nums[0] == 0) return.

2022-03-24 12:34:55 4302

原创 LeetCode第402题移掉K位数字

算法单调栈、贪心核心思想第一个数字a直接入栈，其他数字b与已经入栈的数字进行比较，如果b < a，则a出栈，直到①栈为空；②b >= a；③已经删除了k个数字.此外还存在三个特殊情况：①删除的数字少于k，则从末尾删除；②存在零，删掉；③序列为空，返回0.我采用的思路是贪心加递归，从前k个数中选择一个最小的(从这里开始错误，因为不保证在剩下的地方能找到其他小的），然后依次找其他数字。此这种方法还存在一个问题就是递归无法解决0的问题。代码class Solution { .

2022-03-23 21:48:33 227

原创 LeetCode第452题用最少数量的箭引爆气球

算法贪心核心思想整体思路就是不断修改射击的时间，在经过以起点为主的排序后，存在两个前提：前一组points0维必小于下一组points0维，以及同一组0维必小于1维。所以判定条件如下：//存在射击窗口期[start,end]//对于数组[x1,y1],[x2,y2],存在如下情况x2 >= y1 -> 更新start=x2,end=y2;x1 >= x2 >= y1 -> 更新start = x2;x1 > x2 > y2 > y1 -&g.

2022-03-23 13:39:13 430

原创 LeetCode第860题柠檬水找零

算法贪心核心思想用的sitch case，我以为会超出时间限制，没想到竟然过了。这道题我想有两个需要注意的点，记录不同零钱数目的数组长度为2即可，20的零钱没有意义；第二点是当使用的是20的零钱时，要优先使用10美刀，这里是贪心的使用。代码class Solution { public boolean lemonadeChange(int[] bills) { if(bills[0] == 10 || bills[0] == 20) return false; .

2022-03-22 15:31:59 85

原创 LeetCode第455题分发饼干

算法贪心核心思想挺经典的贪心法吧，小孩子只能吃一块饼干注意一下就行了。PS：我还重写了一下排序算法代码class Solution { public static void swap(int[] a, int i, int j){ int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } public static int[] se.

2022-03-22 15:12:20 1672

原创 LeetCode第11题盛最多水的容器

算法双指针、贪心核心思想这道题采用贪心的思想来做，贪心意为每一步都使当前利益最大化。最开始的想法是求出每一对之间的水量，然后从最大的水量的一组数中分别向左向右扩展，但是这个方法我没有通过数学证明出来。最终采用了别人的方法，同样是贪心，两个指针分别从头从尾开始，每次移动的是当前较小的板子，因为如果移动较大的板子存在变小的可能。这个代码也是写的精彩非常，给作者点赞代码class Solution { public int maxArea(int[] height) { .

2022-03-22 14:27:28 521

原创 LeetCode第977题有序数组的平方

算法双指针核心思想这道题其实最简单的思路是直接平方以后，找个排序算法一排就可以，可以直接用快排。但是如果要求使用时间复杂度O（n）的算法，那就不能用排序算法，因为即便是快排，时间复杂度也要O(nlogn)。所以要利用非递减顺序这一条件。整个数组在平方后以第一个出现的正数为界，前半部分为逆序，后半部分为正序。可以令第一个指针指向正数前面的数字，第二个指针指向第一个正数，依次比较，存入新的数组中。如果为全正数数组，直接返回；全负数数组，颠倒顺序返回。代码class Solution { .

2022-03-21 18:49:40 386

原创 LeetCode面试第16题部分排序

算法双指针核心思想不能用快排来做题，因为快排的指针无论从小到大还是从大到小所囊括的范围都存在一小部分多余的。采用双指针，分别从头从尾扫。头指针每次与当前最大的比较，碰到小的，便保存当前位置。代码class Solution { public int[] subSort(int[] array) { int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE; int len = ar.

2022-03-21 16:46:57 593

原创 LeetCode第75题颜色分类

思想堆排序核心算法要求为使用常数空间，则符合要求的有冒泡排序、选择排序、插入排序、希尔排序、堆排序。本次采用堆排序。因为限制为2，计数排序应该效果也不错。代码class Solution { public static void swap(int[] a, int i, int j){ int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } public voi.

2022-03-21 13:48:35 622

原创 LeetCode 第88题合并两个有序数组

算法双指针核心思想两个指针分别指向一个数组，挨个比较，较小的进入新数组。这一部分和归并排序的合并部分方法是一样的。代码class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { int[] temp = new int[nums1.length]; int i = 0,j = 0,k = 0; while(i != m &a.

2022-03-21 13:38:57 457

空空如也

空空如也