HashMap on Coder_Studio

BISHI24 谐距下标对

Sun, 08 Feb 2026 22:46:33 +0000

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        // 创建HashMap：键=差值diff（Integer），值=该diff出现的次数（Integer）
        Map<Integer, Integer> hMap = new HashMap<>();

        for (int i = 0; i < n; i++) {
            in.nextToken();
            int a = (int) in.nval;

            // diff = 前整数 - 它的位置索引
            int diff = a - i;
            hMap.put(diff, hMap.getOrDefault(diff, 0) + 1);
        }
        long total = 0;

        // 遍历Map中所有diff的出现次数
        for (int count : hMap.values()) {
            // 只有出现次数>1的diff，才能组成数对（至少2个元素才能配对）
            if (count > 1) {
                // 相同 diff 的数，两两之间都满足题目要求的条件，
                // 所以统计每个 diff 的出现次数，再算组合数就是答案。
                total += (long) count * (count - 1) / 2;
            }
        }

        out.println(total);

        out.flush();
        out.close();
        br.close();
    }

小贴士

$a_j -a_i = j-i$➡️$a_j - j= a_i-i$

BISHI23 小红书推荐系统

Sun, 08 Feb 2026 21:42:22 +0000

求解代码

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    String str = br.readLine();
    
    String[] wordStrings = str.split("\\s+");

    Map<String, Integer> hMap = new HashMap<>();
    
    for (String word : wordStrings) {
        hMap.put(word, hMap.getOrDefault(word, 0) + 1);
    }

    //    Map.Entry<String, Integer>：表示Map中的一个键值对（包含key和value）
    List<Map.Entry<String, Integer>> keywords = new ArrayList<>();
    
    for (Map.Entry<String, Integer> entry : hMap.entrySet()) {
        // 只保留出现次数≥3的单词
        if (entry.getValue() >= 3) {
            keywords.add(entry);
        }
    }

    keywords.sort((o1, o2) -> {

        if (!o1.getValue().equals(o2.getValue()) ) {
            return o2.getValue() - o1.getValue();// 降序
        } else {
            return o1.getKey().compareTo(o2.getKey());// 升序
        }
    });

    for(Map.Entry<String,Integer> entry:keywords){
        out.println(entry.getKey());
    }

    out.flush();
    out.close();
    br.close();
}

小贴士

hMap.entrySet()返回一个包含所有 Entry 的集合（Set<Map.Entry>）；
Entry 是 Map 中键值对的最小封装单元，一个 Entry 对象 = 一个 key + 一个对应的 value。

大整数哈希

Thu, 05 Feb 2026 20:38:24 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        HashMap<Long, Long> hmap = new HashMap<>();

        long total = 0;
        int n = Integer.parseInt(in.nextToken());

        for (int i = 1; i <= n; i++) {

            in = new StringTokenizer(br.readLine());
            long x = Long.parseUnsignedLong(in.nextToken());
            long y = Long.parseUnsignedLong(in.nextToken());

            long ans = hmap.getOrDefault(x, 0L);

            total += (long) i * ans;

            hmap.put(x, y);
        }

        out.println(Long.toUnsignedString(total));

        out.flush();
        out.close();
        br.close();
    }

小贴士

Long.parseUnsignedLong()专门解析 64 位无符号整数。
Long.toString()是把最高位当作符号位，输出带正负的有符号数,而Long.toUnsignedString()不会修改内存中的数据，只是换一种规则解读二进制，把所有位都当作数值位，直接解析为无符号十进制数，和题目要求的 $\text{mod}~2^{64}$结果完全一致。

哈希-缺失的第一个正整数

Sat, 17 Jan 2026 20:07:30 +0000

求解代码

public int minNumberDisappeared (int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            set.add(nums[i]);
        }
        int res = 1;
        while (set.contains(res)) {
            res++;
        }
        return res;
    }

小贴士

利用HashSet的O (1) 快速查找特性，先把数组所有元素存入哈希表，再从最小正整数1开始依次校验，找到第一个不在哈希表中的正整数，就是答案。

哈希-两数之和

Sat, 17 Jan 2026 11:13:46 +0000

求解代码

public int[] twoSum (int[] numbers, int target) {
        HashMap<Integer,Integer> map = new HashMap<>();
        int[] ans = {-1,-1};
        for(int i=0;i<numbers.length;i++){
            if(map.containsKey(target-numbers[i])){
                ans[0]= map.get(target-numbers[i])+1;
                ans[1]=i+1;
                break;
            }else{
                map.put(numbers[i], i);
            }
        }
        return ans;
    }

小贴士

对每个数字 numbers[i]，找之前已经遍历过的数字中，有没有 target - numbers[i]。

如果有，说明找到了答案。

那答案的两个下标就分别是：

之前的数的下标：map.get(target - numbers[i]) （map 里存的都是之前遍历过的数）

