《LeetCode之每日一题》:19.整数转罗马数字

Posted 2021-05-16 是七喜呀！

整数转罗马数字

• 有关题目
• • 题解

题目链接： 整数转罗马数字

有关题目

罗马数字包含以下七种字符： 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:

输入: 3
输出: "III"

示例 2:

输入: 4
输出: "IV"

示例 3:

输入: 9
输出: "IX"

示例 4:

输入: 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.

示例 5:

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

提示：

1 <= num <= 3999

题解

1、体现贪心算法思想

char * intToRoman(int num){
    char* Res,* Res1;//这边也要注意，别忘了* Res1
    int i;
    Res = Res1 = (char*)calloc(16,sizeof(char));//连续赋值
    while(num >= 1000)
    {
        *Res1++ = 'M';
        num -= 1000;
    }
    i = num / 100;
    if (i == 9)
    {
        *Res1++ = 'C';
        *Res1++ = 'M';
        num -= 900;
    }
    else if (i == 4)
    {
        *Res1++ = 'C';
        *Res1++ = 'D';
        num -= 400;
    }
    else
    {
        if (i > 4)
            {
                *Res1++ = 'D';
                num -= 500;
            }
        while(num >= 100)
        {
            *Res1++ = 'C';
            num -= 100;
        }
    }
    i = num / 10;
    if (i == 9)
    {
        *Res1++ = 'X';
        *Res1++ = 'C';
        num -= 90;
    }
    else if (i == 4)
    {
        *Res1++ = 'X';
        *Res1++ = 'L';
        num -= 40;
    }
    else
    {
        if (i > 4)
        {
            *Res1++ = 'L';
            num -= 50;
        }
        while(num >= 10)
        {
            *Res1++ = 'X';
            num -= 10;
        }
    }
    //到这边要换num的个位数字进行判断
    if (num == 9)
    {
        *Res1++ = 'I';
        *Res1++ = 'X';
        num -= 9;
    }
    else if (num == 4)
    {
        *Res1++ = 'I';
        *Res1++ = 'V';
        num -= 4;
    }
    else 
    {
        if (num > 4)
        {
            *Res1++ = 'V';
            num -= 5;
        }
        while(num > 0)
        {
            *Res1++ = 'I';
            num--;
        }
    }
    *Res1 = '\\0';//别忘了字符串结束符
    return Res;
}

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

2、贪心算法

贪心算法是一种在当前时间做出最佳可能决策的算法；
在这种情况下，它会取出最大可能的符号。

思路：给定的整数转换为罗马数字需要找到上述 13 个符号的序列，
这些符号的对应值加起来就是整数。
根据符号值，此序列必须按从大到小的顺序排列

char * intToRoman(int num){
    //1、创建13个有顺序的符号序列与对应数组,注意不能使用char*,
    //因为二位字符型数组其实存的就是对应字符串的地址了。
    int value[13] = { 1000,900,500,400,100,90,50,40,10,9,5,4,1};
    char RoTable[13][3] = { "M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
    //2、开辟存放结果的字符串数组
    char* Res = (char*)calloc(16,sizeof(char));
    //为啥这边开辟16个字节，因为3888对应的该题最长罗马数字为
    //"MMMDCCCLXXXVIII"占16个字节
    int count = 0;//罗马字符拷贝次数
    //3、遍历寻找对应的罗马字符
    for (int i = 0; i < 13; i++)
    {
        
        count = num / value[i];
        num %= value[i];
        //追加罗马字符到Res后
        for (int j = 0; j < count; j++)
            strcat(Res,RoTable[i]);
    }
    return Res;
}
//变化①当然你也可以对于第三步选择不采用计数
//for(int i = 0; i < 13;i++)
//{
//	while(num >= value[i])
//	{
//		strcat(Res,RoTable[i])
//		num -= value[i];
//	}
//}

//变化②我们可以用空间换取时间
//int count[13] = { 0 };我们一下把对应的value[i]中的值存放到该数组
for (int i = 0; i < 13 ; i++)
{	
	while(num >= value[i])
	{
			count[i]++；
			num -= value[i];
	}
	//上面的while你也可以换为
	count[i] = num / value[i];
	num %= value[i];
}
for (i = 0; i < 13; i++)
	while(count[i]-- > 0)
		strcat(Res,RoTable[i]);

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

3、硬编码数字

const char* thousands[] = {"", "M", "MM", "MMM"};
const char* hundreds[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
const char* tens[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
const char* ones[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
//空字符串""不会显示出来的
char* intToRoman(int num) {
    char* roman = malloc(sizeof(char) * 16);
    roman[0] = '\\0';
    strcpy(roman + strlen(roman), thousands[num / 1000]);
    strcpy(roman + strlen(roman), hundreds[num % 1000 / 100]);
    strcpy(roman + strlen(roman), tens[num % 100 / 10]);
    strcpy(roman + strlen(roman), ones[num % 10]);
    return roman;
}

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

C++版本

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

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

4、模拟

const pair<int, string> valueSymbols[] = {
    {1000, "M"},
    {900,  "CM"},
    {500,  "D"},
    {400,  "CD"},
    {100,  "C"},
    {90,   "XC"},
    {50,   "L"},
    {40,   "XL"},
    {10,   "X"},
    {9,    "IX"},
    {5,    "V"},
    {4,    "IV"},
    {1,    "I"},
};//pair相当于内容只有两个的结构体变量，分别存放value 和 symbol
class Solution {
public:
    string intToRoman(int num) {
        string roman;
        for (const auto &[value, symbol] : valueSymbols)
        {
            while(num >= value)
            {
                roman += symbol;//C++的字符串可以直接进行加减操作
                num -= value;
            }
            if (num == 0)//优化一下，省的非得进行13次循环
                break;
        }
        return roman;
    }
};

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

C版本

const int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
const char* symbols[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};

char* intToRoman(int num) {
    char* roman = malloc(sizeof(char) * 16);
    roman[0] = '\\0';
    for (int i = 0; i < 13; i++) {
        while (num >= values[i]) {
            num -= values[i];
            strcpy(roman + strlen(roman), symbols[i]);
 //strcpy拷贝完自动在后面加上\\0，在结合strlen(roman)来进行偏移，就很nice
        }
        if (num == 0) {
            break;
        }
    }
    return roman;
}