342. 4的幂

难度：简单

给定一个整数，写一个函数来判断它是否是 4 的幂次方。如果是，返回 true ；否则，返回 false 。

整数 n 是 4 的幂次方需满足：存在整数 x 使得 n == 4^x

示例 1：

输入：n = 16输出：true

示例 2：

输入：n = 5输出：false

示例 3：

输入：n = 1输出：true

提示：

• -2³¹ <= n <= 2³¹ - 1

进阶：你能不使用循环或者递归来完成本题吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/power-of-four/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

4的n次幂模4 和 4的 n-k次幂模4 都为0

解题代码

/* * @lc app=leetcode.cn id=342 lang=cpp * * [342] 4的幂 */// @lc code=startclass Solution {public:    bool isPowerOfFour(int num) {        return num>0 && (num == 1 ||(num%4==0 && isPowerOfFour(num/4)));    }};// @lc code=end

输入：nums = [1,2,3]输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

输入：nums = [0]输出：[[],[0]]

class Solution {public:    vector<vector<int>> subsets(vector<int>& nums) {        vector<vector<int>> res{vector<int>()};        int i, j, len;        for (i=0; i<nums.size(); i++) {            len = res.size();            for (j=0; j<len; j++) {                auto tmp = res[j];                tmp.push_back(nums[i]);                res.push_back(tmp);            }        }        return res;    }};

难度：中等

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 **有效的 **括号组合。

示例 1：

输入：n = 3输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1输出：["()"]

提示：

• 1 <= n <= 8

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/generate-parentheses/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

dfs，左右子树为（），刚好对应二叉树结构

解题代码

class Solution {public:    vector<string> generateParenthesis(int n) {        vector<string> res;        if (n <= 0) return res;        dfs(n, "", res, 0, 0);        return res;    }    void dfs(int n, string path, vector<string>& res, int open, int close) {        if (open > n || close > open) return;        if (path.length() == 2 * n) {            res.push_back(path);            return;        }        dfs(n, path + "(", res, open + 1, close);        dfs(n, path + ")", res, open, close + 1);    }};

难度：简单

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7输出: 4

提示:

• 1 <= nums.length <= 10⁴
• -10⁴ <= nums[i] <= 10⁴
• nums 为 **无重复元素 **的 **升序 **排列数组
• -10⁴ <= target <= 10⁴

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

简单二分，要求O(log n) ，尽量不要暴力搜索

解题代码

class Solution {public:    int searchInsert(vector<int>& nums, int target) {        int left=0;        int right=nums.size()-1;        int mid=left+(right-left)/2;        if(target>nums[right]){            return right+1;        }        while(left<right){            if(nums[mid]==target){                return mid;            }            if(nums[mid]<target){                left=mid+1;            }else{                right=mid;            }            mid=left+(right-left)/2;        }        return mid;    }};

难度：困难

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]输出：6解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 

示例 2：

输入：height = [4,2,0,3,2,5]输出：9

提示：

• n == height.length
• 1 <= n <= 2 * 10⁴
• 0 <= height[i] <= 10⁵

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/trapping-rain-water/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

日常接雨水，暴力搜索，脑子不够

解题代码

暴力搜索

