day06 | Hash专题 242,349,202,1

LeetCode242 力扣

有效的字母异位词，由于是操作string，可以使用字典(int[26])进行处理

package algor.trainingcamp;

/**
 * @author lizhe
 * @version 1.0
 * @description: https://leetcode.cn/problems/valid-anagram/
 *
 * 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
 *
 * 注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/valid-anagram
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 * @date 2023/4/10 12:22
 *
 * 字母异位词: 两个string中相同的字符出现的次数是否相等
 *
 * (1) 可以采用两个数组记录下字符出现的次数，再比较两个数组是否一致
 * (2) 可以采用一个数组， ++ --的方式判断是否一致
 */
public class LeetCode242 {
    public boolean isAnagram(String s, String t) {
        int[] dic = new int[26];

        char[] charS = s.toCharArray();
        char[] charT = t.toCharArray();

        for(char elemS : charS){
            dic[elemS - 'a']++;
        }

        for(char elemT : charT){
            dic[elemT - 'a']--;
        }

        for(int i = 0;i < dic.length;i++){
            if(dic[i] != 0){
                return false;
            }
        }

        return true;
    }
}

 LeetCode349: 力扣

* set的简单应用（注：一般代码中可以直接写，或者用redis的 set指令来处理并交差级）

package algor.trainingcamp;

import java.util.HashSet;
import java.util.Set;

/**
 * @author lizhe
 * @version 1.0
 * @description: 给定两个数组 nums1 和 nums2 ，
 * 返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
 * @date 2023/4/10 12:29
 *
 * 输出交集
 */
public class LeetCode349 {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(null == nums1 || null == nums2 || nums1.length == 0 || nums2.length == 0){
            return null;
        }

        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();

        for(int num : nums1){
            set1.add(num);
        }

        for(int num : nums2){
            if(set1.contains(num)){
                resSet.add(num);
            }
        }

        int[] res = new int[resSet.size()];
        int count = 0;
        for(int num : resSet){
            res[count++] = num;
        }

        return res;
    }
}

 

LeetCode202力扣

* 快乐数 => 最终所有的操作结果会收敛到一个区间（采用set接收，如果重复出现两次，说明已经进入了循环）

package algor.trainingcamp;

import java.util.HashSet;
import java.util.Set;

/**
 * @author lizhe
 * @version 1.0
 * @description: https://leetcode.cn/problems/happy-number/
 * @date 2023/4/10 12:43
 * 编写一个算法来判断一个数 n 是不是快乐数。
 *
 * 「快乐数」 定义为：
 *
 * 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
 * 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
 * 如果这个过程 结果为 1，那么这个数就是快乐数。
 * 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/happy-number
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 * 注: '可能会无限循环' => 如果算出快乐数的过程中发现同样的数出现了两次，则会进入循环，无需再计算
 *
 * 证明过程:
 * 先证明所有的数都会在有限次数的转化中变成小于243的数。
 * 枚举1——243，就会发现，非快乐数最终都在特定循环4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 内。
 * 第一点的证明，对于任意一个k位数，其值只能在10^(k-1)——10^k-1之间，而最大的k位数的各位数平方和是81*k，
 * 归纳证明除了k<=3以外，有81*k<10^(k-1)，
 * 这不等式意味着当某个数的位数k>3时，其各位数的平方和的位数k'<k，
 * 所以任何位数大于3的数在一次转化后肯定会降低位数，
 * 那么有限次后肯定会变成3位数，而3位数中最大的数999的各位平方和为243，所以第一点就证明成立。
 */
public class LeetCode202 {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while(n != 1 && !set.contains(n)){
            set.add(n);
            n = calc(n);
        }

        return n == 1;
    }

    /**
     * 各个位数相加
     */
    public int calc(int n){
        int sum = 0;
        while(n > 0){
            int sub = n %10;
            sum += sub * sub;
            n /= 10;
        }

        return sum;
    }
}

LeetCode01 力扣

两数之和，绝对经典的题目，除了使用Hash之外，唯一的坑可能在于是先判断 还是先入map的顺序了.. （掉进去无数回。。）

package algor.trainingcamp;

import java.util.HashMap;
import java.util.Map;

/**
 * @author lizhe
 * @version 1.0
 * @description: https://leetcode.cn/problems/two-sum/
 * 两数之和
 * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，
 * 并返回它们的数组下标。
 * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
 * 你可以按任意顺序返回答案。
 *
 * 注意: map检查应该放在map加入数的前面，先进行检查 再插数（否则类似 3,3 target = 6这种有问题）
 */
public class LeetCode01 {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();

        for(int i = 0;i < nums.length;i++){
            if(map.containsKey(target - nums[i])){
                return new int[]{i, map.get(target - nums[i])};
            }
            map.put(nums[i], i);
        }

        return null;
    }

    public static void main(String[] args) {
        LeetCode01 demo = new LeetCode01();
        demo.twoSum(new int[]{3,3}, 6);
    }
}