怒刷LeetCode的第14天（Java版）

news2024/11/23 7:38:05

目录

第一题

题目来源

题目内容

解决方法

方法一：动态规划

方法二：栈

方法三：双指针

第二题

题目来源

题目内容

解决方法

方法一：二分查找

方法二：线性扫描

方法三：递归

第三题

题目来源

题目内容

解决方法

方法一：二分查找

方法二：线性扫描

方法三：双指针

第一题

题目来源

32. 最长有效括号 - 力扣（LeetCode）

题目内容

解决方法

方法一：动态规划

  1. 创建一个长度为 n 的数组 dp，用于保存以当前字符结尾的最长有效括号子串的长度。
  2. 初始化 dp 数组的所有元素为 0。
  3. 遍历字符串 s 的每个字符：
    • 如果当前字符是 (，则直接跳过。
    • 如果当前字符是 )，则判断前一个字符是否是 (：
      • 如果前一个字符是 (，则更新 dp[i] = dp[i-2] + 2，表示以当前字符结尾的最长有效括号子串长度为前一个字符结尾的最长有效括号子串长度加上当前的两个括号。
      • 如果前一个字符是 )，则判断前一个字符结尾的最长有效括号子串之前的字符是否是 (，即判断 i-dp[i-1]-1 位置的字符是否是 (：
        • 如果是 (，则更新 dp[i] = dp[i-1] + dp[i-dp[i-1]-2] + 2，表示以当前字符结尾的最长有效括号子串长度为前一个字符结尾的最长有效括号子串长度加上前一个字符结尾的最长有效括号子串之前的最长有效括号子串长度加上当前的两个括号。
  4. 遍历完整个字符串后，找出 dp 数组中的最大值，即为最长有效括号子串的长度。
public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        
        int n = s.length();
        int[] dp = new int[n];
        int maxLen = 0;
        
        for (int i = 1; i < n; i++) {
            if (s.charAt(i) == ')') {
                if (s.charAt(i - 1) == '(') {
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
                } else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
                    dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxLen = Math.max(maxLen, dp[i]);
            }
        }
        
        return maxLen;
    }
}

复杂度分析：

时间复杂度：

  • 遍历字符串 s 的每个字符需要 O(n) 的时间。
  • 在每个字符上，我们都进行了常数次的比较和更新操作。
  • 因此，总体上，时间复杂度为 O(n)。

空间复杂度：

  • 我们使用了一个长度为 n 的数组 dp 来保存以当前字符结尾的最长有效括号子串的长度。
  • 因此，空间复杂度为 O(n)。

综合起来，该解法的时间复杂度为 O(n)，空间复杂度为 O(n)。

注意：对于这个特定的问题，在给定的限制条件下（0 <= s.length <= 3 * 10^4），这个解法是高效且可行的。

LeetCode运行结果：

方法二：栈

该方法的思路如下：

  • 首先，我们使用一个栈来保存括号的索引位置。
  • 初始化栈，将一个特殊的值 -1 放入栈中。
  • 遍历字符串 s 的每个字符：
    • 如果遇到左括号 (，将其索引位置压入栈中。
    • 如果遇到右括号 )，弹出栈顶元素，表示当前右括号匹配了一个左括号。
      • 如果栈为空，将当前右括号的索引位置压入栈中，作为一个新的起点。
      • 如果栈不为空，计算当前有效括号子串的长度，更新最大长度。
  • 最后，返回最大长度即可。
import java.util.Stack;

public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        
        int maxLen = 0;
        Stack<Integer> stack = new Stack<>();
        stack.push(-1);
        
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            
            if (c == '(') {
                stack.push(i);
            } else {
                stack.pop();
                
                if (stack.isEmpty()) {
                    stack.push(i);
                } else {
                    maxLen = Math.max(maxLen, i - stack.peek());
                }
            }
        }
        
        return maxLen;
    }
}

复杂度分析：

