leetcode13 罗马数字转整数

题目描述：罗马数字由七种字符组成，分别为 I、V、X、L、C、D 和 M，对应的数值分别为 1、5、10、50、100、500 和 1000。在一般情况下，小的数字位于大的数字右边，但有特殊情况，如 IV 表示 4，IX 表示 9，XL 表示 40，XC 表示 90，CD 表示 400，CM 表示 900。给定一个罗马数字，需要将其转换成整数。

例如：罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

 方法1 模拟

该方法的思想类似于“对号入座”，找到什么罗马符号对应的什么值就写进去，但是最关键的是要搞清楚前后的加减关系，以Roman=“MCMXCIV”为例，第二个位置上的C所对应的值要比第三个位置上的M所对应的值要小，关于前后是进行加法运算还是减法运算，可以看下图的图解，通过图解就可以清楚的知道该如何进行运算。 

 python完整代码：

class Solution:
    symbol_values = {
        "I": 1,
        "V": 5,
        "X": 10,
        "L": 50,
        "C": 100,
        "D": 500,
        "M": 1000
    }
    def romanToInt(self, str):
        digital = 0  # 定义当前数字
        n = len(str)  # 罗马字数字长度
        for i, ch in enumerate(str):
            value = Solution.symbol_values[ch]
            if i < n - 1 and value < Solution.symbol_values[str[i + 1]]:
                digital -= value  # 左边比右边小--->减
            else:
                digital += value  # 左边比右边大--->加
        return digital

# 设置罗马数字
Roman = "MCMXCIV"
solution = Solution()
result = solution.romanToInt(Roman)
print("罗马数字转整数的结果为: ", result)

c++完整代码： 

#include<iostream>
#include<unordered_map>
using namespace  std;

class Solution{
private:
    unordered_map<char, int> symbol_values ={
            {'I', 1},
            {'V', 5},
            {'X', 10},
            {'L', 50},
            {'C', 100},
            {'D', 500},
            {'M', 1000}
    };
public:
    int romanToInt(string str){
        int digital = 0;
        int n = str.length();
        for(int i = 0;i < n;++i){
            int value = symbol_values[str[i]];
            if(i < n - 1 && value < symbol_values[str[i + 1]]){
                digital -= value;
            } else{
                digital += value;
            }
        }
        return digital;
    }
};

int main(){
    string Roman = {"MCMXCIV"};
    Solution solution;
    int result = solution.romanToInt(Roman);
    cout << Roman << " into roman digital " << result << endl;// 输出转换结果
    return 0;
}

java完整代码： 

import java.util.HashMap;

public class RomanToInt {
    HashMap<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
        put('I', 1);
        put('V', 5);
        put('X', 10);
        put('L', 50);
        put('C', 100);
        put('D', 500);
        put('M', 1000);
    }};

    public int romanToInt(String str) {
        int digital = 0;
        int n = str.length();
        for (int i = 0; i < n; ++i) {
            int value = this.symbolValues.get(str.charAt(i));
            if (i < n - 1 && value < this.symbolValues.get(str.charAt(i + 1))) {
                digital -= value;
            } else {
                digital += value;
            }
        }
        return digital;
    }
    public static void main(String[] args) {
        // 创建 RomanToInt 类的实例
        RomanToInt converter = new RomanToInt();
        // 设置当前罗马数字
        String Roman = "MCMXCIV";
        // 调用方法将罗马数字转换为整数
        int result = converter.romanToInt(Roman);
        // 输出转换结果
        System.out.println("罗马数字转整数为: " + result);
    }
}

 方法2 贪心哈希表

该方法其实和上面的方法差不多，也是逐一逐二的遍历哈希表中存储的罗马字符，在根据所对应的值生成我们想要的整数，其中关键的还是怎样分清楚什么时候加，什么时候进行减。

 python完整代码：

