LeetCode撕代码记录

LeetCode随笔，持续更新

812. 最大三角形面积

给定包含多个点的集合，从其中取三个点组成三角形，返回能组成的最大三角形的面积。

个人思路：使用i,j,k三层循环强行遍历所有三个点的情况，并分别使用公式S=1/2[(x1y2-x2y1)+(x2y3-x3y2)+(x3y1-x1y3)]计算出可能的三角形面积，取最大值返回。

class Solution {
    public double largestTriangleArea(int[][] points) {
        double area = 0.00, maxArea = 0.00;
        for(int i = 0;i<points.length;i++){
            for(int j = 0;j<points.length;j++){
                for(int k = 0;k<points.length;k++){
                    area = (points[i][0]*points[j][1]-
                           points[j][0]*points[i][1]+
                           points[j][0]*points[k][1]-
                           points[k][0]*points[j][1]+
                           points[k][0]*points[i][1]-
                           points[i][0]*points[k][1])*0.5;
                    if(area>maxArea){
                        maxArea = area;
                    }
                }
            }
        }
        return maxArea;
    }
}

819. 最常见的单词

给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。题目保证至少有一个词不在禁用列表中，而且答案唯一。

禁用列表中的单词用小写字母表示，不含标点符号。段落中的单词不区分大小写。答案都是小写字母。

个人思路太过混乱，执行时间长，首先将符号排除掉，然后大写转小写，然后空格分隔字符串，然后用hashmap选出出现次数最多的单词。

class Solution {
    public String mostCommonWord(String paragraph, String[] banned) {
        int num = 0;
        String key = "";
        Map<String, Integer> map = new HashMap<>();
        paragraph = paragraph.replaceAll(", "," ");
        paragraph = paragraph.replaceAll(","," ");
        String[] parts = paragraph.split(" ");
        for(int i = 0;i<parts.length;i++){
            parts[i] = parts[i].toLowerCase();
            if(parts[i].substring(parts[i].length()-1).equals(";")||
              parts[i].substring(parts[i].length()-1).equals(".")||
              parts[i].substring(parts[i].length()-1).equals("?")||
              parts[i].substring(parts[i].length()-1).equals("!")||
              parts[i].substring(parts[i].length()-1).equals("'")){
                parts[i] = parts[i].substring(0,parts[i].length()-1);
            }
            for(int j = 0;j<banned.length;j++){
                if(parts[i].equals(banned[j])){
                    parts[i] = "*";
                }
            }
            if(!parts[i].equals("*")){
                if(!map.containsKey(parts[i])){
                    map.put(parts[i],1);
                    if(num == 0){
                        num = 1;
                        key = parts[i];
                    }
                }else{
                    map.put(parts[i],map.get(parts[i])+1);
                    if(map.get(parts[i])+1>num){
                        num = map.get(parts[i])+1;
                        key = parts[i];
                    }
                }
            }
        }
        return key;
    }
}

7. 整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

个人思路：先转字符串，然后找出特殊情况：0、以0结尾，利用string的反转方法，将字符串反转，然后判断是否溢出，最后转为整形返回。

class Solution {
    public int reverse(int x) {
        if(x == 0){
            return 0;
        }else{
            int flag = 0;
            String str = String.valueOf(x);
            char ch = str.charAt(str.length()-1);
            while(ch == '0'){
                str = str.substring(0,str.length()-1);
                ch = str.charAt(str.length()-1);
            }
            if(str.charAt(0) == '-'){
                flag = 1;
                str = str.substring(1);
            }
            str = new StringBuilder(str).reverse().toString();
            if(Long.valueOf(str)>2147483647){
                return 0;
            }else{
                if(flag == 0){
                    return Integer.valueOf(str);
                }else{
                    return -Integer.valueOf(str);    
                }
            }
        }
    }
}

9. 回文数

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

个人思路：没有考虑降低时间复杂度的方法，直接使用了String的反转和比较函数。提交之后耗时230ms是否恐怖，仔细看才发现原来是因为有1w+的测试用例导致的。