时间复杂度：

  • 遍历字符串 s 的每个字符需要 O(n) 的时间。
  • 在每个字符上，我们进行了常数次的栈操作（压栈和弹栈）。
  • 因此，总体上，时间复杂度为 O(n)。

空间复杂度：

  • 我们使用了一个栈来保存括号的索引位置。
  • 在最坏情况下，当所有字符都是左括号时，栈的大小为 n。
  • 因此，空间复杂度为 O(n)。

综合起来，该方法的时间复杂度为 O(n)，空间复杂度为 O(n)。

LeetCode运行结果：

方法三：双指针

除了动态规划和栈，还有一种双指针的方法来解决最长有效括号问题。

这种方法的思路如下：

  • 从左到右遍历字符串，统计左右括号的数量。
  • 如果左右括号数量相等，则更新最大长度。
  • 如果右括号数量大于左括号数量，则重置左右括号数量为0。
  • 然后从右到左再进行一次相同的操作。
public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        
        int left = 0; // 左括号数量
        int right = 0; // 右括号数量
        int maxLen = 0; // 最大长度
        
        // 从左到右遍历
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(') {
                left++;
            } else {
                right++;
            }
            
            // 如果左括号数量等于右括号数量，则计算当前有效括号子串的长度
            if (left == right) {
                maxLen = Math.max(maxLen, right * 2);
            } else if (right > left) { // 右括号数量大于左括号数量，重置左右括号数量为0
                left = 0;
                right = 0;
            }
        }
        
        left = 0;
        right = 0;
        
        // 从右到左遍历
        for (int i = s.length() - 1; i >= 0; i--) {
            char c = s.charAt(i);
            if (c == ')') {
                right++;
            } else {
                left++;
            }
            
            // 如果左括号数量等于右括号数量，则计算当前有效括号子串的长度
            if (left == right) {
                maxLen = Math.max(maxLen, left * 2);
            } else if (left > right) { // 左括号数量大于右括号数量，重置左右括号数量为0
                left = 0;
                right = 0;
            }
        }
        
        return maxLen;
    }
}

复杂度分析：

时间复杂度：

  • 遍历字符串 s 的每个字符需要 O(n) 的时间。
  • 在第一次从左到右遍历中，我们进行了常数次的操作，不会产生额外的时间复杂度。
  • 在第二次从右到左遍历中，同样也进行了常数次的操作。
  • 因此，总体上，时间复杂度为 O(n)。

空间复杂度：

  • 我们只使用了常数个变量来保存左右括号的数量和最大长度，没有使用额外的数据结构。
  • 因此，空间复杂度为 O(1)。

综合起来，该方法的时间复杂度为 O(n)，空间复杂度为 O(1)。

LeetCode运行结果：

第二题

题目来源

33. 搜索旋转排序数组 - 力扣（LeetCode）

题目内容

解决方法

方法一：二分查找

使用二分查找的思想，通过判断左右半边哪一边是有序的来决定向哪边继续查找。具体步骤如下：

  1. 初始化左指针 left 为数组的第一个元素的索引，右指针 right 为数组最后一个元素的索引。
  2. 在每次循环中，计算中间元素的索引 mid。
  3. 如果中间元素等于目标值，则返回 mid。
  4. 判断左半边是否有序（即 nums[left] <= nums[mid]）：
    • 如果目标值在左半边的有序范围内，则将右指针 right 移动到 mid - 1，继续在左半边查找。
    • 否则，将左指针 left 移动到 mid + 1，继续在右半边查找。
  5. 如果左半边不是有序的，则右半边一定是有序的。判断目标值是否在右半边的有序范围内：
    • 如果是，则将左指针 left 移动到 mid + 1，继续在右半边查找。
    • 否则，将右指针 right 移动到 mid - 1，继续在左半边查找。
  6. 如果循环结束仍未找到目标值，则返回 -1。
