Day3 LeetCode 11 14 15

LeetCode刷题第三天  11/14/15题

1. 盛最多水的容器（LeetCode 11 题）

1.1题目

 

1.2思路

 

本题原本我使用map方法，对每两个数字进行计算然后统计，用之前计算的值和现在求出来的值进行比较，然后简化计算得到最大值。但是这个方法在LeetCode的一个比较巨大的测试例子中超时了。（我简单说说，就是先给出对角线的值，然后把后面的平行对角线的值通过边界算出来一个值，然后和左边、下方的填入值比较求出最大值。这样节约了前面计算的次数，但是大大增加了存储空间……害，最后失败告终）

这是失败的代码，不过我觉得看我能写出来也能看到自己的进步。

public static int maxArea(int[] height) {
        int[][] map = new int[height.length][height.length] ;
        for (int i = 0; i < height.length; i++) {
            map[i][i]= 0;
        }
        for (int i = 0; i < height.length-1; i++) {
//            System.out.println(i);
            int j=0,k=i+1;
            while(j<height.length-i-1){
                int vnotCop = (i+1)*Math.min(height[j],height[k]);
                int v = vnotCop>map[j][k-1]?vnotCop:map[j][k-1];
                map[j][k] = v>map[j+1][k]?v:map[j+1][k];
                j++;k++;
            }
        }
        return map[0][height.length-1];
    }

 

下面是可以通过方法的思路。

首先我们要理解如何得到最大值。最简单的思路就是任取两个做计算体积。非常直接但是有待优化。（时间复杂度 N2）

 public static int maxArea(int[] height) {
        int maxS = 0;
        for (int i = 0; i < height.length; i++) {
            for (int j = i+1; j < height.length; j++) {
                maxS = Math.max(maxS,Math.min(height[i],height[j])*(j-i));
            }
        }
        return maxS;
    }

比较理想的思路是采用双指针的方法进行求解，构造两个指针指向两边，然后不断收缩。双指针有个优点就是计算的时候，这个体积是根据比较小的一遍决定总体积的，那一边小即让哪一边的指针收缩。这样不断收缩内部的距离，遍历完所有的值，结束时就有最大的体积啦。（时间复杂度N）

1.3代码

class Solution {
    public int maxArea(int[] height) {
        int maxS = 0;
        int i=0,j=height.length-1;
        int haighB = 0;
        while(i<j){
            maxS = Math.max(maxS,Math.min(height[i],height[j])*(j-i));
            int k = height[i]<height[j]?i++:j--; //k没有意义 就是写起来好看
        }
        return maxS;
    }
}

2. 最长公共子串（LeetCode 14 题）

2.1题目

2.2思路

太困了，明天补

2.3代码

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs.length==0)return "";
        String s=strs[0];
        for (String string : strs) {
            while(!string.startsWith(s)){
                if(s.length()==0)return "";
                s=s.substring(0,s.length()-1);
            }
        }
        return s;
    }
}

 

3. 最长公共子串（LeetCode 15 题）

3.1题目

3.2思路

首先需要对每个起始点进行存储，然后简化成两个数加法。

3.3代码

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> re = new ArrayList<>();
        Arrays.sort(nums);
        int n = nums.length;
        for (int i = 0; i < nums.length-1; i++) {
            if (i>1&&nums[i]==nums[i-1]){
                continue;
            }
            int third = n-1;
            int target = -nums[i];
            int second = i+1;
            while (second<third){
                if (target==nums[second]+nums[third]){
                    ArrayList<Integer> numss = new ArrayList<>();
                    numss.add(nums[i]);
                    numss.add(nums[second]);
                    numss.add(nums[third]);
                    int j;
                    for (j = 0; j < re.size(); j++) {
                        if (re.get(j).equals(numss)) break;
                    }if (j==re.size()){
                        re.add(numss);
                    }
                    while (second<third&&nums[second]==nums[second+1]){
                        second++;
                    }
                    second++;
                    while (nums[third]==nums[third-1]&&second<third){
                        third--;
                    }
                    third--;
                }else if (target<nums[second]+nums[third]){
                    third--;
                }else second++;
            }
        }
        return re;
    }
}