【夜深人静学数据结构与算法 | 第十一篇】枚举算法

刺骨的言语ヽ痛彻心扉 2024-03-17 00:08 85阅读 0赞

## ![b14ee4befa9345baa31ba330972a7699.png][] ##

**目录**

前言：

枚举算法：

优点：

枚举算法的种类：

枚举算法案例：

343. 整数拆分 - 力扣（LeetCode）

12. 整数转罗马数字 - 力扣（LeetCode）

总结：

--------------------

## 前言： ##

本文我们将为大家介绍什么是枚举算法，以及枚举算法的优点，在后面我们也会为大家讲解几道枚举算法的经典例题，各位感兴趣的可以点击进来进行阅读。

## 枚举算法： ##

枚举算法也称为穷举算法，是一种基本的计算机算法。**该算法的基本思想是列举出所有可能的情况，并一一进行考虑和判断，最终得出正确的答案**。

枚举算法的步骤通常如下：  
1. 确定问题的解空间，即问题的所有可能解的集合；  
2. 枚举解空间中所有可能的解；  
3. 对于每个解，判断其是否符合问题的要求；  
4. 最终得出所求的答案，即符合问题要求的解。

枚举算法的优点在于其思路简单，易于理解和实现。但是，**由于其需要遍历所有可能的解，因此它的计算量较大，对于规模较大的问题，枚举算法的效率会比较低。**

在实际应用中，枚举算法通常用于解决一些简单的问题，如求解一个方程的整数解、求解最大公约数和最小公倍数等。除此之外，枚举算法也可以作为其他算法（如贪心算法、动态规划算法等）的子算法，用于求解一些复杂问题。

**下面我们以求解一个整数数组的最大值为例来介绍枚举算法的思路：**

假设我们有一个长度为 n 的整数数组，我们要找到其中的最大值。最朴素的方法就是遍历数组中的所有元素，依次比较得到最大值。具体思路如下：

1.  假设数组中第一个元素为最大值 max。
2.  遍历数组中的所有元素，对于每个元素，与 max 进行比较，若当前元素比 max 大，则更新 max 的值。
3.  遍历结束后，max 的值即为数组最大值。

该算法的实现方式非常简单，以下是一个代码示例：

int max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }

**该算法的时间复杂度为 O(n)，因为需要遍历整个数组，与数组大小 n 成正比。这种算法通常适用于数据规模较小的情况下。若数据规模较大时，该算法的时间复杂度会变得非常高，这时相应地需要使用更为高效的算法。**

总的来说，枚举算法虽然简单，但具有一定的局限性。在实际应用中，需要根据具体问题选择合适的算法，以满足问题求解的要求。

其实枚举算法的核心思想很简单，暴力求解出所有问题的答案，然后根据需求确定返回值就可以了。

### 优点： ###

**1. 思路简单，易于理解和实现**：枚举算法的基本思想是列举出所有可能的情况，并一一进行考虑和判断，这个过程比较直观，容易理解。

**2. 适用范围广泛：**枚举算法适用于解决各种类型的问题，不论是数值计算、图论、字符串等方面，都可以使用枚举算法来解决。

**3. 可以保证求解结果的正确性：**由于枚举算法会穷举所有可能的解，因此可以保证其求解结果是正确的，而不会产生遗漏的情况。

**4. 实现复杂度低：**相对于其他更为高级的算法，如动态规划、贪心算法等，枚举算法的实现复杂度要比较低，因为不需要进行过于复杂的优化。

**5. 可以用来验证其他算法的正确性：**由于枚举算法能够保证结果正确，因此可以用来和复杂度更高的算法结果进行对比，以验证这些算法的正确性。

总的来说，枚举算法虽然存在一些明显的缺点（如计算量大），但其简单易懂、适用范围广泛和保证结果正确性等优点，使得枚举算法在解决某些问题时，仍然是一种非常有用的算法。

### 枚举算法的种类： ###

**1. 完全枚举：**

完全枚举算法，即穷尽所有可能性，在所有情况下依次判断，求出满足要求的正确答案。这种算法看似简单，**但由于它的时间复杂度通常比较高，因此对于较大的问题规模，完全枚举的效率会比较低。**

完全枚举算法往往适用于解决规模较小的问题，如求解一个方程的整数解、求解最大公约数和最小公倍数等。

2. 部分枚举：

部分枚举算法，即不完全地枚举解空间，只考虑一部分情况或减少某些非必须分支路径，以提高计算效率。**部分枚举算法的时间复杂度通常比完全枚举算法低，因此在处理复杂问题时较为常见。**

