[C++]LeetCode: 16 Roman to Integer

题目：

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

Attention： 是罗马数字，不是阿拉伯数字！

Error Code:

阿拉伯数字 Code:

class Solution {
public:
    int romanToInt(string s) {
        //输入罗马数字，输出整型；题目约定数字范围在1~3999，不需要考虑溢出。
        //思路：依次读取s中的每一位，然后计算int
        
        if(s == "0" || s.empty())
            return 0;
        
        int ret = 0;
        int tmp;
        int StrLength = s.length();
        
        for(int i = 0; i < StrLength; i++)
        {
            tmp = s[i];
            ret = ret * 10 + tmp; 
        }
        
        return ret;
        
    }
};

Roman numerals:

Error Code:

对罗马数字准换的错误理解：

class Solution {
public:
    int romanToInt(string s) {
        //思路：罗马数字有一个对应的表，可以建立一个罗马数字的map表，然后查询匹配后求和。
        //Attention:
        map<char, int> RomanHash;
        typedef map<char, int>::value_type valType;
        int StrLength = s.length();
        //int tmp = 0;
        int ret = 0;
        
        //初始化Roman的数字表
        RomanHash.insert(valType('I', 1));
        RomanHash.insert(valType('V', 5));
        RomanHash.insert(valType('X', 10));
        RomanHash.insert(valType('L', 50));
        RomanHash.insert(valType('C', 100));
        RomanHash.insert(valType('D', 500));
        RomanHash.insert(valType('M', 1000));
        
        for(int i = 0; i < StrLength; i++)
        {
            if(RomanHash.find(s[i]) != RomanHash.end())
            {
                ret += RomanHash[s[i]];
            }
        }
        
        return ret;
    }
};

思路：罗马数字有一个对应的表，可以建立一个罗马数字的map表，然后查询匹配后求和。

标记上次的字符，然后做判断，是否是三准则的相减准则，需要特殊处理。

Attention: 罗马数字计算有三条规则：最多重复三个，重复为三个相加；I/X/C可以写在大数左边，表示大数-I/X/C;其他就是相加求和。

                一定要注意要减去两次上次的值，上次的值加了两次!!!!!

复杂度：O(n) 只遍历一次。

AC Code:  my_code

class Solution {
public:
    int romanToInt(string s) {
        //思路：罗马数字有一个对应的表，可以建立一个罗马数字的map表，然后查询匹配后求和。
        //Attention:罗马数字计算有三条规则：最多重复三个，重复为三个相加；I/X/C可以写在大数左边，表示大数-I/X/C;其他就是相加求和。
        //一定要注意要减去两次上次的值，上次的值加了两次。
        //思路：标记上次的字符，然后做判断，是否是三准则的相减准则，需要特殊处理。
        
        map<char, int> RomanHash;
        typedef map<char, int>::value_type valType;
      
        //初始化Roman的数字表
        RomanHash.insert(valType('I', 1));
        RomanHash.insert(valType('V', 5));
        RomanHash.insert(valType('X', 10));
        RomanHash.insert(valType('L', 50));
        RomanHash.insert(valType('C', 100));
        RomanHash.insert(valType('D', 500));
        RomanHash.insert(valType('M', 1000));
        
        int StrLength = s.length();
        char LastTag = s[0];
        int ret = RomanHash[s[0]] ;
        
        for(int i = 1; i < StrLength; i++)
        {    
            LastTag = s[i - 1];
            if(RomanHash.find(s[i]) != RomanHash.end())
            {
                if(LastTag == 'I' || LastTag == 'X' || LastTag == 'C')
                {
                    if(RomanHash[s[i]] - RomanHash[LastTag] > 0)
                    { 
                        //关键点！！！减掉两次RomanHash[LastTag]
                        ret += RomanHash[s[i]] - 2 * RomanHash[LastTag];
                    }
                    else
                    {
                        ret += RomanHash[s[i]];
                    }
                }
                else
                {
                    ret += RomanHash[s[i]]; 
                }
            }
        }
        
        return ret;
    }
};