LeetCodeOJ刷题之12【Integer to Roman】

Integer to Roman

Given an integer, convert it to a roman numeral.

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

意思就是：

给出一个整数 num( 0<=num<=3999)，返回其对应的罗马数字表示；

罗马数字有：

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

• Math
• String

Solutions

• 1 Integer to Roman -- 143ms

  • 这个方式不知道为什么很慢，是我第一个想出的几乎相当于暴力的方法。

  class Solution {
  public:
      string intToRoman(int num) {
          if(num<=0||num>3999)return string();
          map<int,string> one,two,three,four;  //这里使用的是 Map
          one[0]="";      two[0]="";      three[0]="";
          one[1]="I";     two[1]="X";     three[1]="C";       four[1]="M";
          one[2]="II";    two[2]="XX";    three[2]="CC";      four[2]="MM";
          one[3]="III";   two[3]="XXX";   three[3]="CCC";     four[3]="MMM";
          one[4]="IV";    two[4]="XL";    three[4]="CD";
          one[5]="V";     two[5]="L";     three[5]="D";
          one[6]="VI";    two[6]="LX";    three[6]="DC";
          one[7]="VII";   two[7]="LXX";   three[7]="DCC";
          one[8]="VIII";  two[8]="LXXX";  three[8]="DCCC";
          one[9]="IX";    two[9]="XC";    three[9]="CM";
  
          int mod=0,idx=1;
          string rs="",tmp="";
          while(num>0){
              mod=num%10;
              switch(idx){
                  case 1:{
                      tmp=one[mod];
                      rs=tmp+rs;
                      break;
                  }
                  case 2:{
                      tmp=two[mod];
                      rs=tmp+rs;
                      break;
                  }
                  case 3:{
                      tmp=three[mod];
                      rs=tmp+rs;
                      break;
                  }
                  case 4:{
                      tmp=four[mod];
                      rs=tmp+rs;
                      break;
                  }
              }
              num=num/10;
              ++idx;
          }
          return rs;
      }
  };
  

  后来经过了测试，发现貌似主要原因在于使用了 map，所以在第二次测试中将 map 改为了 string 数组

• 2 Integer to Roman -- 68ms

  • 果然，改进后，运行时间从原来的 143ms 变成了 68ms ,这是第一个改进：

  //原来的 map
  map<int,string> one,two,three,four;  //这里使用的是 Map
  //改进后
  string* one=new string[10],*two=new string[10],*three=new string[10],*four=new string[4];
  

• 3 Integer to Roman -- 54ms

  • 方法1和2中，使用了很大的空间来存储全部的罗马特殊数字，增加了空间复杂性，所以我就想，能不能不存储这些特殊数字，只存储最基本的罗马基数数字 IVXLCDM ，然后根据当前数字进行判断，生成对应的罗马数字。下面是这一思想的代码：

  class Solution {
  public:
      string intToRoman(int num) {
          if(num<=0||num>3999)return string();
          string roman="IVXLCDM";  //存储基数
          string rs="",tmp="";
          int ndx=0,mod=0;  // ndx 用来记录当前基数（即第n位对应的最小罗马数字坐标）
          while(num>0){
              mod=num%10; //求余数
              if(ndx==6){ //千位只有 M
                  rs=string(mod,'M')+rs;
                  break;
              }
              if(mod==0){
                  tmp="";
              }else if(mod<4){
                  tmp=string(mod,roman[ndx]);
              }else if(mod==4){
                  tmp=string(1,roman[ndx])+string(1,roman[ndx+1]);
              }else if(mod<9){
                  tmp=string(1,roman[ndx+1])+string(mod-5,roman[ndx]);
              }else if(mod==9){
                  tmp=string(1,roman[ndx])+string(1,roman[ndx+2]);
              }
              rs=tmp+rs;
              ndx+=2; //基数向前进2个
              num/=10;
          }
          return rs;
      }
  };
  

  • 这一思想中，有两点是需要考虑的：
    1. 千位只有 M ；
    2. 数字4 , 9很特殊；
  • 对于数字 4 来说，如果当前基数坐标为 ndx ，则其对应的罗马数字为：

  string(1,roman[ndx])+string(1,roman[ndx+1]);
  

  比如当前位为十位，则 ndx=2; roman[ndx]='X'; roman[ndx+1]='L' ; 对应罗马数字为： XL

  • 对于数字 9 来说，对应罗马数字为：

  string(1,roman[ndx])+string(1,roman[ndx+2]);
  

  比如当前位为十位，则 ndx=2; roman[ndx]='X'; roman[ndx+2]='C' ; 对应罗马数字为： XC

  • 小于 4 的数字 mod，则为 mod 个连续基数；
  • 大于 4 小于 9 的数字 mod ， 则为 一个 roman[ndx+1] 和 mode-5 个连续基数；
  • 同时，这个版本中，我发觉还是可以改进一下的，对于代码的改进，所以出现了方法4

• 4 Integer to Roman -- 48ms

  • 对于代码的进行，方法3中会产生大量的string临时变量，因此这里尽量的使用了迭代器和 string 的insert方法进行处理。代码运行效率得以再次提高：48ms

  class Solution {
  public:
      string intToRoman(int num) {
          if(num<=0||num>3999)return string();
          char roman[]="IVXLCDM";
          string rs="";
          int ndx=0,mod=0;
          while(num>0){
              mod=num%10;
              if(ndx==6){
                  rs=string(mod,'M')+rs;
                  break;
              }
              if(mod<4){
                  rs=string(mod,roman[ndx])+rs;
              }else if(mod==4){
                  rs.insert(rs.begin(),roman[ndx+1]);
                  rs.insert(rs.begin(),roman[ndx]);
                  // rs=string(1,roman[ndx])+string(1,roman[ndx+1])+rs;
              }else if(mod<9){
                  // rs=string(1,roman[ndx+1])+string(mod-5,roman[ndx])+rs;
                  rs=string(mod-5,roman[ndx])+rs;
                  rs.insert(rs.begin(),roman[ndx+1]);
              }else if(mod==9){
                  rs.insert(rs.begin(),roman[ndx+2]);
                  rs.insert(rs.begin(),roman[ndx]);
                  // rs=string(1,roman[ndx])+string(1,roman[ndx+2])+rs;
              }
              ndx+=2;
              num/=10;
          }
          return rs;
      }
  };
  

• 5 Integer to Roman -- 57ms

  • 这是LeetCode上网友的答案，感觉跟简洁，同时算法也很容易理解，和这里第一种的思想很像：

  class Solution {
  public:
      string intToRoman(int num) {
          string M[] = {"", "M", "MM", "MMM"};
          string C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
          string X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
          string I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
          return M[num/1000] + C[(num%1000)/100] + X[(num%100)/10] + I[num%10];
      }
  };
  

  • 但这里有一个问题，就是这种方法的思想和第二种很像，但是运行时间却更少，于是我将第二种的方法又进行了改进，我感觉差异应该是出现在：第二种方法在赋值时是先定义后赋值，且使用了 new 操作符，这里没有！所以有了下一个简单的改进：
  • 方法二的四个字符串数组，使用方法 5 的方式定义赋值。运行后时间为 58ms，果然这个是原因！看来以后对于内容不是很多的字符数组应该优先不使用 new ，这里还要注意的是，我在第二种方法里 new 的那些个字符数组~~~，忘了一个很重要的操作：delete 。