class Solution:
    def romanToInt(self, str):  # 添加 self 参数
        roman_dict = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}  # 哈希表
        digital = 0  # 整数结果

        for i in range(len(str)):  # 遍历每个字符
            # 如果当前字符比下一个字符小，则减去当前字符的值
            if i < len(str) - 1 and roman_dict[str[i]] < roman_dict[str[i + 1]]:
                digital -= roman_dict[str[i]]  # 当前字符比下一个字符小--->减
            else:
                digital += roman_dict[str[i]]  # 当前字符比下一个字符大--->加

        return digital

# 示例
Roman = "MCMXCIV"
solution = Solution()
integer_value = solution.romanToInt(Roman)
print(f"罗马数字 {Roman} 转换为整数为: {integer_value}")

c++完整代码：

#include <iostream>
#include <unordered_map>
using namespace std;

class Solution {
public:
    int romanToInt(string str) {
        unordered_map<char, int> roman_dict = {{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50}, {'C', 100}, {'D', 500}, {'M', 1000}};
        int digital = 0;

        for (int i = 0; i < str.length(); ++i) {
            // 如果当前字符比下一个字符小，则减去当前字符的值
            if (i < str.length() - 1 && roman_dict[str[i]] < roman_dict[str[i + 1]]) {
                digital -= roman_dict[str[i]];  //当前字符比下一个字符小--->减
            } else {
                digital += roman_dict[str[i]]; //当前字符比下一个字符大--->加
            }
        }
        return digital;
    }
};

int main() {
    Solution solution;
    string Roman = "MCMXCIV";
    int integer_value = solution.romanToInt(Roman);
    cout << "Roman digital " << Roman << " into int: " << integer_value << endl;
    return 0;
}

 java完整代码：

import java.util.HashMap;
public class RomanToInt1 {
    public int romanToInt(String str) {
        HashMap<Character, Integer> romanDict = new HashMap<>();
        romanDict.put('I', 1);
        romanDict.put('V', 5);
        romanDict.put('X', 10);
        romanDict.put('L', 50);
        romanDict.put('C', 100);
        romanDict.put('D', 500);
        romanDict.put('M', 1000);

        int digital = 0;

        for (int i = 0; i < str.length(); ++i) {
            // 如果当前字符比下一个字符小，则减去当前字符的值
            // 在Java中，charAt 是一个用于获取字符串中指定位置字符的方法。它是String类的一个成员方法
            // 语法为char charAt(int index) 
            // 其中，index 是字符串中字符的索引，从0开始计数。返回值是指定索引位置的字符
            if (i < str.length() - 1 && romanDict.get(str.charAt(i)) < romanDict.get(str.charAt(i + 1))) {
                digital -= romanDict.get(str.charAt(i));
            } else {
                digital += romanDict.get(str.charAt(i));
            }
        }

        return digital;
    }

    public static void main(String[] args) {
        RomanToInt1 solution = new RomanToInt1();
        String roman = "MCMXCIV";
        int integerValue = solution.romanToInt(roman);
        System.out.println("罗马数字 " + roman + " 转换为整数为: " + integerValue);
    }
}

 方法3 if-else方法

if-else方法的思路很简答，主要思想就是从罗马数字的最右边往左遍历，假如输入的都是图（a）中的罗马数字，那么我们根本不用费什么劲，直接划拉一遍，直接M对应1000，I对应1等等等等，然后把得到的对应的整数加一块就皆大欢喜了，但是最重要的问题是输入的罗马数字会出现图(b)所示的情况，那么怎么解决这种情况呢？方法很简单，我们图(a)中所对应的罗马数字的情况中再加上图(b)这种情况，也就是在当前位置再往前一位进行比较，如果出现图（b）的情况时，再补充上，最后全部遍历完后，把所有数字加一块就功成身退了。、

  c++完整代码： 

// -*- coding: utf-8 -*-
// @Time    : 2024/1/4 10:28
// @Author  : 长沙有肥鱼
// @FileName: 罗马数字转整数_if.cpp
// @Software: CLion
// @Blog    : https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

#include <iostream>
using namespace std;

