C++ c+中的置换+；

我有一个带有一些值的数组，例如

A=[a,b,c];

《C++》中最简单、最快的计算方法是：

int SUM;
SUM= a*b + a*c + b*a + b*c + c*a + c*b;

在这种情况下，

a*c！=c*a

在实际情况中，我有不同大小的大数组，将从其他数组中获取a、b和c的值

/提前感谢

请尝试以下代码：

int sum = 0;

for(int i=0 ; i < size ; i++)
{
    int tmp = 0;
    for(int j=0 ; j < size ; j++)
    {
          if( i != j )
             tmp += a[i] * a[j];
    }
    sum += tmp;
}

int和=0；
对于（int i=0；i

除非我遗漏了什么，否则应该简单到：

int sum = 0;

for(unsigned int i = 0; i < ARRAYSIZE; i++){
    for(unsigned int j = 0; j < ARRAYSIZE; j++){
        if(i != j){
            sum += A[i] * A[j];
        }
    }
}

int和=0；
for（无符号整数i=0；i

这里有一个解决方案，用9个ifs交换3个乘法和3个减法

int sum = 0;
for (int i = 0; i < 3; ++i)
{
    for (int j = 0; j < 3; ++j)
    {
        sum += A[i] * A[j];
    }
    sum -= A[i] * A[i];
}

int和=0；
对于（int i=0；i<3；++i）
{
对于（int j=0；j<3；++j）
{
总和+=A[i]*A[j]；
}
总和-=A[i]*A[i]；
}

也许是这样（假设您确实想要添加a*b和b*a）：

---

访客代码可以进一步简化：

const int array_sum( std::accumulate(a, a + array_size, 0) );
int sum( array_sum * array_sum );
for (int i = 0; i < array_size; ++i) {
    sum -= a[i] * a[i];
}

const int array_sum（标准：：累加（a，a+array_size，0））；
整数和（数组和*数组和）；
对于（int i=0；i

我想可以用一个临时的：

const int array_sum（标准：：累加（a，a+array_size，0））；
整数和（数组和*数组和）；
对于（int i=0；i

当然，也可以使用STL完成平方步骤：

const int array_sum( std::accumulate(a, a + array_size, 0) );
std::transform( a, a + array_size, a, a, std::multiplies<int>() );  // store in a
const int sum( array_sum * array_sum - std::accumulate(a, a + array_size, 0) );

const int array_sum（标准：：累加（a，a+array_size，0））；
std:：transform（a，a+array_size，a，a，std:：multiplies（））；//贮藏
const int sum（array_sum*array_sum-std:：accumulate（a，a+array_size，0））；

编辑：具有单个过程的简单循环：

int array_sum( 0 ), square_sum( 0 );
for( int i(0) ; i < array_size; ++i )
{
   int tmp(a[i]);
   array_sum += tmp;
   square_sum += tmp * tmp;
}
const int sum(  array_sum * array_sum - square_sum );

int数组和（0），平方和（0）；
for（int i（0）；i

我会使用更短的循环：

int SUM = 0;
for (int i = 0; i < 2; i++) {
    for (int j = i+1; j < 3; j++) {
        SUM += A[i] * A[j];
        SUM += A[j] * A[i];
    }
}

int和=0；
对于（int i=0；i<2；i++）{
对于（int j=i+1；j<3；j++）{
总和+=A[i]*A[j]；
总和+=A[j]*A[i]；
}
}

---

然后，这就不需要进行if（i！=j）检查，只需要较少的i++和j++就可以了，对集合

A

的属性（可交换性等）进行等轴分析可能会有帮助。我认为这是一本很好的读物，并且与你的问题有关：由于乘法的关联属性，

A*b

与

b*A

相同，这是

2*a*b

。还有，

a*c！=c*a

？我会在编码之前简化代数。只有当a和b是实变量时才是这样。然而，在这种情况下，它们可以是矩阵……你的代码被破坏了——去掉

tmp

，在内部循环中执行

sum+=a[i]*a[j]

。你不需要临时变量，这会弄乱结果。你在计算a*c+b*c+c*b哦，是的，这就是我需要的。我以前写过一百次同样的代码。。。我不知道为什么我现在遇到了问题…可能是你还需要演示如何使用单次传递（OP也要求提供最快的方法）：使用相同的传递将项目及其平方相加并计算结果？使用STL算法进行单次传递循环会很好。我想这会有点太过分：）。既然没有现成的东西可以做，你就得花很多力气去做一些琐碎的事情。谢谢，看起来很有趣。这可能回答了问题的“最快”部分。我想这就是我稍后将要使用的…这是与visitor相同的代码。然而，这是第一个在ac和ca不同的情况下同时添加ac和ca的产品！谢谢

const int array_sum( std::accumulate(a, a + array_size, 0) );
int sum( array_sum * array_sum );
for (int i = 0; i < array_size; ++i) {
    sum -= a[i] * a[i];
}

const int array_sum( std::accumulate(a, a + array_size, 0) );
int sum( array_sum * array_sum );
for (int i = 0; i < array_size; ++i) {
    const int tmp( a[i] );
    sum -= tmp * tmp;
}

const int array_sum( std::accumulate(a, a + array_size, 0) );
std::transform( a, a + array_size, a, a, std::multiplies<int>() );  // store in a
const int sum( array_sum * array_sum - std::accumulate(a, a + array_size, 0) );

int array_sum( 0 ), square_sum( 0 );
for( int i(0) ; i < array_size; ++i )
{
   int tmp(a[i]);
   array_sum += tmp;
   square_sum += tmp * tmp;
}
const int sum(  array_sum * array_sum - square_sum );

int SUM = 0;
for (int i = 0; i < 2; i++) {
    for (int j = i+1; j < 3; j++) {
        SUM += A[i] * A[j];
        SUM += A[j] * A[i];
    }
}