挑战程序设计竞赛(算法和数据结构)——4.6 数据结构的应用——计算面积Java代码实现

Posted 小乖乖的臭坏坏

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了挑战程序设计竞赛(算法和数据结构)——4.6 数据结构的应用——计算面积Java代码实现相关的知识,希望对你有一定的参考价值。

题目:

代码及实现思路如下:

import java.io.BufferedInputStream;
import java.util.Scanner;
import java.util.Stack;
import java.util.Vector;

public class _4_6 {
    public static void main(String[] args) {
        /*
        设计两个栈,S1和S2.
        S1为int栈:
        用于存放输入进来的"\\"的位置,用i表示(输入数据时即可用于遍历,s.length(),s.charAt(i)).
        如果遇到了"/",则计算i与栈顶数之差,并将栈顶数弹栈。
        S2为Area类型的栈:
        Area类包含一个记录最左侧"\\"位置的pos(int)以及当前积水处的面积L(int)。
        S2.size()就是积水处到的数量。
        */

        //定义一个Area类型的类
        class Area{
            int pos;
            int L;
            Area(int pos, int L){
                this.pos = pos;
                this.L = L;
            }
        }

        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        System.out.println("请输入一个水坝:(只能包含\\\\, _, /)");
        String dam = cin.nextLine();
        int N = dam.length();
        Stack<Integer> S1 = new Stack<Integer>();
        Stack<Area> S2 = new Stack<Area>();



        for(int i=0;i<N;i++){
            if(dam.charAt(i) == '\\\\'){
                S1.push(i);
            }
            else if(dam.charAt(i) == '/'){
                if(S1.size() == 0){continue;}//如果没有与之对应的\\,那么这个位置的/无效,直接跳到下一个循环即可
                else{
                    int square = i - S1.peek();//计算每一个小面积
                    //对S2进行操作
                    if(S2.size()==0){//如果栈为空,则直接压栈
                        Area new_area = new Area(S1.peek(), square);
                        S2.push(new_area);
                    }
                    else{
                        if(S2.peek().pos < S1.peek()){
                            //如果栈内面积涉及的\\在新计算的面积的左边,说明两个凹槽不重叠,记录新的水坑面积,即执行压栈操作
                            Area new_area = new Area(S1.peek(), square);
                            S2.push(new_area);
                        }
                        else if(S2.peek().pos > S1.peek()){
                            //如果栈内面积涉及的\\在新计算的面积的右边,说明两个凹槽重叠,合并水坑面积,并记录更新新位置;这个操作可能嵌套,要循环
                            Area new_area = new Area(S1.peek(), square);//用一个值来暂存最左侧的\\和目前的面积值
                            while(S2.size()>0 && S2.peek().pos > S1.peek()) {
                                new_area = new Area(S1.peek(), S2.peek().L + new_area.L);//每次循环将面积值合并
                                S2.pop();
                            }
                            S2.push(new_area);
                        }
                    }
                    S1.pop();//计算完成后,将S1的位置弹栈
                }

            }
        }/**/

        Stack<Area> S3 = new Stack<Area>();
        while(S2.size()!=0){
            S3.push(S2.pop());
        }

        System.out.println("水坑数量有:" + S3.size());
        System.out.println("每个水坑的面积分别为:");
        while(S3.size()!=0){
            System.out.println(S3.pop().L + " ");
        }
    }
}



//        int sum = 0;
//
//        for(int i=0;i<N;i++){
//            if(dam.charAt(i) == '\\\\'){
//                S1.push(i);//只要是“\\”,就对S1执行入栈操作
//            }
//            else if(dam.charAt(i) == '/' && S1.size()>0){//如果是/,且S1栈内不为空
//                int j = S1.peek();//记录S1栈顶的值
//                S1.pop();//S1出栈
//                sum+=i-j;
//                int a = i-j;//记录小面积
//                while (S2.size()>0 && S2.peek().pos>j){//只要S2不为空且S2的栈顶值大于S1的栈顶值
//                    a += S2.peek().L;
//                    S2.pop();
//                }
//                Area temp = new Area(j, a);
//                S2.push(temp);
//            }
//        }

        /*Vector<Integer> ans = new Vector<>();
        while(S2.size()>0){ans.addElement(S2.peek().L);S2.pop();}*/

输入:

\\\\///\\_/\\/\\\\\\\\/_/\\\\///__\\\\\\_\\\\/_\\/_/\\

输出:

水坑数量有:5
每个水坑的面积分别为:
4 
2 
1 
19 
9 

以上是关于挑战程序设计竞赛(算法和数据结构)——4.6 数据结构的应用——计算面积Java代码实现的主要内容,如果未能解决你的问题,请参考以下文章

挑战程序设计竞赛(算法和数据结构)——分割(下)&快速排序的JAVA实现

挑战程序设计竞赛(算法和数据结构)——7.1归并排序JAVA实现

挑战程序设计竞赛(算法和数据结构)——15.5最小生成树(Kruskal算法)的JAVA实现

挑战程序设计竞赛(算法和数据结构)——4.5 Java 中对应C++STL的数据结构类

挑战程序设计竞赛(算法和数据结构)——16.12凸包(安德鲁算法)的JAVA实现

挑战程序设计竞赛(算法和数据结构)——3.6希尔排序的JAVA实现