怒刷LeetCode的第26天(Java版)

目录

第一题

题目来源

题目内容

解决方法

方法一:动态规划

第二题

题目来源

题目内容

解决方法

方法一:有限状态自动机

方法二:正则表达式

第三题

题目来源

题目内容

解决方法

方法一:从最后一位向前遍历

方法二:数学运算


第一题

题目来源

64. 最小路径和 - 力扣(LeetCode)

题目内容

解决方法

方法一:动态规划

可以使用动态规划来解决这个问题。

  1. 首先创建一个与网格大小相同的二维数组dp,用于存储从起点到每个位置的最小路径和。
  2. 然后初始化dp[0][0] = grid[0][0],表示起点的最小路径和为起点的值。
  3. 接下来进行动态规划的遍历,遍历顺序可从起点开始按行或按列遍历。对于每个位置dp[i][j],其最小路径和为grid[i][j]加上它左边或上边位置的最小路径和的较小值。

复杂度分析:

时间复杂度:

  • 遍历网格中的每个元素,所以需要进行两层嵌套循环,总共遍历次数为m * n,其中m为网格的行数,n为网格的列数。
  • 在每次循环中,执行常数时间的操作,将上方和左方的最小路径和与当前位置的值相加,然后取最小值。
  • 因此,整体的时间复杂度为O(m * n)。

空间复杂度:

  • 创建了一个与网格大小相同的二维数组dp,用于存储从起点到每个位置的最小路径和。因此需要额外的空间来存储这些最小路径和。
  • dp数组的大小为m * n,与原始网格的大小相同。
  • 所以,空间复杂度为O(m * n)。

综上所述,该算法的时间复杂度为O(m * n),空间复杂度为O(m * n)。

LeetCode运行结果:

第二题

题目来源

65. 有效数字 - 力扣(LeetCode)

题目内容

解决方法

方法一:有限状态自动机

可以使用有限状态自动机(DFA)来解决该问题。我们需要设计合适的状态集合以及状态转移规则。其中,状态包括以下几种:

起始空格状态:在这个状态下,前面的空格已经被忽略。 符号位状态:在这个状态下,可能出现 + 或 -。 整数状态:在这个状态下,输入了数字 0-9。 小数点状态:在这个状态下,已经输入了小数点。 小数状态:在这个状态下,已经输入了数字并带有小数点。 幂符号状态:在这个状态下,出现了字符 e 或 E。 幂符号后的符号位状态:在这个状态下,出现了符号位 + 或 -。 幂符号后的整数状态:在这个状态下,输入了数字 0-9。 终止状态:如果当前输入的字符不合法或者最后一步能够到达终止状态,则说明输入是一个合法的数字。

