挑战程序竞赛系列（53）：4.4 栈

最新推荐文章于 2023-05-08 00:00:00 发布
最新推荐文章于 2023-05-08 00:00:00 发布
阅读量371 收藏
点赞数
分类专栏： 挑战程序 算法集中营
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014688145/article/details/77878355
版权

挑战程序竞赛系列（53）：4.4 栈

详细代码可以fork下Github上leetcode项目，不定期更新。

练习题如下：

POJ 3250: Bad Hair Day

思路：
找下一个比它大的元素的下标，假设nxt大的下标为id，则能够看到的头的个数为 id - i - 1，i表示当前坐标。

接着采用记忆手段构造，首先判断下一元素比当前大还是小，如果小则放入栈顶，如果大，则更新每一个栈中元素的下标。

具体思路可以参考：【Next Greater Element 系列】

代码如下：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main{

    String INPUT = "./data/judge/201709/P3250.txt";

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    void solve() {
        int n = ni();
        int[] nums = new int[n];
        for (int i = 0; i < n; ++i) {
            nums[i] = ni();
        }

        int[] stack = new int[n + 16];
        int[] nxt   = new int[n + 16];

        int t = 0;
        for (int i = 0; i < n; ++i) {
            int h = nums[i];
            while (t > 0 && h >= nums[stack[t - 1]]) {
                nxt[stack[t - 1]] = i;
                t --;
            }
            stack[t++] = i;
        }

        while (t > 0) {
            nxt[stack[t - 1]] = n;
            t --;
        }

        long sum = 0;
        for (int i = 0; i < n; ++i) {
            sum += (nxt[i] - i - 1);
        }

        out.println(sum);
    }

    FastScanner in;
    PrintWriter out;

    void run() throws IOException {
        boolean oj;
        try {
            oj = ! System.getProperty("user.dir").equals("F:\\java_workspace\\leetcode");
        } catch (Exception e) {
            oj = System.getProperty("ONLINE_JUDGE") != null;
        }

        InputStream is = oj ? System.in : new FileInputStream(new File(INPUT));
        in = new FastScanner(is);
        out = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        out.flush();
        if (!oj){
            System.out.println("[" + (System.currentTimeMillis() - s) + "ms]");
        }
    }

    public boolean more(){
        return in.hasNext();
    }

    public int ni(){
        return in.nextInt();
    }

    public long nl(){
        return in.nextLong();
    }

    public double nd(){
        return in.nextDouble();
    }

    public String ns(){
        return in.nextString();
    }

    public char nc(){
        return in.nextChar();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        boolean hasNext;

        public FastScanner(InputStream is) throws IOException {
            br = new BufferedReader(new InputStreamReader(is));
            hasNext = true;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    hasNext = false;
                    return "##";
                }
            }
            return st.nextToken();
        }

        String next = null;
        public boolean hasNext(){
            next = nextToken();
            return hasNext;
        }

        public int nextInt() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Integer.parseInt(more);
        }

        public long nextLong() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Long.parseLong(more);
        }

        public double nextDouble() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Double.parseDouble(more);
        }

        public String nextString(){
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return more;
        }

        public char nextChar(){
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return more.charAt(0);
        }
    }

    static class ArrayUtils {

        public static void fill(int[][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                Arrays.fill(f[i], value);
            }
        }

        public static void fill(int[][][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                fill(f[i], value);
            }
        }

        public static void fill(int[][][][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                fill(f[i], value);
            }
        }
    }
}

注意：相等高度是看不到的，所以要取个等号，遇到相等高度时，也及时更新。

精简了一下：

    void solve() {
        int n = ni();

        int[] nums = new int[n];
        int[] stack = new int[n + 16];

        long sum = 0;
        int t = 0;
        for (int i = 0; i < n; ++i) {
            nums[i] = ni();
            while (t > 0 && nums[i] >= nums[stack[t - 1]]) {
                sum += i - stack[t - 1] - 1;
                t --;
            }
            stack[t++] = i;
        }

        while (t > 0) {
            sum += n - stack[t - 1] - 1;
            t --;
        }

        out.println(sum);
    }

这里写图片描述

POJ 2082: Terrible Sets

晦涩难读的题目。。。说的直白点给个图解就不行么，唉。

实际上给定不同宽度下的每个长方体摆成1到n的序列，求最大的长方形面积。《挑战》P335的例题稍微改改就过了。

如果还不懂题意可以参考：
http://www.hankcs.com/program/algorithm/poj-2082-terrible-sets.html

所以这里求出L和R之后，再求w的累积和即可。

L和R的思路来源如下：
alt text