例如，对于实现图像处理算法，可以使用部分枚举来优化处理效率。例如，可以先检查图像中是否存在某些既定的特征（比如颜色、亮度等方面），然后只需对这些区域进行进一步处理，从而减少完成整个图像处理的计算量。

## 枚举算法案例： ##

## [343. 整数拆分 - 力扣（LeetCode）][343. _ - _LeetCode] ##

给定一个正整数 `n` ，将其拆分为 `k` 个 **正整数** 的和（ `k >= 2` ），并使这些整数的乘积最大化。

返回 *你可以获得的最大乘积* 。

![f910eeb9351a495585a46649945b3076.png][]

这道题本质上是一个动态规划解决的题，我们在力扣刷题篇中遇到过，也基于动态规划思路作了详细的讲解做了详细的讲解：

[【力扣刷题 | 第十五天】\_我是一盘牛肉的博客-CSDN博客][_ _-CSDN]

![9b3548e25a5f44ccb64dbfd4c4f62f16.png][]但其实我们根据这个提示来讲，n只有58，也就是只有58种结果，那麽我们直接枚举就可以了。

class Solution {
        public int integerBreak(int n) {
            if (n == 2) return 1;
            else if (n == 3) return 2;
            else if (n == 4) return 4;
            else if (n == 5) return 6;
            else if (n == 6) return 9;
            else if (n == 7) return 12;
            else if (n == 8) return 18;
            else if (n == 9) return 27;
            else if (n == 10) return 36;
            else if (n == 11) return 54;
            else if (n == 12) return 81;
            else if (n == 13) return 108;
            else if (n == 14) return 162;
            else if (n == 15) return 243;
            else if (n == 16) return 324;
            else if (n == 17) return 486;
            else if (n == 18) return 729;
            else if (n == 19) return 972;
            else if (n == 20) return 1458;
            else if (n == 21) return 2187;
            else if (n == 22) return 2916;
            else if (n == 23) return 4374;
            else if (n == 24) return 6561;
            else if (n == 25) return 8748;
            else if (n == 26) return 13122;
            else if (n == 27) return 19683;
            else if (n == 28) return 26244;
            else if (n == 29) return 39366;
            else if (n == 30) return 59049;
            else if (n == 31) return 78732;
            else if (n == 32) return 118098;
            else if (n == 33) return 177147;
            else if (n == 34) return 236196;
            else if (n == 35) return 354294;
            else if (n == 36) return 531441;
            else if (n == 37) return 708588;
            else if (n == 38) return 1062882;
            else if (n == 39) return 1594323;
            else if (n == 40) return 2125764;
            else if (n == 41) return 3188646;
            else if (n == 42) return 4782969;
            else if (n == 43) return 6377292;
            else if (n == 44) return 9565938;
            else if (n == 45) return 14348907;
            else if (n == 46) return 19131876;
            else if (n == 47) return 28697814;
            else if (n == 48) return 43046721;
            else if (n == 49) return 57395628;
            else if (n == 50) return 86093442;
            else if (n == 51) return 129140163;
            else if (n == 52) return 172186884;
            else if (n == 53) return 258280326;
            else if (n == 54) return 387420489;
            else if (n == 55) return 516560652;
            else if (n == 56) return 774840978;
            else if (n == 57) return 1162261467;
            else return 1549681956;
        }
    }

## [12. 整数转罗马数字 - 力扣（LeetCode）][12. _ - _LeetCode] ##

罗马数字包含以下七种字符： 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。  
给你一个整数，将其转为罗马数字。

![0bfbd3e0b6454f89b165d10d929a08e3.png][]

这道题我们用暴力枚举也可以做，虽然思路简单，但是代码太过于繁杂。