public class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        int left = 0;
        int right = nums.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (nums[mid] == target) {
                return mid;
            }
            
            if (nums[left] <= nums[mid]) { // 左半边有序
                if (target >= nums[left] && target < nums[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else { // 右半边有序
                if (target > nums[mid] && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        
        return -1;
    }
}

复杂度分析：

  • 该算法的时间复杂度为O(log n)，其中n是数组的长度。在每次循环中，都将搜索范围缩小一半，所以总共最多需要进行log n次循环。因此，算法的时间复杂度为O(log n)。
  • 空间复杂度为O(1)，因为算法只使用了有限的额外空间来存储指针和常量。

总结起来，该算法具有较低的时间复杂度和空间复杂度，能够高效地解决搜索旋转排序数组的问题。

LeetCode运行结果：

方法二：线性扫描

除了二分查找的方法，还可以使用线性扫描的方法来搜索旋转排序数组。

该算法从数组的第一个元素开始，依次遍历数组中的每个元素，如果找到目标值，则返回其索引；如果遍历结束仍未找到目标值，则返回-1。

public class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                return i;
            }
        }
        
        return -1;
    }
}

复杂度分析：

  • 线性扫描算法的时间复杂度为O(n)，其中n是数组的长度。算法需要遍历整个数组来查找目标值，因此最坏情况下需要执行n次比较操作。
  • 空间复杂度为O(1)，因为算法没有使用额外的空间，只需常数级别的额外空间。

相对于二分查找算法的O(log n)时间复杂度，线性扫描算法的时间复杂度较高。但在某些特定场景或者输入规模较小的情况下，线性扫描算法也可以快速解决问题。

综上所述，线性扫描算法适用于简单的问题或者规模较小的数据集，但在更大规模的数据集上，二分查找算法通常更具优势。

LeetCode运行结果：

方法三：递归

除了二分查找和线性扫描的方法，还可以使用递归的方法来搜索旋转排序数组。

该算法与二分查找算法类似，也是通过判断左右半边哪一边是有序的来决定向哪边继续查找。不同之处在于，该算法使用递归的方式实现，将数组的搜索范围不断缩小。

  1. 算法首先检查数组是否为空或者长度为0，如果是，则返回-1。然后调用递归函数 search 进行搜索，传入参数 nums 数组、目标值 target、搜索范围的左右端点索引 left 和 right。
  2. 在递归函数中，首先判断搜索范围是否合法，如果不合法，则返回-1。然后计算中间元素索引 mid。如果中间元素等于目标值，则返回 mid。
  3. 接着判断左半边是否有序（即 nums[left] <= nums[mid]）。如果是，则判断目标值是否在左半边的有序范围内。如果是，则继续在左半边递归查找；否则，在右半边递归查找。
  4. 如果左半边不是有序的，则右半边一定是有序的。判断目标值是否在右半边的有序范围内。如果是，则在右半边递归查找；否则，在左半边递归查找。
  5. 最后，如果循环结束仍未找到目标值，则返回-1。
public class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        return search(nums, target, 0, nums.length - 1);
    }
    
    private int search(int[] nums, int target, int left, int right) {
        if (left > right) {
            return -1;
        }
        
        int mid = left + (right - left) / 2;
        
        if (nums[mid] == target) {
            return mid;
        }
        
        if (nums[left] <= nums[mid]) { // 左半边有序
            if (target >= nums[left] && target < nums[mid]) {
                return search(nums, target, left, mid - 1);
            } else {
                return search(nums, target, mid + 1, right);
            }
        } else { // 右半边有序
            if (target > nums[mid] && target <= nums[right]) {
                return search(nums, target, mid + 1, right);
            } else {
                return search(nums, target, left, mid - 1);
            }
        }
    }
}

复杂度分析：

时间复杂度：

  • 最好情况下，数组是完全有序的，每次都能通过比较找到目标值，时间复杂度为 O(log n)。
  • 最坏情况下，每次都只能排除一个元素，需要遍历整个数组，时间复杂度为 O(n)。
  • 平均情况下，假设数组中大致一半是有序的，一半是无序的，时间复杂度介于 O(log n) 和 O(n) 之间。