说说我直观的看法：
遍历1到n的每个高度，那么在当前高度下，尽可能的找到两个边界L和R，也就是书中所说的L[i]和R[i]，这样最后再遍历一次所有的高度，更新在该高度下构成的最大矩阵即可。

代码如下：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main{

    String INPUT = "./data/judge/201709/P2082.txt";

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    static final int MAX_N = 50000 + 16;
    int[] w, h, L, R, stack;
    int n;

    void init() {
        w     = new int[MAX_N];
        h     = new int[MAX_N];
        L     = new int[MAX_N];
        R     = new int[MAX_N];
        stack = new int[MAX_N];
    }

    void solve() {
        while (true) {
            n = ni();
            if (n == -1) break;
            init();
            for (int i = 0; i < n; ++i) {
                w[i] = ni();
                h[i] = ni();
            }
            out.println(area());
        }
    }

    int area() {
        int sum  = 0;
        int[] w_sum = new int[MAX_N];

        for (int i = 0; i < n; ++i) {
            w_sum[i + 1] = w[i] + w_sum[i];
        }

        int t = 0;
        for (int i = 0; i < n; ++i) {
            while (t > 0 && h[i] <= h[stack[t - 1]]) t--;
            L[i] = t == 0 ? 0 : stack[t - 1] + 1;
            stack[t++] = i;
        }

        t = 0;
        for (int i = n - 1; i >= 0; --i) {
            while (t > 0 && h[i] <= h[stack[t - 1]]) t--;
            R[i] = t == 0 ? n : stack[t - 1];
            stack[t++] = i;
        }

        for (int i = 0; i < n; ++i) {
            sum = Math.max(sum, h[i] * (w_sum[R[i]] - w_sum[L[i]]));
        }
        return sum;
    }

    FastScanner in;
    PrintWriter out;

    void run() throws IOException {
        boolean oj;
        try {
            oj = ! System.getProperty("user.dir").equals("F:\\java_workspace\\leetcode");
        } catch (Exception e) {
            oj = System.getProperty("ONLINE_JUDGE") != null;
        }

        InputStream is = oj ? System.in : new FileInputStream(new File(INPUT));
        in = new FastScanner(is);
        out = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        out.flush();
        if (!oj){
            System.out.println("[" + (System.currentTimeMillis() - s) + "ms]");
        }
    }

    public boolean more(){
        return in.hasNext();
    }

    public int ni(){
        return in.nextInt();
    }

    public long nl(){
        return in.nextLong();
    }

    public double nd(){
        return in.nextDouble();
    }

    public String ns(){
        return in.nextString();
    }

    public char nc(){
        return in.nextChar();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        boolean hasNext;

        public FastScanner(InputStream is) throws IOException {
            br = new BufferedReader(new InputStreamReader(is));
            hasNext = true;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    hasNext = false;
                    return "##";
                }
            }
            return st.nextToken();
        }

        String next = null;
        public boolean hasNext(){
            next = nextToken();
            return hasNext;
        }

        public int nextInt() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Integer.parseInt(more);
        }

        public long nextLong() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Long.parseLong(more);
        }

        public double nextDouble() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Double.parseDouble(more);
        }

        public String nextString(){
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return more;
        }

        public char nextChar(){
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return more.charAt(0);
        }
    }

    static class ArrayUtils {

        public static void fill(int[][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                Arrays.fill(f[i], value);
            }
        }

        public static void fill(int[][][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                fill(f[i], value);
            }
        }

        public static void fill(int[][][][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                fill(f[i], value);
            }
        }
    }
}

alt text

POJ 3494: Largest Submatrix of All 1’s

都是些经典题，leetcode上也刷到过，利用上一题的做法，先统计当前行每一列对应的最大高度是多少，接着每一行都有对应的高度序列，求一次最大矩阵面积即可。

