luogu P1440 求m区间内的最小值 滑动窗口的最小值 单调队列或优先级队列

最新推荐文章于 2022-10-16 19:31:46 发布
最新推荐文章于 2022-10-16 19:31:46 发布
阅读量188 收藏
点赞数
文章标签： 单调队列 优先级队列 滑动窗口的最小值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31036127/article/details/108991773
版权

题目描述

一个含有 nnn 项的数列，求出每一项前的 mmm 个数到它这个区间内的最小值。若前面的数不足 mmm 项则从第 111 个数开始，若前面没有数则输出 000。
输入格式

第一行两个整数，分别表示 nnn，mmm。

第二行，nnn 个正整数，为所给定的数列 aia_iai​。
输出格式

nnn 行，每行一个整数，第 iii 个数为序列中 aia_iai​ 之前 mmm 个数的最小值。
输入输出样例
输入 #1

6 2
7 8 1 4 3 2

输出 #1

0
7
7
1
1
3

说明/提示

对于 100%100%100% 的数据，保证 1≤m≤n≤2×1061\le m\le n\le2\times10^61≤m≤n≤2×106，1≤ai≤3×1071\le a_i\le3\times10^71≤ai​≤3×107。

题意：求滑动窗口的里的最小值
解法一 : 单调队列 O(N)

用双端队列deque模拟窗口

  1. deque里存储结构体{下标，值}
  2. 先把所有队尾back比当前值a[i]大的全部弹出，while(back > a[i]) deque.pop_back()
  3. a[i]入队列，deque.push_back(a[i])
  4. 如果队头的下标front_id不在窗口区间[i-m, i]内就弹出队头

洛谷大佬@lcglcg的题解：https://www.luogu.com.cn/blog/lcglcg/solution-p1440

signed main() {
#ifdef debug
	freopen("test.txt", "r", stdin);
	clock_t stime = clock();
#endif
	scanf("%d %d ", &n, &m);
	for(int i=1; i<=n; i++) scanf("%d ", a+i);

	deque<pair<int,int> > q; //deque模拟窗口
	printf("0\n");
	for(int i=1; i<n; i++) {
		//先把队尾大于a[i]的弹出干净
		while(!q.empty() && q.back().second>a[i]) q.pop_back();
		q.push_back({i, a[i]}); //压入队尾
		//再把队头所有不在区间 [i-m, i] 内的弹出干净
		while(!q.empty() && q.front().first+m<=i) q.pop_front();
		printf("%d\n", q.front().second);
	}



#ifdef debug
	clock_t etime = clock();
	printf("rum time: %lf 秒\n",(double) (etime-stime)/CLOCKS_PER_SEC);
#endif 
	return 0;
}
解法二：小根堆优化 O(N log N)

用priority_queue模拟窗口，

  1. 堆里存储结构体{下标，值}
  2. 压入值后，把所有不在窗口区间[i-m, i]内的堆顶弹出
signed main() {
#ifdef debug
	freopen("test.txt", "r", stdin);
	clock_t stime = clock();
#endif
	scanf("%d %d ", &n, &m);
#if 1
	for(int i=1; i<=n; i++) scanf("%d ", a+i);
	// show(n, m);
	// forarr(a, 1, n);
	#define PII (pair<int,int>)
	priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int> > > q;
	printf("0\n");
	for(int i=1; i<n; i++) {
		#define fstid (q.front().first)
		#define fstval (q.front().second)
		#define topval (q.top().first)
		#define topid (q.top().second)
		q.push({a[i], i});
		while(topid <= i-m) q.pop();
		printf("%d\n", topval);
	}
#endif



#ifdef debug
	clock_t etime = clock();
	printf("rum time: %lf 秒\n",(double) (etime-stime)/CLOCKS_PER_SEC);
#endif 
	return 0;
}

用java完美MLE