空间复杂度：

  • 每次递归调用会在栈上保存一些临时变量和返回地址，最大递归深度为 log n，因此空间复杂度为 O(log n)。

综合考虑，递归搜索旋转排序数组的算法在最坏情况下的时间复杂度为 O(n)，空间复杂度为 O(log n)。但如果数组是近似有序的或者目标值位于有序部分内，时间复杂度可以接近 O(log n)，效率较高。

需要注意的是，递归算法和二分查找算法类似，但由于需要额外的栈空间，因此可能会更慢。在处理超大规模数据时，可能会导致栈溢出问题。

LeetCode运行结果：

第三题

题目来源

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

题目内容

解决方法

方法一：二分查找

  1. 首先，我们定义一个长度为2的整数数组 result，并初始化为 {-1, -1}。这个数组表示目标值的开始位置和结束位置。
  2. 然后，我们使用两个辅助函数 findLeft 和 findRight 来分别查找目标值的开始位置和结束位置。
  3. 在 findLeft 函数中，我们使用二分查找来搜索目标值的开始位置。初始时，左边界 left 指向数组的第一个元素，右边界 right 指向数组的最后一个元素。在每次循环中，计算中间元素索引 mid，并将它与目标值进行比较。如果中间元素大于或等于目标值，则将右边界 right 缩小为 mid；否则，将左边界 left 扩大为 mid + 1。最后，返回 left 的值作为目标值的开始位置。如果目标值不存在，则返回 -1。
  4. 在 findRight 函数中，我们同样使用二分查找来搜索目标值的结束位置。不过这次的二分查找稍有不同。初始时，左边界 left 指向数组的第一个元素，右边界 right 指向数组的最后一个元素。在每次循环中，计算中间元素索引 mid，并将它与目标值进行比较。如果中间元素小于或等于目标值，则将左边界 left 扩大为 mid；否则，将右边界 right 缩小为 mid - 1。最后，返回 left 的值作为目标值的结束位置。如果目标值不存在，则返回 -1。
  5. 最后，在主函数 searchRange 中，我们首先判断特殊情况，即数组为空或长度为0的情况，直接返回初始化好的 result 数组。
  6. 然后，我们通过调用辅助函数 findLeft 和 findRight 分别得到目标值的开始位置和结束位置，并将它们存储在 result 数组中。
  7. 最后，返回 result 数组作为结果。
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        int leftIndex = findLeft(nums, target);
        int rightIndex = findRight(nums, target);
        
        if (leftIndex <= rightIndex) {
            result[0] = leftIndex;
            result[1] = rightIndex;
        }
        
        return result;
    }
    
    private int findLeft(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left < right) {
            int mid = left + (right - left) / 2;
            
            if (nums[mid] >= target) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        
        return nums[left] == target ? left : -1;
    }
    
    private int findRight(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left < right) {
            int mid = left + (right - left) / 2 + 1;
            
            if (nums[mid] <= target) {
                left = mid;
            } else {
                right = mid - 1;
            }
        }
        
        return nums[left] == target ? left : -1;
    }
}

复杂度分析：

  • 时间复杂度：O(log n)。每次迭代都将搜索空间减半，因此时间复杂度为对数级别。
  • 空间复杂度：O(1)。仅使用了有限的额外空间来存储几个变量。

LeetCode运行结果：

方法二：线性扫描

