C 两个数组中两个元素的最小和，使得索引不相同

给定两个数组

ar1

和

ar2

，我们如何从两个数组中找到两个元素的和，从而使索引不相同且其和最小

但是，我已经写了以下内容，但我不确定是否将总和存储在临时变量中，并将总和与下一个过程中的总和进行比较：

int twinArrays(int ar1_size, int* ar1, int ar2_size, int* ar2)
{
    int temp;
    for(int i = 0; i < ar1_size;i++) 
    {
        for(int j=0; j < ar2_size; j++) {
            int sum=0;
            if( i != j) 
                sum = ar1[i] + ar2[j];
            }
        }      
        return temp;
    }
}

int双数组（int-ar1\u大小，int*ar1，int-ar2\u大小，int*ar2）
{
内部温度；
对于（int i=0；i

---

C中的建议会很有帮助。

两个数组中两个元素的最小和就是其最小元素的和

但是，当任何数组的大小为0时会发生什么情况。。。？这个问题的提法在这方面没有定义

以下最坏情况的时间复杂度为O（N），最坏情况的空间复杂度为O（1）：

#包括
整数双数组（整数ar1\u大小，整数*ar1，整数ar2\u大小，整数*ar2）
{
int min1=int_MAX，min2=int_MAX；
对于（int i=0；i0&&min2>INT\u MAX-min1）{
/*句柄溢出*/
返回INT_MAX；
}else if（min1<0&&min2

到目前为止，您的代码不是一种解决方案，而是：

• temp

  应已初始化为足够大的值，以符合所需结果
• 当

  i！=j

  ，如果

  sum

  处于

  temp

  下，您应该将

  sum

  与

  temp

  进行比较以存储结果

• 返回

  未放置

因此，更正后的代码可能如下所示：

#include <limits.h>

int twinArrays(int ar1_size, int* ar1, int ar2_size, int* ar2)
{
    int sum_min = INT_MAX;

    /* for each element in ar1 */
    for (int i = 0; i < ar1_size; i++)
    {

        /* for each element in ar2 */
        for (int j = 0; j < ar2_size; t++)
        {
            /* go to next j if indices are the same */
            if (i != j)
            {
                /* compute sum */
                int sum = ar1[i] + ar2[j];

                /* compare to best */
                if (sum < sum_min)
                {
                    /* remember the best */
                    sum_min = sum;
                }
            }
        }        
    }

    return sum_min;   
}

#包括
整数双数组（整数ar1\u大小，整数*ar1，整数ar2\u大小，整数*ar2）
{
int sum_min=int_MAX；
/*对于ar1中的每个元素*/
对于（int i=0；i

不确定您不确定的内容，但有一件事是确定的：由于

temp

从未初始化或分配任何确定值，因此您可以指望调用者从

返回的temp中获得不确定的垃圾代码有什么问题？你是否在找人为你设计和编写算法？或者你有我不知道的具体问题吗？你不需要
temp
。只需将
sum
移动到两个循环之外，将数组中的第一个限定值分配给它，然后运行循环，仅当
ar1[i]+ar2[j]
小于
sum
的当前值时，才将
sum
重置为较低的值。最后，返回
sum
。不是很复杂有效，但它会起作用。考虑最小值和最小值之和，除非它们具有相同的索引。在这种情况下，两个选项将成为一个数组的最小值和另一个数组的第二小元素的总和。这是一个O（n）算法，而不是O（n^2）。你能在忽略不同索引限制的情况下快速找到最小和吗？你能同样快地找到第二个最小的和吗？嵌套循环解决方案太慢。
ar[1]
似乎是一个输入错误，应该是
ar1[i]
，
ar2[1]
应该是
ar2[i]
。您的代码忽略了索引不应相等的要求。变量INT_MAX的用途是什么？
INT_MAX
是可由
INT
表示的最大值，如果设置了另一个值，我们将面临总和大于卖出值的风险。
#include <limits.h>

int twinArrays(int ar1_size, int* ar1, int ar2_size, int* ar2)
{
    int sum_min = INT_MAX;

    /* for each element in ar1 */
    for (int i = 0; i < ar1_size; i++)
    {

        /* for each element in ar2 */
        for (int j = 0; j < ar2_size; t++)
        {
            /* go to next j if indices are the same */
            if (i != j)
            {
                /* compute sum */
                int sum = ar1[i] + ar2[j];

                /* compare to best */
                if (sum < sum_min)
                {
                    /* remember the best */
                    sum_min = sum;
                }
            }
        }        
    }

    return sum_min;   
}