LeetCode-13-罗马数字转整数

LeetCode-13-罗马数字转整数

问题描述

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”
输出: 3
示例 2:

输入: “IV”
输出: 4
示例 3:

输入: “IX”
输出: 9
示例 4:

输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:

输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/roman-to-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题

方法一：堆栈的方法

可以用一个字典将罗马字母与十进制的数字对应起来

具体方法是：给定一个罗马数字的字符串s，第一个字符所表示的数字先入栈，然后从s[1]开始，将所有的字符都遍历一遍。

如果当前扫描的字符比栈顶元素所表示的罗马数字要小或者相等，则入栈

如果当前扫描的字符比栈顶元素所表示的罗马数字大，则弹栈，并将当前扫描的字符所表示的数字与弹出的这个数字相减，将相减得出的结果入栈。

等遍历完成之后，将栈中所有的元素想加，就是正确的结果

• Python代码：

class Solution(object):
    def romanToInt(self, s):
        roman = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
        l = len(s)
        st = []
        st.append(roman[s[0]])
        i=1
        ans = 0
        while i <l:
            if roman[s[i]] <= roman[s[i-1]]:
                st.append(roman[s[i]])
            else:
                st.pop()
                tmp = roman[s[i]] - roman[s[i-1]]
                st.append(tmp)
            i +=1
        for v in st:
            ans += v
        return ans

• c#代码

  public class Solution {
      public int RomanToInt(string s) {
              int ans = 0;
              Dictionary<char,int> dict = new Dictionary<char, int>{
                  {'I',1},
                  {'V',5},
                  {'X',10},
                  {'L',50},
                  {'C',100},
                  {'D',500},
                  {'M',1000}
              };
              Stack st = new Stack();
              st.Push(dict[s[0]]);
              for(int i=1;i<s.Length;i++)
              {
                  if(dict[s[i]]<=dict[s[i-1]])
                  {
                      st.Push(dict[s[i]]);
                  }
                  else
                  {
                      st.Pop();
                      int tmp = dict[s[i]] - dict[s[i-1]];
                      st.Push(tmp);
                  }
              }
              
              while(st.Count != 0)
              {
                  int t = Convert.ToInt32(st.Peek());
                  st.Pop();
                  ans += t;
              }
              return ans;
          }
  }
  

方法二：就地相加减

传入一个罗马字母的字符串s

从s[0]开始扫描，如果当前扫描的字符所表示的数字比下一个字符所表示的数字要大或者相等，则直接相加。否则，减去当前扫描到底字符所表示的数字。并不影响结果。这样就不需要堆栈占用额外的空间了

• C#代码：

public class Solution {
   public int RomanToInt(string s) {
            Dictionary<char,int> dict = new Dictionary<char, int>{
                {'I',1},
                {'V',5},
                {'X',10},
                {'L',50},
                {'C',100},
                {'D',500},
                {'M',1000}
            };

            int ans = 0;
            int l = s.Length;
            for(int i=0;i<l-1;i++)
            {
                if(dict[s[i]]<dict[s[i+1]])
                {
                    ans -= dict[s[i]];
                }
                else
                {
                    ans += dict[s[i]];
                }
            }
            ans += dict[s[l-1]];
            return ans;
        }
}

• Python代码：

class Solution(object):
    def romanToInt(self, s):
        roman = {"I":1,"V":5,"X":10,"L":50,"C":100,"D":500,"M":1000}
        l = len(s)
        ans = 0
        i = 0
        while i < l-1:
            if roman[s[i]] < roman[s[i+1]]:
                ans -= roman[s[i]]
            else:
                ans += roman[s[i]]
            i += 1
        ans += roman[s[l-1]]
        return ans