Leetcode刷题日记：11-15题篇

简介

这个系列将是Leetcode的刷题记录贴，按照题库顺序，每五题为一贴，主要目的做自己的记录、总结之用，但若有同学或同好看到此贴，并有所帮助，也算额外之喜，共勉！

题目：

十一.盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

题解：

class Solution {
public:
    int maxArea(vector<int>& height) {
        //定义两个指针分别指向头和尾
        int head=0,tail=height.size()-1;
        //计算以头尾为底边的初始容器的面积
        int maxarea=min(height[head],height[tail])*(tail-head);
        while(tail>head){
            //比较两个指针的边的长度，保留高的一个更容易得到大的面积
            if(height[head]>height[tail]) tail-=1;
            else head+=1;
            int tmparea=min(height[head],height[tail])*(tail-head);
            maxarea=max(tmparea,maxarea);
        }
        return maxarea;

    }
};

思路：双指针，初始时容器为头和尾构成，然后对指针进行移动，由于不论头或者尾每移动一格对底边的改变是一样的，故对两条边进行比较，将短的一条进行移动更有利于获得一个更大的容器，循环结束的条件便是尾指针>头指针

十二、整数转罗马数字

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

字符	Value
I	1
V	5
X	10
L	50
C	100
D	500
M	1000

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 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。

给你一个整数，将其转为罗马数字。

示例：

输入: num = 3
输出: “III”

题解：

class Solution {
public:
    string intToRoman(int num) {
        string ans;
        //使用两个数组，对应于同一个i，[i]和chara[i]即是相互对应的
        //使用倒序，符合输出形式
        //在已知数组长度时，使用数组而非vector，可以减小内存消耗
        int value[13]={1000,900,500,400,100,90,50,40,10,9,5,4,1};
        string chara[13]={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};

        int i=0;
        while(num>0){
            if(num>=value[i]){
                ans=ans+chara[i];
                //这里使用减法而非除法
                num-=value[i];
            }
            else i++;
        }
        return ans;
    }
};

思路：
给一个数2100，首先判断其是否大于1000，大于1000就将"M"放入ans尾部，然后这个数减去1000，再判断，还是大于1000，ok再减去1000，再将一个"M"放入ans尾部，减去1000，剩下100，判断是否大于900、500、400，直到100，将一个"C"放入ans尾部，减去100，剩下0，循环结束
执行用时击败94%，内存消耗击败97%

总结：
1.在已知数据数量时，使用数组而非vector<>可以有效减下内存消耗

十三、罗马数字转整数

题目条件如第十二题，要求输入一个罗马数字输出对应整数

示例：

输入: “III”
输出: 3

题解：

class Solution {
public:
    int romanToInt(string s) {
        int ans=0;
        unordered_map<string,int> mymap={{"I",1},{"IV",4},{"V",5},{"IX",9},{"X",10},{"XL",40},{"L",50},{"XC",90},{"C",100},{"CD",400},{"D",500},{"CM",900},{"M",1000}};

        int i=0;
        while(i<s.size()){
            //判断是否存在4，9之类的数
            if(mymap.find( s.substr(i,2) )!=mymap.end() ){
                ans+=mymap[s.substr(i,2)]; 
                i+=2;
                //注意continue
                continue;
            }
            else{
                ans+=mymap[s.substr(i,1)];
                i++;
            }
        }
        return ans;
    }
};

思路：使用hashmap存储对应关系，例如对于 IV，先要判断是否存在4，9之类的数，故对s.substr(i,i+2)进行find(),得到结果是4，若先判断单个字符，则会得到 1+5 = 6，出错

总结：
1.find()函数的参数不能写 s[i],s[i]+s[i+1] ,而要使用 s.substr(head,length),因为s[i]的类型是 char，而 s.substr(i,1)的类型是string

十四、最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例：

输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”

题解：

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int minlen=INT_MAX;
        int minsubstr;
        for(int i=0;i<strs.size();i++)
            if(minlen>strs[i].size() ){
                //记录下最小的字串的长度，用以下面的循环的边界条件
                minlen=strs[i].size();
                //记录最小的字串的序号，当循环结束都未出现不同的字符时，则最短的字串即为答案
                minsubstr=i;
            }
        for(int i=0;i<minlen;i++){
            for(int j=0;j<strs.size();j++){
                //只要出现不同的字符，即刻结束，返回此时的子串
                if(strs[j][i] != strs[0][i])
                    return strs[0].substr(0,i);
            }
        }
        return strs[minsubstr];
    }
};

思路：对每个字符串的第 i 个字符进行比较，全部相同则 i 加一，直到不同为止，此时的 i 即是最长的前缀的长度，对任何一个字符串的前 i 个字符输出即可

十五、 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例2：

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

题解：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int> > ans;
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();i++){
            if(i>0 && nums[i]==nums[i-1]) continue;
            int head=i+1,tail=nums.size()-1;
            while(head<tail){
                if(head>i+1 && nums[head]==nums[head-1]){
                    head++;
                    continue;
                } 
                int sum=nums[head]+nums[tail]+nums[i];
                if(sum<0)
                    head++;
                if(sum>0)
                    tail--;
                if(sum==0){
                    ans.push_back({nums[i],nums[head],nums[tail]});
                    head++;
                }
            }
        }
        return ans;
    }
};

思路：使用了双指针解法，双指针的核心代码和传统解法的对比如下：

//这是双指针的写法
while(head<tail){
    if(sum<0)
        head++;
    if(sum>0)
        tail--;
    if(sum==0)
        //...
}
//这是普通写法
for(int i=0;i<m;i++)
    for(int j=0;j<n;j++){
        if(sum==0)
            //...
}

可以看到，双指针将一个两层循环转化成了一层循环，时间复杂度也从n^2变成了n，那么如何实现将普通写法到双指针写法的转换呢？
一般来讲，当遇到需要对一个数组进行重复遍历时，可以想到使用双指针法
说是指针，其实是设置两个int变量分别赋值为数组的首和尾，在一层循环内，每次只对其中一个指针进行移动，找到判断指针移动的条件是双指针的核心，在该题中，是一个求和为0的问题，那么当sum>0时，显然说明整体的值太大了，应该让其更小，故对于排序后的数组将尾指针左移，显然，sum和0的大小便是此题中判断指针移动的条件

注

题目来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

博客著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。