class Solution {
public:
    int romanToInt(std::string str) {
        int len = str.length();
        int digital = 0;
        for (int i = len - 1; i >= 0; i--) {  //从右往左边遍历
            if (str[i] == 'V') {
                if (i - 1 >= 0 && str[i - 1] == 'I') {
                    //当V左边的罗马数字为I时 digital--->+4
                    //当V左边的罗马数字不为I时 digital--->+5 因为除I以外的罗马数字都比它大
                    digital += 4;
                    i--;
                    continue;
                } else {
                    digital += 5;
                    continue;
                }
            }
            if (str[i] == 'X') {
                //当X左边的罗马数字为X时 digital--->+9
                //当X左边的罗马数字不为I时 digital--->+10
                if (i - 1 >= 0 && str[i - 1] == 'I') {
                    digital += 9;
                    i--;
                    continue;
                } else {
                    digital += 10;
                    continue;
                }
            }
            if (str[i] == 'L') {
                if (i - 1 >= 0 && str[i - 1] == 'X') {
                    //当L左边的罗马数字为X时 digital--->+40
                    //当L左边的罗马数字不为X时 digital--->+50
                    digital += 40;
                    i--;
                    continue;
                } else {
                    digital += 50;
                    continue;
                }
            }
            if (str[i] == 'C') {
                if (i - 1 >= 0 && str[i - 1] == 'X') {
                    //当C左边的罗马数字为X时 digital--->+90
                    //当C左边的罗马数字不为X时 digital--->+100
                    digital += 90;
                    i--;
                    continue;
                } else {
                    digital += 100;
                    continue;
                }
            }
            if (str[i] == 'D') {
                if (i - 1 >= 0 && str[i - 1] == 'C') {
                    //当D左边的罗马数字为C时 digital--->+400
                    //当D左边的罗马数字不为C时 digital--->+500
                    digital += 400;
                    i--;
                    continue;
                } else {
                    digital += 500;
                    continue;
                }
            }
            if (str[i] == 'M') {
                if (i - 1 >= 0 && str[i - 1] == 'C') {
                    //当M左边的罗马数字为C时 digital--->+900
                    //当M左边的罗马数字不为C时 digital--->+1000
                    digital += 900;
                    i--;
                    continue;
                } else {
                    digital += 1000;
                    continue;
                }
            }
            if (str[i] == 'I') {
                //当L左边的罗马数字为I时 digital--->+1
                digital++;
            }
        }
        return digital;
    }
};

int main() {
    Solution solution;
    std::string roman = "MCMXCIV";
    int integerValue = solution.romanToInt(roman);
    std::cout << "Roman digital " << roman << " into int:  " << integerValue << std::endl;

    return 0;
}

python完整代码： 

# -*- coding: utf-8 -*-
# @Time    : 2024/1/4 10:22
# @Author  : 长沙有肥鱼
# @FileName: 罗马数字转整数_if_else.py
# @Software: PyCharm
# @Blog    : https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343
class Solution:
    def romanToInt(self, str):
        length = len(str)
        digital = 0

        i = length - 1
        while i >= 0:
            if str[i] == 'V':
                if i - 1 >= 0 and str[i - 1] == 'I':
                    digital += 4
                    i -= 1
                else:
                    digital += 5
                i -= 1
            elif str[i] == 'X':
                if i - 1 >= 0 and str[i - 1] == 'I':
                    digital += 9
                    i -= 1
                else:
                    digital += 10
                i -= 1
            elif str[i] == 'L':
                if i - 1 >= 0 and str[i - 1] == 'X':
                    digital += 40
                    i -= 1
                else:
                    digital += 50
                i -= 1
            elif str[i] == 'C':
                if i - 1 >= 0 and str[i - 1] == 'X':
                    digital += 90
                    i -= 1
                else:
                    digital += 100
                i -= 1
            elif str[i] == 'D':
                if i - 1 >= 0 and str[i - 1] == 'C':
                    digital += 400
                    i -= 1
                else:
                    digital += 500
                i -= 1
            elif str[i] == 'M':
                if i - 1 >= 0 and str[i - 1] == 'C':
                    digital += 900
                    i -= 1
                else:
                    digital += 1000
                i -= 1
            elif str[i] == 'I':
                digital += 1
        return digital