class Solution {public:    int trap(vector<int>& nums) {        int maxHeight=0;                int rain=0;        for(int i=0;i<nums.size();i++){            maxHeight=max(nums[i],maxHeight);        }        for(int i=0;i<nums.size();i++){            int maxleft=0,maxright=0;            //左侧最大高度            for(int j=0;j<=i;j++){                maxleft=max(maxleft,nums[j]);            }            // 右侧最大高度            for(int j=i;j<nums.size();j++){                maxright=max(maxright,nums[j]);            }            //当前位置可接高度min(Maxleft,Maxright),取决于左右最大高度低值            rain+=min(maxright, maxleft)-nums[i];;        }        return rain;    }};

超时了！！！×&%￥#@……。

果然日常接雨水啊！！！！！

DP法

看看别人的，需要从两头重新遍历一遍求出左右两侧的最大高度，这里是有很多重复计算的，很明显最大高度是可以记忆化的，用两个数组分别存每个位置的左右最大高度，

int[][] dp = new int [n] [2],其中，dp [i] [0] 表示下标i的柱子左边的最大值，dp[i] [1] 表示下标i的柱子右边的最大值。

类比这题

• 807.城市天际线

左右高度数组如下图所示

class Solution {public:int trap(vector<int>& height) {int n = height.size();// left[i]表示i左边的最大值，right[i]表示i右边的最大值vector<int> left(n), right(n);for (int i = 1; i < n; i++) {left[i] = max(left[i - 1], height[i - 1]);}for (int i = n - 2; i >= 0; i--) {right[i] = max(right[i + 1], height[i + 1]);}int water = 0;for (int i = 0; i < n; i++) {int level = min(left[i], right[i]);water += max(0, level - height[i]);}return water;}};

难度：简单

山脉数组arr

• arr.length >= 3
• 存在 i（0 < i < arr.length - 1）使得：
  • arr[0] < arr[1] < ... arr[i-1] < arr[i]
  • arr[i] > arr[i+1] > ... > arr[arr.length - 1]

给你由整数组成的山脉数组 arr ，返回任何满足 arr[0] < arr[1] < … arr[i - 1] < arr[i] > arr[i + 1] > … > arr[arr.length - 1] 的下标 i 。

示例 1：

输入：arr = [0,1,0]输出：1

示例 2：

输入：arr = [0,2,1,0]输出：1

示例 3：

输入：arr = [0,10,5,2]输出：1

示例 4：

输入：arr = [3,4,5,1]输出：2

示例 5：

输入：arr = [24,69,100,99,79,78,67,36,26,19]输出：2

提示：

• 3 <= arr.length <= 10⁴
• 0 <= arr[i] <= 10⁶
• 题目数据保证 arr 是一个山脉数组

进阶：很容易想到时间复杂度 O(n) 的解决方案，你可以设计一个 O(log(n)) 的解决方案吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

1. 直接暴力法arr[i]>arr[i-1]&&arr[i]>arr[i+1]
2. 二分法

支持暴力法和二分法，显然二分法更快

解题代码

//暴力法class Solution {public:    int peakIndexInMountainArray(vector<int>& arr) {        if(arr[0]>arr[1]){            return 0;        }        for(int i=1;i<arr.size()-1;i++){            if(arr[i]>arr[i-1]&&arr[i]>arr[i+1]){                return i;            }         }        return arr.size()-1;    }};

class Solution {public:    int peakIndexInMountainArray(vector<int>& arr) {        // if(arr[0]>arr[1]){return 0;}        int left=0,right=arr.size()-1,mid=left+(right-left)/2;        while(left!=right){            if(arr[left]<arr[mid]){                right=mid;            }else{                left=mid+1;            }            mid=left+(right-left)/2;        }        return left;    }};

难度：简单

猜数字游戏的规则如下：

• 每轮游戏，我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
• 如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。

你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：

• -1：我选出的数字比你猜的数字小 pick < num
• 1：我选出的数字比你猜的数字大 pick > num
• 0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num

返回我选出的数字。

示例 1：

输入：n = 10, pick = 6输出：6

示例 2：

输入：n = 1, pick = 1输出：1

示例 3：

输入：n = 2, pick = 1输出：1

示例 4：

输入：n = 2, pick = 2输出：2

提示：

• 1 <= n <= 2³¹ - 1
• 1 <= pick <= n

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/guess-number-higher-or-lower/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

二分核心，精髓，这样写防止越界，mid = left + ((right - left) / 2);

while(l!=r){    int mid = l +(r - l)/2;    if(guess(mid)==1) l = mid+1;    else r = mid;}

解题代码

public class Solution extends GuessGame {    public int guessNumber(int n) {        int l = 1, r = n;        while(l!=r){            int mid = l +(r - l)/2;            if(guess(mid)==1) l = mid+1;            else r = mid;        }        return l;    }}

难度：中等

给你一座由 n x n 个街区组成的城市，每个街区都包含一座立方体建筑。给你一个下标从 0 开始的 n x n 整数矩阵 grid ，其中 grid[r][c] 表示坐落于 r 行 c 列的建筑物的 高度 。

城市的 天际线 是从远处观察城市时，所有建筑物形成的外部轮廓。从东、南、西、北四个主要方向观测到的 天际线 可能不同。

我们被允许为 任意数量的建筑物 的高度增加 任意增量（不同建筑物的增量可能不同） 。 高度为 0 的建筑物的高度也可以增加。然而，增加的建筑物高度 不能影响 从任何主要方向观察城市得到的 天际线 。

在 不改变 从任何主要方向观测到的城市 天际线 的前提下，返回建筑物可以增加的 最大高度增量总和 。

示例 1：

输入：grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]输出：35解释：建筑物的高度如上图中心所示。用红色绘制从不同方向观看得到的天际线。在不影响天际线的情况下，增加建筑物的高度：gridNew = [ [8, 4, 8, 7],            [7, 4, 7, 7],            [9, 4, 8, 7],            [3, 3, 3, 3] ]

示例 2：

输入：grid = [[0,0,0],[0,0,0],[0,0,0]]输出：0解释：增加任何建筑物的高度都会导致天际线的变化。

提示：

• n == grid.length
• n == grid[r].length
• 2 <= n <= 50
• 0 <= grid[r][c] <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-increase-to-keep-city-skyline/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

正视（先列中最大）和侧视（先行中最大）的最大值，再求n*n根据两个组的最小数赋值给[i,j]，即为当前的楼最低点，算与真实的差值即为加高层数

解题代码

class Solution {public:    int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {        int n=grid.size();        //侧视图天际线最低        vector<int> row_max_min(n);        //正视图天际线最低        vector<int> col_max_min(n);        for(int i=0;i<n;i++){            int tmp=*max_element(grid[i].begin(),grid[i].end());            row_max_min[i]=tmp;        }        for(int i = 0; i < n; i++)        {            for(int j = 0; j < n; j++)            {                col_max_min[j] = max(col_max_min[j], grid[i][j]);            }        }        int res = 0;        for(int i = 0; i < n; i++)        {            for(int j = 0; j < n; j++)            {                res += min(col_max_min[j],row_max_min[i])-grid[i][j];            }        }        return res;    }};

难度：简单

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

输入: nums = [-1,0,3,5,9,12], target = 9输出: 4解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2输出: -1解释: 2 不存在 nums 中因此返回 -1

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

两种方法，注意边界条件和更新条件

解题代码

class Solution {public:    // 定义target在左闭右开的区间里，即：[left, right]    int search(vector<int> &nums, int target) {        int head = 0;        int rear = nums.size() - 1;        int mid;        while (head <= rear) {            mid = (head + rear) / 2;            if (nums[mid] == target)                return mid;            else if (nums[mid] < target) {                head = mid + 1; // 注意            } else if (nums[mid] > target) {                rear = mid - 1;            }        }        return 0;    }    // 定义target在左闭右开的区间里，即：[left, right)    int search2(vector<int>& nums, int target) {        int left = 0;        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <            int middle = left + ((right - left) >> 1);            if (nums[middle] > target) {                right = middle; // target 在左区间，在[left, middle)中            } else if (nums[middle] < target) {                left = middle + 1; // target 在右区间，在[middle + 1, right)中            } else { // nums[middle] == target                return middle; // 数组中找到目标值，直接返回下标            }        }        // 未找到目标值        return -1;    }};

217. 存在重复元素

难度：简单

nums

至少两次

true

false

示例 1：

输入：nums = [1,2,3,1]输出：true

示例 2：

输入：nums = [1,2,3,4]输出：false

示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]输出：true

提示：

• 1 <= nums.length <= 10⁵
• -10⁹ <= nums[i] <= 10⁹

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/contains-duplicate/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

排序，有相同的肯定近邻

解题代码

class Solution {public:    bool containsDuplicate(vector<int>& nums) {        sort(nums.begin(), nums.end());        while(nums.size()>1&&(nums[nums.size()-1]!=nums[nums.size()-2])){            // 判断栈顶和倒二是否相等，注意边界条件            nums.pop_back();        }        // for(int i=0; i<nums.size();i++){        //     cout << nums[i] << " ";        // }        if(nums.size()==1) return false;else return true;    }};

木木 堆了个奇怪的雪人

秦淮河畔

分割线，听首歌吧

]]> https://tianwen42.top/posts/b2d9.html 2022-03-21T03:04:00.000Z

堆了个奇怪的雪人

秦淮河畔

2022-06-30T08:02:52.000Z

输入: n = 2输出: 1解释: 2 = 1 + 1, 1 × 1 = 1。

输入: n = 10输出: 36解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

//动态规划class Solution {public:    int integerBreak(int n) {        if(n==2)            return 1;        vector<int> dp(n+1,0);        dp[2] = 1;        for(int i=3;i<=n;++i){            for(int j=1;j<i;++j)                dp[i] = max(dp[i],max(dp[i-j]*j,(i-j)*j));        }        return dp[n];    }};

//贪心算法//时间复杂度O(n)//空间复杂度O(1)class Solution {public:    int integerBreak(int n) {        if (n == 2) return 1;        if (n == 3) return 2;        if (n == 4) return 4;        int result = 1;        while (n > 4) {            result *= 3;            n -= 3;        }        result *= n;        return result;    }};

输入：x = 123输出：321

输入：x = -123输出：-321

输入：x = 120输出：21

输入：x = 0输出：0

//123  321//-123 -321//0    0#include <iostream>class Solution {public:    int reverse2(int x) {        int ans = 0;        while(x != 0)        {            if(ans > INT_MAX || ans < INT_MIN)                return 0;            ans = ans * 10 + x % 10;            x /= 10;        }        return ans;    }};

//数字对称//123 123321//-8 -88//-10 -1001int symmetryReverse(int x) {        using namespace std;        int ans = x;        while(x != 0)        {            if(ans > INT_MAX || ans < INT_MIN)                return 0;            ans = ans * 10 + x % 10;            //cout<<ans<<endl;            x /= 10;        }        return ans;    }

//数字重复//105 105105//10  1010//1   11int digitalRepeated(int x) {        using namespace std;                int ans = x;        int num = 1 + log10(x);  //位数        for (int i = num - 1; i >= 0; i--) {            if (ans == 0 || ans > INT_MAX || ans < INT_MIN)      //用for要注意0或者溢出                return 0;            int maxdigit = (int) pow(10, i);            // cout<<ans<<endl;            ans = ans * 10 + (x / maxdigit) % 10;            x %= maxdigit;        }        return ans;    }

难度：简单

在一个 平衡字符串 中，’L’ 和 ‘R’ 字符的数量是相同的。

给你一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。

注意：分割得到的每个字符串都必须是平衡字符串，且分割得到的平衡字符串是原平衡字符串的连续子串。

返回可以通过分割得到的平衡字符串的 最大数量 。

示例 1：

输入：s = "RLRRLLRLRL"输出：4解释：s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。

示例 2：

输入：s = "RLLLLRRRLR"输出：3解释：s 可以分割为 "RL"、"LLLRRR"、"LR" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。

示例 3：

输入：s = "LLLLRRRR"输出：1解释：s 只能保持原样 "LLLLRRRR".

示例 4：

输入：s = "RLRRRLLRLL"输出：2解释：s 可以分割为 "RL"、"RRRLLRLL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。

提示：

• 1 <= s.length <= 1000
• s[i] = ‘L’ 或 ‘R’
• s 是一个 平衡 字符串

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/split-a-string-in-balanced-strings/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

上楼梯问题，L下一步R上一步，在平地上num+1

“括号匹配”问题,主要是栈操作,’R’进栈,’L’出栈,栈空则匹配成功,结果加一

解题代码

class Solution:    def balancedStringSplit(self, s: str) -> int:        s=list(s)        stack=[]        high,num=0,0        while s:            if s.pop()!='R':                high-=1            else:                high+=1            if high==0:                num+=1        return num

难度：简单

给你一个字符串 s ，根据下述规则反转字符串：

• 所有非英文字母保留在原有位置。
• 所有英文字母（小写或大写）位置反转。

返回反转后的 s 。

示例 1：

输入：s = "ab-cd"输出："dc-ba"

示例 2：

输入：s = "a-bC-dEf-ghIj"输出："j-Ih-gfE-dCba"

示例 3：

输入：s = "Test1ng-Leet=code-Q!"输出："Qedo1ct-eeLg=ntse-T!"

提示

• 1 <= s.length <= 100
• s 仅由 ASCII 值在范围 [33, 122] 的字符组成
• s 不含 ‘"‘ 或 ‘\‘

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-only-letters/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

双指针法遍历

class Solution:    def reverseOnlyLetters(self, s: str) -> str:        s=list(s)        head,tail=0,len(s)-1        while(head<tail):            if s[head].isalpha() and s[tail].isalpha():                s[head],s[tail]=s[tail],s[head]    #交换                head+=1                tail-=1            elif (s[head].isalpha()) and (s[tail].isalpha()==False):                tail-=1            elif (s[head].isalpha()==False) and (s[tail].isalpha()):                head+=1            elif (s[head].isalpha()==False) and (s[tail].isalpha()==False):                head+=1                tail-=1                return ''.join(s)

难度：简单

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2输出：1解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3输出：2解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4输出：3解释：F(4) = F(3) + F(2) = 2 + 1 = 3

提示：

• 0 <= n <= 30

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fibonacci-number/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

#递归法class Solution:    def fib(self, n: int) -> int:        if(n==0):return 0        elif(n==1):return 1        else:return self.fib(n-1)+self.fib(n-2)

#通项法import mathclass Solution:    def fib(self, N):        """        :type N: int        :rtype: int        """        sqrt5=math.sqrt(5)        return round(pow((1+sqrt5)/2,N)/sqrt5)

难度：简单

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符          数值I             1V             5X             10L             50C             100D             500M             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:

输入: s = "III"输出: 3

示例 2:

输入: s = "IV"输出: 4

示例 3:

输入: s = "IX"输出: 9

示例 4:

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

示例 5:

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

提示：

• 1 <= s.length <= 15
• s 仅含字符 (‘I’, ‘V’, ‘X’, ‘L’, ‘C’, ‘D’, ‘M’)
• 题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
• 题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
• IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
• 关于罗马数字的详尽书写规则，可以参考 罗马数字 - Mathematics 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/roman-to-integer/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

替换双位罗马字符，再映射

解题代码

class Solution:    def romanToInt(self, s: str) -> int:        s = s.replace('CM', 'Q')        s = s.replace('CD', 'W')        s = s.replace('XC', 'E')        s = s.replace('XL', 'R')        s = s.replace('IX', 'T')        s = s.replace('IV', 'Y')        keys = {            'Q' : 900,            'W' : 400,            'E' : 90,            'R' : 40,            'T' : 9,            'Y' : 4,            'M' : 1000,            'D' : 500,            'C' : 100,            'L' : 50,            'X' : 10,            'V' : 5,            'I' : 1        }        ans = 0        for ch in s:            ans += keys[ch]                return ans

1. 普通指针
2. 指向 const 对象的指针
3. 指向 非const 对象的 const 指针
4. 指向 const 对象的 const 指针

首先区分引用变量与指针的区别

当创建一个变量时，通过变量名修改和指针修改的安全性不同

内存泄漏

tips

• 创建内存后一定记得free, malloc,free成对出现

• 指针创建后记得要初始化

初始化静态或全局变量不能调用函数，如

static int *pi=malloc(sizeof(int));  //编译错误

改为

static int *pi;pi = malloc(sizeof(int));