LeetCode算法题完成计划（二）

最新推荐文章于 2022-02-10 12:55:43 发布

南城无雪

最新推荐文章于 2022-02-10 12:55:43 发布

阅读量1.1k

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/qq_35848614/article/details/98025412

版权

本文介绍了LeetCode中的一系列算法问题，包括平方数之和、两个数组的交集、第三大的数等，并提供了相应的解决方案，如双指针法、哈希表等，旨在帮助读者提升算法能力。

摘要由CSDN通过智能技术生成

1、平方数之和

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c。

分析：可以用双指针法来解决，时间复杂度是O(n)

class Solution {
    public boolean judgeSquareSum(int c) {
        int left = 0,right = (int)Math.sqrt(c);
		while (left<=right){
			if(left*left+right*right>c){
				right--;
			}else if(left*left+right*right<c){
				left++;
			}else 
				return true;
		}
		return false;
    }
}

2、两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

分析：可以先用set过滤数组中相同的元素，然后再遍历其中一个数组

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> result = new HashSet<>();
		Set<Integer> num = new HashSet<>();
		for(int n :nums1){
			num.add(n);
		}
		for(int n:nums2){
			if(num.contains(n))
				result.add(n);
		}
		int[] r = new int[result.size()];
		int i =0;
		for(int temp:result){
			r[i++]=temp;
		}
		return r;
    }
}

3、第三大的数

给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。

分析：可以暴力破解，先找出第一大的数，再找第二大的数，再找第三大的数，时间复杂度也是O（n）

class Solution {
    public int thirdMax(int[] nums) {
        if(nums.length==1)
			return nums[0];
		else if(nums.length==2){
			return nums[0]>nums[1]?nums[0]:nums[1];
		}else {
			int third  = Integer.MIN_VALUE;
			int second = Integer.MIN_VALUE;
			int first  = Integer.MIN_VALUE;
			int count  = 0;
            boolean f=true;
			for(int n :nums){
            if(n==Integer.MIN_VALUE&&f){
                count++;
                f=false;
            }
				if(n>first){
					count++;
					third = second;
					second = first;
					first = n;
				}else if(n>second&&n<first){
                    count++;
                    third = second;
                    second = n;
                }else if(n>third&&n<second){
                    count++;
                    third = n;
                }
			}
			return count>=3?third:first;
		}
    }
}

4、等价多米诺骨牌对的数量

给你一个由一些多米诺骨牌组成的列表 dominoes。

如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。

形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 a==c 且 b==d，或是 a==d 且 b==c。

在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。

分析：可以用哈希表来存储数对，存储时数对按照小-大来存储，以免重复

class Solution {
    public int numEquivDominoPairs(int[][] dominoes) {
        int count =0;
		Map<String,Integer> map = new HashMap<>();
		for (int[] dominoe : dominoes) {
			int min  = dominoe[0]>dominoe[1]?dominoe[1]:dominoe[0];
			int max  = dominoe[0]>dominoe[1]?dominoe[0]:dominoe[1];
			String key  = min+"-"+max;
			if(map.containsKey(key)){
				map.put(key,map.get(key)+1);
			}else {
				map.put(key,1);
			}
		}
		for(Integer integer :map.values()){
			if(integer>1){
				count += integer*(integer-1)/2;
			}
		}
		return count;
    }
}

5、亲密字符串

给定两个由小写字母构成的字符串 A 和 B ，只要我们可以通过交换 A 中的两个字母得到与 B