阵列旋转 TLE（超出时间限制）

Posted 2023-02-22

【中文标题】阵列旋转 TLE（超出时间限制）

【英文标题】：Array rotation TLE (Time Limit Exceeded)

【发布时间】：2020-09-12 19:45:12

【问题描述】：

我真的很困惑，为什么我的 java 代码无法正常工作，它会在 Hacker Earth 上的 Code Monks 上提供 TLE。 这是1的链接

Link to Question 第一个问题MONK AND ROTATION

import java.util.Scanner;
class TestClass 
    static int[] ar=new int[100001];
    public static void main(String args[] )
        Scanner in=new Scanner(System.in);
        byte t=in.nextByte();
        while(t-->0)
            int n=in.nextInt();
            int k=in.nextInt()%n;
                for(int i=0;i<n-k;i++)
                    ar[i]=in.nextInt();
                for(int i=0;i<k;i++)
                    System.out.print(in.nextInt()+" ");
                for(int i=0;i<n-k;i++)
                    System.out.print(ar[i]+" ");
            System.out.println();
        
    

我不知道为什么它给 TLE 我认为有一些无限循环。

网站上的问题是-

僧侣和旋转 Monk 喜欢对数组执行不同的操作，因此作为 HackerEarth School 的校长，他将一项任务分配给了他的新学生 Mishki。 Mishki 将获得一个大小为 N 的整数数组 A 和一个整数 K ，她需要将数组沿正确方向旋转 K 步，然后打印结果数组。由于她是新来的学校，请帮助她完成任务。

输入： 第一行由一个整数 T 组成，表示测试用例的数量。 对于每个测试用例：

第一行由两个整数 N 和 K 组成，N 是数组中元素的数量，K 表示旋转的步数。 下一行由 N 个空格分隔的整数组成，表示数组 A 的元素。 输出： 打印所需的数组。

约束：

1<=T<=20
1<=N<=10^5
0<=K<=10^6
0<=A[i]<=10^6

示例输入

1

5 2

1 2 3 4 5

样本输出

4 5 1 2 3

解释

这里T为1，表示一个测试用例。

表示数组中的元素个数， ，表示旋转的步数。

初始数组是： 在第一次旋转中，5 将进入第一个位置，所有其他元素将移动到当前位置的前一个位置。现在，结果数组将是

在第二次旋转中，4 将进入第一个位置，所有其他元素将移动到当前位置的前一个位置。现在，结果数组将是

时间限制：每个输入文件 1.0 秒 内存限制：256 MB 源限制：1024 KB

【参考方案1】：

我不确定您的解决方案是否正确，但请尝试使用 StreamTokenizer 或 BufferedReader 而不是 Scanner。 Scanner 速度太慢，当您需要读取大量数据时可能会导致 TLE。

【参考方案2】：

减少对 System.in 和 System.out 的读写次数。 看看下面的解决方案

        Scanner scanner = new Scanner(System.in);
        int noOfTestCases = scanner.nextInt();

        for (int i = 0; i < noOfTestCases; i++) 
            int arraySize = scanner.nextInt();
            int noOfRotations = scanner.nextInt();
            noOfRotations = noOfRotations % arraySize;
            scanner.nextLine();
            String inputString = scanner.nextLine();
            String[] inputStringArray = inputString.split(" ");

            StringBuffer sb = new StringBuffer();

            for (int j = 0; j < arraySize; j++) 
                sb.append(inputStringArray[(arraySize + j - noOfRotations) % arraySize] + " ");
            

            System.out.print(sb);
            System.out.println("");
        

【参考方案3】：

import java.util.*;
public class temp 
    public static void main (String[] args) 
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0)
            int n = sc.nextInt();
            int k = sc.nextInt();
            int p = 0;
            int ar[] = new int[n];
            for(int i=0;i<n;i++)
                ar[i] = sc.nextInt();
            
            k %= n;
            for(int i=0;i<n;i++)
                p = ar[(i+(n-k))%n];
                System.out.print(p+" ");
            
            System.out.println();
               
    

虽然我在开始时没有使用大数组，但这段代码在所有测试用例中都可以正常工作。

试试这个。

【讨论】：

兄弟，我也试过上面的代码，甚至用缓冲阅读器代替扫描仪，但在一种情况下仍然给出TLE，网络是否也起到读取输入的作用

没有。网络应该不是问题。如果您知道特定的测试用例，也可以离线尝试。在 CPP 等任何其他语言中尝试相同的逻辑，因为我之前在 Java 中遇到过问题，但在 CPP 语言中不存在。

【参考方案4】：

从不同的角度思考。我们可以应用不同的逻辑，而不是拆分字符串并将其转换为数组并应用迭代逻辑。

诀窍是你只需要找到输入字符串的位置，我们只需要拆分一次。 我的意思是， 输入=> 6 2       //4是数字的长度，2是旋转的索引 1 2 3 4 5 6     //数组（使用缓冲读取器将输入作为字符串）

在这里，我们只需要在倒数第二个空格即第四个空格处拆分数组字符串。所以只需将字符串拆分一次即可实现输出- 5 6 1 2 3 4 第一次拆分- 5 6 + 空格 + 第二次拆分- 1 2 3 4 这个逻辑对我有用，所有的测试用例都通过了。

当数组输入字符串只有一个数字时，不要忘记覆盖极端情况。

代码片段-

int count=0;
for(int k=0; k<arr.length(); k++) 
    if(arr.charAt(k)==' ')
        count++;
    if(count==size-rot) 
         System.out.println(arr.substring(k+1,arr.length())
             + " " + arr.substring(0,k));
         break;
    

【参考方案5】：

问题出在 for 循环内的 System.out.print() 调用中。这是一个相当繁重的调用，如果调用太多次并产生开销。此解决方案有效：

//import for Scanner and other utility classes
import java.util.*;

class TestClass 

    public static void main(String[] args) 
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        int noOfTests = Integer.parseInt(input);
        for (int t = 0; t < noOfTests; t++) 
            input = s.nextLine();
            String[] str = input.split(" ");
            int sizeOfArray = Integer.parseInt(str[0]);
            int noOfRotations = Integer.parseInt(str[1]);
            String strIntegerArray = s.nextLine();
            String[] array = strIntegerArray.split(" ");
            printRightRotatedArray(array, noOfRotations, strIntegerArray.length());
        
    

    static void printRightRotatedArray(String[] array, int noOfRotations, int lengthOfStr) 
        int len = array.length;
        int noOfAcutalRotations = noOfRotations % len;
        int startingIndex = len - noOfAcutalRotations;
        StringBuilder sb = new StringBuilder(lengthOfStr+1);
        for (int i = 0; i < len; i++) 
            sb.append(array[(startingIndex + i) % len]);
            sb.append(" ");
        
        System.out.println(sb);