Panjang subrentetan terkecil yang mengandungi semua vokal

Masalah biasa yang sering dihadapi dalam tugasan manipulasi rentetan adalah untuk mengenal pasti subrentetan terpendek yang mengandungi setiap vokal sekurang-kurangnya sekali. Tugasan ini mempunyai aplikasi dalam pelbagai bidang seperti analisis data, bioinformatik, dan pemprosesan bahasa semula jadi. Matlamatnya adalah untuk mencari bahagian terkecil berturut-turut daripada rentetan sedia ada yang mengandungi lima huruf ini (a, e, i, o, u) sekurang-kurangnya sekali. Proses pemilihan untuk menyelesaikan cabaran ini termasuk pelbagai teknik, seperti melaksanakan algoritma tetingkap gelongsor, menggunakan proses pencincangan atau memanfaatkan ungkapan biasa, antara lain. Mencari penyelesaian yang mantap untuk masalah ini selalunya menjadi penting, kerana banyak senario kehidupan sebenar memerlukan kaedah manipulasi teks yang boleh dipercayai.

Kaedah

Terdapat pelbagai cara untuk mencari panjang subrentetan terkecil yang mengandungi semua vokal.

Kaedah 1. Kaedah tetingkap gelongsor

Kaedah 2. Kaedah double pointer

Kaedah 3. Kaedah tatasusunan frekuensi

Kaedah 1: Kaedah tetingkap gelongsor

Untuk menentukan dengan cepat saiz subrentetan terpendek yang mengandungi semua vokal dalam setiap rentetan, gunakan kaedah tetingkap gelongsor. Kaedah ini menggunakan dua penunjuk, sering dipanggil "kiri" dan "kanan", untuk menghasilkan tetingkap gelongsor yang meluncur di sepanjang rentetan.

Tatabahasa

Berikut ialah sintaks untuk mencari panjang subrentetan minimum yang mengandungi semua vokal menggunakan kaedah tetingkap gelongsor -

def find_smallest_substring(string):
   vowels = {'a', 'e', 'i', 'o', 'u'}
   unique_vowels = set()
   start = 0
   end = 0
   min_length = float('inf')
    
   while end < len(string):
      # Expand the window
      if string[end] in vowels:
         unique_vowels.add(string[end])
        
      # Contract the window
      while len(unique_vowels) == len(vowels):
         min_length = min(min_length, end - start + 1)
         if string[start] in vowels:
         unique_vowels.remove(string[start])
         start += 1
        
       end += 1
    
   return min_length

Algoritma

Langkah 1 - Gunakan tingkap gelongsor bersaiz n (panjang tali) dan gerakkannya dari kiri ke kanan.

Langkah 2 - Pada setiap kedudukan dalam tetingkap, pastikan subrentetan terdiri sepenuhnya daripada vokal. Jika ya, kemas kini panjang minimum subrentetan yang ditemui setakat ini.

Langkah 3 - Gunakan jadual cincang untuk merekodkan bilangan ulangan setiap vokal dalam subrentetan untuk menentukan sama ada substring mengandungi semua vokal.

Langkah 4 - Jika subrentetan tidak mengandungi semua vokal, teruskan ujian dengan mengalihkan tetingkap ke kanan dan ulangi proses sehingga semua subrentetan berpotensi telah diuji.

Terjemahan bahasa Cina bagi

Contoh 1

ialah:

Contoh 1

Untuk menentukan sama ada aksara yang diberikan ialah vokal dalam pelaksanaan ini, kami mentakrifkan fungsi pembantu ialahVokal. Untuk menerangkan tetingkap gelongsor, kami juga menggunakan dua penunjuk di sebelah kiri dan kanan.

Jika aksara semasa ialah vokal, kami mula-mula memanjangkan tetingkap dengan menambahkannya pada koleksi tetingkap di dalam gelung while. Kemudian sahkan bahawa saiz koleksi tetingkap ialah 5 (iaitu, semua vokal hadir). Jika ya, ubah suai respons dan kurangkan saiz tetingkap dengan menghapuskan aksara paling kiri daripada set tetingkap sehingga kurang daripada 5.

Hasil gelung mengembalikan panjang subrentetan terkecil yang mengandungi semua vokal.

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