当前数的下标：i ，题目要求返回从 1 开始的下标，所以两个下标值都要 +1。

再说说返回的下标必须按升序排列：

由于HashMap 中存的元素的下标是「之前遍历的下标」，当前正在遍历的元素的下标是「现在的下标」，那必然满足「之前遍历的下标」 < 「现在的下标」，所以采用HashMap 解法能天然保证升序。

哈希-数组中出现次数超过一半的数字

Sat, 17 Jan 2026 11:13:35 +0000

求解代码

public int MoreThanHalfNum_Solution (int[] numbers) {
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<numbers.length;i++){
            map.put(numbers[i], map.getOrDefault(numbers[i],0)+1);
            if(map.get(numbers[i])>(numbers.length/2)){
                return numbers[i];
            }
        }
        return 0;
    }

小贴士

map.getOrDefault(k, defaultValue) ：获取 key也就是k对应的值，存在则返回原值，不存在则返回默认值defaultValue

表达式求值

Fri, 16 Jan 2026 22:24:33 +0000

求解代码

HashMap<Character,Integer> map = new HashMap<Character,Integer>(){{
        put('+',1);
        put('-',1);
        put('*',2);
    }};

    void calc(LinkedList<Integer> nums,LinkedList<Character> operators){
        if(nums.isEmpty()||nums.size()<2){
            return;
        }

        if(operators.isEmpty()){
            return;
        }

        int b = nums.pollLast();
        int a = nums.pollLast();
        char operator = operators.pollLast();

        int res = 0;

        if(operator=='+'){
            res = a+b;
        }else if(operator=='-'){
            res = a-b;
        }else if(operator=='*'){
            res = a*b;
        }
        nums.addLast(res);
    }
    public int solve(String s) {
        s = s.replaceAll(" ", "");

        char[] str = s.toCharArray();
        int n = s.length();


        LinkedList<Integer> nums = new LinkedList<>();
        LinkedList<Character> operators = new LinkedList<>();
        nums.addLast(0);

        for(int i=0;i<n;i++){
            char c = str[i];

            if(c=='('){
                operators.addLast(c);
            }else if(c==')'){
                while(!operators.isEmpty()){
                    if(operators.peekLast()!='('){
                        calc(nums,operators);
                    }else{
                        operators.pollLast();
                        break;
                    }
                }
            }else{
                if(Character.isDigit(c)){
                    int base = 0;
                    int j=i;
                    while(j<n&&Character.isDigit(str[j])){
                        base=base*10+(str[j++]-'0');
                    }
                    nums.addLast(base);
                    i=j-1;
                }else{
                    if(i>0&&(str[i-1]=='('||str[i-1]=='+'||str[i-1]=='-')){
                        nums.addLast(0);
                    }

                    while(!operators.isEmpty()&&operators.peekLast()!='('){
                        char prev = operators.peekLast();
                        if(map.get(prev)>=map.get(c)){
                            calc(nums,operators);
                        }else{
                            break;
                        }
                    }
                    operators.addLast(c);
                }
            }
        }

        while(!operators.isEmpty()&&operators.peekLast()!='('){
            calc(nums,operators);
        }
        return nums.peekLast();
        

    }

小贴士

1.nums.addLast(0) 主要用于处理【表达式以正负号开头】的场景，比如 -1+2、+3*4，可以把 -1 转为 0-1，把 +3 转为 0+3

2.i = j - 1可以修正外层 for 循环的索引i，让i直接跳到「当前多位数的最后一位」，抵消 for 循环的自动i++，避免重复遍历已经处理过的数字字符。、

比如表达式123+4，j=3：

执行 i = j - 1 → i = 3 - 1 = 2，然后，外层 for 循环执行自动 i++ → i从2变成3，下一轮循环，i=3，正好读取字符str[3] → '+'。

并查集-Leetcode947移除最多的同行或同列石头

Sat, 03 Jan 2026 23:05:05 +0000

求解代码

	public static HashMap<Integer,Integer> rowFirst = new HashMap<Integer,Integer>();
	public static HashMap<Integer,Integer> colFirst = new HashMap<Integer,Integer>();

	public static int MAXN = 1001;
	public static int[] father = new int[MAXN];

	public static int sets;

	public static void build(int n){
		rowFirst.clear();
		colFirst.clear();
		for(int i=0;i<n;i++){
			father[i]=i;
		}
		sets = n;
	}

	public static int find(int i){
		if (i!=father[i]) {
			father[i]=find(father[i]);
		}
		return father[i];
	}

	public static void union(int x,int y){
		int fx = find(x);
		int fy = find(y);
		if (fx!=fy) {
			father[fx]=fy;
			sets--;
		}
	}

	public static int removeStones(int[][] stones){
		int n = stones.length;
		build(n);

		for(int i =0;i<n;i++){
			int row = stones[i][0];
			int col = stones[i][1];
			if(!rowFirst.containsKey(row)){
				rowFirst.put(row, i);
			}else{
				union(i, rowFirst.get(row));
			}

			if(!colFirst.containsKey(col)){
				colFirst.put(col, i);
			}else{
				union(i, colFirst.get(col));
			}
		}
		return n-sets;
	}

