LeetCode 13. Roman to Integer 罗马数字转阿拉伯数字

13. 罗马数字转阿拉伯数字

13. Roman to Integer

LeetCode 12 的镜像问题

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, two is written as II in Roman numeral, just two one’s added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

• I can be placed before V (5) and X (10) to make 4 and 9.
• X can be placed before L (50) and C (100) to make 40 and 90.
• C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.

Example 1:

Input: "III"
Output: 3

Example 2:

Input: "IV"
Output: 4

Example 3:

Input: "IX"
Output: 9

Example 4:

Input: "LVIII"
Output: 58
Explanation: L = 50, V= 5, III = 3.

Example 5:

Input: "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

从头往后扫描转换

根据阿拉伯数字和罗马数字的关键建立映射。只需遍历整个字符串一次，通过映射关系找到对应的阿拉伯数字的值，然后相加即可。对于IV这样子的罗马数字，采用字符比较的方式进行判定。若前一个字符比后一个字符所代表的意思小的话，那么应该减去前一个字符的值。

class Solution {
    public int romanToInt(String s) {
        Map<Character,Integer> map = new HashMap<Character,Integer>(){{
            put('I',1);
            put('V',5);
            put('X',10);
            put('L',50);
            put('C',100);
            put('D',500);
            put('M',1000);
        }};
        
        int result = map.get(s.charAt(0));
        int sLen = s.length();
        
        for(int i = 1; i < sLen ;i++){
            int pre = map.get(s.charAt(i - 1));
            int cur = map.get(s.charAt(i));
            
            if(cur <= pre){
                result += cur;
            } else {
                result += (cur - 2 * pre);
            }
        }
        
        return result;
        
    }
}

从后往前转换

同样也可以从后往前转换。处理IV这样子的数字的时候，采用的处理方式也和刚才一样。当遇到I时，和上一个扫过的V进行对比。

class Solution {
    public int romanToInt(String s) {
        Map<Character,Integer> map = new HashMap<Character,Integer>(){{
            put('I',1);
            put('V',5);
            put('X',10);
            put('L',50);
            put('C',100);
            put('D',500);
            put('M',1000);
        }};
        
        int sLen = s.length();
        int result = 0;
        int n = result;
        for(int i = sLen - 1; i >= 0; i--){
            int cur = map.get(s.charAt(i));
            if(cur < n){
                result -= cur;
            } else {
                result += cur;
            }
            n = cur;
        }
        return result;
    }
}
          } else {
                result += cur;
            }
            n = cur;
        }
        return result;
    }
}