Algorithm 数组中小于O（N2）的所有元素之和

我有一个大小为N的数组A。我想创建一个大小为N*N的新数组，这样我的新数组B将如下所示，时间复杂度小于Ω（N2）：

例如：

A={1,2}

序列B是

{A1+A1，A1+A2，A2+A1，A2+A2}={2,3,3,4}。

---

请提供此问题的代码。

问题描述示例不一致

你提供了：

For A[0..N-1] ,
B= {A[0]+A[1], A[0]+A[2], ……., A[1]+A[0], A[1]+A[2], ……., A[N-1]+A[0], A[N-1]+A[1],..., A[N-1]+A[N-1]}

如果你观察的话，这个数字本身并没有增加。[0]似乎没有添加[0]，而[1]似乎没有添加[1]。但是，A[n-1]似乎在末尾加上了[n-1]。我认为遵循这个模式应该是一个[n]+A[n-1]。同样，在这种情况下，B的大小应该是N*（N-1）

同样，您给出的示例与问题描述不匹配。在您的示例中，您似乎将数字添加到自身中

A={1,2}
The sequence B is { A1+A1, A1+A2, A2+A1, A2+A2 } = {2,3,3,4}.

请更新问题并更正示例或问题描述，如果您能提供问题的文本描述以及数字示例说明，这将非常有用。

这是无法做到的

---

填充大小为N2的数组至少需要N2次写入，因此需要Ω（N2）时间。

如果每个数组元素都要与其他元素形成一个和，那么基本上就是在对角线上形成数据的镜像

A1+A2将给出与A2+A1相同的结果，因此您只需要循环大约（n*n）/2次

示例代码：

int[] nums = {1, 2, 3, 4};
int[][] matrix = new int[r][c];

for(int x=0; x<=r; x++)
    for(int y=0; y<r-x; y++){
        matrix[x][y] = nums[x] + nums[y];       //update 1st diagonal half
        matrix[r-x-1][c-y-1] = matrix[x][y];    //update the next half (follow 1st half)
    }

int[]nums={1,2,3,4}；
int[][]矩阵=新的int[r][c]；
对于（intx=0；x我已经尝试过这种方法。

long long a[n],i,j,b[n*n],cnt=0;
        for(i=0;i<n;i++)
            cin>>a[i];
        int l=0,r=n-1;
        for(i=0,j=n-1;;)
        {
            if(i!=j)
            {
                b[i]=a[i]+a[l];
                b[j]=a[j]+a[r];
            }
            if(i==j)
            {
                b[i]=a[i]+a[l];
            }
            l++;
            r--;
            cnt++;
            if(l==n-1 && r==0)
            {
                i++;
                j--;
            }
            if(cnt%n==0)
            {
                l=0;
                r=n-1;
            }
            if(cnt==n*n || i>j)break;

长a[n]，i，j，b[n*n]，cnt=0；
对于（i=0；i>a[i]；
int l=0，r=n-1；
对于（i=0，j=n-1；；）
{
如果（i！=j）
{
b[i]=a[i]+a[l]；
b[j]=a[j]+a[r]；
}
如果（i==j）
{
b[i]=a[i]+a[l]；
}
l++；
r--；
cnt++；
如果（l==n-1&&r==0）
{
i++；
j--；
}
如果（cnt%n==0）
{
l=0；
r=n-1；
}
如果（cnt==n*n | i>j）中断；
B有
N*N
元素。每个元素都必须被分配，这至少需要一些时间。你想在
O（N*N）
时间内完成这项工作。你看到这里有问题吗？我已经编辑了你问题的标签，因为它根本不是（如上所述）关于C和C++，是的，我已经尝试了2个循环，这样显然是行不通的。有没有办法解决O（n）而不是O（n*n）呢？@BrettHale知道数组中的某些元素是重复的，这并不能提供一种用更少的数组写入来填充整个数组的方法。这可能意味着以后对数组所做的任何事情都不需要整个数组，但这是另一个问题。@Piyu戴上我的猜测帽，很可能是给了你一些任务X并问了你有一定的时间限制（理论上的或测量的）。您决定为了执行任务X，您应该让代码创建这个数组
B
。但是这花费了太多的时间，现在我们说不，这不能在
O（N*N）
时间内完成。在
O（N*N）时间内完成任务X可能仍然是可能的
time，但如果是这样，它将需要一种不同的方法，不需要存储
N*N
或更多的值。它仍然是ω（N^2）。不，等一下，我们不必循环N^2次。如果赋值是常量，我们忽略常量，它将不是O（N^2）因为在这种情况下我们不必循环n^2次。我们可以在循环大约（n^2）后停止/2次。缩放常数被忽略。每次操作执行恒定的工作量仍然需要与操作执行次数成比例的工作量，而不管每次操作的常量是多少。如果您理解我的问题陈述，那么您可以为此提供代码吗？@Piyu查看我的代码。这将循环不到n^2次，但是我希望对大O表示法有很好理解的人能让我知道在这种情况下我的大O效率是多少。如果你理解我的问题，你能提供代码吗？
long long a[n],i,j,b[n*n],cnt=0;
        for(i=0;i<n;i++)
            cin>>a[i];
        int l=0,r=n-1;
        for(i=0,j=n-1;;)
        {
            if(i!=j)
            {
                b[i]=a[i]+a[l];
                b[j]=a[j]+a[r];
            }
            if(i==j)
            {
                b[i]=a[i]+a[l];
            }
            l++;
            r--;
            cnt++;
            if(l==n-1 && r==0)
            {
                i++;
                j--;
            }
            if(cnt%n==0)
            {
                l=0;
                r=n-1;
            }
            if(cnt==n*n || i>j)break;