93.LeetCode 热题 100---1-3

我非算法战士 而只是像学四大件那样 无聊打发时间罢了 所以没那么厉害也没那么深入

将来的有关这个的总结 我也都分为三步走 思路 实现 学习

1.两数之和

首先说我的思路

比如说第一个元素3 然后target-3=6 就要拿着这个6去元素3后面的元素找 有的话输出 没的话下一个
唯一需要稍微动动脑的我就认为是 加一个中间量 a来等于这个target-i元素

实现起来不难

    int nums[] = new int[5], target;
        Scanner scanner = new Scanner(System.in);
        if (scanner.hasNext()) {
            for (int i = 0; i < nums.length; i++) {
                nums[i] = scanner.nextInt();
            }
        }
        target = scanner.nextInt();
//        for (int i = 0; i < nums.length; i++) {
//            System.out.println(nums[i]);
//        }
        for (int i = 0; i < nums.length; i++) {
            int a = target - nums[i];
            for (int j = i + 1; j < nums.length; j++) {
                if (a == nums[j]) {
                    System.out.println(i + "," + j);
                }
            }
        }

因为题目并没有要求实际复杂度的东西
在此推荐一个网页AI测试代码时间复杂度工具：https://www.timecomplexity.ai/

---

2.字母异位词分组

这道题我没有实现出来 但有思路 因为之前未接触过算法刷题 所以也想不到去用什么hash
先说之前的思路

我依旧打算停留在for循环来 一一查找元素 但正如ai所说 我这样的效率肯定是低的 但是思路容易理解
实现当然更复杂了 所以拆一会 再for一会 我自己都放弃这样的方法

这是ai给出的我开始思路的方法实现 当然我果断放弃 哪怕hash理解起来困难
public class GroupAnagrams {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> result = new ArrayList<>();
        boolean[] visited = new boolean[strs.length];
        
        for (int i = 0; i < strs.length; i++) {
            if (visited[i]) {
                continue;
            }
            List<String> group = new ArrayList<>();
            group.add(strs[i]);
            visited[i] = true;
            
            for (int j = i + 1; j < strs.length; j++) {
                if (!visited[j] && isAnagram(strs[i], strs[j])) {
                    group.add(strs[j]);
                    visited[j] = true;
                }
            }
            result.add(group);
        }
        return result;
    }

    private boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        int[] count = new int[26];
        for (char c : s.toCharArray()) {
            count[c - 'a']++;
        }
        for (char c : t.toCharArray()) {
            int index = c - 'a';
            count[index]--;
            if (count[index] < 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        GroupAnagrams solution = new GroupAnagrams();
        // 示例测试
        String[] strs1 = {"eat", "tea", "tan", "ate", "nat", "bat"};
        System.out.println(solution.groupAnagrams(strs1)); // 输出分组结果
        
        String[] strs2 = {""};
        System.out.println(solution.groupAnagrams(strs2)); // 输出[[""]]
        
        String[] strs3 = {"a"};
        System.out.println(solution.groupAnagrams(strs3)); // 输出[["a"]]
    }
}

先给出代码 再一一刨析

        HashMap<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String key = new String(chars);
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            map.get(key).add(str);
        }
        System.out.println(map.values());

思路：

---

3.最长连续序列

这道题如果单论实现的话 哈哈我认为我做应该是最快的 脑子一下就有了思路
但是人家要求有时间复杂度为O(n) 所以很大一部分人都应该像我这样的实现方法加入了排序
同样也在排序上消耗了时间

        int nums[] = {0, 3, 7, 2, 5, 8, 4, 6, 0, 1};
        Arrays.sort(nums);
        int a = 0;
        for (int i = 0; i < nums.length - 1; i++) {
            if ((nums[i] == nums[i + 1] - 1) || (nums[i] == nums[i + 1])) {
                a++;
            }
        }
        System.out.println(a);

在使用好方法的时候 我先来说一下我那个方法的思路

哈哈那我们来看正确的题解

        // 以下为最佳解法 时间复杂度为O(n) 省去了sort排序的时间
        HashSet<Integer> numSet = new HashSet<>();
        for (int num : nums) {
            numSet.add(num);
        }
        int longestStreak = 0;
        for (int num : numSet) {
            if (!numSet.contains(num - 1)) {
                int currentNum = num;
                int currentStreak = 1;
                while (numSet.contains(currentNum + 1)) {
                    currentNum += 1;
                    currentStreak += 1;
                }
                longestStreak = Math.max(longestStreak, currentStreak);
            }
        }
        System.out.println(longestStreak);

思路图解：

最终结果为4

以上三道题 顶多三个做出来一个半 准确对一个
可见算法一般 那无所谓 慢慢刷呗