Question

数组包含元素（1,2,2,1,1）。我必须发现子数组中不同元素的数量应该等于给定数组中不同元素的数量，即数组中不同元素的数量 2 （1和2）。

所有可能的子阵列都是[1,2]，[1,3]，[1,4]，[1,5]，[2,4]，[2,5]，[3,4]， [3,5]

区别意味着没有明显的元素2 {1,2,2}有2个不同的元素。在这个问题中，1,4并不意味着我们包括第一个元素和第四个元素，这意味着我们的子数组从1开始，到4结束因此子数组是[1,2,2,1]，它有2个不同的元素，它满足整个数组有2个不同的元素。

que的问题是我得到2个lacs的数组大小的测试用例，我必须在1秒内得到输出，每次超时都会超出。

看到答案后，我必须使用缓冲读取器（而不是扫描仪{由于性能问题}）和hashmap。

首先，我使用了扫描仪和缓冲液阅读器，两者都在2分17秒内输出（对于2个lac输入）。那么为什么需要使用缓冲读取器（使用扫描器减少了代码的长度）。

其次，我在网站上测试了两个代码，并且两个代码都在1秒内输出了输出，而在我的本地机器中则需要2分17秒。我不明白为什么会有这么大的差异。

第三，这段代码的含义是什么： final int mod =（int）1e9 + 7; （虽然我在使用大量时已多次看到）

第四，缓冲读卡器使用以下代码有什么用。

我是java的新手，所以请给出简单的答案，对不起，

class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;

public InputReader(InputStream stream)
{
    this.stream = stream;
}

public int read()
{
    if (numChars == -1)
        throw new InputMismatchException();
    if (curChar >= numChars)
    {
        curChar = 0;
        try
        {
            numChars = stream.read(buf);
        } catch (IOException e)
        {
            throw new InputMismatchException();
        }
        if (numChars <= 0)
            return -1;
    }
    return buf[curChar++];
}

public int readInt()
{
    int c = read();
    while (isSpaceChar(c))
        c = read();
    int sgn = 1;
    if (c == '-')
    {
        sgn = -1;
        c = read();
    }
    int res = 0;
    do
    {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
    } while (!isSpaceChar(c));
    return res * sgn;
}

public String readString()
{
    int c = read();
    while (isSpaceChar(c))
        c = read();
    StringBuilder res = new StringBuilder();
    do
    {
        res.appendCodePoint(c);
        c = read();
    } while (!isSpaceChar(c));
    return res.toString();
}
public double readDouble() {
    int c = read();
    while (isSpaceChar(c))
        c = read();
    int sgn = 1;
    if (c == '-') {
        sgn = -1;
        c = read();
    }
    double res = 0;
    while (!isSpaceChar(c) && c != '.') {
        if (c == 'e' || c == 'E')
            return res * Math.pow(10, readInt());
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
    }
    if (c == '.') {
        c = read();
        double m = 1;
        while (!isSpaceChar(c)) {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, readInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            m /= 10;
            res += (c - '0') * m;
            c = read();
        }
    }
    return res * sgn;
}
public long readLong() {
    int c = read();
    while (isSpaceChar(c))
        c = read();
    int sgn = 1;
    if (c == '-') {
        sgn = -1;
        c = read();
    }
    long res = 0;
    do {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
    } while (!isSpaceChar(c));
    return res * sgn;
}
public boolean isSpaceChar(int c)
{
    if (filter != null)
        return filter.isSpaceChar(c);
    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

public String next()
{
    return readString();
}

public interface SpaceCharFilter
{
    public boolean isSpaceChar(int ch);
}
}

class OutputWriter
{
private  PrintWriter writer;

public OutputWriter(OutputStream outputStream)
{
    writer = new PrintWriter(new BufferedWriter(new      OutputStreamWriter(outputStream)));
}

public OutputWriter(Writer writer)
{
    this.writer = new PrintWriter(writer);
}

public void print(Object... objects)
 {
    for (int i = 0; i < objects.length; i++)
    {
        if (i != 0)
            writer.print(' ');
        writer.print(objects[i]);
    }
 }

public void printLine(Object... objects)
{
    print(objects);
    writer.println();
}

public void close()
{
    writer.close();
}

public void flush()
{
    writer.flush();
}
}

Answer 1

回答第四个查询：代码比使用普通的Scanner类快。因此，您可以在编码竞争中使用它。我在~55 MB文本文件“test.txt”上使用了以下代码。

package so;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;

public class UseIR {
public static void main(String[] args) throws IOException {

//checked using the class provided 'InputReader'
InputReader ob=new InputReader(new FileInputStream(new File("src\\so\\test.txt")));
long str=0;
StringBuilder sb=new StringBuilder();
long curTime=System.currentTimeMillis();
while((str=ob.read())!=-1){
    sb.append(((char)str));
}
System.out.println("done "+(System.currentTimeMillis()-curTime));

//checked using the Scanner class

curTime=System.currentTimeMillis();
Scanner s=new Scanner(new File("src\\so\\test.txt"));
sb=new StringBuilder();
while(s.hasNext()){
    sb.append(s.next());
}
System.out.println("done "+(System.currentTimeMillis()-curTime));
}
}

使用以下输出：

done 447
done 2061

希望有所帮助：）

遍历一个大阵列

1 个答案: