c++给你两个一维数组arr与brr，每个arr的元素对应一个brr中的元素，你可以交换arr中的任意两个元素，直到每个位置的元素和原来不同，有解就输出最小交换次数，无解输出-1

在C++中，这个问题可以使用贪心算法和哈希表来解决。首先，我们需要理解，如果arr中的一个元素可以通过一次交换得到与之对应的brr中不同的元素，那么这两个元素应该被交换。如果一个元素在arr和brr中都出现在相同的位置，则不需要交换。为了解决这个问题，我们可以构建一个哈希表来记录arr中每个元素及其在arr中的索引，同时检查每个元素是否在brr中有一个不同的对应元素。

算法步骤如下：
1. 创建两个哈希表，一个用于记录arr中每个元素的索引，另一个用于记录brr中每个元素的索引。
2. 遍历arr数组，对于每个元素：
a. 检查brr中的对应元素是否与arr中的元素不同。
b. 如果不同，则记录下需要交换的次数（每次交换两个元素的索引对应关系）。
c. 如果相同，则检查brr中的元素是否在arr中有不同的位置。
3. 如果发现有元素在arr和brr中位置相同且值也相同，则说明无解，输出-1。
4. 如果所有元素都可以通过交换得到不同的值，则输出累计的最小交换次数。

下面是这个算法的一个可能的实现：

#include <iostream>
#include <vector>
#include <unordered_map>

int minSwaps(std::vector<int>& arr, std::vector<int>& brr) {
    std::unordered_map<int, int> arrMap, brrMap;
    std::vector<int> arrIndex(arr.size());
    std::vector<bool> visited(arr.size(), false);

    // 记录arr中每个元素的索引
    for (int i = 0; i < arr.size(); ++i) {
        arrMap[arr[i]] = i;
    }

    // 记录brr中每个元素的索引
    for (int i = 0; i < brr.size(); ++i) {
        brrMap[brr[i]] = i;
    }

    int swapCount = 0;
    for (int i = 0; i < arr.size(); ++i) {
        if (visited[i] || arr[i] == brr[i]) {
            continue; // 如果已经访问过或者值相同且位置相同，则跳过
        }

        // 检查是否有可以交换的元素
        int j = i;
        int cycleSize = 0;
        while (!visited[j]) {
            // 如果在brr中的元素和arr中的元素相同，那么无法交换
            if (arr[j] == brr[j]) {
                return -1;
            }
            visited[j] = true;
            j = arrMap[brr[j]]; // 在arr中找到brr[j]的索引
            ++cycleSize;
        }

        // 如果当前循环中有多个元素，则需要增加交换次数
        if (cycleSize > 0) {
            swapCount += cycleSize - 1;
        }
    }
    return swapCount;
}

int main() {
    std::vector<int> arr = {1, 2, 3, 4};
    std::vector<int> brr = {2, 1, 4, 3};
    std::cout << "Minimum swaps required: " << minSwaps(arr, brr) << std::endl;
    return 0;
}

这段代码实现了上述的算法逻辑，并计算出了最小的交换次数。如果在计算过程中发现无解的情况，则会输出-1。