除了二分查找，还可以使用线性扫描的方法来搜索排序数组中目标值的开始位置和结束位置。

  1. 我们首先遍历整个数组来查找目标值的开始位置。如果找到目标值，我们将其索引存储在 result[0] 中并立即退出循环。如果没有找到目标值，则 result[0] 保持为初始值 -1。
  2. 接着，我们再从数组的末尾开始向前遍历，查找目标值的结束位置。如果找到目标值，我们将其索引存储在 result[1] 中并立即退出循环。如果没有找到目标值，则 result[1] 保持为初始值 -1。
  3. 最后，我们返回存储了目标值开始位置和结束位置的 result 数组。
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                result[0] = i;
                break;
            }
        }
        
        if (result[0] != -1) {
            for (int j = nums.length - 1; j >= 0; j--) {
                if (nums[j] == target) {
                    result[1] = j;
                    break;
                }
            }
        }
        
        return result;
    }
}

复杂度分析：

  • 时间复杂度：O(n)。需要遍历整个数组，其中 n 是数组的长度。
  • 空间复杂度：O(1)。仅使用了有限的额外空间来存储几个变量。

因为二分查找的时间复杂度为 log n，而线性扫描的时间复杂度为 n，所以在数组较大且已排序的情况下，二分查找的性能更好。它减少了搜索空间的大小，使得平均查找次数更低。然而，在数组较小或未排序的情况下，线性扫描是一种简单有效的方法。

LeetCode运行结果：

方法三：双指针

除了二分查找和线性扫描，还有一种常用的方法是双指针法。这种方法适用于有序数组或部分有序数组，并且可以在 O(n) 的时间复杂度内找到目标值的开始位置和结束位置。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        int left = 0;
        int right = nums.length - 1;
        
        // 查找目标值的开始位置
        while (left <= right) {
            if (nums[left] == target && nums[right] == target) {
                result[0] = left;
                result[1] = right;
                break;
            }
            
            if (nums[left] < target) {
                left++;
            }
            
            if (nums[right] > target) {
                right--;
            }
        }
        
        return result;
    }
}

在上述代码中，我们使用两个指针 left 和 right 来标记搜索区间。通过不断更新指针的位置，我们可以确定目标值的开始位置和结束位置。

具体步骤如下：

  1. 初始化指针 left 和 right 分别指向数组的首尾元素。
  2. 当 left 指向的元素小于目标值时，将 left 向右移动一位。
  3. 当 right 指向的元素大于目标值时，将 right 向左移动一位。
  4. 如果 left 和 right 指向的元素都等于目标值，则找到了目标值的开始位置和结束位置。将结果存储在 result 数组中，并退出循环。
  5. 如果找不到目标值，则返回初始值为 -1 的 result 数组。

复杂度分析：

  • 使用双指针法的时间复杂度是 O(n)，其中 n 是数组的长度。在最坏的情况下，即目标值不在数组中或者目标值在数组中出现了 n 次，我们需要将指针 left 和 right 分别移动到数组的两端。因此，最多需要遍历整个数组一次，时间复杂度为 O(n)。
  • 空间复杂度是 O(1)，因为我们只需要使用有限的额外变量来记录指针的位置和存储结果数组。

需要注意的是，双指针法适用于有序数组或部分有序数组，如果数组无序，则双指针法无法正确找到目标值的开始位置和结束位置。

LeetCode运行结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1035042.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【WSL】仅适用于装C盘情况-用WSL在win10安装LInux

【WSL】仅适用于装C盘情况-用WSL在win10安装LInux

研究了一点点伪分布式的内容。决定搞一个Linux系统玩一下 参考来自微软官方安装步骤&#xff1a; 旧版 WSL 的手动安装步骤 https://learn.microsoft.com/zh-cn/windows/wsl/install-manual WSL全称为&#xff0c;Windows Subsystem for Linux 法一&#xff1a;应用商店装 查…
阅读更多...
你写过的最蠢的代码是？

你写过的最蠢的代码是？

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页: &#x1f405;&#x1f43e;猫头虎的博客&#x1f390;《面试题大全专栏》 &#x1f995; 文章图文并茂&#x1f996…
阅读更多...
RestTemplate：简化HTTP请求的强大工具

RestTemplate：简化HTTP请求的强大工具