import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Main {
    public static final boolean debug = true;
    public static String INPATH = "C:\\Users\\majiao\\Desktop\\test.txt",
            OUTPATH = "C:\\Users\\majiao\\Desktop\\out.txt";
    public static StreamTokenizer tok;
    public static BufferedReader cin;
    public static PrintWriter cout;

    public static long start_time = 0, out_time = 0;
    public static int n, m, K, Q, MAXN = (int)16, INF = 0x3f3f3f3f,
            pre[] = new int[MAXN], sum[] = new int[MAXN], POS = 50000;
    public static byte buf[] = new byte[MAXN];

    public static int fa(int x) { return pre[x]==x ? x : (pre[x]=fa(pre[x])); }

    public static void union_xy(int x, int y) {
        x = fa(x); y = fa(y);
        if(x != y) {
            sum[x] += sum[y];
            pre[y] = x;
        }
    }


    public static void main(String[] args) throws IOException {
        main_init();
        if(debug) { start_time = System.currentTimeMillis(); }
        if(false) { System.setOut(new PrintStream(OUTPATH)); }

        n = read_int(); m = read_int();
        cout.printf("0\n");
        int x;
        PriorityQueue<Pair> q = new PriorityQueue<>();
        for(int i=1; i<n; i++) {
            x = read_int();
            Pair now = new Pair(i, x);
            q.add(now);
            Pair top = null;
            while(q.peek().fst+m <= i) q.poll();
            cout.printf("%d\n", q.peek().sec);
        }










        if(debug) {
            out_time = System.currentTimeMillis();
            cout.printf("run time : %d ms\n", out_time-start_time);
        }
        cout.flush();
    }

    public static void show(List<Object> list, Object... obj) {
        cout.printf("%s : ", obj.length>0 ? obj[0] : "");
        for(Object x : list) {
            cout.printf("[%s] ", x);
        }
        cout.printf("\n");
    }

    public static void show(Map<Object, Object> mp, Object... obj) {
        cout.printf("%s : ", obj.length>0 ? obj[0] : "");
        Set<Map.Entry<Object, Object>> entries = mp.entrySet();
        for (Map.Entry<Object, Object> en : entries) {
            cout.printf("[%s,%s] ", en.getKey(), en.getValue());
        }
        cout.printf("\n");
    }

    public static<T> void forarr(T arr[], int ...args) {
        int lef = 0, rig = arr.length - 1;
        if(args.length > 0) { lef = args[0]; rig = args[1]; }
        cout.printf(" : ");
        for( ; lef<=rig; lef++) {
            cout.printf("[%s] ", args[lef]);
        }
        cout.printf("\n");
    }

    public static void main_init() {
        try {
            if (debug) {
                cin = new BufferedReader(new InputStreamReader(
                        new FileInputStream(INPATH)));
            } else {
                cin = new BufferedReader(new InputStreamReader(System.in));
            }
            cout = new PrintWriter(new OutputStreamWriter(System.out));
//            cout = new PrintWriter(OUTPATH);
            tok = new StreamTokenizer(cin);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static String next_str() {
        try {
            tok.nextToken();
            if (tok.ttype == StreamTokenizer.TT_EOF)
                return null;
            else if (tok.ttype == StreamTokenizer.TT_NUMBER) {
                return String.valueOf((int)tok.nval);
            } else if (tok.ttype == StreamTokenizer.TT_WORD) {
                return tok.sval;
            } else return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static int read_int() {
        String tmp_next_str = next_str();
        return null==tmp_next_str ? -1 : Integer.parseInt(tmp_next_str);
    }
    public static long read_long() { return Long.parseLong(next_str()); }
    public static double read_double() { return Double.parseDouble(next_str()); }
    public static BigInteger read_big() { return new BigInteger(next_str()); }
    public static BigDecimal read_dec() { return new BigDecimal(next_str()); }


    static class Edge implements Comparable<Edge> {
        int u, v, w;
        @Override
        public int compareTo(Edge o) { return w - o.w; }
    }
    static Edge a[] = new Edge[MAXN];

    static class Pair implements Comparable<Pair>{
        int fst, sec;
        public Pair() { }
        public Pair(int fst, int sec) {
            this.fst = fst;
            this.sec = sec;
        }
        @Override
        public int compareTo(Pair o) {
//            return fst - o.fst == 0 ? sec - o.sec : fst - o.fst;
            return sec - o.sec;
        }
    }
}







import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Main {
    public static final boolean debug = true;
    public static String INPATH = "C:\\Users\\majiao\\Desktop\\test.txt",
            OUTPATH = "C:\\Users\\majiao\\Desktop\\out.txt";
    public static StreamTokenizer tok;
    public static BufferedReader cin;
    public static PrintWriter cout;

    public static long start_time = 0, out_time = 0;
    public static int n, m, K, Q, MAXN = (int)16, INF = 0x3f3f3f3f,
            pre[] = new int[MAXN], sum[] = new int[MAXN], POS = 50000;
    public static byte buf[] = new byte[MAXN];

    public static int fa(int x) { return pre[x]==x ? x : (pre[x]=fa(pre[x])); }

    public static void union_xy(int x, int y) {
        x = fa(x); y = fa(y);
        if(x != y) {
            sum[x] += sum[y];
            pre[y] = x;
        }
    }


    public static void main(String[] args) throws IOException {
        main_init();
        if(debug) { start_time = System.currentTimeMillis(); }
        if(false) { System.setOut(new PrintStream(OUTPATH)); }

        n = read_int(); m = read_int();
        cout.printf("0\n");
        int x;
        Deque<Pair> q = new LinkedList<>();
        for(int i=1; i<n; i++) {
            x = read_int();
            while(!q.isEmpty() && q.peekLast().sec > x) q.pollLast();
            q.addLast(new Pair(i, x));
            if(q.peekFirst().fst+m <= i) q.pollFirst();
            cout.printf("%d\n", q.peek().sec);
        }










        if(debug) {
            out_time = System.currentTimeMillis();
            cout.printf("run time : %d ms\n", out_time-start_time);
        }
        cout.flush();
    }

    public static void show(List<Object> list, Object... obj) {
        cout.printf("%s : ", obj.length>0 ? obj[0] : "");
        for(Object x : list) {
            cout.printf("[%s] ", x);
        }
        cout.printf("\n");
    }

    public static void show(Map<Object, Object> mp, Object... obj) {
        cout.printf("%s : ", obj.length>0 ? obj[0] : "");
        Set<Map.Entry<Object, Object>> entries = mp.entrySet();
        for (Map.Entry<Object, Object> en : entries) {
            cout.printf("[%s,%s] ", en.getKey(), en.getValue());
        }
        cout.printf("\n");
    }

    public static<T> void forarr(T arr[], int ...args) {
        int lef = 0, rig = arr.length - 1;
        if(args.length > 0) { lef = args[0]; rig = args[1]; }
        cout.printf(" : ");
        for( ; lef<=rig; lef++) {
            cout.printf("[%s] ", args[lef]);
        }
        cout.printf("\n");
    }

    public static void main_init() {
        try {
            if (debug) {
                cin = new BufferedReader(new InputStreamReader(
                        new FileInputStream(INPATH)));
            } else {
                cin = new BufferedReader(new InputStreamReader(System.in));
            }
            cout = new PrintWriter(new OutputStreamWriter(System.out));
//            cout = new PrintWriter(OUTPATH);
            tok = new StreamTokenizer(cin);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static String next_str() {
        try {
            tok.nextToken();
            if (tok.ttype == StreamTokenizer.TT_EOF)
                return null;
            else if (tok.ttype == StreamTokenizer.TT_NUMBER) {
                return String.valueOf((int)tok.nval);
            } else if (tok.ttype == StreamTokenizer.TT_WORD) {
                return tok.sval;
            } else return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static int read_int() {
        String tmp_next_str = next_str();
        return null==tmp_next_str ? -1 : Integer.parseInt(tmp_next_str);
    }
    public static long read_long() { return Long.parseLong(next_str()); }
    public static double read_double() { return Double.parseDouble(next_str()); }
    public static BigInteger read_big() { return new BigInteger(next_str()); }
    public static BigDecimal read_dec() { return new BigDecimal(next_str()); }


    static class Edge implements Comparable<Edge> {
        int u, v, w;
        @Override
        public int compareTo(Edge o) { return w - o.w; }
    }
    static Edge a[] = new Edge[MAXN];

    static class Pair implements Comparable<Pair>{
        int fst, sec;
        public Pair() { }
        public Pair(int fst, int sec) {
            this.fst = fst;
            this.sec = sec;
        }
        @Override
        public int compareTo(Pair o) {
//            return fst - o.fst == 0 ? sec - o.sec : fst - o.fst;
            return sec - o.sec;
        }
    }
}
马角的逆袭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Luogu P2278 [HNOI2003]操作系统
01-20
当一个任务执行完毕或被中断时，CPU会从等待队列中取出优先级最高的任务继续执行。值得注意的是，一旦被中断的任务再次开始，它从中断点继续，而不是从头开始。 在实现这个问题的解法时，可以使用优先级队列（通常...
7.1-单调队列
qq_62649563的博客
07-02 106
单调队列，求m区间的最小值
P1440 求M区间内的最小值
代码笔记本
07-12 510
https://www.luogu.com.cn/problem/P1440 题目描述 一个含有nn项的数列，求出每一项前的mm个数到它这个区间内的最小值。若前面的数不足mm项则从第11个数开始，若前面没有数则输出00。 输入格式 第一行两个整数，分别表示nn，mm。 第二行，nn个正整数，为所给定的数列a_iai​。 输出格式 nn行，每行一个整数，第ii个数为序列中a_iai​之前mm个数的最小值。 输入输出样例 输入 #1复制 6 2 7 8...
P1440 求m区间内的最小值 【单调队列】
ln2037的博客
09-09 202
题目描述 一个含有 nnn 项的数列，求出每一项前的 mmm 个数到它这个区间内的最小值。若前面的数不足 mmm 项则从第 111 个数开始，若前面没有数则输出 000。 输入格式 第一行两个整数，分别表示 nnn，mmm。 第二行，nnn 个正整数，为所给定的数列 aia_iai​。 输出格式 nnn 行，每行一个整数，第 iii 个数为序列中 aia_iai​ 之前 mmm 个数的最小值。 输入输出样例 输入 #1 6 2 7 8 1 4 3 2 输出 #1 0 7 7 1 1 3 说明/提示 对于 1
洛谷P1440 求m区间内的最小值
lzx_xzl_______的博客
10-16 221
一个含有 nn 项的数列，求出每一项前的 mm 个数到它这个区间内的最小值。若前面的数不足 mm 项则从第 11 个数开始，若前面没有数则输出 00。对于 100%100% 的数据，保证 1\le m\le n\le2\times10^61≤m≤n≤2×10。nn 行，每行一个整数，第 ii 个数为序列中 a_ia。第二行，nn 个正整数，为所给定的数列 a_ia。第一行两个整数，分别表示 nn，mm。之前 mm 个数的最小值。
【洛谷】P1440 求m区间内的最小值
数学、算法爱好者的博客
08-31 1259
题目地址： https://www.luogu.com.cn/problem/P1440 题目描述： 一个含有nnn项的数列，求出每一项前的mmm个数到它这个区间内的最小值。若前面的数不足mmm项则从第111个数开始，若前面没有数则输出000。 输入格式： 第一行两个整数，分别表示nnn，mmm。第二行，nnn个正整数，为所给定的数列aia_iai​。 输出格式： nnn行，每行一个整数，第iii个数为序列中aia_iai​之前mmm个数的最小值。 数据范围： 对于100%100\%100%的数据，保证1≤
luogu P4568代码
01-27
洛谷P4568题解 其实就是个简单的NOIP..
https://www.luogu.com.cn/problem/solution/P8595
最新发布
07-09
https://www.luogu.com.cn/problem/P8595 https://www.luogu.com.cn/problem/P8595 https://www.luogu.com.cn/problem/P8595 https://www.luogu.com.cn/problem/P8595 https://www.luogu.com.cn/problem/P8595 ...
vscode-luogu:解决VSCode中落谷问题
05-30
vscode-luogu轻松的让你在VSCode 上提交洛谷代码使用说明查看题目按下F1或Ctrl+Shift+P ，查找Luogu: 查看题目命令，点击后输入题号完成搜索点击界面左侧洛谷图片，然后点击搜索图标，输入题号完成搜索完成功能查看...
Luogu3.0plusplus:罗谷3.0 ++解释器，求星
04-05
使用方式：命令行格式luogu++ fileplace解释器会自动找到.lgpp源代码和.in栈初始化（可以没有），生成输出至.out .in格式： A data0 data1 ... datan C data0 data1 ... datam 其中data0〜datan按从栈底到栈顶的...
P1440 求m区间内的最值题解
YSJ的博客
07-10 353
查看原题： https://www.luogu.com.cn/problem/P1440 题目描述 一个含有 nn 项的数列，求出每一项前的 mm 个数到它这个区间内的最小值。若前面的数不足 mm 项则从第 11 个数开始，若前面没有数则输出 00。 输入格式 第一行两个整数，分别表示 n，m。 第二行，nn个正整数，为所给定的数列 ai。 输出格式 n 行，每行一个整数，第 i 个数为序列中 ai 之前 m 个数的最小值。 输入输出样例 输入 #1 6 2 7 8 1 4 3 2 输出 #1 0 7.
单调队列（求区间最值）
Stockholm_Sun的博客
08-07 2035
P1440 求m区间内的最小值题目描述 一个含有n项的数列(n<=2000000)，求出每一项前的m个数到它这个区间内的最小值。若前面的数不足m项则从第1个数开始，若前面没有数则输出0。输入输出格式输入格式： 第一行两个数n，m。 第二行，n个正整数，为所给定的数列。输出格式： n行，第i行的一个数ai，为所求序列中第i个数前m个数的最小值。输入样例#1： 6 2 7 8 1 4 3 2
单调队列-滑动窗口最小值
欣欣子的博客
11-09 313
单调队列-滑动窗口最小值单调队列题目：滑动窗口的最小值（递增队列）代码 2021-11-7 凌晨一点看着直播里edg捧起了全球总决赛冠军奖杯，我直接肝到三点，给自己助助兴~ 单调队列 单调队列和单调栈有着相同的思想，最大的区别就在于队列的左端右端都可以弹出，这就让单调队列相比较于单调栈更有弹性，更适用于那些对已经满足单调性的元素追加要求的情况。以下为单调递增队列图解（和单调栈一样的）单调栈可借鉴https://blog.csdn.net/smily94/article/details/121214795?s
滑动窗口求解最大 最小值问题
guapi_poe的博客
07-17 1260
题目：有一个整型数组 arr 和一个大小为 w 的窗口从数组的最左边滑到最右边，窗口每次向右边 滑一个位置。 例如，数组为[4,3,5,4,3,3,6,7]，窗口大小为 3 时： [4 3 5] 4 3 3 6 7 窗口中最大值为 5 4 [3 5 4] 3 3 6 7 窗口中最大值为 5 4 3 [5 4 3] 3 6 7 窗口中最大值为 5 4 3 5 [4 3 3] 6 7 窗口中最大值为 4 4 3 5 4 [3 3 6] 7 窗口中最大值...
求m区间内的最小值
guo_dong_yu的博客
06-10 1515
一个含有n项的数列(n<=2000000)，求出每一项前的m个数到它这个区间内的最小值。若前面的数不足m项则从第1个数开始，若前面没有数则输出0。 某谷的题面 看完题应该先想到的是模拟，一个个比较然后再输出，但当我们看完了数据范围： m≤n≤2000000 ohhhhhhh不超时算我输好吧。 所以还是思考思考正解： 先来看看样例数据： 7 8 1 4 3 2 每次取某位置之前连续两个数中的最小值。 第 1 个位置之前没有值所以是 0，现在有了一个数 7；第 2 个位置之前只有一个数 7，故最小.
滑动窗口【区间最大值区间&最小值】【单调队列】
YingMila的博客
04-03 1561
问题描述 ZJM 有一个长度为 n 的数列和一个大小为 k 的窗口, 窗口可以在数列上来回移动. 现在 ZJM 想知道在窗口从左往右滑的时候，每次窗口内数的最大值和最小值分别是多少. 例如： 数列是 [1 3 -1 -3 5 3 6 7], 其中 k 等于 3. Input 输入有两行。第一行两个整数n和k分别表示数列的长度和滑动窗口的大小，1<=k<=n<=1000000。第...
洛谷P1440 求m区间内的最小值（单调队列）
一只快乐的小蒟蒻~
03-09 525
【题目描述】 一个含有nnn项的数列，求出每一项aia_iai​前的mmm个数到它这个区间内（即[i−m,i−1][i-m,i-1][i−m,i−1]）的最小值。若前面的数不足mmm项则从第111个数开始，若前面没有数则输出000。 【输入格式】 第一行两个整数，分别表示n,mn,mn,m。 第二行，nnn个正整数，为所给定的数列aia_iai​。 【输出格式】 nnn行，每行一个整数，第iii个数为序列中aia_iai​之前mmm个数的最小值。 【数据范围】 1≤m≤n≤2×106,1≤ai≤3×1071
【单调队列 双端队列deque操作 模板题】求前m个数中的最小值 洛谷 P1440 求m区间内的最小值
qq_41037114的博客
03-15 340
洛谷 P1440 求m区间内的最小值 https://www.luogu.org/problemnew/show/P1440 题目描述 一个含有n项的数列(n&lt;=2000000)，求出每一项前的m个数到它这个区间内的最小值。若前面的数不足m项则从第1个数开始，若前面没有数则输出0。 输入输出格式 输入格式： 第一行两个数n，m。 第二行，n个正整数，为所给定的数列。 ...
求m区间内的最小值（洛谷P1440）
不知所云的博客
09-04 808
求m区间内的最小值 题目描述 一个含有n项的数列(n<=2000000)，求出每一项前的m个数到它这个区间内的最小值。若前面的数不足m项则从第1个数开始，若前面没有数则输出0。 输入格式 第一行两个数n，m。 第二行，n个正整数，为所给定的数列。 输出格式 n行，第i行的一个数ai，为所求序列中第i个数前m个数的最小值。 输入 #1 6 2 7 8 1 4 3 2 输出 #1 0 7 ...
Luogu P1088 火星人
06-07
这是一道算法竞赛中的题目，需要使用动态规划算法来解决。 题目描述：有n个火星人，他们的能力值分别为a1,a2,…,an。现在你需要将他们划分成两组，使得他们的能力值之差最小，求这个最小的差值。 解题思路：首先将题目转化为背包问题，将火星人分为两组，使得两组的能力值之差最小，可以看作是在一组火星人中选择若干个人，使得他们的能力值之和尽可能接近所有火星人的能力值之和的一半。 然后，使用动态规划算法求解，设dp[i][j]表示在前i个火星人中选取若干个人，使得他们的能力值之和不超过j的最大值。则可以得到状态转移方程：dp[i][j] = max(dp[i-1][j], dp[i-1][j-a[i]]+a[i])。 最后，将所有能力值之和的一半减去dp[n][sum/2]即可得到最小的能力值之差。 代码实现：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值