Permutasi Tatasusunan

Menjana pilih atur tatasusunan ialah tugas pengiraan biasa. Memandangkan tatasusunan elemen yang berbeza, bagaimanakah kita boleh mengira semua kemungkinan susunan elemen ini?

Algoritma Rekursif

Satu algoritma klasik untuk penjanaan pilih atur menggunakan rekursi. Idea teras adalah untuk mempertimbangkan setiap elemen dalam tatasusunan sebagai elemen pertama yang berpotensi, kemudian secara rekursif permusikan elemen yang tinggal untuk mencari semua kombinasi yang mungkin bermula dengan elemen pertama itu:

// Recursive method for permutation generation
public static void permute(int[] arr, int k) {
    for (int i = k; i < arr.length; i++) {
        // Swap elements at positions k and i
        Collections.swap(arr, k, i);
        // Recursively permute the remaining elements
        permute(arr, k + 1);
        // Restore original order of elements
        Collections.swap(arr, k, i);
    }
    if (k == arr.length - 1) {
        // Once all elements are permuted, print the current permutation
        System.out.println(Arrays.toString(arr));
    }
}

Dalam algoritma ini, parameter k menjejaki kedudukan semasa dalam tatasusunan. Pada mulanya, k ditetapkan kepada 0, menunjukkan elemen pertama. Untuk setiap kedudukan k, ia melelang melalui elemen yang tinggal, menukarnya dengan elemen pada kedudukan k dan secara rekursif mengubah suai tatasusunan yang lain bermula dengan kedudukan k 1. Ini secara berkesan mempertimbangkan semua susunan yang mungkin bermula dengan setiap elemen.

Algoritma Bukan Rekursif untuk Elemen Berbeza

Algoritma bukan rekursif alternatif berfungsi baik untuk kes di mana semua elemen dalam tatasusunan adalah berbeza. Ia membina pilih atur dengan menukar elemen secara berulang untuk mencapai corak tertentu:

for (int tail = arr.length - 1; tail > 0; tail--) {
    // Find the first decreasing element from the end
    if (arr[tail - 1] < arr[tail]) {
        // Find the last element greater than the decreasing element
        int s = arr.length - 1;
        while (arr[tail - 1] >= arr[s]) {
            s--;
        }
        // Swap the decreasing element with the greater element
        swap(arr, tail - 1, s);
        // Reverse the order of elements after the swap
        reverse(arr, tail);
        break;
    }
}

Algoritma ini bermula dengan jujukan elemen menaik dalam tatasusunan. Ia mengimbas tatasusunan dari kanan ke kiri, mencari elemen menurun pertama. Sebaik sahaja ia menjumpai elemen menurun, ia menukarnya dengan elemen terkecil dalam ekor tatasusunan yang lebih besar daripadanya. Akhirnya, ia membalikkan susunan unsur dalam ekor untuk mendapatkan pilih atur seterusnya.

Algoritma Bukan Rekursif untuk Elemen Yang Sama

Dalam kes di mana elemen dalam tatasusunan tidak berbeza, menggunakan HashMap untuk memetakan elemen kepada indeksnya boleh mengendalikan potensi ulangan:

// Create a HashMap to map elements to their indices
Map<E, Integer> map = new HashMap<>();
for (int i = 0; i < arr.length; i++) {
    map.put(arr[i], i);
}
// Sort the array in ascending order
Arrays.sort(arr);
// Initialize the index array
int[] ind = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
    ind[i] = map.get(arr[i]);
}

Dengan pemetaan dan pengindeksan yang betul, algoritma bukan rekursif yang sama boleh menjana semua pilih atur, mengendalikan elemen berulang dengan sewajarnya.

Atas ialah kandungan terperinci Bagaimanakah Kita Boleh Menjana Semua Pilihan Pilih Atur Kemungkinan, Mengendalikan Kedua-dua Elemen Beza dan Tidak Beza?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!