文章目录 什么是RestTemplateRestTemplate的作用代码示例 RestTemplate与HttpClient 什么是RestTemplate RestTemplate是一个在Java应用程序中发送RESTful HTTP请求的强大工具。本文将介绍RestTemplate的定义、作用以及与HttpClient的对比&#xff0c;以帮助读者更好地理解和使…
阅读更多...
资料分析笔记

资料分析笔记

统计术语 现期&#xff1a;现在的时间 基期&#xff1a;之前的时间 现期量 基期量 增长量&#xff08;有正负&#xff09; 增长率 【增幅、增速、r】&#xff08;有正负&#xff09; 同比&#xff1a;例&#xff1a;2014年5月 和 2013年5月 环比&#xff1a;例&#xff1a;20…
阅读更多...
Vue通过配置代理解决跨域问题

Vue通过配置代理解决跨域问题

VueCli2.0版本 1.找到config文件目录下的dev.env.js以及prod.env.js文件 dev.env.js是配置本地环境的 prod.env.js是配置正式环境的 分别在这两个文件下的API_URL中写下对应的正式服测试服域名 下面的是正式服的域名 2.配置跨域 //vue2.0 //config -> index.js proxyt…
阅读更多...
[C++ 网络协议] 多线程服务器端

[C++ 网络协议] 多线程服务器端

具有代表性的并发服务器端实现模型和方法&#xff1a; 多进程服务器&#xff1a;通过创建多个进程提供服务。 多路复用服务器&#xff1a;通过捆绑并统一管理I/O对象提供服务。 多线程服务器&#xff1a;通过生成与客户端等量的线程提供服务。✔ 目录 1. 线程的概念 1.1 为什…
阅读更多...
【MySQL】 MySQL索引事务

【MySQL】 MySQL索引事务

文章目录 &#x1f6eb;索引&#x1f38d;索引的概念&#x1f333;索引的作用&#x1f384;索引的使用场景&#x1f340;索引的使用&#x1f4cc;查看索引&#x1f4cc;创建索引&#x1f332;删除索引 &#x1f334;索引保存的数据结构&#x1f388;B树&#x1f388;B树&#x…
阅读更多...
【python】Seaborn画热力图，只显示第一行数字---seaborn与matplotlib版本问题

【python】Seaborn画热力图，只显示第一行数字---seaborn与matplotlib版本问题

github上有这个讨论&#xff1a;Heatmap only has annotation text in the top row only Issue #3478 mwaskom/seaborn (github.com)翻译过来就是&#xff1a;热图仅在最上面一行有注释文本&#xff1b; 原因就是matplotlib 在2023年9月更新到了 3.8.0版本&#xff0c;改变了…
阅读更多...
pyspark常用算子总结

pyspark常用算子总结

欢迎关注微信公众号&#xff0c;更多优质内容会在微信公众号首发 1. pyspark中时间格式的数据转换为字符串格式的时间&#xff0c;示例代码 from datetime import datetimedate_obj datetime(2023, 7, 2) formatted_date date_obj.strftime("%Y-%m-%d %H:%M:%S")p…
阅读更多...
Spring循环依赖大全

Spring循环依赖大全

本博客挑出出现大部分情况的循环依赖场景进行分析&#xff0c;分析启动会不会报循环依赖的错误&#xff01; 一、常规的A依赖B&#xff0c;B依赖A&#xff0c;代码如下&#xff1a; Component public class A {Resourceprivate B b; } Component public class B {Resourcepri…
阅读更多...
Codeforces Round 898 (Div. 4)

Codeforces Round 898 (Div. 4)

Dashboard - Codeforces Round 898 (Div. 4) - Codeforces F. Money Trees 双指针&#xff08;需要细心&#xff09; #include<bits/stdc.h> using namespace std; const int N 2e5 10; void solve() {int n, k, ans 0, a[N], h[N];cin >> n >> k;for(…
阅读更多...
Java基础（五）

Java基础（五）

