LeetCode刷题——题目11、12、13、14

11.盛最多水的容器

解题：

class Solution {
public:
    int maxArea(vector<int>& height) {
        //计算面积的最大值，面积S=height · weight；
        int s=0,temp_s=0;
        int left=0,right=height.size()-1;
        while(left<right){
            temp_s=min(height[right],height[left])*(right-left);
            s=s>=temp_s?s:temp_s;
            if (height[left]>height[right]) right--;
            else left++; 
        }
        return s;
    }
};

经典面试题。思路是双指针，不多赘述。

还有用动态规划做的。暴力方法不可，会超时。

通过情况：

12.整数转罗马数字

 解题：（贪心思想）

抓住题目的核心：

可以被直接用罗马数字表示的10进制数字有：1000,900,500,400,100,90,50,40,10,9,5,4,1

那么就直接用input的十进制数字不断减去上面它能减的最大值，同时记录被减数对应的罗马数字即为最后的结果。

class Solution {
public:
    string intToRoman(int num) {
    // 1 <= num <= 3999
    string s;
    int a[13] = { 1000,900,500,400,100,90,50,40,10,9,5,4,1 };
    string b[13] = { "M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I" };
    while (num) {
        //可以直接被表示的数字有：1/5/10/50/100/500/1000   4/9/40/90/400/900
        for (int i = 0; i < 13; i++) {
            while(num >= a[i]) {
                num = num - a[i];
                s = s.append(b[i]);
            }
        }
    }
    return s;
}
};

通过结果：

 第一个while是多余的，直接去掉：

 更快的方法：直接暴力匹配。牺牲了空间，提高了速度

把所有的直接写出来：

然后一个while循环不断匹配，结束。

class Solution {
public:
    string intToRoman(int num) {
    // 1 <= num <= 3999
    string s;
    string table[4][10] = { // 1~9
                           {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"},
                            // 10~90
                           {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"},
                            // 100~900
                           {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}, 
                            // 1000~3000
                           {"", "M", "MM", "MMM"} 
                          };
    int count=0;
    while(num){
        int temp=num%10;
        s=(table[count][temp])+s;  //注意顺序
        num/=10;
        count++;
    }
    return s;
}
};

13.罗马数字转整数

 

 解题：

class Solution {
public:
    int romanToInt(string s) {
  int i = 0;
  int res = 0;
  while(i < s.size()) {
    if (s[i] == 'M') {
      res += 1000;
      i++;
    } else if (s[i] == 'C' && s[i+1] == 'M') {
      res += 900;
      i += 2;
    } else if (s[i] == 'D') {
      res += 500;
      i++;
    } else if (s[i] == 'C' && s[i+1] == 'D') {
      res += 400;
      i += 2;
    } else if (s[i] == 'C') {
      res += 100;
      i++;
    } else if (s[i] == 'X' && s[i+1] == 'C') {
      res += 90;
      i += 2;
    } else if (s[i] == 'L') {
      res += 50;
      i++;
    } else if (s[i] == 'X' && s[i+1] == 'L') {
      res += 40;
      i += 2;
    } else if (s[i] == 'X') {
      res += 10;
      i++;
    } else if (s[i] == 'I' && s[i+1] == 'X') {
      res += 9;
      i += 2;
    } else if (s[i] == 'V') {
      res += 5;
      i++;
    } else if (s[i] == 'I' && s[i+1] == 'V') {
      res += 4;
      i += 2;
    } else if (s[i] == 'I') {
      res += 1;
      i++;
    } 
  }
  return res;
    }
};

通过结果：

 其他写法：用了个映射，本质思想没变

class Solution {
public:
    int romanToInt(string s) {
        unordered_map<char, int> map={  //映射
            {'I', 1},
            {'V', 5},
            {'X', 10},
            {'L', 50},
            {'C', 100},
            {'D', 500},
            {'M', 1000}
        };
        int num=0;
        for(int i=0;i<s.size();i++){
            int value=map[s[i]];
            if(i<s.size() && value <map[s[i+1]]){
                num=num-value;
            }
            else num=num+value;
        }
        return num;
    }
};

 

14.最长公共前缀

 思路：

 下面采用的是纵向扫描的思路。

解题：

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int len=strs.size();
        int len_min=strs[0].size();
        for(int i=0;i<len;i++){
            if(strs[i].size()<len_min) len_min=strs[i].size();
        }
        string s;
        for(int i=0;i<len_min;i++){
            int j=0;
            while(j<len-1){
                if(strs[j].substr(i,1) == strs[j+1].substr(i,1)){
                    j++;
                }
                else break;
            }
            if(j==len-1){
                s=s+strs[j].substr(i,1);
            }
            else break;
        }
        return s;
    }
};

通过结果：

 其他思路：

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        sort(strs.begin(), strs.end());  //先对数组进行了从小到大的排序
        string s;
        string first = strs.front();  //字符串数组第一个字符串
        string last = strs.back();  //字符串数组最后一个字符串
        for(int i = 0; i<first.size() && i<last.size(); i++){  //无法判断谁长谁短
            if(first[i] != last[i]) break;
            s += first[i];
        }
        return s;
    }
};

 这个方法妙在sort函数。它对字符串进行了从小到大的排序，以["flower","flow","flight"]为例：

sort（数组的开头，数组的结尾）->["flight","flow","flower"]，不难发现这个排序是在对每个字符串的第一个/第二个依次比较，然后从小到大排列。这就说明，第一个字符串的前缀如果和最后一个字符串的前缀能匹配上，那这个前缀一定能和中间字符串的前缀匹配，这就非常节省时间。