Leetcode刷题（二十一）

整数转罗马数字（Medium）

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

输入: num = 3
输出: "III"
示例 2:

输入: num = 4
输出: "IV"
示例 3:

输入: num = 9
输出: "IX"
示例 4:

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

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

1 <= num <= 3999
Related Topics
哈希表
数学
字符串

思路分析

最开始的思路就是直接使用条件判断所有情况，直接按照位数进行拆解，但是时间复杂度会很差。
代码如下：

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public String intToRoman(int num) {
        String result = "";
        if (num >= 1000){
            int integer_part = num/1000;
            num = num%1000;
            for (int i = 0; i < integer_part; i++){
                result = result + "M";
            }

        }
        if (num < 1000 && num >= 900){
            num = num%900;
            result = result + "CM";
        }
        if (num < 900 && num >= 500){
            int integer_part = num/500;
            num = num%500;
            for (int i = 0; i < integer_part; i++){
                result = result + "D";
            }
        }
        if (num < 500 && num >= 400){
            num = num%400;
            result = result + "CD";
        }
        if (num < 400 && num >= 100){
            int integer_part = num/100;
            num = num%100;
            for (int i = 0; i < integer_part; i++){
                result = result + "C";
            }
        }
        if (num < 100 && num >= 90){
            num = num%90;
            result = result + "XC";
        }
        if (num < 90 && num >= 50){
            int integer_part = num/50;
            num = num%50;
            for (int i = 0; i < integer_part; i++){
                result = result + "L";
            }
        }
        if (num < 50 && num >= 40){
            num = num%40;
            result = result + "XL";
        }
        if (num < 40 && num >= 10){
            int integer_part = num/10;
            num = num%10;
            for (int i = 0; i < integer_part; i++){
                result = result + "X";
            }
        }
        if (num < 10 && num >= 9){
            num = num%9;
            result = result + "IX";
        }
        if (num < 9 && num >= 5){
            int integer_part = num/5;
            num = num%5;
            for (int i = 0; i < integer_part; i++){
                result = result + "V";
            }
        }
        if (num < 5 && num >= 4){
            num = num%4;
            result = result + "IV";
        }
        if (num < 4 && num >=1){
            int integer_part = num/1;
            num = num%1;
            for (int i = 0; i < integer_part; i++){
                result = result + "I";
            }
        }

        return result;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

思路优化

根据这个粗暴的方法我发现，这道题主要有两个要注意的地方，一个是能用最大的数值来拆分就尽量用最大的（这就是贪心算法），第二个要注意的是从之前的代码中可以看出，900、400、90、40、9、4这几个数字和另外几个不一样，他们没有循环，最多出现一次，而其他的数字最多出现3次。
这里根据第二条可以证明贪心算法在这里运用的正确性，由于最多只能出现的次数是三次和一次，所以使用贪心算法可以保证字符在这样的规则下使用数量最少。

代码实现

public class Solution {

    public String intToRoman(int num) {
        // 把阿拉伯数字与罗马数字可能出现的所有情况和对应关系，放在两个数组中，并且按照阿拉伯数字的大小降序排列
        int[] nums = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        String[] romans = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};

        StringBuilder stringBuilder = new StringBuilder();
        int index = 0;
        while (index < 13) {
            // 特别注意：这里是等号
            while (num >= nums[index]) {
                stringBuilder.append(romans[index]);
                num -= nums[index];
            }
            index++;
        }
        return stringBuilder.toString();
    }
}

这里的两个数组可以用哈希表来进行表示会更简洁一点。