Leetcode(盛水最多的容器；整数转罗马数字；罗马数字转整数；回文数；删除排序数组中的重复项；移除元素）

1.盛水最多的容器

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

方法一：暴力法，挺简单但提交时用大的数组测试就歇菜。

方法二：双指针法。核心在于从两个方向同时开始查找，比较height[left]和height[right]的大小，小的一侧向中间偏移一次。

class Solution {
public:
    int maxArea(vector<int>& height) {
        int maxVolumn=0;
        int currentVolumn=0;
        int left=0;
        int right=height.size()-1;
        int width;
        int h;
        while(left!=right){
            width=right-left;
            if(height[left]>=height[right]){
                h=height[right];
                right--;
            }
            else{
                h=height[left];
                left++;
            }
            currentVolumn=h*width;
            if(currentVolumn>maxVolumn)
                maxVolumn=currentVolumn;
        }

        return maxVolumn;
    }
};

 2.整数转罗马数字：

class Solution {
public:
    string intToRoman(int num) {
        if(num<1||num>3999)
            return 0;
        int b;
        int num_copy=num;
        string Roman;
        stack<int> s;
        while(num_copy>0){
            b=num_copy%10;
            num_copy=(num_copy-b)/10;
            s.push(b);
        }
        int n=s.size();
        while(!s.empty()){
            b=s.top();
            if(b==0){
                s.pop();
                n--;
                continue;
            }
            if(n==4){
                while(b>0){
                    Roman+="M";
                    b--;
                }
                s.pop();
                n--;
                continue;
            }
            if(n==3){
                switch(b){
                    case 1:
                    Roman+="C";
                    break;
                    case 2:
                    Roman+="CC";
                    break;
                    case 3:
                    Roman+="CCC";
                    break;
                    case 4:
                    Roman+="CD";
                    break;
                    case 5:
                    Roman+="D";
                    break;
                    case 6:
                    Roman+="DC";
                    break;
                    case 7:
                    Roman+="DCC";
                    break;
                    case 8:
                    Roman+="DCCC";
                    break;
                    case 9:
                    Roman+="CM";
                    break;
                }
                s.pop();
                n--;
                continue;
            }
            if(n==2){
                switch(b){
                    case 1:
                    Roman+="X";
                    break;
                    case 2:
                    Roman+="XX";
                    break;
                    case 3:
                    Roman+="XXX";
                    break;
                    case 4:
                    Roman+="XL";
                    break;
                    case 5:
                    Roman+="L";
                    break;
                    case 6:
                    Roman+="LX";
                    break;
                    case 7:
                    Roman+="LXX";
                    break;
                    case 8:
                    Roman+="LXXX";
                    break;
                    case 9:
                    Roman+="XC";
                    break;
                }
                s.pop();
                n--;
                continue;
            }
            if(n==1){
                    switch(b){
                    case 1:
                    Roman+="I";
                    break;
                    case 2:
                    Roman+="II";
                    break;
                    case 3:
                    Roman+="III";
                    break;
                    case 4:
                    Roman+="IV";
                    break;
                    case 5:
                    Roman+="V";
                    break;
                    case 6:
                    Roman+="VI";
                    break;
                    case 7:
                    Roman+="VII";
                    break;
                    case 8:
                    Roman+="VIII";
                    break;
                    case 9:
                    Roman+="IX";
                    break;
                }
                s.pop();
                n--;
                continue;
            }
        }
        return Roman;
    }
};

寻找更好的方法：（刷到一种很机智的算法）：

class Solution
{
public:
    string intToRoman(int num)
    {
        string result;
        vector<int> store = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        vector<string> strs = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        int storeSize = int(store.size());
        //贪心法
        for (int i = 0; i < storeSize; i++)
        {
            while (num >= store[i])
            {
                result.append(strs[i]);
                num -= store[i];
            }
        }
        return result;
    }
};

 3.罗马数字转数字（比较前后两个罗马数字大小，再分类累加）

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

 4.回文数。

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0)   
            return false;
        vector<int> v;
        stack<int> s;
        int temp;
        while(x>0){
            temp=x%10;
            s.push(temp);
            v.push_back(temp);
            x=(x-temp)/10;
        }
        int n=v.size();
        for(int i=0;i){
            if(v[i]==s.top()){
                s.pop();
            }
            else
                return false;
        }
        return true;
    }
};

自己想的方法，时间和内存上都不咋的。

5.合并两个有序链表

使用递归法：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL)
            return l2;
        if(l2==NULL)
            return l1;
        if(l1->valval){
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        else{
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};

 6.删除排序数组中的重复项

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
    if(nums.empty())
        return 0;
    int current=0;
    int length=0;
    for(int i=1;i<nums.size();){
        if(nums[i]==nums[current]){
            i++;
        }
        else{
            nums[++current]=nums[i];
            i++;
            length++;
        }
    }
    return length+1;
    }
};

7.移除元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int end=nums.size();
        int offset=end-1;
        for(int i=end-1;i>=0;i--){
            if(nums[i]==val){
                nums[i]=nums[offset];
                nums[offset]=val;
                offset--;
            }
        }
        return offset+1;
    }
};