Kira semua pilih atur integer yang membentuk graf akiklik mengikut keadaan yang diberi

Untuk mengira peringkat dalam integer N, membentuk graf akiklik memerlukan penyiasatan setiap perubahan yang mungkin dan menyemak sama ada ia membentuk graf akiklik mengikut syarat yang diberikan. Keadaan ini mungkin berkaitan dengan struktur graf koordinasi yang dibentuk oleh perubahan, di mana ketiadaan kitaran menunjukkan keasiklikan. Masalah ini melibatkan konsep daripada teori graf dan boleh diselesaikan dengan carian pertama mendalam atau pengaturcaraan dinamik. Carian pertama mendalam berfungsi dengan menyiasat setiap peringkat secara rekursif, dan pengaturcaraan dinamik mengoptimumkan gelung dengan menyimpan hasil perantaraan. Bilangan peringkat sah yang dikira pada penghujung menunjukkan bilangan cara dalam integer N yang boleh disusun menjadi graf akiklik yang memenuhi syarat yang telah ditetapkan.

Kaedah penggunaan

• Depth First Search (DFS)

• Pengaturcaraan dinamik

Depth First Search (DFS)

Dalam kaedah DFS menjana kumpulan dengan operasi tertentu, kita mulakan dari nombor yang diberikan dan mengira semula sehingga nilai 1 dicapai. Kami meneruskan seperti berikut: jika nombor itu sememangnya 2, kami membahagikannya dengan 2; jika ia adalah nombor ganjil, kami mendarabkannya dengan 3 dan menambah 1. Kami mengemas kini nombor untuk menggambarkan hasil yang tidak digunakan dan menambahkannya pada siri. Proses ini berterusan sehingga bilangannya mencapai 1. Urutan yang terhasil mewakili urutan Collatz yang berulang untuk nombor permulaan yang diberikan. Pendekatan ini membolehkan kami menjejaki janjang nombor apabila ia berubah melalui pengiraan berulang, mendedahkan corak dan mempertimbangkan kelakuan jujukan Collatz. Ia menyediakan kaedah yang mudah dan boleh dihasilkan semula untuk menjana jujukan dan menganalisis ciri-ciri menarik bagi keajaiban matematik ini.

Algoritma

• Pilih hab permulaan untuk memulakan perjalanan anda

• Tandai pusat sebagai dilawati untuk memantau pusat mana yang telah disiasat secara proaktif.

• Lawati jiran yang tidak dilawati dari nod pusat yang sedang berjalan (jika ada). Untuk menentukan jiran nod tengah yang sedang berjalan, anda benar-benar perlu mengetahui perihalan graf yang menular (cth., senarai kedekatan atau rangka kerja kedekatan)

• Andaikan ada jiran yang tidak dilawati, pilih salah seorang daripada mereka dan ulang peringkat 2 hingga 4 daripada jiran tersebut (secara rekursif)

• Andaikan tiada jiran yang tidak dikunjungi, kembali ke pusat lalu dan teruskan siasatan dari situ (jika boleh). Langkah ini adalah penting untuk meneroka semua laluan berpotensi dalam graf

• Pencincangan semula peringkat 2 hingga 5 sehingga semua nod pusat dalam graf telah dilawati. Jika graf tidak disambungkan (mengandungi berbilang bahagian), anda mungkin perlu melakukan carian mendalam-pertama (DFS) bermula dari nod pusat yang tidak dilawati.

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

#include <iostream>
#include <vector>

using namespace std;

void dfs(int node, vector<vector<int>>& graph, vector<bool>& visited) {
   visited[node] = true;
   cout << "Visited hub: " << node << endl;
   for (int neighbor : graph[node]) {
      if (!visited[neighbor]) {
         cout << "Moving to neighbor: " << neighbor << endl;
         dfs(neighbor, graph, visited);
      }
   }
}