class Solution:
        def intToRoman(self, num: int) -> str:
            s=str(num)
            if num<4:
                return 'I'*num
            elif num==4:
                return 'IV'
            elif num<9:
                return 'V'+'I'*(num-5)
            elif num==9:
                return 'IX'
            #<39
            elif num<40:
                if s[1]=='4':
                    return 'X'*(num//10)+'IV'
                elif s[1]=='9':
                    return 'X'*(num//10)+'IX'
                elif int(s[1])<4:
                    return 'X'*(num//10)+'I'*(int(s[1]))
                elif int(s[1])<9:
                    return 'X'*(num//10)+'V'+'I'*(int(s[1])-5)
            #40-49
            elif num<50:
                if s[1]=='4':
                    return 'XL'+'IV'
                elif s[1]=='9':
                    return 'XL'+'IX'
                elif int(s[1])<4:
                    return 'XL'+'I'*(int(s[1]))
                elif int(s[1])<9:
                    return 'XL'+'V'+'I'*(int(s[1])-5)
            #50-89
            elif num<90:
                if s[1]=='4':
                    return 'L'+'X'*((num-50)//10)+'IV'
                elif s[1]=='9':
                    return 'L'+'X'*((num-50)//10)+'IX'
                elif int(s[1])<4:
                    return 'L'+'X'*((num-50)//10)+'I'*(int(s[1]))
                elif int(s[1])<9:
                    return 'L'+'X'*((num-50)//10)+'V'+'I'*(int(s[1])-5)
            #90-99
            elif num<100:
                if s[1]=='4':
                    return 'XC'+'IV'
                elif s[1]=='9':
                    return 'XC'+'IX'
                elif int(s[1])<4:
                    return 'XC'+'I'*(int(s[1]))
                elif int(s[1])<9:
                    return 'XC'+'V'+'I'*(int(s[1])-5)
            #100-399
            elif num<400:
                if s[1]=='4':
                    if s[2]=='4':
                        return 'C'*(num//100)+'XL'+'IV'
                    elif s[2]=='9':
                        return 'C'*(num//100)+'XL'+'IX'
                    elif int(s[2])<4:
                        return 'C'*(num//100)+'XL'+'I'*int(s[2])
                    else:
                        return 'C'*(num//100)+'XL'+'V'+'I'*(int(s[2])-5)
                elif s[1]=='9':
                    if s[2]=='4':
                        return 'C'*(num//100)+'XC'+'IV'
                    elif s[2]=='9':
                        return 'C'*(num//100)+'XC'+'IX'
                    elif int(s[2])<4:
                        return 'C'*(num//100)+'XC'+'I'*int(s[2])
                    else:
                        return 'C'*(num//100)+'XC'+'V'+'I'*(int(s[2])-5)
                elif int(s[1])<4:
                    if s[2]=='4':
                        return 'C'*(num//100)+'X'*(int(s[1]))+'IV'
                    elif s[2]=='9':
                        return 'C'*(num//100)+'X'*(int(s[1]))+'IX'
                    elif int(s[2])<4:
                        return 'C'*(num//100)+'X'*(int(s[1]))+'I'*int(s[2])
                    else:
                        return 'C'*(num//100)+'X'*(int(s[1]))+'V'+'I'*(int(s[2])-5)    
                else:
                    if s[2]=='4':
                        return 'C'*(num//100)+'L'+'X'*(int(s[1])-5)+'IV'
                    elif s[2]=='9':
                        return 'C'*(num//100)+'L'+'X'*(int(s[1])-5)+'IX'
                    elif int(s[2])<4:
                        return 'C'*(num//100)+'L'+'X'*(int(s[1])-5)+'I'*int(s[2])
                    else:
                        return 'C'*(num//100)+'L'+'X'*(int(s[1])-5)+'V'+'I'*(int(s[2])-5)
            #400-499
            elif num<500:
                if s[1]=='4':
                    if s[2]=='4':
                        return 'CD'+'XL'+'IV'
                    elif s[2]=='9':
                        return 'CD'+'XL'+'IX'
                    elif int(s[2])<4:
                        return 'CD'+'XL'+'I'*int(s[2])
                    else:
                        return 'CD'+'XL'+'V'+'I'*(int(s[2])-5)
                elif s[1]=='9':
                    if s[2]=='4':
                        return 'CD'+'XC'+'IV'
                    elif s[2]=='9':
                        return 'CD'+'XC'+'IX'
                    elif int(s[2])<4:
                        return 'CD'+'XC'+'I'*int(s[2])
                    else:
                        return 'CD'+'XC'+'V'+'I'*(int(s[2])-5)
                elif int(s[1])<4:
                    if s[2]=='4':
                        return 'CD'+'X'*(int(s[1]))+'IV'
                    elif s[2]=='9':
                        return 'CD'+'X'*(int(s[1]))+'IX'
                    elif int(s[2])<4:
                        return 'CD'+'X'*(int(s[1]))+'I'*int(s[2])
                    else:
                        return 'CD'+'X'*(int(s[1]))+'V'+'I'*(int(s[2])-5)    
                else:
                    if s[2]=='4':
                        return 'CD'+'L'+'X'*(int(s[1])-5)+'IV'
                    elif s[2]=='9':
                        return 'CD'+'L'+'X'*(int(s[1])-5)+'IX'
                    elif int(s[2])<4:
                        return 'CD'+'L'+'X'*(int(s[1])-5)+'I'*int(s[2])
                    else:
                        return 'CD'+'L'+'X'*(int(s[1])-5)+'V'+'I'*(int(s[2])-5)
            # 500-899
            elif num<900:
                if s[1]=='4':
                    if s[2]=='4':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XL'+'IV'
                    elif s[2]=='9':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XL'+'IX'
                    elif int(s[2])<4:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XL'+'I'*int(s[2])
                    else:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XL'+'V'+'I'*(int(s[2])-5)
                elif s[1]=='9':
                    if s[2]=='4':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XC'+'IV'
                    elif s[2]=='9':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XC'+'IX'
                    elif int(s[2])<4:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XC'+'I'*int(s[2])
                    else:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'XC'+'V'+'I'*(int(s[2])-5)
                elif int(s[1])<4:
                    if s[2]=='4':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'X'*(int(s[1]))+'IV'
                    elif s[2]=='9':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'X'*(int(s[1]))+'IX'
                    elif int(s[2])<4:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'X'*(int(s[1]))+'I'*int(s[2])
                    else:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'X'*(int(s[1]))+'V'+'I'*(int(s[2])-5)    
                else:
                    if s[2]=='4':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'L'+'X'*(int(s[1])-5)+'IV'
                    elif s[2]=='9':
                        return 'D'*(num//500)+'C'*((num-500)//100)+'L'+'X'*(int(s[1])-5)+'IX'
                    elif int(s[2])<4:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'L'+'X'*(int(s[1])-5)+'I'*int(s[2])
                    else:
                        return 'D'*(num//500)+'C'*((num-500)//100)+'L'+'X'*(int(s[1])-5)+'V'+'I'*(int(s[2])-5)
            # 900-999                    
            elif num<1000:
                if s[1]=='4':
                    if s[2]=='4':
                        return 'CM'+'XL'+'IV'
                    elif s[2]=='9':
                        return 'CM'+'XL'+'IX'
                    elif int(s[2])<4:
                        return 'CM'+'XL'+'I'*int(s[2])
                    else:
                        return 'CM'+'XL'+'V'+'I'*(int(s[2])-5)
                elif s[1]=='9':
                    if s[2]=='4':
                        return 'CM'+'XC'+'IV'
                    elif s[2]=='9':
                        return 'CM'+'XC'+'IX'
                    elif int(s[2])<4:
                        return 'CM'+'XC'+'I'*int(s[2])
                    else:
                        return 'CM'+'XC'+'V'+'I'*(int(s[2])-5)
                elif int(s[1])<4:
                    if s[2]=='4':
                        return 'CM'+'X'*(int(s[1]))+'IV'
                    elif s[2]=='9':
                        return 'CM'+'X'*(int(s[1]))+'IX'
                    elif int(s[2])<4:
                        return 'CM'+'X'*(int(s[1]))+'I'*int(s[2])
                    else:
                        return 'CM'+'X'*(int(s[1]))+'V'+'I'*(int(s[2])-5)    
                else:
                    if s[2]=='4':
                        return 'CM'+'L'+'X'*(int(s[1])-5)+'IV'
                    elif s[2]=='9':
                        return 'CM'+'L'+'X'*(int(s[1])-5)+'IX'
                    elif int(s[2])<4:
                        return 'CM'+'L'+'X'*(int(s[1])-5)+'I'*int(s[2])
                    else:
                        return 'CM'+'L'+'X'*(int(s[1])-5)+'V'+'I'*(int(s[2])-5)                
            #1000-3999
            else:
                if s[1]=='4':
                    if s[2]=='4':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CD'+'XL'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CD'+'XL'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CD'+'XL'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CD'+'XL'+'V'+'I'*(int(s[3])-5)
                    elif s[2]=='9':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CD'+'XC'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CD'+'XC'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CD'+'XC'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CD'+'XC'+'V'+'I'*(int(s[3])-5)
                    elif int(s[2])<4:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CD'+'X'*(int(s[2]))+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CD'+'X'*(int(s[2]))+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CD'+'X'*(int(s[2]))+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CD'+'X'*(int(s[2]))+'V'+'I'*(int(s[3])-5)    
                    else:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CD'+'L'+'X'*(int(s[2])-5)+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CD'+'L'+'X'*(int(s[2])-5)+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CD'+'L'+'X'*(int(s[2])-5)+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CD'+'L'+'X'*(int(s[2])-5)+'V'+'I'*(int(s[3])-5)     
                elif s[1]=='9':
                    if s[2]=='4':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CM'+'XL'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CM'+'XL'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CM'+'XL'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CM'+'XL'+'V'+'I'*(int(s[3])-5)
                    elif s[2]=='9':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CM'+'XC'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CM'+'XC'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CM'+'XC'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CM'+'XC'+'V'+'I'*(int(s[3])-5)
                    elif int(s[2])<4:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CM'+'X'*(int(s[2]))+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CM'+'X'*(int(s[2]))+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CM'+'X'*(int(s[2]))+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CM'+'X'*(int(s[2]))+'V'+'I'*(int(s[3])-5)    
                    else:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'CM'+'L'+'X'*(int(s[2])-5)+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'CM'+'L'+'X'*(int(s[2])-5)+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'CM'+'L'+'X'*(int(s[2])-5)+'IX'
                        else:
                            return 'M'*(int(s[0]))+'CM'+'L'+'X'*(int(s[2])-5)+'V'+'I'*(int(s[3])-5)  
                elif int(s[1])<4:
                    if s[2]=='4':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XL'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XL'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XL'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XL'+'V'+'I'*(int(s[3])-5)
                    elif s[2]=='9':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XC'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XC'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XC'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'XC'+'V'+'I'*(int(s[3])-5)
                    elif int(s[2])<4:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'X'*(int(s[2]))+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'X'*(int(s[2]))+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'X'*(int(s[2]))+'IX'
                        else:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'X'*(int(s[2]))+'V'+'I'*(int(s[3])-5)    
                    else:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'L'+'X'*(int(s[2])-5)+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'L'+'X'*(int(s[2])-5)+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'L'+'X'*(int(s[2])-5)+'IX'
                        else:
                            return 'M'*(int(s[0]))+'C'*(int(s[1]))+'L'+'X'*(int(s[2])-5)+'V'+'I'*(int(s[3])-5)  
                else:
                    if s[2]=='4':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XL'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XL'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XL'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XL'+'V'+'I'*(int(s[3])-5)
                    elif s[2]=='9':
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XC'+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XC'+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XC'+'IX'
                        else:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'XC'+'V'+'I'*(int(s[3])-5)
                    elif int(s[2])<4:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'X'*(int(s[2]))+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'X'*(int(s[2]))+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'X'*(int(s[2]))+'IX'
                        else:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'X'*(int(s[2]))+'V'+'I'*(int(s[3])-5)    
                    else:
                        if s[3]=='4':
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'L'+'X'*(int(s[2])-5)+'IV'
                        if int(s[3])<4:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'L'+'X'*(int(s[2])-5)+'I'*(int(s[3]))
                        if int(s[3])==9:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'L'+'X'*(int(s[2])-5)+'IX'
                        else:
                            return 'M'*(int(s[0]))+'D'+'C'*(int(s[1])-5)+'L'+'X'*(int(s[2])-5)+'V'+'I'*(int(s[3])-5)

## 总结： ##

枚举算法是一种简单的算法思想，它利用结果数量少，以此列举出所有的结果，再根据需求返回值，缺点相信大家通过两道例题也可以看出来：代码过于繁杂，但确实是一种淳朴的算法思想。

如果我的内容对你有帮助，请**点赞，评论，收藏**。创作不易，大家的支持就是我坚持下去的动力！

![69e9169c980f43e0aad31ff9ada88a9c.png][]

[b14ee4befa9345baa31ba330972a7699.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/50551c1570b94f63ad62304c6da5a145.png
[343. _ - _LeetCode]: https://leetcode.cn/problems/integer-break/comments/
[f910eeb9351a495585a46649945b3076.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/741b734bc18c4df0a712ae15c08bbed7.png
[_ _-CSDN]: https://blog.csdn.net/fckbb/article/details/131388906
[9b3548e25a5f44ccb64dbfd4c4f62f16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/33e654512df3474aa7c437526e586ad2.png
[12. _ - _LeetCode]: https://leetcode.cn/problems/integer-to-roman/
[0bfbd3e0b6454f89b165d10d929a08e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/f232cbe8635446aaa9b77d8c56335586.png
[69e9169c980f43e0aad31ff9ada88a9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7a8ba1f7b3ad4ad68986fe11a0846bb8.png