前言&#xff1a;本博客主要记录学习网络通信的基本知识以及网络编程的应用。 网络编程 基本的通信架构 CS架构&#xff08;Cilent客户端/Server服务端&#xff09; BS架构&#xff08;Browser浏览器/Server服务端&#xff09; 网络通信三要素 网络通信三要素&#xff1a;…
阅读更多...
【02】FISCOBCOS搭建区块链网络

【02】FISCOBCOS搭建区块链网络

官方文档https://fisco-bcos-documentation.readthedocs.io/zh_CN/latest/docs/installation.html 第一步. 安装依赖 开发部署工具 build_chain.sh脚本依赖于openssl, curl&#xff0c;根据您使用的操作系统&#xff0c;使用以下命令安装依赖。 sudo apt install -y openssl …
阅读更多...
【深度学习实验】前馈神经网络（九）：整合训练、评估、预测过程（Runner）

【深度学习实验】前馈神经网络（九）：整合训练、评估、预测过程（Runner）

目录 一、实验介绍 二、实验环境 1. 配置虚拟环境 2. 库版本介绍 三、实验内容 0. 导入必要的工具包 1. __init__(初始化) 2. train(训练) 3. evaluate(评估) 4. predict(预测) 5. save_model 6. load_model 7. 代码整合 一、实验介绍 二、实验环境 本系列实验使用…
阅读更多...
latexocr安装过程中遇到的问题解决办法

latexocr安装过程中遇到的问题解决办法

环境要求&#xff1a;需要Python版本3.7&#xff0c;并安装相应依赖文件 具体的详细安装步骤可见我上次写的博文&#xff1a;Mathpix替代者|科研人必备公式识别插件|latexocr安装教程 ‘latexocr‘ 不是内部或外部命令&#xff0c;也不是可运行的程序或批处理文件的相关解决办…
阅读更多...
获取文件创建时间

获取文件创建时间

版权声明 本文原创作者&#xff1a;谷哥的小弟作者博客地址&#xff1a;http://blog.csdn.net/lfdfhl Java源码 public void testGetFileTime() {try {String string "E://test.txt";File file new File(string);Path path file.toPath();BasicFileAttributes ba…
阅读更多...
Python 运行代码

Python 运行代码

一、Python运行代码 可以使用三种方式运行Python&#xff0c;如下&#xff1a; 1、交互式 通过命令行窗口进入 Python 并开始在交互式解释器中开始编写 Python 代码 2、命令行脚本 可以把代码放到文件中&#xff0c;通过python 文件名.py命令执行代码&#xff0c;如下&#xff…
阅读更多...
Grafana离线安装部署以及插件安装

Grafana离线安装部署以及插件安装

Grafana是一个可视化面板&#xff08;Dashboard&#xff09;&#xff0c;有着非常漂亮的图表和布局展示&#xff0c;功能齐全的度量仪表盘和图形编辑器&#xff0c;支持Graphite、zabbix、InfluxDB、Prometheus和OpenTSDB作为数据源。Grafana主要特性&#xff1a;灵活丰富的图形…
阅读更多...
Idea远程调试Linux服务器(和docker容器)中的Java服务,实测可用

Idea远程调试Linux服务器(和docker容器)中的Java服务,实测可用

目录 idea远程调试linux上的java服务 idea远程调试linux上docker中的java服务 本地配置 打开设置 添加Remote 环境:java1.8 idea远程调试linux上的java服务 在远程Linux服务器上启动Java应用程序时&#xff0c;请使用以下命令行选项启用调试&#xff1a; java -agentlib:…
阅读更多...
R3300L, Q7 ATV Android9固件

R3300L, Q7 ATV Android9固件

R3300L, Q7 ATV Android9固件 固件来源 https://www.znds.com/tv-1239603-1-1.html 之前在恩山上发布过1080p安卓6固件 https://www.right.com.cn/forum/thread-1761250-1-1.html, 这个固件的不足之处就是没有 Google Service Framework, 只能通过 Smart Youtube 之类的第三方…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023