LeetCode Day2

最新推荐文章于 2025-02-10 16:59:43 发布

creep9709

最新推荐文章于 2025-02-10 16:59:43 发布

阅读量178

点赞数

CC 4.0 BY-SA版权

分类专栏：学习

本文链接：https://blog.youkuaiyun.com/qq_40676859/article/details/90145289

学习专栏收录该内容

9 篇文章

订阅专栏

本文探讨了三个经典算法问题：单词拆分、最大数构建及直线上最多点数的计算。通过深入解析，展示了如何使用动态规划、自定义比较器和几何算法解决这些挑战。

139.单词拆分
难度：中等
给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
说明：
拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。
示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
     注意你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

解：
执行用时 : 14 ms, 在Word Break的Java提交中击败了61.75% 的用户
内存消耗 : 41.4 MB, 在Word Break的Java提交中击败了49.95% 的用户
思路：dp
Code:

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
    boolean dp[]=new boolean[s.length()+1];
    dp[0]=true;
    for(int i=1;i<=s.length();++i){
        for(int j=0;j<i;++j){
            if(dp[j]&&wordDict.contains(s.substring(j,i))){
                dp[i]=true;
                break;
            }
                
        }
    }
    return dp[s.length()];
}
}

179. 最大数‘
难度：中等
给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。
示例 1:

输入: [10,2]
输出: 210

示例 2:

输入: [3,30,34,5,9]
输出: 9534330

说明: 输出结果可能非常大，所以你需要返回一个字符串而不是整数。
解：
执行用时 : 17 ms, 在Largest Number的Java提交中击败了76.64% 的用户
内存消耗 : 41.4 MB, 在Largest Number的Java提交中击败了67.54% 的用户
思路：自己实现Comparator接口满足题目要求
Code:

class Solution {
    public String largestNumber(int[] nums) {
        String[]s = new String[nums.length];
        for(int i = 0;i < nums.length;i++){
            s[i] = nums[i]+"";
        }
        Arrays.sort(s, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return -(a+b).compareTo(b+a);
            }
        });
    if(s[0].equals("0"))
        return "0";
    String reslut="";
    for(int i = 0;i < s.length;++i){
            reslut += s[i];
    }
    return reslut;
    }
}

149.直线上最多的点
难度：困难
给定一个二维平面，平面上有 n 个点，求最多有多少个点在同一条直线上。

示例 1:

输入: [[1,1],[2,2],[3,3]]
输出: 3
解释:
^
|
|        o
|     o
|  o  
+------------->
0  1  2  3  4

示例 2:

输入: [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出: 4
解释:
^
|
|  o
|     o        o
|        o
|  o        o
+------------------->
0  1  2  3  4  5  6

解：
执行用时 : 40 ms, 在Max Points on a Line的Java提交中击败了52.82% 的用户
内存消耗 : 37.7 MB, 在Max Points on a Line的Java提交中击败了49.51% 的用户
思路：遍历任意两点，求斜率，用hashmap存储，精度问题用乘以10000.0解决。
Code:

class Solution {
    public int maxPoints(int[][] points) {
        if(points.length<3)
            return points.length;
        int max=0;	//存放结果
        int tmp;	
        Double k;	//斜率
        int samenum;	//相同点
        int inf;	//斜率为无穷大，单独存放
        for(int i=0;i<points.length;++i){
        HashMap<Double,Integer> hs=new HashMap<>();
        samenum=0;
        inf=0;
            for(int j=0;j<points.length;++j){
                if(points[i][1]==points[j][1]&&points[i][0]==points[j][0])
                    samenum++;  //相同
                else if(points[i][0]==points[j][0])
                    inf++;  //斜率无穷大
                else{
                k=(points[i][1]-points[j][1])*10000.0/(points[i][0]-points[j][0]);//求斜率，防止斜率过小精度丢失，乘以10000.0
                if(!(hs.containsKey(k)))
                   hs.put(k,1);
                else
                   hs.put(k,hs.get(k)+1);
                }
                
            }
            for(int m:hs.values()){  //遍历hashmap的value
                if (m + samenum > max) {
					max = m + samenum;//寻找最大值
				}
            }
            if (inf + samenum>max ) {//与斜率为无穷比较
				max = inf + samenum;
			}
            }
        return max;
        }
}