int main() {
   vector<vector<int>> graph = {
      {1, 2},
      {0, 2, 3},
      {0, 1, 3},
      {1, 2, 4},
      {3}
   };
   int hubs = graph.size();
   vector<bool> visited(hubs, false);
   int startingHub = 0;
   cout << "DFS Traversal starting from hub " << startingHub << ":" << endl;
   dfs(startingHub, graph, visited);
   return 0;
}

Output

DFS Traversal starting from hub 0:
Visited hub: 0
Moving to neighbor: 1
Visited hub: 1
Moving to neighbor: 2
Visited hub: 2
Moving to neighbor: 3
Visited hub: 3
Moving to neighbor: 4
Visited hub: 4

Pengaturcaraan dinamik

Dalam pendekatan ini, kita boleh menggunakan pengaturcaraan dinamik untuk mengira dengan cekap bilangan peringkat asiklik untuk mencapai N. Kami akan mentakrifkan jadual DP, di mana dp[i] mewakili bilangan peralihan bukan kitaran yang berakhir dengan nombor I.

Algoritma

• Siasat masalah dan tentukan sama ada ia boleh dipecahkan kepada sub-masalah yang lebih kecil. Jika menyelesaikan submasalah yang sama beberapa kali adalah tidak cekap, pengaturcaraan dinamik boleh menambah baik penyelesaian dengan mengingati penyelesaian kepada submasalah tersebut.

• Nyatakan susunan masalah yang lebih besar sebagai susunan sub-masalahnya. Sambungan pendua ini adalah kunci untuk menyelesaikan masalah menggunakan DP.

• Memandangkan sambungan berulang, buat jadual atau paparan untuk menyimpan jawapan kepada sub-soalan. Ini akan menghalang pengiraan dua kali.

• Isi borang bermula daripada submasalah terkecil, biasanya dalam pendekatan bawah ke atas, atau menggunakan memoisasi untuk menyimpan dan mendapatkan semula penyelesaian dalam proses rekursif

• Apabila semua submasalah diselesaikan, pisahkan pilih atur akhir daripada jadual DP atau paparan memoized.

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

#include <iostream>
#include <vector>
using namespace std;

int knapsackHelper(vector<vector<int>>& dp, vector<int>& weights, vector<int>& values, int n, int capacity) {
   if (n == 0 || capacity == 0) {
      return 0;
   }

   if (dp[n][capacity] != -1) {
      return dp[n][capacity];
   }

   if (weights[n - 1] <= capacity) {
      dp[n][capacity] = max(values[n - 1] + knapsackHelper(dp, weights, values, n - 1, capacity - weights[n - 1]),
                      knapsackHelper(dp, weights, values, n - 1, capacity));
   } else {
      dp[n][capacity] = knapsackHelper(dp, weights, values, n - 1, capacity);
   }

   return dp[n][capacity];
}

int knapsack(vector<int>& weights, vector<int>& values, int capacity) {
   int n = weights.size();
   vector<vector<int>> dp(n + 1, vector<int>(capacity + 1, -1));
   return knapsackHelper(dp, weights, values, n, capacity);
}

int main() {
   vector<int> weights = {10, 20, 30};
   vector<int> values = {60, 100, 120};
   int capacity = 50;
   cout << "Maximum value in Knapsack: " << knapsack(weights, values, capacity) << endl;
   return 0;
}

Output

Maximum value in Knapsack: 220

Kesimpulan

Peringkat pengiraan cara graf akiklik boleh dibentuk melibatkan kajian susunan integer yang berbeza untuk memastikan ia memenuhi syarat tertentu. DFS meneroka peringkat secara rekursif, manakala DP menambah baik gelung melalui penghafalan. Kedua-dua kaedah ini menyediakan cara penting untuk menyelesaikan masalah ini. Pilihan kaedah bergantung kepada kekangan dan saiz N. Melalui kaedah ini, kami boleh mencari bilangan peringkat undang-undang dengan cekap, membantu kami memahami cara nombor boleh membentuk graf akiklik mengikut syarat yang telah ditetapkan.

Atas ialah kandungan terperinci Kira semua pilih atur integer yang membentuk graf akiklik mengikut keadaan yang diberi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!