数组自己就是哈希表-这道Hard题的解法太惊艳了

Fri, 19 Dec 2025 20:04:55 +0000

求解思路

这道题我们把数组想象成一个特殊的容器,理想情况下索引 0 应该放数字 1,索引 1 应该放数字 2,以此类推。

我们用两个指针来维护三个区域:

左边是已经整理好的"完美区"(每个位置都放着正确的数字),

中间是待处理区,

右边是"垃圾区"(存放那些不可能成为答案的数字,比如负数、超大的数、重复的数)。

处理过程就像整理房间,

我们盯着待处理区的左边界,如果这个位置的数字恰好是它该在的位置,就扩大完美区;

如果这个数字是垃圾(太小、太大或重复),就把它扔到垃圾区;

如果这个数字本身没问题但放错了位置,就把它交换到它应该去的地方。

这样不断循环,当完美区和垃圾区碰头时,完美区的长度加 1 就是我们要找的第一个缺失正数。

代码实现

public static int firstMissingPositive(int[] arr) {
    int l = 0;  // 左指针,左边是完美区 [0...l-1]
    int r = arr.length;  // 右指针,右边是垃圾区 [r...n-1]
    
    while (l < r) {
        if (arr[l] == l + 1) {
            // 当前位置数字正确,扩大完美区
            l++;
        } else if (arr[l] <= l || arr[l] > r || arr[arr[l] - 1] == arr[l]) {
            // 垃圾数字:太小、太大或目标位置已有相同数字
            swap(arr, l, --r);
        } else {
            // 将数字交换到它应该在的位置
            swap(arr, l, arr[l] - 1);
        }
    }
    return l + 1;  // 完美区长度+1就是答案
}

public static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

举个栗子

假设输入数组为 [3, 4, -1, 1]:

初始:l=0, r=4, arr=[3,4,-1,1]
arr[0]=3,交换到索引2:arr=[−1,4,3,1]
arr[0]=-1是垃圾,扔到垃圾区:arr=[1,4,3,−1], l=0, r=3
arr[0]=1正确,l++:l=1
arr[1]=4>r=3,是垃圾:arr=[1,3,4,−1], l=1, r=2
arr[1]=3>r=2,是垃圾:arr=[1,3,4,−1], l=1, r=1
退出循环,返回 l+1=2

答案是 2,因为数组中有 1 但没有 2。

如果觉得有帮助，欢迎点赞、关注、转发~

这道LeetCode-Hard题-用一个转化思想就变简单了

Thu, 11 Dec 2025 21:55:43 +0000

求解思路

这道题将"恰好k种"这个条件转化为两个"最多k种"的问题相减。

我们可以这样理解：

如果我们知道有多少个子数组最多包含k种不同数字,再减去最多包含k-1种不同数字的子数组个数,剩下的就是恰好包含k种不同数字的子数组。

想象有一个可伸缩的窗口在数组上滑动,右指针不断向右扩展窗口,每次加入一个新数字就用计数器记录它出现的次数,如果这个数字是第一次出现就让种类数加1。

当窗口内的数字种类超过k时,我们就移动左指针收缩窗口,同时减少对应数字的计数,如果某个数字的计数变为0就让种类数减1,直到窗口内的种类数重新满足不超过k的条件。

在这个过程中,每当右指针固定在某个位置时,从左指针到右指针之间的所有子数组都是满足条件的,所以每次我们把当前窗口的长度也就是r-l+1累加到答案中。

这样遍历完整个数组后,就得到了所有最多包含k种不同数字的子数组总数。

代码实现上,我们使用一个计数数组cnts来记录每个数字在当前窗口中出现的次数,用collect变量维护当前窗口内不同数字的种类数。

通过这种方式,只需要遍历两遍数组分别计算"最多k种"和"最多k-1种",然后做个减法就能得到"恰好k种"的答案。

完整代码

public static int subarraysWithKDistinct(int[] arr, int k) {
    return numsOfMostKinds(arr, k) - numsOfMostKinds(arr, k - 1);
}

public static int MAXN = 20001;

public static int[] cnts = new int[MAXN];

