shabi算法总结-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_38608582/article/details/121795783

本文总结了几个算法问题，包括53题的最大子数组和，采用了特定的解法；825题适龄朋友的解决策略，通过排序和双指针或桶排序加前缀和；还提到了1题两数之和的解决方案，具有o(n)的时间复杂度和o(n)的空间复杂度。此外，提及了无法理解的846题一手顺子问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

53、最大子数组和

class Solution {
    public int maxSubArray(int[] nums) {
        int ans = nums[0];
        int sum = 0;
        for(int num: nums) {
            if(sum > 0) {
                sum += num;
            } else {
                sum = num;
            }
            ans = Math.max(ans, sum);
        }
        return ans;
    }
}

（算法抄的）解法：

想通了，希望下次遇到还记得

825.适龄朋友

排序 + 双指针

class Solution {
    public int numFriendRequests(int[] ages) {
        Arrays.sort(ages);
        int n = ages.length, ans = 0;
        for (int k = 0, i = 0, j = 0; k < n; k++) {
            while (i < k && !check(ages[i], ages[k])) i++;
            if (j < k) j = k;
            while (j < n && check(ages[j], ages[k])) j++;
            if (j > i) ans += j - i - 1;
        }
        return ans;
    }
    boolean check(int x, int y) {
        if (y <= 0.5 * x + 7) return false;
        if (y > x) return false;
        if (y > 100 && x < 100) return false; 
        return true;
    }
}

桶排序 + 前缀和

class Solution {
    int N = 130;
    public int numFriendRequests(int[] ages) {
        int[] nums = new int[N];
        for (int i : ages) nums[i]++;
        for (int i = 1; i < N; i++) nums[i] += nums[i - 1];
        int ans = 0;
        for (int y = 1, x = 1; y < N; y++) {
            int a = nums[y] - nums[y - 1]; // 有 a 个 y
            if (a == 0) continue;
            if (x < y) x = y;
            while (x < N && check(x, y)) x++;
            int b = nums[x - 1] - nums[y - 1] - 1; // [y, x) 为合法的 x 范围，对于每个 y 而言，有 b 个 x
            if (b > 0) ans += b * a;
        }
        return ans;
    }
    boolean check(int x, int y) {
        if (y <= 0.5 * x + 7) return false;
        if (y > x) return false;
        if (y > 100 && x < 100) return false; 
        return true;
    }
}

两个解法都看不到卧槽。。。。

1、两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

时间复杂度 o(n)

空间复杂度 o(n)

846.一手顺子

class Solution {
    public boolean isNStraightHand(int[] hand, int groupSize) {
        int n = hand.length;
        if (n % groupSize != 0) {
            return false;
        }
        Arrays.sort(hand);
        Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();
        for (int x : hand) {
            cnt.put(x, cnt.getOrDefault(x, 0) + 1);
        }
        for (int x : hand) {
            if (!cnt.containsKey(x)) {
                continue;
            }
            for (int j = 0; j < groupSize; j++) {
                int num = x + j;
                if (!cnt.containsKey(num)) {
                    return false;
                }
                cnt.put(num, cnt.get(num) - 1);
                if (cnt.get(num) == 0) {
                    cnt.remove(num);
                }
            }
        }
        return true;
    }
}

看不懂