java 复制代码
class Solution {
public boolean isNumber(String s) {
    // 定义有限状态自动机
    Map<State, Map<CharType, State>> transfer = new HashMap<>(); 
    transfer.put(State.STATE_INITIAL, new HashMap<>() {{
        put(CharType.CHAR_SPACE, State.STATE_INITIAL); // 起始空格状态
        put(CharType.CHAR_NUMBER, State.STATE_INTEGER); // 整数状态
        put(CharType.CHAR_SIGN, State.STATE_SIGN); // 符号位状态
        put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT); // 小数点状态(前面没有数字)
    }});
    transfer.put(State.STATE_SIGN, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_INTEGER); // 整数状态
        put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT); // 小数点状态(前面没有数字)
    }});
    transfer.put(State.STATE_INTEGER, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_INTEGER); // 整数状态
        put(CharType.CHAR_EXP, State.STATE_EXP); // 幂符号状态
        put(CharType.CHAR_POINT, State.STATE_POINT); // 小数状态
        put(CharType.CHAR_SPACE, State.STATE_END); // 终止状态
    }});
    transfer.put(State.STATE_POINT, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_FRACTION); // 小数状态
        put(CharType.CHAR_EXP, State.STATE_EXP); // 幂符号状态
        put(CharType.CHAR_SPACE, State.STATE_END); // 终止状态
    }});
    transfer.put(State.STATE_POINT_WITHOUT_INT, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_FRACTION); // 小数状态
    }});
    transfer.put(State.STATE_FRACTION, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_FRACTION); // 小数状态
        put(CharType.CHAR_EXP, State.STATE_EXP); // 幂符号状态
        put(CharType.CHAR_SPACE, State.STATE_END); // 终止状态
    }});
    transfer.put(State.STATE_EXP, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER); // 幂符号后的整数状态
        put(CharType.CHAR_SIGN, State.STATE_EXP_SIGN); // 幂符号后的符号位状态
    }});
    transfer.put(State.STATE_EXP_SIGN, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER); // 幂符号后的整数状态
    }});
    transfer.put(State.STATE_EXP_NUMBER, new HashMap<>() {{
        put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER); // 幂符号后的整数状态
        put(CharType.CHAR_SPACE, State.STATE_END); // 终止状态
    }});
    transfer.put(State.STATE_END, new HashMap<>() {{
        put(CharType.CHAR_SPACE, State.STATE_END); // 终止状态
    }});
    
    // 根据定义的状态转移规则,判断该字符串是否为有效数字
    int length = s.length();
    State state = State.STATE_INITIAL;
    for (int i = 0; i < length; i++) {
        CharType type = toCharType(s.charAt(i));
        if (!transfer.get(state).containsKey(type)) { // 当前输入不合法
            return false;
        }
        state = transfer.get(state).get(type); // 进入下一个状态
    }
    // 最后一步能够到达终止状态说明该字符串是一个有效数字
    return state == State.STATE_INTEGER || state == State.STATE_POINT ||
            state == State.STATE_FRACTION || state == State.STATE_EXP_NUMBER ||
            state == State.STATE_END;
}

// 定义字符类型枚举类
enum CharType {
    CHAR_NUMBER,
    CHAR_EXP,
    CHAR_POINT,
    CHAR_SIGN,
    CHAR_SPACE,
    CHAR_ILLEGAL
}

// 判断字符类型
private CharType toCharType(char ch) {
    if (ch >= '0' && ch <= '9') {
        return CharType.CHAR_NUMBER;
    } else if (ch == 'e' || ch == 'E') {
        return CharType.CHAR_EXP;
    } else if (ch == '.') {
        return CharType.CHAR_POINT;
    } else if (ch == '+' || ch == '-') {
        return CharType.CHAR_SIGN;
    } else if (ch == ' ') {
        return CharType.CHAR_SPACE;
    } else {
        return CharType.CHAR_ILLEGAL;
    }
}

// 定义状态枚举类
enum State {
    STATE_INITIAL,
    STATE_INTEGER,
    STATE_POINT,
    STATE_POINT_WITHOUT_INT,
    STATE_FRACTION,
    STATE_EXP,
    STATE_EXP_SIGN,
    STATE_EXP_NUMBER,
    STATE_SIGN,
    STATE_END
}
}

复杂度分析:

  • 时间复杂度为O(n),其中n表示字符串的长度。算法需要对字符串中的每个字符进行遍历,因此时间复杂度与字符串的长度成正比。
  • 空间复杂度为O(1),因为算法只使用了常数个变量和一个固定大小的哈希表(状态转移规则),不随输入规模的增加而增加额外的空间消耗。因此,算法的空间复杂度是常数级别的。

LeetCode运行结果:

方法二:正则表达式

除了有限状态自动机,还可以使用正则表达式来判断一个字符串是否为有效数字。Java中提供了一个函数matches(String regex)来判断一个字符串是否能够匹配指定的正则表达式。

java 复制代码
class Solution {
public boolean isNumber(String s) {
    // 使用正则表达式匹配字符串
    return s.trim().matches("[+-]?(?:\\d+\\.?\\d*|\\.\\d+)(?:[Ee][+-]?\\d+)?");
}
}

复杂度分析:

该算法的时间复杂度为O(1),因为使用了Java内置函数,时间复杂度是固定的。空间复杂度为O(1),因为没有使用额外的空间。

需要注意的是,使用正则表达式虽然代码简单易懂,但是性能可能不如有限状态自动机。正则表达式求解的时间复杂度是O(n),其中n是字符串长度,适用于一些简单的模式匹配。对于复杂模式,引擎会消耗非常多的时间和空间,建议在使用时注意性能问题。

LeetCode运行结果:

第三题

题目来源

