【LeetCode】13. Roman to Integer（简单难度）

最新推荐文章于 2025-07-18 13:00:25 发布

原创最新推荐文章于 2025-07-18 13:00:25 发布 · 251 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

LeetCode 专栏收录该内容

39 篇文章

订阅专栏

这篇博客介绍了三种不同的方法将罗马数字转换为整数，包括遍历解析、特殊组合查找和规则判断。解法涉及字符串处理、条件判断和时间复杂度分析，其中最优解法的时间和空间复杂度均为O(1)。

在这里插入图片描述

解法一

先来一种不优雅的，也就是遍历字符串，然后转换就可以，但同时得考虑 Ⅳ，X 那些特殊情况。

class Solution {
    public int getInt(char r){
        int ans = 0;
        switch(r){
            case 'I':
                ans = 1;
                break;
            case 'V':
                ans = 5;
                break;
            case 'X':
                ans = 10;
                break;
            case 'L':
                ans = 50;
                break;
            case 'C':
                ans = 100;
                break;
            case 'D':
                ans = 500;
                break;
            case 'M':
                ans = 1000;
        }
        return ans;
    }

    public int getInt(char r, char r_after){
        int ans = 0;
        switch(r){
            case 'I':
                ans = 1;
                break;
            case 'V':
                ans = 5;
                break;
            case 'X':
                ans = 10;
                break;
            case 'L':
                ans = 50;
                break;
            case 'C':
                ans = 100;
                break;
            case 'D':
                ans = 500;
                break;
            case 'M':
                ans = 1000;
                break;
        }
        if(r == 'I'){
            switch(r_after){
                case 'V':
                    ans = 4;
                    break;
                case 'X':
                    ans = 9;
            }
        }
        if(r == 'X'){
            switch(r_after){
                case 'L':
                    ans = 40;
                    break;
                case 'C':
                    ans = 90;
            }
        }
        if(r == 'C'){
            switch(r_after){
                case 'D':
                    ans = 400;
                    break;
                case 'M':
                    ans = 900;
            }
        }
        return ans;
    }

    public boolean isGetTwoInt(char r, char r_after){
        if(r == 'I'){
            switch(r_after){
                case 'V':
                    return true;
                case 'X':
                    return true;
            }
        }
        if(r == 'X'){
            switch(r_after){
                case 'L':
                    return true;
                case 'C':
                    return true;
            }
        }
        if(r == 'C'){
            switch(r_after){
                case 'D':
                    return true;
                case 'M':
                    return true;
            }
        }
        return false;
    }

    public int romanToInt(String s) {
        int ans = 0;
        for(int i = 0; i < s.length() - 1; i++){
            ans += getInt(s.charAt(i),s.charAt(i+1));
            //判断是否是两个字符的特殊情况
            if(isGetTwoInt(s.charAt(i),s.charAt(i+1))){
                i++;
            }
        }
        //将最后一个字符单独判断，如果放到循环里会越界
        if(!(s.length() >= 2 && isGetTwoInt(s.charAt(s.length() - 2),s.charAt(s.length() - 1)))){
            ans += getInt(s.charAt(s.length() - 1));
        }
        return ans;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

解法二

class Solution {
    public int romanToInt(String s) {
        int sum = 0;
        if(s.indexOf("IV") != -1){sum -= 2;}
        if(s.indexOf("IX") != -1){sum -= 2;}
        if(s.indexOf("XL") != -1){sum -= 20;}
        if(s.indexOf("XC") != -1){sum -= 20;}
        if(s.indexOf("CD") != -1){sum -= 200;}
        if(s.indexOf("CM") != -1){sum -= 200;}

        char c[] = s.toCharArray();
        int count = 0;

        for(;count <= s.length() - 1;count++){
            if(c[count] == 'M') sum += 1000;
            if(c[count] == 'D') sum += 500;
            if(c[count] == 'C') sum += 100;
            if(c[count] == 'L') sum += 50;
            if(c[count] == 'X') sum += 10;
            if(c[count] == 'V') sum += 5;
            if(c[count] == 'I') sum += 1;
        }

        return sum;
    }
}

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
如果要检索的字符串值没有出现，则该方法返回 -1。
String.indexOf函数用法小结
indexOf 的参数是 String, startIndex: Number;
indexOf 的返回值为 int,
Function indexOf 包含如下几个格式：
1). Strng.indexOf(substring) //搜索String中的substring,默认从0位开始；
2). String.indexOf(substring,m) //搜索String中的substring, 默认从第m位开始；
str1.indexOf(“字串”)；//查找“字串”的第一个字符在str1中的索引值（位置）
str1.indexOf(“字”,start,end)；//从start第start+1个字符起，查找end个字符，查找“字”在字符串STR1中的位置[从第一个字符算起]注意:start+end不能大于str1的长度
indexOf参数为string,在字符串中寻找参数字符串第一次出现的位置并返回该位置。如string s=“0123dfdfdf”; var i=s.indexof(“df”);这时i==4。
string test=“asdfjsdfjgkfasdsfsgfhgjgfjgdddd”;
test.indexof(‘d’) =2 //从前向后定位 d 第一次出现的位置
test.indexof(‘d’,1) =2 //从前向后定位 d 从第1+1个字符串开始计算第一次出现的位置
test.indexof(‘d’,5,2) =6 //从前向后定位 d 从第5 位开始查，查2位，即从第5位到第7位；

ToCharArray( )的用法，将字符串对象中的字符转换为一个字符数组。
详解释就是：
字符串转换成字符数组后，每个字符的ASC码与字符T的ASC码进行二进制异或运算。最后把结果转换回字符。

时间复杂度：O(1)
空间复杂度：O(1)

解法三

https://leetcode.com/problems/roman-to-integer/discuss/6509/7ms-solution-in-Java.-easy-to-understand

利用到罗马数字的规则，一般情况是表示数字大的字母在前，数字小的字母在后，如果不是这样，就说明出现了特殊情况，此时应该做减法。

class Solution {
    public int getVal(char c){
        switch(c){
            case 'M':
                return 1000;
            case 'D':
                return 500;
            case 'C':
                return 100;
            case 'L':
                return 50;
            case 'X':
                return 10;
            case 'V':
                return 5;
            case 'I':
                return 1;
        }
        throw new IllegalArgumentException("unsupported character");
    }

    public int romanToInt(String s) {
        int res = 0;
        if(s.length() == 0) return res;
        for(int i = 0;i < s.length() - 1;i++){
            int cur = getVal(s.charAt(i));
            int nex = getVal(s.charAt(i+1));
            if(cur < nex){
                res -= cur;
            }else{
                res += cur;
            }
        }
        return res + getVal(s.charAt(s.length() - 1));
    }
}