• 怒刷LeetCode的第6天（Java版）

    目录

    第一题

    题目来源

    题目内容

    解决方法

    方法一：哈希表

    方法二：逐个判断字符

    方法三：模拟减法

    第二题

    题目来源

    题目内容

    解决方法

    方法一：水平扫描法

    方法二：垂直扫描法

    方法三：分治法

    方法四：二分查找

    第三题

    题目来源

    题目内容

    解决方法

    方法一：双指针

    第一题

    题目来源

    13. 罗马数字转整数 - 力扣（LeetCode）

    题目内容

    解决方法

    方法一：哈希表

    根据题目要求，我们需要将给定的罗马数字转换成整数。根据题目中给出的规则，我们可以逐个字符判断并累加得到最终的整数表示。

    具体的步骤如下：

    • 初始化一个变量result为0，表示最终的整数结果。
    • 遍历给定的罗马数字字符串s，从左往右逐个字符判断：
    1. 如果当前字符的值比下一个字符的值小，则需要执行减法操作。根据题目中的特殊规则，可以判断当前字符的值是负数。将该负数加到result上，并跳过下一个字符。
    2. 否则，直接将当前字符的值加到result上。
    • 返回result作为最终的整数表示。
    1. class Solution {
    2.     public int romanToInt(String s) {
    3.     Map romanMap = new HashMap<>();
    4.     romanMap.put('I', 1);
    5.     romanMap.put('V', 5);
    6.     romanMap.put('X', 10);
    7.     romanMap.put('L', 50);
    8.     romanMap.put('C', 100);
    9.     romanMap.put('D', 500);
    10.     romanMap.put('M', 1000);
    11.  
    12.     int result = 0;
    13.     for (int i = 0; i < s.length(); i++) {
    14.         int value = romanMap.get(s.charAt(i));
    15.         if (i < s.length() - 1 && value < romanMap.get(s.charAt(i + 1))) {
    16.             result -= value;
    17.         } else {
    18.             result += value;
    19.         }
    20.     }
    21.  
    22.     return result;
    23. }
    24.  
    25. }

    复杂度分析：

    • 时间复杂度：O(n)，其中n是给定的罗马数字字符串的长度。遍历一次罗马数字字符串，每个字符只被访问一次。
    • 空间复杂度：O(1)。虽然我们使用了一个哈希表来存储罗马数字字符与对应的数值映射关系，但是由于罗马数字字符数量有限且固定，因此哈希表的大小是恒定不变的，可以视为常数级别的空间复杂度。除此之外，我们并没有使用任何额外的数据结构。

    LeetCode运行结果：

    方法二：逐个判断字符

    除了使用哈希表的方法，还可以使用逐个判断字符的方法来将罗马数字转换成整数。

    具体的步骤如下：

    1. 初始化一个变量result为0，表示最终的整数结果。

    2. 遍历给定的罗马数字字符串s，从左往右逐个字符判断：

      • 如果当前字符是'I'，并且下一个字符是'V'或'X'，则需要执行减法操作，将4或9加到result上，并跳过下一个字符。

      • 如果当前字符是'X'，并且下一个字符是'L'或'C'，则需要执行减法操作，将40或90加到result上，并跳过下一个字符。

      • 如果当前字符是'C'，并且下一个字符是'D'或'M'，则需要执行减法操作，将400或900加到result上，并跳过下一个字符。

      • 否则，直接将当前字符的值加到result上。

    3. 返回result作为最终的整数表示。

    1. class Solution {
    2.     public int romanToInt(String s) {
    3.     int result = 0;
    4.     for (int i = 0; i < s.length(); i++) {
    5.         char currentChar = s.charAt(i);
    6.         if (currentChar == 'I' && i < s.length() - 1 && (s.charAt(i + 1) == 'V' || s.charAt(i + 1) == 'X')) {
    7.             result -= 1;
    8.         } else if (currentChar == 'X' && i < s.length() - 1 && (s.charAt(i + 1) == 'L' || s.charAt(i + 1) == 'C')) {
    9.             result -= 10;
    10.         } else if (currentChar == 'C' && i < s.length() - 1 && (s.charAt(i + 1) == 'D' || s.charAt(i + 1) == 'M')) {
    11.             result -= 100;
    12.         } else {
    13.             switch (currentChar) {
    14.                 case 'I':
    15.                     result += 1;
    16.                     break;
    17.                 case 'V':
    18.                     result += 5;
    19.                     break;
    20.                 case 'X':
    21.                     result += 10;
    22.                     break;
    23.                 case 'L':
    24.                     result += 50;
    25.                     break;
    26.                 case 'C':
    27.                     result += 100;
    28.                     break;
    29.                 case 'D':
    30.                     result += 500;
    31.                     break;
    32.                 case 'M':
    33.                     result += 1000;
    34.                     break;
    35.                 default:
    36.                     break;
    37.             }
    38.         }
    39.     }
    40.  
    41.     return result;
    42. }
    43.  
    44. }

    该算法直接根据题目中的规则进行逐个字符判断，并计算最终的整数结果。时间复杂度为O(n)，其中n是给定的罗马数字字符串的长度。空间复杂度为O(1)。 

    LeetCode运行结果：

    方法三：模拟减法

    还有一种方法是基于模拟减法的思路来将罗马数字转换成整数。

    具体的步骤如下：

    1. 初始化一个变量result为0，表示最终的整数结果。

    2. 遍历给定的罗马数字字符串s，从左往右逐个字符判断：

      • 如果当前字符的值比前一个字符的值大，则需要执行减法操作。将两个字符对应的值进行减法操作，并将结果加到result上。注意，这里要通过减去两倍的前一个字符的值，来抵消之前被加上的值。

      • 否则，直接将当前字符的值加到result上。

    3. 返回result作为最终的整数表示。

    1. class Solution {
    2. public int romanToInt(String s) {
    3.     Map romanMap = new HashMap<>();
    4.     romanMap.put('I', 1);
    5.     romanMap.put('V', 5);
    6.     romanMap.put('X', 10);
    7.     romanMap.put('L', 50);
    8.     romanMap.put('C', 100);
    9.     romanMap.put('D', 500);
    10.     romanMap.put('M', 1000);
    11.  
    12.     int result = 0;
    13.     int prevValue = 0;
    14.     for (int i = 0; i < s.length(); i++) {
    15.         int value = romanMap.get(s.charAt(i));
    16.         if (value > prevValue) {
    17.             result += value - 2 * prevValue;
    18.         } else {
    19.             result += value;
    20.         }
    21.         prevValue = value;
    22.     }
    23.  
    24.     return result;
    25. }
    26.  
    27.  
    28. }

    该算法通过模拟减法的操作来计算最终的整数结果。时间复杂度为O(n)，其中n是给定的罗马数字字符串的长度。空间复杂度为O(1)。 

    LeetCode运行结果：

    第二题

    题目来源

    14. 最长公共前缀 - 力扣（LeetCode）

    题目内容

    解决方法

    方法一：水平扫描法

    可以使用水平扫描法来查找字符串数组中的最长公共前缀。

    具体的步骤如下：

    1、初始化一个空字符串prefix，表示最长公共前缀。

    2、如果输入的字符串数组为空或长度为0，则直接返回空字符串。

    3、遍历字符串数组中的第一个字符串strs[0]的每个字符：

    • 对于每个字符，遍历字符串数组中的其他字符串strs[i]，其中i从1到n-1（n是字符串数组的长度）。
    • 如果当前字符在其他字符串的相同位置上的字符不相等，或者其他字符串的长度小于等于当前位置，则表示不匹配，直接返回当前的公共前缀。
    • 否则，将当前字符添加到prefix中。

    4、返回prefix作为最长公共前缀。

    1. class Solution {
    2.     public String longestCommonPrefix(String[] strs) {
    3.     if (strs == null || strs.length == 0) {
    4.         return "";
    5.     }
    6.  
    7.     String prefix = strs[0];
    8.     for (int i = 1; i < strs.length; i++) {
    9.         while (strs[i].indexOf(prefix) != 0) {
    10.             prefix = prefix.substring(0, prefix.length() - 1);
    11.             if (prefix.isEmpty()) {
    12.                 return "";
    13.             }
    14.         }
    15.     }
    16.  
    17.     return prefix;
    18. }
    19.  
    20. }

    该算法通过逐个字符比较字符串数组中的字符串来查找最长公共前缀。时间复杂度为O(mn)，其中m是最长公共前缀的长度，n是字符串数组的长度。空间复杂度为O(1)。 

    LeetCode运行结果：

    方法二：垂直扫描法

    具体的步骤如下：

    1、如果输入的字符串数组为空或长度为0，则直接返回空字符串。

    2、遍历字符串数组中的每个字符的索引位置idx，从0到字符数组中最短字符串的长度-1：

    • 对于每个索引位置idx，遍历字符串数组中的每个字符串strs[i]，其中i从0到n-1（n是字符串数组的长度）。
    • 如果当前索引位置超过了当前字符串的长度，或者当前字符在其他字符串的相同位置上的字符不相等，则表示不匹配，直接返回当前的公共前缀。
    • 否则，将当前字符添加到最长公共前缀的末尾。

    3、返回最长公共前缀作为结果。

    1. class Solution {
    2. public String longestCommonPrefix(String[] strs) {
    3.     if (strs == null || strs.length == 0) {
    4.         return "";
    5.     }
    6.  
    7.     int minLength = getMinLength(strs);
    8.     StringBuilder prefix = new StringBuilder();
    9.     for (int idx = 0; idx < minLength; idx++) {
    10.         char currentChar = strs[0].charAt(idx);
    11.         for (int i = 1; i < strs.length; i++) {
    12.             if (strs[i].charAt(idx) != currentChar) {
    13.                 return prefix.toString();
    14.             }
    15.         }
    16.         prefix.append(currentChar);
    17.     }
    18.  
    19.     return prefix.toString();
    20. }
    21.  
    22. private int getMinLength(String[] strs) {
    23.     int minLength = Integer.MAX_VALUE;
    24.     for (String str : strs) {
    25.         minLength = Math.min(minLength, str.length());
    26.     }
    27.     return minLength;
    28. }
    29.  
    30.  
    31. }

    该算法通过逐个字符比较字符串数组中的字符串来查找最长公共前缀。时间复杂度为O(mn)，其中m是最短字符串的长度，n是字符串数组的长度。空间复杂度为O(1)。

    LeetCode运行结果：

    方法三：分治法

    具体的步骤如下：

    1. 如果输入的字符串数组为空或长度为0，则直接返回空字符串。
    2. 调用一个辅助函数longestCommonPrefixHelper，传入字符串数组和索引范围[0, n-1]（n是字符串数组的长度）。
    3. 在longestCommonPrefixHelper函数中，如果起始索引等于结束索引，则返回当前字符串作为最长公共前缀。
    4. 将索引范围划分为两半，分别调用longestCommonPrefixHelper函数来获取左半部分和右半部分的最长公共前缀。
    5. 对左半部分和右半部分的最长公共前缀进行比较，取两者的最长公共前缀作为结果。
    1. class Solution {
    2. public String longestCommonPrefix(String[] strs) {
    3.     if (strs == null || strs.length == 0) {
    4.         return "";
    5.     }
    6.  
    7.     return longestCommonPrefixHelper(strs, 0, strs.length - 1);
    8. }
    9.  
    10. private String longestCommonPrefixHelper(String[] strs, int start, int end) {
    11.     if (start == end) {
    12.         return strs[start];
    13.     }
    14.  
    15.     int mid = (start + end) / 2;
    16.     String leftPrefix = longestCommonPrefixHelper(strs, start, mid);
    17.     String rightPrefix = longestCommonPrefixHelper(strs, mid + 1, end);
    18.  
    19.     return commonPrefix(leftPrefix, rightPrefix);
    20. }
    21.  
    22. private String commonPrefix(String str1, String str2) {
    23.     int length = Math.min(str1.length(), str2.length());
    24.     int i = 0;
    25.     while (i < length && str1.charAt(i) == str2.charAt(i)) {
    26.         i++;
    27.     }
    28.     return str1.substring(0, i);
    29. }
    30.  
    31. }

    该算法使用递归地将字符串数组划分为更小的部分，最终求得最长公共前缀。时间复杂度为O(mnlogn)，其中m是字符串的平均长度，n是字符串数组的长度。空间复杂度为O(logn)，用于递归调用栈的额外空间。

    LeetCode运行结果：

    方法四：二分查找

    具体的步骤如下：

    1. 如果输入的字符串数组为空或长度为0，则直接返回空字符串。
    2. 将最短的字符串作为起始点，将最长的字符串作为终止点。
    3. 计算起始点和终止点的中点mid。
    4. 判断从起始点到中点的字符串是否都是其他字符串的公共前缀。如果是，则继续在右半部分查找；否则，在左半部分查找。
    5. 重复步骤3和步骤4，直到起始点和终止点相等或者起始点大于终止点。
    6. 返回起始点和终止点相等的字符串作为结果。
    1. class Solution {
    2. public String longestCommonPrefix(String[] strs) {
    3.     if (strs == null || strs.length == 0) {
    4.         return "";
    5.     }
    6.  
    7.     int minLength = getMinLength(strs);
    8.     int start = 0, end = minLength - 1;
    9.     while (start <= end) {
    10.         int mid = (start + end) / 2;
    11.         if (isCommonPrefix(strs, mid)) {
    12.             start = mid + 1;
    13.         } else {
    14.             end = mid - 1;
    15.         }
    16.     }
    17.  
    18.     return strs[0].substring(0, (start + end + 1) / 2);
    19. }
    20.  
    21. private int getMinLength(String[] strs) {
    22.     int minLength = Integer.MAX_VALUE;
    23.     for (String str : strs) {
    24.         minLength = Math.min(minLength, str.length());
    25.     }
    26.     return minLength;
    27. }
    28.  
    29. private boolean isCommonPrefix(String[] strs, int idx) {
    30.     String prefix = strs[0].substring(0, idx + 1);
    31.     for (int i = 1; i < strs.length; i++) {
    32.         if (!strs[i].startsWith(prefix)) {
    33.             return false;
    34.         }
    35.     }
    36.     return true;
    37. }
    38.  
    39. }

    该算法使用二分查找来逐步缩小最长公共前缀的范围，时间复杂度为O(mnlogm)，其中m是最短字符串的长度，n是字符串数组的长度。空间复杂度为O(1)。

    LeetCode运行结果：

    第三题

    题目来源

    15. 三数之和 - 力扣（LeetCode）

    题目内容

    解决方法

    方法一：双指针

    可以使用双指针的方法来解决这个问题。首先，对数组进行排序，然后使用两个指针i和j来遍历数组。

    具体的步骤如下：

    1. 对数组进行排序，确保数组是有序的。
    2. 遍历数组，对于每个元素nums[i]，设置两个指针left和right分别指向i之后的开始和结束位置。
    3. 在left和right之间使用双指针法，寻找满足nums[i]+nums[left]+nums[right]==0的三元组。
    4. 如果找到满足条件的三元组，将其加入结果集。
    5. 跳过重复的元素，即如果nums[i]和nums[i-1]相等，则跳过当前循环。
    1. import java.util.ArrayList;
    2. import java.util.Arrays;
    3. import java.util.List;
    4. class Solution {
    5. public List> threeSum(int[] nums) {
    6.     List> result = new ArrayList<>();
    7.     if (nums == null || nums.length < 3) {
    8.         return result;
    9.     }
    10.  
    11.     Arrays.sort(nums); // 排序数组
    12.  
    13.     for (int i = 0; i < nums.length - 2; i++) {
    14.         if (i > 0 && nums[i] == nums[i - 1]) {
    15.             continue; // 跳过重复的元素
    16.         }
    17.  
    18.         int target = -nums[i];
    19.         int left = i + 1, right = nums.length - 1;
    20.  
    21.         while (left < right) {
    22.             int sum = nums[left] + nums[right];
    23.             if (sum == target) {
    24.                 result.add(Arrays.asList(nums[i], nums[left], nums[right]));
    25.                 left++;
    26.                 right--;
    27.  
    28.                 // 跳过重复的元素
    29.                 while (left < right && nums[left] == nums[left - 1]) {
    30.                     left++;
    31.                 }
    32.                 while (left < right && nums[right] == nums[right + 1]) {
    33.                     right--;
    34.                 }
    35.             } else if (sum < target) {
    36.                 left++;
    37.             } else {
    38.                 right--;
    39.             }
    40.         }
    41.     }
    42.  
    43.     return result;
    44. }
    45. }

    该算法的时间复杂度为O(n^2)，其中n是数组的长度。排序的时间复杂度为O(nlogn)，双指针的遍历时间复杂度为O(n^2)。空间复杂度为O(logn)或O(n)，取决于排序算法的实现。最终返回的结果列表所占用的空间不计入空间复杂度。 

    LeetCode运行结果：

  • 相关阅读:
    OOP面向对象编程
    Python 图形化界面基础篇：使用网格布局（ Grid Layout ）排列元素
    Http常见的请求头和响应头说明
    笔记/日记应用 memos
    [Firefox/快捷键] 禁用Ctrl-W快捷键
    【5.Vue 父子组件监听数据】
    Kotlin File writeText appendText appendBytes readBytes readText
    Vue 获取 public图片
    基于SAE堆叠自编码器的单维时间序列预测研究（matlab代码实现）
    大坑-MATLAB图片转存时需注意的点
  • 原文地址：https://blog.csdn.net/m0_74293254/article/details/132986448