66. 加一 - 力扣(LeetCode)

题目内容

解决方法

方法一:从最后一位向前遍历

该方法从数组的最后一位开始向前遍历,将当前位加一,如果加一后不需要进位,则直接返回结果。如果加一后需要进位,则将当前位置为0,并继续处理前一位。如果所有位都需要进位,则返回新的结果数组,长度为原数组长度加一,首位为1,其余位为0。

java 复制代码
class Solution {
public int[] plusOne(int[] digits) {
    int n = digits.length;
    
    // 从最后一位开始向前遍历
    for (int i = n - 1; i >= 0; i--) {
        // 当前位加一
        digits[i]++;
        
        // 如果当前位加一后仍然小于10,没有进位,直接返回结果
        if (digits[i] < 10) {
            return digits;
        }
        
        // 有进位,当前位变为0,继续处理前一位
        digits[i] = 0;
    }
    
    // 若所有位都有进位,则数组长度需要增加1,首位为1,后面全是0
    int[] result = new int[n + 1];
    result[0] = 1;
    
    return result;
}

}

复杂度分析:

  • 时间复杂度:O(n),其中n为数组的长度。在最坏情况下,需要遍历整个数组一次。
  • 空间复杂度:O(n),需要创建一个新的结果数组,长度可能为n+1。

LeetCode运行结果:

方法二:数学运算

还可以使用数学运算来实现加一操作。

  1. 首先将数组最后一位加一,记录进位carry。
  2. 从数组倒数第二位开始,将当前位加上进位carry,并更新进位carry。
  3. 如果进位carry为0,则无需继续处理,直接返回结果数组。
  4. 如果进位carry不为0,则继续向前处理前一位。
  5. 如果处理完所有位后,进位carry仍然不为0,说明需要扩展结果数组的长度,将原数组复制到新的结果数组中,并在首位插入进位carry。
java 复制代码
class Solution {
public int[] plusOne(int[] digits) {
    int n = digits.length;
    int carry = 1; // 进位初始化为1
    
    // 从数组最后一位开始计算
    for (int i = n - 1; i >= 0; i--) {
        digits[i] += carry; // 当前位加上进位
        carry = digits[i] / 10; // 计算新的进位
        digits[i] %= 10; // 当前位取模,得到个位数

        // 如果进位为0,说明不需要再进位,直接返回结果数组
        if (carry == 0) {
            return digits;
        }
    }
    
    // 若所有位都有进位,则数组长度需要增加1,首位为进位carry,后面全是0
    int[] result = new int[n + 1];
    result[0] = carry;
    System.arraycopy(digits, 0, result, 1, n);
    
    return result;
}

}

复杂度分析:

  • 时间复杂度:遍历数组需要线性时间O(n),其中每个元素只进行一次常数级别的数学运算,所以总体时间复杂度也是O(n)。
  • 空间复杂度:除了原数组外,需要在进位的情况下创建一个新数组来存储结果,所以空间复杂度为O(n)。

LeetCode运行结果:

相关推荐
丫头,冲鸭!!!12 分钟前
B树(B-Tree)和B+树(B+ Tree)
笔记·算法
Re.不晚16 分钟前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea
sszmvb123422 分钟前
测试开发 | 电商业务性能测试: Jmeter 参数化功能实现注册登录的数据驱动
jmeter·面试·职场和发展
测试杂货铺28 分钟前
外包干了2年,快要废了。。
自动化测试·软件测试·python·功能测试·测试工具·面试·职场和发展
为什么这亚子1 小时前
九、Go语言快速入门之map
运维·开发语言·后端·算法·云原生·golang·云计算
1 小时前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习
~yY…s<#>2 小时前
【刷题17】最小栈、栈的压入弹出、逆波兰表达式
c语言·数据结构·c++·算法·leetcode
测试界萧萧2 小时前
外包干了4年,技术退步太明显了。。。。。
自动化测试·软件测试·功能测试·程序人生·面试·职场和发展
小码哥说测试2 小时前
接口测试用例设计的关键步骤与技巧解析!
自动化测试·测试工具·jmeter·职场和发展·测试用例·接口测试·postman
幸运超级加倍~2 小时前
软件设计师-上午题-16 算法(4-5分)
笔记·算法