// arr中有多少子数组,数字种类不超过k
// arr的长度是n,arr里的数值1~n之间
public static int numsOfMostKinds(int[] arr, int k) {
    Arrays.fill(cnts, 1, arr.length + 1, 0);
    int ans = 0;
    for (int l = 0, r = 0, collect = 0; r < arr.length; r++) {
        if (++cnts[arr[r]] == 1) {
            collect++;
        }
        while (collect > k) {
            if (--cnts[arr[l++]] == 0) {
                collect--;
            }
        }
        ans += r - l + 1;
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

使子数组和能被P整除

Fri, 28 Nov 2025 21:46:29 +0000

求解思路

首先计算整个数组的和对p取模得到余数mod，如果mod为0说明已经满足条件直接返回0。

移除一段子数组后，剩余部分的和能被p整除，等价于找到一个子数组其和模p的余数恰好等于mod。

利用前缀和的性质，如果前缀和pre[j] - pre[i]的余数等于mod，那么移除(i, j]这段区间即可。

为了快速查找符合条件的左端点，用哈希表存储每个余数最晚出现的位置，遍历时对于当前位置i的前缀和余数cur，需要找到之前某个位置的余数find满足(cur - find) % p = mod，变换后得到find = (cur - mod + p) % p，从哈希表中查询find是否存在即可更新最短长度。

代码实现

public int minSubarray(int[] nums, int p) {
    // 计算整体余数
    int mod = 0;
    for (int num : nums) {
        mod = (mod + num) % p;
    }
    if (mod == 0) {
        return 0;
    }
    
    // key: 前缀和%p的余数, value: 最晚出现的位置
    HashMap<Integer, Integer> map = new HashMap<>();
    map.put(0, -1);
    int ans = Integer.MAX_VALUE;
    
    for (int i = 0, cur = 0, find; i < nums.length; i++) {
        // 当前前缀和的余数
        cur = (cur + nums[i]) % p;
        // 需要找的余数
        find = cur >= mod ? (cur - mod) : (cur + p - mod);
        
        if (map.containsKey(find)) {
            ans = Math.min(ans, i - map.get(find));
        }
        map.put(cur, i);
    }
    
    return ans == nums.length ? -1 : ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

LeetCode-1124-表现良好的最长时间段

Thu, 27 Nov 2025 21:18:29 +0000

解题思路

这道题我们把工作时间大于8小时的天数记为+1,小于等于8小时的记为-1,这样问题就转化为求和大于0的最长子数组。

计算过程中维护一个前缀和：

如果当前前缀和大于0,说明从开头到当前位置就是一个有效时间段;

如果前缀和小于等于0,我们需要找到最早出现"sum-1"的位置j,因为从j的下一个位置到当前位置i这段区间的和等于sum-(sum-1)=1(大于0),这样就找到了一个有效区间。

用哈希表记录每个前缀和最早出现的位置,确保找到的区间是最长的,遍历一遍数组即可得到答案。

代码实现

public static int longestWPI(int[] hours) {
    // 某个前缀和,最早出现的位置
    HashMap<Integer, Integer> map = new HashMap<>();
    // 0这个前缀和,最早出现在-1,一个数也没有的时候
    map.put(0, -1);
    int ans = 0;
    for (int i = 0, sum = 0; i < hours.length; i++) {
        sum += hours[i] > 8 ? 1 : -1;
        if (sum > 0) {
            ans = i + 1;
        } else {
            // sum <= 0
            if (map.containsKey(sum - 1)) {
                ans = Math.max(ans, i - map.get(sum - 1));
            }
        }
        if (!map.containsKey(sum)) {
            map.put(sum, i);
        }
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

最长和为0的子数组问题

Wed, 26 Nov 2025 20:29:34 +0000

求解思路

这道题我们先对数组进行预处理,将正数统一变为1,负数统一变为-1,零保持不变。

如果两个位置的前缀和相等,那么这两个位置之间的子数组和必然为0。因此，我们用哈希表记录每个前缀和第一次出现的位置,当再次遇到相同前缀和时,就能计算出一个和为0的子数组长度,遍历过程中不断更新最大值。

注意要在哈希表中预设sum=0对应位置-1,这样可以正确处理从数组开头开始的子数组。

举个栗子

输入数组:[1, -1, 2, -2, 3]
预处理后:[1, -1, 1, -1, 1]

位置0: sum=1, 记录{1→0}
位置1: sum=0, 已存在{0→-1}, 长度=1-(-1)=2
位置2: sum=1, 已存在{1→0}, 长度=2-0=2
位置3: sum=0, 已存在{0→-1}, 长度=3-(-1)=4
位置4: sum=1, 已存在{1→0}, 长度=4-0=4

最长长度为4,对应子数组[-1, 2, -2, 3]。

代码实现

import java.io.*;
import java.util.HashMap;

public class Main{
    public static int MAXN = 100001;
    public static int[] arr = new int[MAXN];
    public static int n;
    public static HashMap<Integer, Integer> map = new HashMap<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            n = (int) in.nval;
            for (int i = 0, num; i < n; i++) {
                in.nextToken();
                num = (int) in.nval;
                // 预处理:正数变1,负数变-1,零保持0
                arr[i] = num != 0 ? (num > 0 ? 1 : -1) : 0;
            }
            out.println(compute());
        }
        out.flush();
        out.close();
        br.close();
    }

    public static int compute() {
        map.clear();
        map.put(0, -1);  // 初始化:前缀和为0对应位置-1
        int ans = 0;
        for (int i = 0, sum = 0; i < n; i++) {
            sum += arr[i];  // 累加前缀和
            if (map.containsKey(sum)) {
                // 找到相同前缀和,计算子数组长度
                ans = Math.max(ans, i - map.get(sum));
            } else {
                // 第一次出现该前缀和,记录位置
                map.put(sum, i);
            }
        }
        return ans;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

子数组和等于目标值的个数问题

Tue, 25 Nov 2025 20:27:40 +0000

求解思路

这道题在遍历数组的过程中维护一个累加和sum，对于当前位置i，如果之前存在某个位置j使得0到j的前缀和等于sum-aim，那么j+1到i这段子数组的和就等于aim。

用哈希表记录每个前缀和出现的次数，每次查询sum-aim出现过多少次，就说明以当前位置结尾有多少个满足条件的子数组。

需要注意的是，在开始遍历前要先将0这个前缀和的出现次数设为1，这表示不选任何元素时前缀和为0，这样当sum本身就等于aim时也能正确统计。

举个栗子

假设数组为 [1, 2, 3]，目标值 aim = 3：

i=0, sum=1, 查找sum-3=-2(不存在)，ans=0，记录前缀和1
i=1, sum=3, 查找sum-3=0(存在1次)，ans=1，记录前缀和3
i=2, sum=6, 查找sum-3=3(存在1次)，ans=2，记录前缀和6

最终返回2，对应子数组 [3] 和 [1,2]。

代码实现

public static int subarraySum(int[] nums, int aim) {
    HashMap<Integer, Integer> map = new HashMap<>();
    // 0这个前缀和，在没有任何数字的时候，已经有1次了
    map.put(0, 1);
    int ans = 0;
    for (int i = 0, sum = 0; i < nums.length; i++) {
        // sum : 0...i前缀和
        sum += nums[i];
        ans += map.getOrDefault(sum - aim, 0);
        map.put(sum, map.getOrDefault(sum, 0) + 1);
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

前缀和+哈希表-求和为目标值的最长子数组

Mon, 24 Nov 2025 20:42:36 +0000

求解思路

这道题，维护一个累加和sum，对于当前位置i，如果存在某个更早的位置j使得从j+1到i的子数组和等于aim，那么必然有sum[i] - sum[j] = aim，即sum[j] = sum[i] - aim。

用哈希表记录每个前缀和第一次出现的位置，遍历数组时检查sum - aim是否在哈希表中，如果存在就计算子数组长度并更新答案。

这里有个细节：初始化时把(0, -1)放入哈希表，表示"什么都不选时前缀和为0"，这样当从数组开头就满足条件时也能正确计算。

另外，每个前缀和只记录最早出现的位置，因为要求的是最长子数组，起点越早长度越大。

举例说明

输入：arr = [1, 2, 3, -2, 5]，aim = 5

i=0: sum=1, 查找-4不存在，记录(1,0)
i=1: sum=3, 查找-2不存在，记录(3,1)
i=2: sum=6, 查找1存在于位置0，长度=2-0=2，记录(6,2)
i=3: sum=4, 查找-1不存在，记录(4,3)
i=4: sum=9, 查找4存在于位置3，长度=4-3=1

最终答案为2，对应子数组[2, 3]。

代码实现

import java.io.*;
import java.util.HashMap;

public class Main{
    public static int MAXN = 100001;
    public static int[] arr = new int[MAXN];
    public static int n, aim;
    // key : 某个前缀和
    // value : 这个前缀和最早出现的位置
    public static HashMap<Integer, Integer> map = new HashMap<>();
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            n = (int) in.nval;
            in.nextToken();
            aim = (int) in.nval;
            for (int i = 0; i < n; i++) {
                in.nextToken();
                arr[i] = (int) in.nval;
            }
            out.println(compute());
        }
        out.flush();
        out.close();
        br.close();
    }
    
    public static int compute() {
        map.clear();
        // 前缀和0在-1位置，表示一个数都不取
        map.put(0, -1);
        int ans = 0;
        for (int i = 0, sum = 0; i < n; i++) {
            sum += arr[i];
            // 如果存在前缀和为sum-aim，说明中间部分和为aim
            if (map.containsKey(sum - aim)) {
                ans = Math.max(ans, i - map.get(sum - aim));
            }
            // 只记录每个前缀和最早出现的位置
            if (!map.containsKey(sum)) {
                map.put(sum, i);
            }
        }
        return ans;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

超级回文数问题

Tue, 18 Nov 2025 20:14:24 +0000

问题分析

如果直接枚举范围 [left, right] 中的每个数字，判断它是否为回文数以及其平方根是否为回文数，时间复杂度会非常高。

但是，如果一个数 x 是超级回文数，那么 x 的平方根必定是回文数。

因此，可以转换思路，不枚举 x，而是枚举 x 的平方根。

由于 x 最大为 $10^{18}$，那么 x 的平方根最大为 $10^9$。

这里还有一个优化：

回文数具有对称性，不需要直接枚举所有 $10^{9}$以内的数字来判断哪些是回文数。

可以用一个"种子"数来构造回文数。

具体来说的话就是：

一个 9 位的回文数（如 123454321）可以由前 5 位（12345）确定，因为后 4 位是前 4 位的镜像；

一个 8 位的回文数（如 12344321）可以由前 4 位（1234）确定。

因此，对于最大 $10^9$（10 位数）的回文数，只需要枚举 1 到 $10^5$（5 位数）的种子，就能构造出所有可能的回文数。

每个种子生成两种回文数：

偶数长度（种子完整镜像，如 123→123321）和奇数长度（种子去掉最后一位后镜像，如 123→12321）。

这样，问题规模就从枚举 $10^9$ 个数降到只需枚举 $10^5$ 个种子，大幅降低了时间复杂度。

求解思路

通过枚举种子数来生成回文数，每个种子可以生成两种回文数：奇数长度的回文数和偶数长度的回文数。

对于每个生成的回文数 num，计算其平方 num²，判断 num² 是否在给定范围 [left, right] 内，并且 num² 本身也是回文数。

如果满足条件，计数器加一。从种子 1 开始递增枚举，直到生成的回文数 num 超过了 right 的平方根为止。

完整代码实现

public class Solution {
    
    public static int superpalindromesInRange(String left, String right) {
        long l = Long.valueOf(left);
        long r = Long.valueOf(right);
        
        // 计算右边界的平方根，作为枚举回文数的上限
        long limit = (long) Math.sqrt((double) r);
        
        // seed: 种子数，用于生成回文数
        // 从1开始枚举，每个种子可以生成奇数长度和偶数长度两种回文数
        long seed = 1;
        
        // num: 根据种子生成的回文数（即超级回文数的平方根）
        long num = 0;
        
        // 统计符合条件的超级回文数数量
        int ans = 0;
        
        do {
            // 用seed生成偶数长度的回文数
            // 例如: 123 -> 123321
            num = evenEnlarge(seed);
            // 检查 num² 是否在范围内且为回文数
            if (check(num * num, l, r)) {
                ans++;
            }
            
            // 用seed生成奇数长度的回文数
            // 例如: 123 -> 12321
            num = oddEnlarge(seed);
            // 检查 num² 是否在范围内且为回文数
            if (check(num * num, l, r)) {
                ans++;
            }
            
            // 种子递增，继续枚举
            seed++;
        } while (num < limit); // 当生成的回文数超过limit时停止
        
        return ans;
    }
    
    public static long evenEnlarge(long seed) {
        long ans = seed;
        // 将seed的每一位依次添加到ans末尾
        while (seed != 0) {
            ans = ans * 10 + seed % 10;  // 取seed最后一位拼接到ans
            seed /= 10;  // 去掉seed的最后一位
        }
        return ans;
    }
    
    public static long oddEnlarge(long seed) {
        long ans = seed;
        seed /= 10;  // 先去掉最后一位，避免中间数字重复
        // 将剩余部分翻转后拼接
        while (seed != 0) {
            ans = ans * 10 + seed % 10;
            seed /= 10;
        }
        return ans;
    }
    
    public static boolean check(long ans, long l, long r) {
        return ans >= l && ans <= r && isPalindrome(ans);
    }
    
    public static boolean isPalindrome(long num) {
        // offset用于定位最高位，例如52725，offset为10000
        long offset = 1;
        // 计算offset的值，使其等于10^(位数-1)
        // 注意这里用 num/offset >= 10 而不是 num >= offset*10，防止溢出
        while (num / offset >= 10) {
            offset *= 10;
        }
        
        // 首尾对比判断是否回文
        while (num != 0) {
            // 比较最高位和最低位
            if (num / offset != num % 10) {
                return false;
            }
            // 去掉最高位和最低位，继续判断内部数字
            num = (num % offset) / 10;  // 去掉最高位后再去掉最低位
            offset /= 100;  // 因为去掉了两位，所以offset除以100
        }
        
        return true;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

LeetCode-381-O(1)-时间插入、删除和获取随机元素-允许重复

Thu, 23 Oct 2025 20:48:13 +0000

与Leetcode380不同的是，这道题允许元素重复。

代码逻辑

1. 插入操作

public boolean insert(int val) {
    arr.add(val);  // 直接添加到数组末尾
    HashSet<Integer> set = map.getOrDefault(val, new HashSet<Integer>());
    set.add(arr.size() - 1);  // 记录该元素在数组中的索引
    map.put(val, set);
    return set.size() == 1;  // 如果是第一次插入,返回 true
}

将元素添加到数组末尾,同时在 HashMap 中记录其索引位置。

2. 删除操作

public boolean remove(int val) {
    if (!map.containsKey(val)) {
        return false;
    }
    
    // 获取要删除元素的任意一个索引
    HashSet<Integer> valSet = map.get(val);
    int valAnyIndex = valSet.iterator().next();
    
    // 获取数组末尾元素
    int endValue = arr.get(arr.size() - 1);
    
    if (val == endValue) {
        // 特殊情况:要删除的就是末尾元素
        valSet.remove(arr.size() - 1);
    } else {
        // 将末尾元素移动到要删除的位置
        HashSet<Integer> endValueSet = map.get(endValue);
        endValueSet.add(valAnyIndex);  // 末尾元素有了新位置
        arr.set(valAnyIndex, endValue);  // 更新数组
        endValueSet.remove(arr.size() - 1);  // 移除末尾位置
        valSet.remove(valAnyIndex);  // 移除被删除元素的位置
    }
    
    arr.remove(arr.size() - 1);  // 删除数组末尾
    
    if (valSet.isEmpty()) {
        map.remove(val);  // 如果该值已经没有了,从 map 中删除
    }
    
    return true;
}

ArrayList 删除中间元素是 O(n) 操作,但删除末尾元素是 O(1)，因此我们把要删除的元素和末尾元素交换,然后删除末尾。

3. 随机获取

1
2
3

public int getRandom() {
    return arr.get((int) (Math.random() * arr.size()));
}

完整代码

class RandomizedCollection{
		public HashMap<Integer,HashSet<Integer>> map;
		public ArrayList<Integer> arr;
		public RandomizedCollection(){
			map = new HashMap<>();
			arr = new ArrayList<>();
		}

		public boolean insert(int val) {
			arr.add(val);  // 直接添加到数组末尾
			HashSet<Integer> set = map.getOrDefault(val, new HashSet<Integer>());
			set.add(arr.size() - 1);  // 记录该元素在数组中的索引
			map.put(val, set);
			return set.size() == 1;  // 如果是第一次插入,返回 true
		}

		public boolean remove(int val) {
			if (!map.containsKey(val)) {
				return false;
			}

			// 获取要删除元素的任意一个索引
			HashSet<Integer> valSet = map.get(val);
			int valAnyIndex = valSet.iterator().next();

			// 获取数组末尾元素
			int endValue = arr.get(arr.size() - 1);

			if (val == endValue) {
				// 特殊情况:要删除的就是末尾元素
				valSet.remove(arr.size() - 1);
			} else {
				// 将末尾元素移动到要删除的位置
				HashSet<Integer> endValueSet = map.get(endValue);
				endValueSet.add(valAnyIndex);  // 末尾元素有了新位置
				arr.set(valAnyIndex, endValue);  // 更新数组
				endValueSet.remove(arr.size() - 1);  // 移除末尾位置
				valSet.remove(valAnyIndex);  // 移除被删除元素的位置
			}

			arr.remove(arr.size() - 1);  // 删除数组末尾

			if (valSet.isEmpty()) {
				map.remove(val);  // 如果该值已经没有了,从 map 中删除
			}

			return true;
		}

		public int getRandom(){
			return arr.get((int) (Math.random()*arr.size()));
		}
	}

LeetCode-380-O(1)-时间插入、删除和获取随机元素

Wed, 22 Oct 2025 21:10:40 +0000

这道题的难点在于如何同时满足三个 O(1) 操作,尤其是随机获取元素。

代码逻辑

1. 插入操作 (insert)

public boolean insert(int val) {
    if (map.containsKey(val)) {
        return false;  // 元素已存在
    }
    map.put(val, arr.size());  // 记录新元素的索引
    arr.add(val);               // 添加到数组末尾
    return true;
}

2. 删除操作 (remove)

直接从数组中间删除元素的时间复杂度是 O(n),因此本文采用交换删除法:

public boolean remove(int val) {
    if (!map.containsKey(val)) {
        return false;  // 元素不存在
    }
    
    // 获取要删除元素的索引
    int valIndex = map.get(val);
    
    // 获取数组最后一个元素
    int endValue = arr.get(arr.size() - 1);
    
    // 用最后一个元素覆盖要删除的元素
    map.put(endValue, valIndex);
    arr.set(valIndex, endValue);
    
    // 删除 map 中的记录和数组末尾元素
    map.remove(val);
    arr.remove(arr.size() - 1);
    
    return true;
}

将要删除的元素与数组最后一个元素交换,然后删除末尾元素,这样删除操作就是 O(1) 了!

3. 随机获取 (getRandom)

1
2
3

public int getRandom() {
    return arr.get((int) (Math.random() * arr.size()));
}

使用了 ArrayList,可以通过索引 O(1) 访问任意元素,配合随机数生成器即可实现等概率随机返回。

完整代码

class RandomizedSet{
        public HashMap<Integer,Integer> map;
        public ArrayList<Integer> arr;
        public RandomizedSet(){
            map = new HashMap<>();
            arr = new ArrayList<>();
        }

        public boolean insert(int val) {
            if (map.containsKey(val)) {
                return false;  // 元素已存在
            }
            map.put(val, arr.size());  // 记录新元素的索引
            arr.add(val);               // 添加到数组末尾
            return true;
        }

        public boolean remove(int val) {
            if (!map.containsKey(val)) {
                return false;  // 元素不存在
            }

            // 获取要删除元素的索引
            int valIndex = map.get(val);

            // 获取数组最后一个元素
            int endValue = arr.get(arr.size() - 1);

            // 用最后一个元素覆盖要删除的元素
            map.put(endValue, valIndex);
            arr.set(valIndex, endValue);

            // 删除 map 中的记录和数组末尾元素
            map.remove(val);
            arr.remove(arr.size() - 1);

            return true;
        }

        public int getRandom(){
            return arr.get((int) (Math.random()*arr.size()));
        }
    }

O(1)时间复杂度实现有setAll功能的哈希表

Mon, 20 Oct 2025 21:55:45 +0000

代码逻辑

这道题的核心在于:

不直接修改所有数据,而是记录一个全局更新时间戳。

通过比较每个元素的更新时间和全局更新时间,动态判断应该返回哪个值。

1. put(k, v)

public static void put(int k, int v) {
    if (map.containsKey(k)) {
        // 键已存在,更新值和时间戳
        int[] value = map.get(k);
        value[0] = v;
        value[1] = cnt++;
    } else {
        // 新键,创建新的 [value, timestamp] 数组
        map.put(k, new int[]{v, cnt++});
    }
}

每次存值时，不仅存具体的value，还会记录当前的cnt（时间戳），然后cnt自增。

2. setAll(v)

public static void setAll(int v) {
    setAllValue = v;      // 记录全局值
    setAllTime = cnt++;   // 记录全局更新时间
}

记录了 “全局值”setAllValue和 “全局更新时间”setAllTime（同样用cnt作为时间戳，然后cnt自增）。

3. get(k)

public static int get(int k) {
    if (!map.containsKey(k)) {
        return -1;
    }
    
    int[] value = map.get(k);
    // 比较时间戳
    if (value[1] > setAllTime) {
        // 单个元素的更新时间晚于全局更新,返回元素自己的值
        return value[0];
    } else {
        // 单个元素的更新时间早于或等于全局更新,返回全局值
        return setAllValue;
    }
}

完整代码

public class SetAllHashMap {
	// 存储实际的键值对,值是一个数组 [value, timestamp]
	public static HashMap<Integer,int[]> map = new HashMap<>();
	// 全局设置的值
	public static int setAllValue;
	// 全局设置的时间戳
	public static int setAllTime;
	// 全局计数器,用于生成递增的时间戳
	public static int cnt;

	public static void put(int k, int v) {
		if (map.containsKey(k)) {
			// 键已存在,更新值和时间戳
			int[] value = map.get(k);
			value[0] = v;
			value[1] = cnt++;
		} else {
			// 新键,创建新的 [value, timestamp] 数组
			map.put(k, new int[]{v, cnt++});
		}
	}

	public static void setAll(int v) {
		setAllValue = v;      // 记录全局值
		setAllTime = cnt++;   // 记录全局更新时间
	}

	public static int get(int k) {
		if (!map.containsKey(k)) {
			return -1;
		}

		int[] value = map.get(k);
		// 比较时间戳
		if (value[1] > setAllTime) {
			// 单个元素的更新时间晚于全局更新,返回元素自己的值
			return value[0];
		} else {
			// 单个元素的更新时间早于或等于全局更新,返回全局值
			return setAllValue;
		}
	}

	public static int n,op,a,b;

	public static void main(String[] args)throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		while(in.nextToken()!=StreamTokenizer.TT_EOF){
			map.clear();
			setAllValue = 0;
			setAllTime  = -1;
			cnt = 0;
			n = (int) in.nval;
			for(int i=0;i<n;i++){
				in.nextToken();
				op = (int) in.nval;
				if(op==1){
					in.nextToken();
					a=(int)in.nval;
					in.nextToken();
					b = (int) in.nval;
					put(a,b);
				}else if(op==2){
					in.nextToken();
					a=(int)in.nval;
					out.println(get(a));
				}else{
					in.nextToken();
					a=(int)in.nval;
					setAll(a);
				}
			}
		}
		out.flush();
		out.close();
		br.close();
	}

}