Question

这是我第一次发帖提问，请原谅我，如果我做错了。我的问题是如何从这段代码中获得更快的算法？我目前正在使用2个堆栈来实现代码，这样它就会获得索引范围之外的最小值。用户要求输入。

示例（2,3,4,5,1），如果（用户选择（1,4）），则表示它们正在查看（2,3,4,5），其输出为2。感谢。

import java.util.*;

interface StackADT <Integer> {
    // check whether stack is empty
    public boolean empty(); 

    // retrieve topmost item on stack
    public int       peek() throws EmptyStackException;

    // remove and return topmost item on stack
    public int       pop() throws EmptyStackException;

    // insert item onto stack
    public void    push(int item);
}


class StackArr <Integer> implements StackADT <Integer> {
    private int[] arr;
    private int top;
    private int maxSize;
    private final int INITSIZE = 1000;

    public StackArr() {
        arr = (int[]) new int[INITSIZE]; // creating array of type E
        top = -1;  // empty stack - thus, top is not on an valid array element
        maxSize = INITSIZE;
    }

    public boolean empty() { 
        return (top < 0); 
    }

    public int peek() throws EmptyStackException {
        if (!empty()) return arr[top];
        else throw new EmptyStackException();
    }

    public int pop() throws EmptyStackException {
        int obj = peek();
        top--;
        return obj;
    }

    public void push(int obj) {
        if (top >= maxSize - 1) enlargeArr();
        top++;
        arr[top] = obj;
    }
}


class RMQ{

    //declare stack object
    Stack<Integer> stack1;

    public RMQ(){
        stack1 = new Stack<Integer>();
    }

    public void insertInt(int num){
        stack1.push(num);
    }






    public int findIndex(int c, int d){



        Stack<Integer> tempStack = new Stack<Integer>();
        Stack<Integer> popStack = new Stack<Integer>();

        tempStack = (Stack)stack1.clone();

        while (d != tempStack.size())
        {
            tempStack.pop();            
        }

        int minValue = tempStack.pop();
        popStack.push(minValue);
        while (c <= tempStack.size())
        {
            int tempValue = tempStack.pop();
            if(tempValue >= minValue)
            {
                continue;
            }
            else
            {
                popStack.push(tempValue);
                minValue = tempValue;

            }
        }

        return popStack.pop();

    }


}




public class Pseudo{

    public static void main(String[] args){
        //declare variables
        int inputNum;
        int numOfOperations;

        //create object
        RMQ rmq = new RMQ();

        Scanner sc = new Scanner(System.in);

        //read input
        inputNum = sc.nextInt();


        //add integers into stack
        for(int i=0; i < inputNum; i++){
            rmq.insertInt(sc.nextInt());
        }

        // read input for number of queries
        numOfOperations = sc.nextInt();


        // Output queries
        for(int k=0; k < numOfOperations; k++){
           int output = rmq.findIndex(sc.nextInt(), sc.nextInt());
           System.out.println(output);
        }

    }
}

Answer 1

你为什么要使用堆栈？只需使用数组：

int[] myArray = new int[inputNum];
// fill the array...

// get the minimum between "from" and "to"
int minimum = Integer.MAX_VALUE;
for(int i = from ; i <= to ; ++i) {
    minimum = Math.min(minimum, myArray[i])
}

就是这样！

Answer 2

我理解你的问题的方式是你想在一个固定的数组上做一些预处理，然后让你对一系列元素的查找最小化操作非常快。

这个答案描述了一种做O（nlogn）预处理工作的方法，然后是每个查询的O（1）工作。

预处理O（nlogn）

想法是准备一个2d数组SMALL [a，k]，其中SMALL [a，k]是从^

开始的2 ^ k个元素中的最小值

您可以通过从k == 0开始以递归方式计算此数组，然后通过将前两个元素组合在一起来为每个更高元素构建值。

SMALL[a,k] = min(SMALL[a,k-1] , SMALL[a+2^(k-1),k-1])

每个查询查找O（1）

然后，您可以通过组合2个预先准备的答案立即找到任何范围的分钟。

假设您要查找从100到133的元素的最小值。您已经知道32个元素100到131的最小值（在BIG [100,5]中）以及从102到133的32个元素的最小值（在大[102,5]）所以你可以找到最小的这些来得到答案。

Answer 3

这是Range Minimum Query problem。

有some algorthms and data structures有效解决问题

一种更有效的算法

3 个答案:

预处理O（nlogn）

每个查询查找O（1）