代码如下：


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main{

    String INPUT = "./data/judge/201709/P3494.txt";

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    int N, M;
    int[][] matrix;
    void solve() {
        while (more()) {
            N = ni();
            M = ni();
            matrix = new int[N][M];

            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < M; ++j) {
                    matrix[i][j] = ni();
                }
            }

            for (int j = 0; j < M; ++j) {
                for (int i = 1; i < N; ++i) {
                    if (matrix[i][j] == 1) {
                        matrix[i][j] += matrix[i - 1][j];
                    }
                }
            }

            int sum = 0;
            for (int i = 0; i < N; ++i) {
                sum = Math.max(sum, area(matrix[i]));
            }

            out.println(sum);
        }
    }

    int area(int[] h) {
        int sum = 0;
        int n   = h.length;
        int[] stack = new int[n + 16];
        int[] L     = new int[n + 16];
        int[] R     = new int[n + 16];

        int t = 0;
        for (int i = 0; i < n; ++i) {
            while (t > 0 && h[i] <= h[stack[t - 1]]) t--;
            L[i] = t == 0 ? 0 : stack[t - 1] + 1;
            stack[t++] = i;
        }

        t = 0;
        for (int i = n - 1; i >= 0; --i) {
            while (t > 0 && h[i] <= h[stack[t - 1]]) t--;
            R[i] = t == 0 ? n : stack[t - 1];
            stack[t++] = i;
        }

        for (int i = 0; i < n; ++i) {
            sum = Math.max(sum, h[i] * (R[i] - L[i]));
        }

        return sum;
    }

    FastScanner in;
    PrintWriter out;

    void run() throws IOException {
        boolean oj;
        try {
            oj = ! System.getProperty("user.dir").equals("F:\\java_workspace\\leetcode");
        } catch (Exception e) {
            oj = System.getProperty("ONLINE_JUDGE") != null;
        }

        InputStream is = oj ? System.in : new FileInputStream(new File(INPUT));
        in = new FastScanner(is);
        out = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        out.flush();
        if (!oj){
            System.out.println("[" + (System.currentTimeMillis() - s) + "ms]");
        }
    }

    public boolean more(){
        return in.hasNext();
    }

    public int ni(){
        return in.nextInt();
    }

    public long nl(){
        return in.nextLong();
    }

    public double nd(){
        return in.nextDouble();
    }

    public String ns(){
        return in.nextString();
    }

    public char nc(){
        return in.nextChar();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        boolean hasNext;

        public FastScanner(InputStream is) throws IOException {
            br = new BufferedReader(new InputStreamReader(is));
            hasNext = true;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    hasNext = false;
                    return "##";
                }
            }
            return st.nextToken();
        }

        String next = null;
        public boolean hasNext(){
            next = nextToken();
            return hasNext;
        }

        public int nextInt() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Integer.parseInt(more);
        }

        public long nextLong() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Long.parseLong(more);
        }

        public double nextDouble() {
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return Double.parseDouble(more);
        }

        public String nextString(){
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return more;
        }

        public char nextChar(){
            if (next == null){
                hasNext();
            }
            String more = next;
            next = null;
            return more.charAt(0);
        }
    }

    static class ArrayUtils {

        public static void fill(int[][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                Arrays.fill(f[i], value);
            }
        }

        public static void fill(int[][][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                fill(f[i], value);
            }
        }

        public static void fill(int[][][][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                fill(f[i], value);
            }
        }
    }
}

alt text