# 示例
solution = Solution()
roman_numeral = "MCMXCIV"
integer_value = solution.romanToInt(roman_numeral)
print(f"罗马数字 {roman_numeral} 转换为整数为: {integer_value}")

Java完整代码： 

public class RomanToInt2 {
    public int romanToInt(String str) {
        int len = str.length();
        int digital = 0;
        // 如果当前字符比下一个字符小，则减去当前字符的值
        // 在Java中，charAt 是一个用于获取字符串中指定位置字符的方法。它是String类的一个成员方法
        // 语法为char charAt(int index)
        // 其中，index 是字符串中字符的索引，从0开始计数。返回值是指定索引位置的字符
        for(int i = len - 1; i >= 0; i--) {
            if(str.charAt(i) == 'V') {
                if((i - 1 >= 0) && (str.charAt(i - 1) == 'I'))
                {
                    digital += 4;
                    i--;
                    continue;
                }
                else {
                    digital+=5;
                    continue;
                }
            }
            if(str.charAt(i) == 'X') {
                if((i - 1 >= 0) && (str.charAt(i - 1) == 'I'))
                {
                    digital += 9;
                    i--;
                    continue;
                }
                else {
                    digital += 10;
                    continue;
                }
            }
            if(str.charAt(i) == 'L') {
                if((i - 1 >= 0) && (str.charAt(i - 1) == 'X'))
                {
                    digital += 40;
                    i--;
                    continue;
                }
                else {
                    digital += 50;
                    continue;
                }
            }
            if(str.charAt(i) == 'C') {
                if((i - 1 >= 0) && (str.charAt(i - 1) == 'X'))
                {
                    digital += 90;
                    i--;
                    continue;
                }
                else {
                    digital += 100;
                    continue;
                }
            }
            if(str.charAt(i) == 'D') {
                if((i - 1 >= 0) && (str.charAt(i - 1) == 'C'))
                {
                    digital += 400;
                    i--;
                    continue;
                }
                else {
                    digital += 500;
                    continue;
                }
            }
            if(str.charAt(i) == 'M') {
                if((i - 1 >= 0) && (str.charAt(i - 1) == 'C'))
                {
                    digital += 900;
                    i--;
                    continue;
                }
                else {
                    digital += 1000;
                    continue;
                }
            }
            if(str.charAt(i) == 'I') {
                digital++;
            }
        }
        return digital;
    }
    public static void main(String[] args) {
        RomanToInt2 solution = new RomanToInt2();
        String roman = "MCMXCIV";
        int integerValue = solution.romanToInt(roman);
        System.out.println("罗马数字 " + roman + " 转换为整数为: " + integerValue);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/291263.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

构建健康游戏环境：DFA算法在敏感词过滤的应用

构建健康游戏环境：DFA算法在敏感词过滤的应用

现在的游戏有敏感词检测这一点，相信大家也不陌生了，不管是聊天，起名，签名还是简介，只要是能让玩家手动输入的地方，一定少不了敏感词识别，至于识别之后是拒绝修改还是星号替换，这个就各有各的做法了，但是绕不开的一定是需要高效的敏感词检测机制。 相信大家对于游戏里聊…
阅读更多...
25. 数组作为函数参数

25. 数组作为函数参数

写代码时&#xff0c;我们会将数组作为参数传给函数 冒泡排序&#xff1a; 两两相邻的元素进行比较&#xff0c;可能的话进行交换 一趟冒泡排序会将一个元素放在其最后应该在的位置 10个数字只需9趟&#xff0c;第一趟10个数字待排序&#xff0c;9对比较&#xff1b;第二趟…
阅读更多...
Hotspot源码解析-第十二章-线程栈保护页

Hotspot源码解析-第十二章-线程栈保护页

了解保护页&#xff0c;先从几个问题开始吧 1、为什么线程栈有栈帧了&#xff0c;还要有保护页&#xff1f; 答&#xff1a;在操作系统中内存可以看成是一个大数组&#xff0c;这就有一个问题&#xff0c;线程之间可能会互相踩了别人的内存空间&#xff0c;所以栈空间也存在这…
阅读更多...
OPENGL,GPU图形库Skia在Windows下编译多种VS版本的DLL

OPENGL,GPU图形库Skia在Windows下编译多种VS版本的DLL

这几天刚改了改Duilib&#xff0c;之前为了让Duilib更好的支持透明异形窗体所以把Duilib改为Gdi和Gdi的双渲染引擎。于是想到了有时间就把渲染引擎完全独立为渲染接口&#xff0c;可以增加更多的渲染引擎。现在来说Skia是个很不错的渲染&#xff0c;之前我只是单独编译了VS2013…
阅读更多...
集群部署篇--Redis 集群动态伸缩

集群部署篇--Redis 集群动态伸缩

文章目录 前言一、redis 节点的添加1.1 redis 的实例部署&#xff1a;1.2 redis 节点添加&#xff1a;1.3 槽位分配&#xff1a;1.4 添加从节点&#xff1a; 二、redis 节点的减少2.1 移除主节点2.1.1 迁移槽位2.1.1 删除节点&#xff1a; 三、redis 删除节点的重新加入3.1 加入…
阅读更多...
Android Studio新手实战——深入学习Activity组件

Android Studio新手实战——深入学习Activity组件

目录 前言 一、Activity简介 二、任务栈相关概念 三、常用Flag 四、结束当前Activity 五、Intent跳转Activity 六、更多资源 前言 Android是目前全球最流行的移动操作系统之一&#xff0c;而Activity作为Android应用程序的四大组件之一&#xff0c;是Android应用程序的核…
阅读更多...
一文讲透怎样用SPSS做二项Logistic回归分析？结果如何解释？

一文讲透怎样用SPSS做二项Logistic回归分析？结果如何解释？

推荐采用《SPSS统计分析入门与应用精解&#xff08;视频教学版&#xff09;》 杨维忠、张甜 清华大学出版社“7.4 二元Logistic回归分析” 的解答。 本节内容选自《SPSS统计分析入门与应用精解&#xff08;视频教学版&#xff09;》 杨维忠、张甜 清华大学出版社“7.4 二元Logi…
阅读更多...
对象克隆学习

对象克隆学习

假如说你想复制一个简单变量。很简单&#xff1a; int apples 5; int pears apples; 不仅仅是int类型&#xff0c;其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。 但是如果你复制的是一个对象&#xff0c;情况就有些复杂了。 …
阅读更多...
VMware Workstation虚拟机CentOS 7.9 配置固定ip的步骤

VMware Workstation虚拟机CentOS 7.9 配置固定ip的步骤

VMware Workstation虚拟机CentOS7.9配置固定ip的步骤 编辑虚拟机 打开VMware Workstation。 选择要配置的虚拟机&#xff0c;但不要启动它。 点击“编辑虚拟机设置”&#xff08;Edit virtual machine settings&#xff09;。 选择“网络适配器”&#xff08;Network Adapter&…
阅读更多...
Mybatis源码基本原理--XML版

Mybatis源码基本原理--XML版

文章目录 mybatis是什么架构设计首先建立起Mapper的代理工程和代理映射器的注册和使用XML文件解析数据源解析、创建和使用SQL执行器&#xff08;Executor&#xff09;的定义与实现SQL解析参数处理器&#xff1a;策略模式实现封装处理结果注解 mybatis 是什么 MyBatis 是一款优…
阅读更多...
光掩膜基板，到2024年全球市场规模将超过30亿美元

光掩膜基板，到2024年全球市场规模将超过30亿美元

光掩膜基板是一种用于微电子加工的关键材料&#xff0c;其特点是具有高透光性和高平整度&#xff0c;能够提升微电子元器件的成品率和品质。全球市场分析 从全球市场来看&#xff0c;光掩膜基板市场规模持续增长。据分析&#xff0c;到2024年&#xff0c;全球光掩膜基板市场规模…
阅读更多...
全志R128硬件设计指南①

全志R128硬件设计指南①

原理图设计 硬件系统框图 R128是一颗专为“音视频解码”而打造的全新高集成度 SoC&#xff0c;主要应用于智能物联和专用语音交互处理解决方案。 单片集成 MCURISCVDSPCODECWIFI/BTPMU&#xff0c;提供生态配套成熟、完善的用于系统、应用和网络连接开发的高效算力&#xff…
阅读更多...
JavaScript高级程序设计读书记录(一):语言基础,语法,变量,数据类型

JavaScript高级程序设计读书记录(一):语言基础,语法,变量,数据类型

1. 语法 很大程度上借鉴了 C 语言和其他类 C 语言&#xff0c;如 Java 和 Perl. 1.1 区分大小写 1.2 标识符 第一个字符必须是一个字母、下划线&#xff08;_&#xff09;或美元符号&#xff08;$&#xff09;&#xff1b; 剩下的其他字符可以是字母、下划线、美元符号或数…
阅读更多...
企业培训系统开发：构建灵活高效的学习平台

企业培训系统开发：构建灵活高效的学习平台

企业培训系统的开发在当今数字化时代是至关重要的。本文将介绍一些关键技术和代码示例&#xff0c;以帮助您构建一个灵活、高效的企业培训系统。 1. 技术选型 在开始企业培训系统的开发之前&#xff0c;首先需要选择合适的技术栈。以下是一个基本的技术选型示例&#xff1a;…
阅读更多...
Spring Boot整合Spring Security：构建安全的Web应用

Spring Boot整合Spring Security：构建安全的Web应用

文章目录 1. 添加依赖2. 配置Spring Security3. 创建用户服务4. 控制器和视图5. 运行应用 &#x1f388;个人主页&#xff1a;程序员 小侯 &#x1f390;CSDN新晋作者 &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏 ✨收录专栏&#xff1a;Java框架 ✨文章内容&#xff1a;…
阅读更多...
RK3568驱动指南｜第九篇 设备模型-第108章 驱动注册流程分析实验

RK3568驱动指南｜第九篇 设备模型-第108章 驱动注册流程分析实验

瑞芯微RK3568芯片是一款定位中高端的通用型SOC&#xff0c;采用22nm制程工艺&#xff0c;搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码&#xff0c;支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU&#xff0c;可用于轻量级人工…
阅读更多...
计算机创新协会冬令营——暴力枚举题目04

计算机创新协会冬令营——暴力枚举题目04

说句实话&#xff0c;单纯的暴力枚举题目太难找了┭┮﹏┭┮&#xff0c;接招吧~~ 题目 2094. 找出 3 位偶数 - 力扣&#xff08;LeetCode&#xff09; 给你一个整数数组 digits &#xff0c;其中每个元素是一个数字&#xff08;0 - 9&#xff09;。数组中可能存在重复元素。…
阅读更多...
光伏效果图是用什么软件建模设计的？

光伏效果图是用什么软件建模设计的？

光伏效果图是展示光伏系统在建筑或地面上的外观和效果的图像。要创建这样的效果图&#xff0c;需要使用专业的建模和设计软件。那么&#xff0c;光伏效果图是用什么软件建模设计的呢&#xff1f; 鹧鸪云光伏设计软件&#xff1a;鹧鸪云是一款集开发、设计和施工为一体的设计软…
阅读更多...
【每日一题】被列覆盖的最多行数

【每日一题】被列覆盖的最多行数

文章目录 Tag题目来源解题思路方法一&#xff1a;二进制枚举 写在最后 Tag 【二进制枚举】【矩阵】【2024-01-04】 题目来源 2397. 被列覆盖的最多行数 解题思路 方法一&#xff1a;二进制枚举 思路 使用二进制枚举所有选中列的集合&#xff0c;对于集合中的每一个二进制数…
阅读更多...
whistle+SwitchyOmega前端api代理调试

whistle+SwitchyOmega前端api代理调试

1、whistle介绍 whistle官网whistle githubwhistle主要用于查看、修改HTTP、HTTPS、Websocket的请求、响应&#xff0c;也可以作为HTTP代理服务器&#xff0c;功能很强大 2、安装教程 官方安装文档 // 全局安装whistle npm install -g whistle// 安装whistle的inspect插件&a…
阅读更多...
最新文章

Copyright @ 2022~2023