011 盛最多水的容器

LeetCode链接
https://leetcode-cn.com/problems/container-with-most-water/

思路：

C++代码：

//假装有代码，代码改天弄上来吧

014 最长公共前缀

LeetCode：https://leetcode-cn.com/problems/longest-common-prefix/

思路：

第一种是暴力法，直接拿第一个字符串每一位与后面的字符串比较。时间复杂度有点高，但是也不会TLE。

C++代码：

//初始代码
class Solution
{
public:
    string longestCommonPrefix(vector<string> &strs)
    {
        string result = "";
        if(!strs.size())
            return result;
        for (int j=0;j<strs[0].size();j++){//第j位字符
       		 for (int i=1;i<strs.size();i++){//第i个字符串
            		if (strs[i][j]!=strs[0][j])
                		return result;
        }
        result += strs[0][j];
    }
    return result;
    }
};

第二种，进行了一点优化，我先进行了一下排序，如果最短的字符串和最长的字符串（其实不是最长的也没有问题）没有相同的前缀，那么整个字符串数组就都没有。如果有的话，存入result，再在strs中查找是、result作为子串的数量，如果数量等于strs中字符串的数量，就说明result是相同前缀，至于为啥要排序，而不是找第一个和第二个。看一下下面的案例。

C++代码：

class Solution
{
public:
    string longestCommonPrefix(vector<string> &strs)
    {
        string result = "";
        if (strs.size() < 1)
            return result;
        sort(strs.begin(), strs.end());
        string s1 = *strs.begin(), s2 = *(strs.end() - 1);
        int i = 0;
        while (i < s1.length())
        {
            if (s1[i] != s2[i])
                break;
            result.push_back(s1[i]);
            i++;
        }
        if (i == 0)
            return "";
        int flag = 0;
        for (int j = 0; j < strs.size(); j++)
        {
            if (strs[j].find(result) != -1)
                flag++;
        }
        if (flag != strs.size())
            return "";
        return result;
    }
};

015 三数之和

LeetCode链接：https://leetcode-cn.com/problems/3sum/

先来放一个TTL的暴力解法，三重循环嵌套＋set容器去重，复杂度O(n^3)

C++代码：

class Solution
{
public:
    vector<vector<int>> threeSum(vector<int> &nums)
    {
        set<vector<int>> result;
        for (int i = 0; i < nums.size(); i++)
        {
            for (int j = i+1; j < nums.size(); j++)
            {
                for (int k = j+1; k < nums.size(); k++)
                {
                    if (nums[i] + nums[j] + nums[k] == 0)
                    {
                        vector<int> temp;
                        temp.push_back(nums[i]);
                        temp.push_back(nums[j]);
                        temp.push_back(nums[k]);
                        sort(temp.begin(),temp.end());//排序是为了去重
                        result.insert(temp);
                    }
                }
            }
        }
        return vector<vector<int>>(result.begin(),result.end());
    }
};

思路1： 首先对数组进行排序，然后再将每个元素看作中间元素，采用折半查找的方式，设置left 和 right 标志，如果三数之和大于 0 ，left --，如果三数之和小于 0 ，right ++，赋值的时候采用set集合可以去重。
但是这种方法特别容易超时，复杂度也太高。

C++代码：

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums)
	{
		set<vector<int>> result;
		if (nums.size() < 3)
		{
			return{};
		}

		sort(nums.begin(), nums.end());
		int left;
		int right;
		int sum;
		for (int i = 1; i < nums.size(); i++)
		{
			left = i - 1;
			right = i + 1;
			while (left >= 0 && right < nums.size())
			{
				sum = nums[i] + nums[left] + nums[right];
				if (0 == sum)
				{
					vector<int> three;
					three.push_back(nums[i]);
					three.push_back(nums[left]);
					three.push_back(nums[right]);
					result.insert(three);
					int last_left = nums[left];
					int last_right = nums[right];
					left--;
					right++;
					while (left >= 0 && last_left == nums[left])
					{
						left--;
					}
					while (right < nums.size() && last_right == nums[right])
					{
						right++;
					}
				}
				else if(sum < 0)
				{
					int last_right = nums[right];
					right++;
					while (right < nums.size() && last_right == nums[right])
					{
						right++;
					}
				}
				else
				{
					int last_left = nums[left];
					left--;
					while (left >= 0 && last_left == nums[left])
					{
						left--;
					}
				}
			}
		}

		return vector<vector<int>>(result.begin(), result.end());
	}
};

思路2：或者让当前元素i作为最小元素，left=i+1，right=nums.size()-1，如果结果大于0，right–，如果结果小于0，left++；这种方法不用set去重。

C++代码：

代码有一点点的小问题，就是这组数据

class Solution
{
public:
    vector<vector<int>> threeSum(vector<int> &nums)
    {
        set<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++)
        {
            int left = i + 1;
            int right = nums.size() - 1;
            if (left >= right)
                break;
            vector<int> Three;
            while (nums[i] + nums[left] + nums[right] != 0 && left < right)
            {
                if (nums[i] + nums[left] + nums[right] < 0)
                    left++;
                if (nums[i] + nums[left] + nums[right] > 0)
                    right--;
            }
            if (nums[i] + nums[left] + nums[right] == 0&&left!=right)
            {
                Three.push_back(nums[i]);
                Three.push_back(nums[left]);
                Three.push_back(nums[right]);
                result.insert(Three);
            }
        }
        return vector<vector<int>>(result.begin(),result.end());
    }
};