Demon的黑与白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机组成原理：4.4CACHE.ppt
09-19
计算机组成原理：4.4CACHE.ppt
burpsuite使用
qq_41509200的博客
10-08 872
burpsuite使用 1 burpsuite 安装及配置 在自己的 Windows10 上安装社区版的 burpsuite，前提是已经安装好了 jdk 图1 安装打开后的界面 然后，在Firefox浏览中安装插件FoxyProxy 图2 FoxyProxy插件 2 Proxy抓OJ数据包 首先，挂上vpn后，在浏览器中输入http://192.168.173.163/JudgeOnline/l...
cumtoj 一起来选课
YZ930035683的博客
12-18 1067
一起来选课 题目地址：http://192.168.173.163/JudgeOnline/problem.php?cid=1019&pid=7 题目 明泽私立大学有n门课程提供给大一的同学来选课，每门课有两个数值来描述，开心程度Hi，复杂程度Ci。LW小太阳是个有奇怪癖好的人，假设他这学期要选m门课，把这m门课的Hi之和定义为sumH，Ci之和定义为sumC，并自己定义出本学期...
【操作指导 | 代码实现】挑战程序设计竞赛2：算法和数据结构
青年有志
09-08 1225
挑战程序设计竞赛2：算法和数据结构
矿大oj网址
qq_43806430的博客
09-14 5594
192.168.173.163/JudgeOnline
计算机类相关比赛（大学生版）
执一抹浅笑的博客
05-08 4412
计算机类相关比赛
httpcore-4.4.13-API文档-中文版.zip
06-06
赠送jar包：httpcore-4.4.13.jar； 赠送原API文档：httpcore-4.4.13-javadoc.jar； 赠送源代码：httpcore-4.4.13-sources.jar； 赠送Maven依赖信息文件：httpcore-4.4.13.pom； 包含翻译后的API文档：...
数字电子技术基础课件：4.4 触发器的脉冲工作特性.ppt
07-04
数字电子技术基础课件：4.4 触发器的脉冲工作特性.ppt
北师大版七年级数学下册教案设计：4.4尺规作三角形.pdf
01-17
北师大版七年级数学下册教案设计：4.4尺规作三角形.pdf
数据结构上机实验6.15
qq_53134669的博客
06-19 1818
问题 A: 出栈合法性 题目描述 已知自然数1，2，…，N（1<=N<=100）依次入栈，请问序列C1，C2，…，CN是否为合法的出栈序列。 输入 输入包含多组测试数据。 每组测试数据的第一行为整数N（1<=N<=100），当N=0时，输入结束。 第二行为N个正整数，以空格隔开，为出栈序列。 输出 对于每组输入，输出结果为一行字符串。 如给出的序列是合法的出栈序列，则输出Yes，否则输出No。 样例输入 5 3 4 2 1 5 5 3 5 1 4 2 0 样例输出 Yes No
挑战程序设计竞赛2：算法和数据结构【试读】
01-18
本书分为准备篇、基础篇和应用篇三大部分，借助在线评测系统Aizu Online Judge以及大量例题，详细讲解了算法与复杂度、初等和高等排序、搜索、递归和分治法、动态规划法、二叉搜索树、堆、图、计算几何学、数论等算法和数据结构的关键知识点，既可以作为挑战程序设计竞赛的参考书，也可以用来引导初学者系统学习算法和数据结构的基础知识。本书适合所有程序设计人员、程序设计竞赛爱好者以及高校计算机专业师生阅读。
java2 实用教程 （全国ITAT大赛指定教材）
10-11
内容详尽，浅显易懂,是ITAT大赛开发指定教辅！
Java设计模式之行为型：迭代器模式
张维鹏的博客
11-03 1万+
迭代器模式提供一种访问集合中的各个元素，而不暴露其内部表示的方法。将在元素之间游走的职责交给迭代器，而不是集合对象，从而简化集合容器的实现，让集合容器专注于在它所应该专注的事情上，更加符合单一职责原则。
文本处理 awk
NIEEPN的博客
02-26 310
======================================================== 一、awk简介 awk 是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个 或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix 下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。...
java hasnext_Java扫描仪的hasNext（）方法与示例
cumtv80668的专栏
07-19 1488
java hasnext 扫描器类的hasNext()方法 (Scanner Class hasNext() method) Syntax: 句法： public boolean hasNext(); public boolean hasNext(Pattern patt); public boolean hasNext(String patt); hasNex...
《挑战程序设计竞赛》 读后感
热门推荐
姚光超的专栏
09-12 2万+
最近要开始准备面试找工作，算法是准备的重中之重，舍友推荐了《挑战程序设计竞赛》这本书。花了一周的时间大体过了一遍，该书真切地让我理解了“智商是硬伤”这句话的含义。我对它的评价是：如果智商小于120，只看前两章就够了；智商大于120小于150，三四章的简单章节还是可以看一下的；智商大于150，看完本书问题不大。望大家量力而为，否则你的自信心会遭受严重的打击。 下面把自己看懂的，并感觉比较重要的内容
http://192.168.1.163:8000/test.asp
我在哈佛念过佛、我在牛津放过牛、我在剑桥建过桥、我在麻省理工理过发。- 程序员之家
04-13 4685
  满分100分 单选题40分 多选题60分 考试时间： 120分钟 计时：  一、单选题（ 总分 40 分，答错不得分 ) 1、下列情形中属于《劳动法》调整的是（ ） A出版社向作者支付稿酬 B企业支付给未签订劳动合同的合同者的劳动报酬 C甲
挑战程序竞赛系列（58）：4.6树上的分治法（1）
Demon-初来驾到
09-12 1507
挑战程序竞赛系列（58）：4.6树上的分治法（1）传送门：POJ 1655: Balancing Act思路： 选择使得删除该顶点后得到的最大子树的顶点数最少的顶点作为分割顶点。为什么就是最大顶点数的最小呢？可以这么考虑，如果存在一种极度不平衡的状态，那么我们可以通过移动树的顶点，让它进入下一状态减少不平衡态，这种情况总能在不平衡态时发生。那么最大子树顶点数最小，意味着剩余顶点数最大但比这最大子树
挑战程序竞赛系列（24）：3.5最大流与最小割
Demon-初来驾到
07-20 1150
挑战程序竞赛系列（24）：3.5最大流与最小割 详细代码可以fork下Github上leetcode项目，不定期更新。 练习题如下： POJ 1273: Drainage Ditches POJ 3713: Transferring Sylla POJ 1273: Drainage Ditches最大流（经典问题），思路： 这类题类似于松弛法，不需要一步给出答案，而是慢慢的逼近最优解，何以理
ffme:windows 4.4.350
最新发布
07-14
使用 ffme:windows 4.4.350，开发人员可以轻松地在 Windows 应用程序中实现音视频播放的功能。它提供了简单的 API 接口，使得开发者可以快速地加载、播放和管理音视频资源。 除了音视频播放，ffme:windows 4.4.350 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值