陣列旋轉 TLE（超出時間限制）

Question

我真的很困惑為什么我的 java 代碼無法正常工作，它會在 Hacker Earth 上的 Code Monks 上提供 TLE。 這是1的鏈接

• 鏈接到問題第一個問題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 和 Rotation Monk 喜歡對數組執行不同的操作，因此作為 HackerEarth School 的校長，他給他的新學生 Mishki 分配了一項任務。 Mishki 將獲得一個大小為 N 的整數數組 A 和一個整數 K ，她需要將數組沿正確方向旋轉 K 步，然后打印結果數組。 由於她是新來的學校，請幫助她完成任務。

輸入：第一行由一個整數 T 組成，表示測試用例的數量。 對於每個測試用例：

1. 第一行由兩個整數 N 和 K 組成，N 是數組中元素的數量，K 表示旋轉的步數。
2. 下一行由 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

Answer 1

我不確定您的解決方案的正確性，但請嘗試使用 StreamTokenizer 或 BufferedReader 而不是 Scanner。 Scanner 速度太慢，當您需要讀取大量數據時可能會導致 TLE。

Answer 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("");
        }

Answer 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();
        }       
    }
}

雖然我在開始時沒有使用大數組，但這段代碼適用於所有測試用例。

試試這個。

Answer 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;
    }
}

Answer 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);
    }
}

Answer 6

將所有內容放入字符串緩沖區並在最后打印對我有用。

class TestClass {
public static void main(String args[] ) throws Exception {
    //BufferedReader
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine());
    StringBuilder sb = new StringBuilder();// output
    for(int i=0;i<t;i++){
        String [] nk=br.readLine().split(" ");
        int n= Integer.parseInt(nk[0]);
        int k=Integer.parseInt(nk[1]);
        String [] a=br.readLine().split(" ");
        int split=n-(k%n);
        for (int j = split; j < a.length; j++) {
            sb.append(a[j]);
            sb.append(' ');
        }
        for (int j = 0 ; j < split; j++) {
            sb.append(a[j]);
            sb.append(' ');
        }
        sb.append("\n");
    }
    System.out.println(sb);
}

}