蓝桥杯算法心得——附近最小（优先队列+滑动窗口）

大家好，我是晴天学长，这题可以用贪心优先队列和滑动窗口来写，需要的小伙伴可以关注支持一下哦！后续会继续更新的。💪💪💪

1) .附近最小

在这里插入图片描述
问题描述
小蓝有—个序列a[1], a[2],...,a[n]。
给定—个正整数k，请问对于每一个1到n之间的序号i，a[i- k], a[i-k ＋1],..., ai＋剐]这2k ＋1个数中的最小值是多少?
当某个下标超过1到n的范围时，数不存在，求最小值时只取存在的那些值。
输入格式
输入的第一行包含一整数n。
第二行包含n个整数，分别表示a[1], a[2],..., a[n]。
第三行包含一个整数k。
输出格式
输出一行，包含n个整数，分别表示对于每个序号求得的最小值。
样例输入
5
5 27 4 3
样例输出
2 2 2 3 3

2) .算法思路

附近最小（优先队列）
用滑动窗口和优先队列写
1.用队列
1.接收数据
2.优先队列
int【】第一个存大小，第二个存位置
3.先存数据进去

开始遍历
1.优先队列都要压进去
2.前进（3种）
1.最小值过了
2.更新最小值
3.最小值不变

附近最小（滑动窗口）

1.接收数据
2.找出最小的（k的大小）
并记录下标位置

然后开始遍历用l，r表示
1.进来的要比最小值都要小（r++）
或者不变
2.当最小值的下标小于时，需要重新遍历，确定最小值（l++）

3）.算法步骤

方法一（优先队列）
1.读取输入的字符串并将其分割为字符串数组。
2.将第一个字符串转换为整数n，表示数组的长度。
3.创建一个长度为n的整数数组N，并将第二个字符串数组中的元素转换为整数并赋值给N数组。
4.将第三个字符串转换为整数k，表示附近的最小元素的个数。
5.创建一个优先队列queue，使用lambda表达式定义比较器，按照元素的值进行升序排序。
6.遍历数组N的前k+1个元素，将其加入优先队列queue中，每个元素是一个数组，包含元素值和元素的索引。
7.创建一个长度为n的整数数组result，用于存储每个位置的附近最小元素。
8.遍历数组result的每个位置i：
a. 如果i不大于n-k，将N[i+k]和i+k加入优先队列queue中。
b. 当队列不为空且队首元素的索引小于i-k时，从队列中移除队首元素。
c. 将队首元素的值赋给result[i]。
9.遍历数组result，输出每个元素的值。
10.完成算法。
方法二（滑动窗口）
创建一个静态整数数组a和一个静态整数min，用于存储输入数据和当前窗口内的最小值。
使用Scanner类读取输入的整数n，表示数组的长度。
创建一个长度为n的整数数组a，并使用循环将输入的整数赋值给数组a。
使用Scanner类读取输入的整数k，表示滑动窗口的大小。
调用findMin方法，传入参数0和k，找到初始窗口内的最小值。
使用循环遍历数组a的每个元素：
a. 计算当前窗口的左边界l，最小值的下标不小于l。
b. 计算当前窗口的右边界r，最小值的下标不大于r。
c. 如果当前窗口的最小值不大于min，则更新min为当前窗口的最小值。
d. 否则，如果当前窗口的左边界大于0且a[l-1]等于min，则调用findMin方法，传入参数l和r，重新找到窗口内的最小值。
e. 输出当前窗口的最小值min。
完成算法。

4）. 代码实例

方法一：优先队列
package LanQiaoTest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.PriorityQueue;

public class 附近最小 {
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static String[] strings;

	public static void main(String[] args) throws IOException {
		strings = in.readLine().split(" ");
		int n = Integer.parseInt(strings[0]);
		int[] N = new int [n];
		strings = in.readLine().split(" ");
		for (int i = 0; i < N.length; i++) {
			N[i] = Integer.parseInt(strings[i]);
		}
		strings = in.readLine().split(" ");
		int k = Integer.parseInt(strings[0]);
		PriorityQueue<int[]> queue = new PriorityQueue<>((o1,o2)->(o1[0]-o2[0]));
		for (int i = 0; i <= k; i++) {
			queue.add(new int[] {N[i],i});
		}
		int[] result = new int[n];
		for (int i = 0; i < result.length; i++) {
				if(!(i>=n-k)) {
					queue.add(new int[] {N[i+k],i+k});
				}
				while (!queue.isEmpty()&&queue.peek()[1]<i-k) {
					queue.poll();
				}
				result[i] = queue.peek()[0];
			
		}
		for (int i = 0; i < result.length; i++) {
			System.out.print(result[i]+" ");
		}
	}

}


方法二：滑动窗口


import java.util.Scanner;

public class Main {
    static int[] a;
    static int min = Integer.MAX_VALUE;

    public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      int n = scanner.nextInt();
      a = new int[n];
      for (int i = 0; i < n; i++) {
		a[i] = scanner.nextInt();
	}
      int k = scanner.nextInt();
      scanner.close();
      findMin(0, k);
      for (int i = 0; i < n; i++) {
		int l = Math.max(i-k, 0);
		int r = Math.min(i+k, n-1);
		if (a[r]<=min) {
			min = a[r];
		}else {
			if (i-k>0&&a[l-1]==min) {
				findMin(l, r);
			}
		}
		System.out.print(min+" ");
	}
 }


    static void findMin(int start, int end) {
        min = Integer.MAX_VALUE;
        for (int i = start; i <= end; i++) {
            min = Math.min(min, a[i]);
        }
    }
}