Minimiser le nombre d'éléments inégaux aux indices correspondants entre les tableaux donnés

Comparez les éléments à chaque index et ajustez-les jusqu'à ce qu'ils correspondent pour réduire le nombre d'éléments incohérents aux indices correspondants entre les tableaux donnés. Ajustez si nécessaire tout en parcourant simultanément les tableaux. Les tableaux deviendront plus similaires et la proportion d’éléments inégaux diminuera en conséquence. En réduisant leurs différences aux positions correspondantes, ce processus cherche à augmenter la similarité entre les réseaux. L'objectif ultime est de produire des tableaux avec les mêmes éléments à chaque index, ce qui réduira le nombre d'éléments inégaux.

使用的方法

• Approche de hachage

• Approche de tri

哈希方法

Dans l'approche de hachage, nous commençons par créer une table de hachage pour l'un des tableaux afin de diminuer le nombre de composants inégaux lors de la comparaison de fichiers entre les tableaux. À ce stade, alors que nous répétons le tableau de moments, nous examinons la fréquence de chaque composant dans la table de hachage. Dans le cas où le composant est retrouvé, il est conservé ; dans le cas contraire, le composant de coordination le plus proche de la table de hachage est utilisé à sa place. Grâce à ce processus, il y a moins d’éléments inégaux aux indices correspondants et les deux tableaux deviennent plus similaires. L'efficacité de cette méthode est un avantage car elle permet d'atteindre la similarité souhaitée en termes de complexité temporelle linéaire O(N) pour les cas moyens et meilleurs.

Algorithme

• Chaque élément du premier tableau doit être ajouté en tant que clés et leurs fréquences en tant que valeurs dans une table de hachage.

• Configurez un pointeur pour pouvoir parcourir le deuxième tableau.

a. Déterminez si chaque élément du deuxième tableau est présent dans la table de hachage.

b. Si c'est le cas, laissez l'élément tranquille.

如果没有的话，找到最接近的匹配项中频率最低的哈希表元素。

d. Remplacez l'élément existant dans le deuxième tableau par la correspondance la plus proche.

• 直到指针达到第二个数组的末尾，重复步骤3再次执行

• 由于数组的存在，相应索引处的不相等元素数量现在将达到最低水平

• La similitude souhaitée avec le premier tableau est présente dans le deuxième tableau modifié.

Exemple

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

void adjustArray(vector<int>& arr1, vector<int>& arr2) {
   unordered_map<int, int> frequency;
   for (int num : arr1) {
      frequency[num]++;
   }

   int ptr = 0;
   while (ptr < arr2.size()) {
      if (frequency.find(arr2[ptr]) != frequency.end()) {
         frequency[arr2[ptr]]--;
         if (frequency[arr2[ptr]] == 0) {
            frequency.erase(arr2[ptr]);
         }
      } else {
         int closestMatch = -1;
         int minDistance = INT_MAX; // Change minFrequency to minDistance
         for (auto it : frequency) {
            if (abs(arr2[ptr] - it.first) < minDistance) { // Change minFrequency to minDistance
               minDistance = abs(arr2[ptr] - it.first); // Change minFrequency to minDistance
               closestMatch = it.first;
            }
         }
         arr2[ptr] = closestMatch;
      }
      ptr++;
   }
}

int main() {
   vector<int> array1 = {1, 2, 3, 3, 5};
   vector<int> array2 = {5, 4, 2, 6, 7, 8};
   adjustArray(array1, array2);

   for (int num : array2) {
      cout << num << " ";
   }
   cout << endl;

   return 0;
}

输出

5 3 2 3 3 3 

Approche de l'ensemble indépendant maximum (MIS)

LCS），以最小化对应索引处不相等元素的数量。为了跟踪两个数组中所有可能排列的元素的LCS长度， Il s'agit d'un système LCS.的元素以匹配LCS，确保数组之间更高的相似度。通过优化数组以共享一个这种动态规划技有效地降低了不相等元素的数量。

Algorithme

• Définissez les longueurs de deux tableaux, appelés array1 et array2, respectivement sur m et n.

• Pour stocker les longueurs LCS pour toutes les combinaisons possibles d'éléments des deux tableaux, créez un tableau 2D DP de taille (m+1) x (n+1).

• 使用两个已解决的循环来强调1和2号群集中的每个组件：

• Définissez DP[i][j] = DP[i-1]. [j-1] 1 si les composants des listes actuelles sont les mêmes.

• Au cas où les composants varient, incrémentez DP[i][j] à la valeur la plus élevée imaginable entre DP[i-1][j] et DP[i][j-1].

• Suivez le LCS à rebours de DP[m][n] à DP[0][0] :

• 如果array1[i-1] et array2[j-1]的元素被提升了，将array1[i-1]的角落移动到DP[i-1][j-1] etarray1[i- 1]合并到最长公共子序列中
  DP[i][j-1]或者向上移动到DP[i-1][j]（如果它们发生了变化）

• Les éléments en dehors du LCS dans les deux tableaux doivent être modifiés pour correspondre au LCS après avoir retracé le LCS afin de réduire le nombre d'éléments inégaux.

• La similitude des tableaux ajustés augmentera et le nombre de composants inégaux lors de la comparaison des listes diminuera.

Example

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

vector<int> findLCS(vector<int>& array1, vector<int>& array2) {
   return {};
}

int minimizeUnequalCount(vector<int>& array1, vector<int>& array2) {
   return 0;
}

void modifyArrays(vector<int>& array1, vector<int>& array2) {
}

int main() {
   vector<int> array1 = {1, 3, 5, 7, 9};
   vector<int> array2 = {2, 4, 5, 8, 9};

   vector<int> lcs = findLCS(array1, array2);
   cout << "Longest Common Subsequence: ";
   for (int num : lcs) {
      cout << num << " ";
   }
   cout << endl;

   int unequalCount = minimizeUnequalCount(array1, array2);
   cout << "Count of Unequal Elements after adjustment: " << unequalCount << endl;

   modifyArrays(array1, array2);
   cout << "Modified Array 1: ";
   for (int num : array1) {
      cout << num << " ";
   }
   cout << endl;

   cout << "Modified Array 2: ";
   for (int num : array2) {
      cout << num << " ";
   }
   cout << endl;

   return 0;
}

输出

Longest Common Subsequence: 
Count of Unequal Elements after adjustment: 0
Modified Array 1: 1 3 5 7 9 
Modified Array 2: 2 4 5 8 9 

Conclusion

有两种技术可用于减少两个给定数组之间对应索引处不相等元素的数量：哈希方法和排序方法。哈希方法为一个数组构建哈希表，并迭代地用哈希表中找到的最接近的匹配替换另一个数组中的元素。对于平均和最佳情况，这将实现O(N)的线性时间复杂度。另一方面，排序方法在迭代两个数组时按升序对它们进行排序，并将元素调整为较小的值。尽管它可能不总是产生最佳结果，但它使数组更具可比性。这两种方法都成功地减少了不一致元素的数量，增加了数组的相似性，并降低了对应位置的不一致元素的总数。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!