bool isVowel(char c) {
   return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
int smallestSubstring(string s) {
   unordered_set<char> vowels = {'a', 'e', 'i', 'o', 'u'};
   unordered_set<char> window;
   int n = s.length(), left = 0, right = 0, ans = n + 1;
    
   while (right < n) {
      // Expand the window by adding the current character
      char c = s[right];
      if (isVowel(c)) {
         window.insert(c);
      } 
      right++;
        
      // close the window by removing the leftmost character
      while (window.size() == 5) {
         ans = min(ans, right - left);
         char d = s[left];
         if (isVowel(d)) {
            window.erase(d);
         }
         left++;
      }
   }
   return ans <= n ? ans : 0;
}

int main() {
   string s = "aeeioubcdfuioaei";
   int len = smallestSubstring(s);
   cout << "Length of smallest substring containing all vowels: " << len << endl;
   return 0;
}

Output

Length of smallest substring containing all vowels: 6

Kaedah 2: Kaedah double pointer

Kaedah penunjuk berganda ialah kaedah popular untuk menyelesaikan pelbagai masalah manipulasi rentetan dengan cepat. Teknik dwi-penunjuk sangat membantu dalam menentukan panjang substring terkecil yang mengandungi semua vokal.

Tatabahasa

Ini ialah sintaks untuk mencari panjang subrentetan minimum yang mengandungi semua vokal menggunakan kaedah penunjuk berganda−

function findSmallestSubstring(str):
   vowels = {'a', 'e', 'i', 'o', 'u'}
   count = 0
   left = 0
   minLength = infinity

   for right in range(length of str):
      if str[right] is a vowel:
         count += 1

       while count is same as the total number of vowels:
         minLength = minimum (minLength, right - left + 1)

         if str[left] is a vowel:
         count -= 1

         left += 1

   return minLength

Algoritma

Langkah 1 - Tetapkan penunjuk permulaan dan penamat untuk menunjuk ke kedudukan permulaan rentetan masing-masing.

Langkah 2 - Teruskan gerakkan penuding hujung ke kanan sehingga anda menemui subrentetan yang mengandungi hanya vokal.

Langkah 3 − Jika kita menjumpai subrentetan yang mengandungi semua vokal, kemudian gerakkan kursor permulaan ke kanan sehingga ia tidak lagi mengandungi semua vokal.

Langkah 4 − Teruskan gerakkan penuding ekor ke kanan sehingga anda menemui subrentetan baharu yang mengandungi semua vokal, kemudian gerakkan penunjuk mula ke kanan sehingga subrentetan tidak lagi mengandungi semua vokal.

Langkah 5 - Muat semula panjang subrentetan terpendek setakat ini.

Terjemahan bahasa Cina bagi

Contoh 2

ialah:

Contoh 2

Dalam contoh ini, untuk mewakili tetingkap gelongsor, kami mengekalkan dua penunjuk, kiri dan kanan. Dari kiri ke kanan, kami mengulangi melalui rentetan str, setiap kali menyemak sama ada aksara semasa ialah vokal. Untuk menjejaki vokal yang diperhatikan setakat ini, jika ia adalah vokal, kami menambahnya pada set yang dilihat.

Kami menggerakkan kursor kiri untuk mengurangkan panjang subrentetan, sebaik sahaja kami melihat subrentetan mengandungi semua vokal. Proses ini berterusan sehingga kursor kanan mencapai penghujung rentetan.

Mengembalikan panjang subrentetan terpendek yang mengandungi semua vokal. Jika tiada subrentetan sedemikian wujud, 0 dikembalikan.

#include <iostream>
#include <string>
#include <unordered_set>
using namespace std;

int smallestSubstringLength(const string& str) {
   int n = str.length();
   unordered_set<char> vowels = {'a', 'e', 'i', 'o', 'u'};

   unordered_set<char> seen;
   int left = 0, right = 0;
   int smallestLength = n + 1;

   while (right < n) {
      if (vowels.find(str[right]) != vowels.end()) {
         seen.insert(str[right]);
      }

      if (seen.size() == vowels.size()) {
         while (seen.size() == vowels.size()) {
            if (right - left + 1 < smallestLength) {
               smallestLength = right - left + 1;
            }

            if (vowels.find(str[left]) != vowels.end()) {
               seen.erase(str[left]);
            }

            left++;
         }
      }
      right++;
   }
   return (smallestLength == n + 1) ? 0 : smallestLength;
}

int main() {
   string str = "aeeiiouuobcdaeiou";
   int length = smallestSubstringLength(str);
   cout << "Length of the smallest substring containing all vowels: " << length << endl;
   return 0;
}

Output

Length of the smallest substring containing all vowels: 7

Kaedah 3. Kaedah tatasusunan frekuensi

Gunakan kaedah tatasusunan frekuensi untuk mengukur subrentetan terpendek yang mengandungi semua vokal dalam setiap rentetan. Ia memerlukan membina tatasusunan kekerapan untuk merekodkan bilangan kemunculan vokal dan kemudian berulang kali berulang ke atas teks untuk mencari subrentetan yang dikehendaki.

Tatabahasa

Sintaks untuk mencari subrentetan terkecil yang mengandungi semua vokal adalah seperti berikut -

# Check if all vowels are present in the current substring
if all(freq[vowel] > 0 for vowel in vowels):
   # Update the minimum length if needed
   min_length = min(min_length, right - left + 1)
    
   # Move the left pointer to find a potentially smaller substring
   while left < right:
      freq[input_string[left]] -= 1
      if freq[input_string[left]] == 0:
      break
      left += 1

# Move the right pointer to expand the current substring
right += 1

算法

步骤 1 − 为了记录每个元音字母（a，e，i，o，u）的重复次数，从大小为5的频率数组开始。

第二步 - 创建开始和结束指针，分别标记字符串的开头。

第三步 - 继续将结束指针向右移动，直到每个元音字母至少被听到一次。

步骤4 − 将起始指针向右移动，直到子字符串不再包含至少每个元音字母的重复。

第五步 - 调整已经识别出的子字符串的最小长度，然后将结束指针向右移动，直到发现一个包含所有元音字母的新子字符串。

步骤 6 - 在每个位置更新频率数组，以验证当前子字符串是否包含所有元音字母。

Example 3

的中文翻译为：

示例3

在这个例子中，函数min Length Substring接受一个字符串作为输入，并计算包含所有五个元音字母（a，e，i，o，u）的最小子字符串的长度。

该函数使用名为vowelCount的频率数组来计算子字符串中的每个元音字母的数量。它通过维护一个名为distinctVowels的计数器来跟踪子字符串中不同元音字母的数量。

通过使用两个指针，即start和finish，该函数循环遍历字符串，对每个遇到的元音字母增加频率数组的vowelCount。一旦找到了每个不同的元音字母，子字符串就开始从起始位置收缩，直到没有不同的元音字母为止。如果发现了更短的子字符串，则更新最小子字符串的长度。

主要功能使用字符串来展示如何使用最小长度子字符串方法，通过输入包含所有元音字母的最短子字符串的长度。

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

int minLengthSubstring(const string& str) {
   const string vowels = "aeiou";
   int vowelCount[5] = {0};  // Frequency array for vowels
   int distinctVowels = 0;  // Count of distinct vowels in the substring

   // Initialize the minimum length to maximum integer value
   int minLength = INT_MAX;

   int start = 0, end = 0;
   while (end < str.length()) {
      // Increment frequency for vowel at 'end' position
      for (int i = 0; i < 5; i++) {
         if (str[end] == vowels[i]) {
            if (vowelCount[i] == 0) {
               distinctVowels++;
            }
            vowelCount[i]++;
            break;
         }
      }

      // If all distinct vowels are found
      if (distinctVowels == 5) {

         while (start < end) {
            // Update minimum length if a shorter substring is found
            if (minLength > end - start + 1) {
               minLength = end - start + 1;
            }

            // Decrement frequency for vowel at 'start' position
               for (int i = 0; i < 5; i++) {
               if (str[start] == vowels[i]) {
                  vowelCount[i]--;
                  if (vowelCount[i] == 0) {
                     distinctVowels--;
                  }
                  break;
               }
            }
            start++;

            // Break if any distinct vowel is missing in the substring
            if (distinctVowels < 5) {
               break;
            }
         }
      }

      end++;
   }

   return minLength == INT_MAX ? -1 : minLength;
}

int main() {
   string str = "aeeioubcdofu";
   int length = minLengthSubstring(str);

   if (length == -1) {
      cout << "No substring containing all vowels found." << endl;
   } else {
      cout << "Length of the smallest substring containing all vowels: " << length << endl;
   }
   return 0;
}

输出

Length of the smallest substring containing all vowels: 6

结论

总之，找到Panjang subrentetan terkecil yang mengandungi semua vokal是一个可以使用各种技术高效解决的问题。通过使用滑动窗口方法或散列元音字母的出现次数，可以遍历字符串并识别满足要求的最小子字符串。这些方法的时间复杂度通常是线性的，适用于大规模输入。然而，重要的是处理边界情况并考虑可能影响解决方案的额外约束条件。总的来说，通过正确的算法方法，可以有效地确定Panjang subrentetan terkecil yang mengandungi semua vokal。

Atas ialah kandungan terperinci Panjang subrentetan terkecil yang mengandungi semua vokal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!