在Java编码时如何避免 TLE？

避免超出时间限制（TLE）是我们在进行竞争性编码以及在技术 PI 期间回答 DSA 问题时需要注意的最重要方面之一。在这种情况下，所有编码平台的一个常见问题是排序或涉及排序的问题。下面的代码是我在练习数据结构时设计的，它以最小的交换次数对从 1 开始的连续数字列表进行线性排序，并返回完成的交换次数的值。

以下代码背后的概念是，考虑到数组索引从 0 开始，数字在已排序数组中的正确位置比数字本身小 1。这是因为数组仅由从 1 开始的连续数字组成。

说明：考虑以下示例：给定的未排序数组是：4 3 1 2 5。

输入：下表是数组元素及其在数组中的当前位置（由第一行中的索引指示）。

0	1	2	3	4
4	3	1	2	5

输出：排序后，数组将如下所示。因此，元素的正确位置只不过是一个比数字本身小 1 的值的索引，因此我们需要做的就是将各个元素放在可以从元素值确定的正确索引上。

0	1	2	3	4
1	2	3	4	5

方法：

我们首先将给定的数组元素插入到 HashMap 中，其中键是元素，值是指示当前位置的索引。
然后我们运行一个 for 循环，从输入数组的初始索引值（即 0）开始，直到比数组大小小 1 的值。
在每次迭代中，我们检查 arr[i] 处的值是否比 'i' 大 1。
如果是这样，则表示该元素在其正确位置，否则其位置需要与它实际所在位置的元素的位置交换（该元素仅是 (i+1)）。每次发生交换时，用于保持交换次数计数的变量都会增加 1。
然后，由于交换而导致的数组中的相应更改也会在 HashMap 中更新。

图片表示：最初的HashMap如下

Element(Key)	Current Index(Value)
4	0
3	1
1	2
2	3
5	4

第一次迭代后，HashMap 将如下所示

Element(Key)	Current Index(Value)
4	2
3	1
1	0
2	3
5	4

当数组变成

0	1	2	3	4
1	3	4	2	5

结论：因此，在每次交换后，一个元素都被放置在正确的位置，并且对哈希图进行了相应的更改，以确保交换次数最少。

执行：

Java

// Java Program to illustrate a Hack to Avoid TLE while
// coding
 
// Importing required libraries
import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;
 
// Main Class
class GFG {
 
    // Method 1
    // To find the minimum number of swaps required
    static int minimumSwaps(int[] arr)
    {
 
        // Declaring and initializing variables to 0
        // Swap and Index variable
        int swap = 0, index = 0;
 
        // Creating object of HashMap class for storing
        // array elements along with corresponding current
        // position in the input array
 
        // Declaring both the objects if Integer type
        HashMap index_table
            = new HashMap<>();
 
        for (int i = 0; i < arr.length; i++) {
 
            index_table.put(arr[i], i);
        }
 
        // Loop variable beginning from 0 so the element
        // that should be present at index i after sorting
        // is, i+1 Hence we check if arr[i] is equal to i+1
        // or not
        for (int i = 0; i < arr.length; i++) {
 
            // Condition check for figuring out correct
            // element
            if (arr[i] != (i + 1))
 
            {
 
                // If the above condition is not fulfilled
                // i.e, if arr[i]!=i+1 that means the
                // correct element needs to be swapped with
                // the current one.
 
                // Find the index of the element i+1 from
                // the hashmap
                index = index_table.get(i + 1);
 
                // Swapping the element
                arr[index] = arr[i];
                arr[i] = i + 1;
 
                // Variable keeping a count of the number of
                // swaps
                swap++;
 
                // Updating the hashmap
                index_table.put(arr[i], i);
 
                index_table.put(arr[index], index);
            }
        }
 
        // Returning the swap counts
        return swap;
    }
 
    // Scnnere Class object to take unput from user
    private static final Scanner scanner
        = new Scanner(System.in);
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
        throws IOException
    {
 
        // Creating an object of BufferedWriter to read
        // input fro te use
        BufferedWriter bufferedWriter = new BufferedWriter(
            new FileWriter(System.getenv("OUTPUT_PATH")));
 
        // Storing the non-primitive datatype
        // Here, Integer value
        int n = scanner.nextInt();
 
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
 
        // Creating arrays
 
        // Array 1
        // Creating an Integer array o sze N
        int[] arr = new int[n];
 
        // Array 2
        // Creating an String array
        String[] arrItems = scanner.nextLine().split(" ");
 
        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
 
        for (int i = 0; i < n; i++) {
 
            int arrItem = Integer.parseInt(arrItems[i]);
 
            arr[i] = arrItem;
        }
 
        int res = minimumSwaps(arr);
 
        bufferedWriter.write(String.valueOf(res));
 
        // Getting to new line
        bufferedWriter.newLine();
 
        // No further input will be accepted
        // isong the close()  method
        bufferedWriter.close();
 
        // Closing the inputs
        scanner.close();
    }
}

输出：

输入：

4 3 1 2 5

输出：