Faktor Kth bagi N - algoritma O(sqrt n).

pengenalan

Baru-baru ini saya menulis siaran Learn Big O Notation sekali dan untuk semua. Dalam catatan itu saya membincangkan semua jenis tatatanda masa Big O yang tersedia di lembaran cheat Big-O. Dan saya tidak fikir akan ada lagi notasi masa yang mungkin di luar tujuh itu.

Seolah-olah alam semesta itu sendiri merendahkan saya dan mengejek kejahilan saya, saya menghadapi masalah LeetCode dengan penyelesaian masa O(√n). Yang boleh diterjemahkan kepada O(N^1/2), jika anda gila.

Masalahnya

Anda diberi dua integer positif n dan k. Faktor bagi integer n ditakrifkan sebagai integer i dengan n % i == 0.

Pertimbangkan senarai semua faktor n yang diisih dalam tertib menaik, kembalikan faktor ke-k dalam senarai ini atau kembalikan -1 jika n mempunyai faktor kurang daripada k.

Penyelesaian yang jelas

Nah, jika anda seperti saya, fikiran pertama anda ialah meneliti setiap nombor dari 1 hingga n, periksa sama ada ia adalah faktor, dan jika ia berada dalam indeks k yang dikehendaki, kembalikannya.

Kodnya kelihatan seperti ini:

def getkthFactorOfN(n, k):
    result = 0
    for i in range(1, n + 1):
        if n % i == 0:
            result = result + 1
            if result == k:
                return i
    return -1

Ini semua baik dan menarik, tetapi ia "sahaja" O(n). Lagipun, hanya ada satu gelung dan ia naik ke n 1.
Setiap operasi lain dibuang apabila mempertimbangkan notasi masa.

Tetapi, kawan saya, ada tangkapan.

Memahami faktor

Jika anda memikirkannya, faktor "dicerminkan" selepas titik tertentu.

Ambil, sebagai contoh, nombor 81. Faktornya ialah [1, 3, 9, 27], di mana:

• 1 * 81 = 81
• 3 * 27 = 81
• 9 * 9 = 81
• 27 * 3 = 81
• 81 * 1 = 81

Jika anda tidak mengira nombor 9, Operasi hanya diulang dan dibalikkan. Jika anda membahagikan n dengan salah satu faktornya, anda mendapat faktor lain.
Jangkakan punca kuasa dua bagi n, di mana ia adalah kuasa dua sendiri (duh).

Berbekalkan pengetahuan ini, kami kini tahu bahawa kami tidak perlu melelang melalui gelung sehingga n kali (dengan julat(1, n 1)), tetapi hanya sehingga math.sqrt(n). Selepas itu, kami mempunyai setiap faktor yang kami perlukan!

Penyelesaian yang tidak begitu jelas

Sekarang kita mempunyai semua yang kita perlukan, kita perlu mengubah gelung ini daripada 1 -> n hingga 1 -> persegi n.

Saya hanya akan membuang kod di sini dan kita akan pergi ke baris satu demi satu.

def getkthFactorOfN(n, k):
    i = 1
    factors_asc = []
    factors_desc = []
    while i * i <= n:
        if n % i == 0:
            factors_asc.append(i)
            if i != n // i:
                factors_desc.append(n // i)
        i += 1
    if k <= len(factors_asc):
        return factors_asc[k-1]
    k -= len(factors_asc)
    if k <= len(factors_desc):
        return factors_desc[-k]
    return -1

Oof, ia jauh lebih kompleks. Jom pecahkan:

Pertama, kita mulakan i = 1. Pembolehubah ini akan digunakan sebagai "nombor yang kita ada sekarang" semasa mencari faktor.

Kedua, kami akan mencipta dua tatasusunan: faktor_asc dan faktor_desc. Keajaiban di sini ialah kita akan menambah faktor pada factor_asc - ia dinamakan seperti ini kerana ia akan secara automatik dalam tertib menaik.
Setiap kali kami menambahkan sesuatu pada factor_asc, kami akan membahagikan n dengannya dan menambahkannya pada faktor_desc. Logik yang sama di sini; ia akan ditambah dengan mudah dalam tertib menurun.

Kemudian, kita mulakan gelung kita. Di sini saya telah menukarnya menjadi semasa i * i <= n, kerana kita berhenti apabila kita mencapai akar n.

Kita mulakan dengan menyemak sama ada nombor semasa ialah faktor (n % i == 0). Jika ya, kami boleh menambahkannya pada tatasusunan factor_asc kami.

Seterusnya, kita mendapat "faktor songsang" i. Kita boleh melakukan ini dengan menyemak sama ada i != n // i, atau dengan kata lain, jika ia bukan punca. Ini kerana akar tidak boleh diduplikasi dalam kedua-dua tatasusunan. Jika tidak, kita mendapat faktor terbalik dengan menjalankan n // i dan menambahkan hasilnya dalam faktor_desc.

Selepas itu, kami menambah 1 pada i dan meneruskan gelung kami.

Selepas gelung selesai, kita mesti mempunyai setiap faktorial yang kita perlukan.

Kita mulakan dengan menyemak sama ada k berada pada separuh pertama termasuk punca (yang boleh ditafsirkan sebagai tengah) dengan jika k <= len(faktor_asc). Jika ya, dapatkan indeks daripada tatasusunan ini (ingat: tatasusunan bermula pada sifar!).

Jika tidak, kita mesti menolak jumlah faktor yang ditemui daripada k dan semak semula - dengan k -= len(faktor_asc) dan jika k <= len(faktor_desc).

Jika k berada di dalam faktor_desc, dapatkan nilainya dengan factor_desk[-k] (dari terakhir hingga pertama).

Jika semuanya gagal, kembalikan -1.

Lengkung

Jika anda tertanya-tanya di mana dalam graf lengkung ia mendarat, ia akan berada di antara O(n) dan O(log n), lebih baik daripada yang pertama dan lebih teruk daripada yang terakhir. Berikut ialah graf:

Terdapat di Mathspace

Kesimpulan

Ini adalah perjalanan untuk mendedahkan dan menyelidik. Terima kasih banyak kerana membaca sehingga ke tahap ini.

Jika anda ingin lebih dioptimumkan, anda boleh mencipta faktor_asc_len dan faktor_desc_len pembolehubah dan menambah 1 setiap kali anda menambahkan nilai pada tatasusunan ini, supaya kaedah len() tidak perlu dipanggil, kerana kaedah ini adalah O(n) supaya ia boleh memberi kesan kepada notasi masa.

Semoga berjaya dalam pelajaran anda dan sehingga kali seterusnya!

Atas ialah kandungan terperinci Faktor Kth bagi N - algoritma O(sqrt n).. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!