C++ 将两个给定数组对应索引处的不相等元素数量最小化

比较每个索引处的元素并进行调整，直到它们匹配以减少给定数组之间对应索引处不一致的元素数量。在同时迭代数组时进行必要的调整。结果是数组变得更加相似，不相等元素的比例会减少。通过减少它们在相应位置上的差异，此过程旨在增加数组之间的相似性。最终目标是产生每个索引处具有相同元素的数组，这将减少不相等元素的数量。

使用的方法

哈希方法
排序方法

哈希方法

在哈希方法中，我们首先为其中一个数组创建哈希表，以降低在比较数组之间的文件时不相等元素的数量。然后，当我们遍历第二个数组时，我们查看哈希表中每个元素的频率。如果找到了该元素，则保留它；如果没有找到，则使用哈希表中最接近的匹配元素代替它。由于此过程，对应索引处的不相等元素数量减少，两个数组变得更加相似。该方法的效率有优势，因为它可以在平均和最佳情况下以线性时间复杂度O(N)实现所需的相似性。

步骤

将第一个数组的每个元素作为键，它们的频率作为值添加到哈希表中。
设置一个指针，用于遍历第二个数组。

a. 判断第二个数组中的每个元素是否存在于哈希表中。

b. 如果存在，则保持元素不变。

c. 如果不存在，则找到哈希表中最低频率并最接近的匹配元素。

d. 将第二个数组中的现有元素更改为最接近的匹配元素。

重复步骤3，直到指针到达第二个数组的末尾。
由于数组的作用，对应索引处的不相等元素数量现在将达到最低点。
修改后的第二个数组与第一个数组具有所需的相似性。

示例

#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

最大独立集(MIS)方法

我们使用动态规划方法来最小化在对应索引上的不相等元素数量，以寻找给定数组之间的最长公共子序列（LCS）。为了跟踪来自两个数组的所有可能排列的LCS长度，我们创建一个二维表格。为了减少差异，可以通过回溯LCS找到需要改变的元素。通过优化数组以共享公共子序列，这种动态规划技术有效降低了不相等元素的数量。

步骤

将两个数组array1和array2的长度分别设置为m和n。
创建一个大小为（m+1）×（n+1）的二维表DP来存储来自两个数组的所有可能排列的LCS长度。
利用两个嵌套循环来遍历cluster1和cluster2中的每个元素：
- 如果当前列表上的元素相同，则将DP[i][j]设置为DP[i-1][j-1]+1。
- 如果元素不同，则将DP[i][j]增加到DP[i-1][j]和DP[i][j-1]中的最大值。
从DP[m][n]到DP[0][0]反向跟踪LCS：
- 如果array1[i-1]和array2[j-1]的元素相等，则将array1[i-1]斜向上移动到DP[i-1][j-1]并将其包括在LCS中。
- 根据DP中的最大值，移动到左边的DP[i][j-1]或者上边的DP[i-1][j]。
找到LCS后，需要将两个数组中LCS之外的元素改变为与LCS相同，以减少不相等元素的数量。
调整后的数组的相似度将增加，对比列表时不相等元素的数量将减少。

示例

#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

结论

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