Ruby 矩阵求和挑战

下面的算法用于将“下矩阵”转换为“后矩阵”。根据“矩阵后”查找“矩阵前”

对每个after（x，y）运行该算法以确定其值。给定后，在前中查找原始值

范例

之后=[[2,5]，[7,17]]

计算“后”和“前”中的值

after[0][0] = before[0][0] = 2

after[0][1] = before[0][0] + before[0][1] = 2 + 3 = 5

after[1][0] = before[0][0] + before[1][0] = 2 + 5 = 7

after[1][1] = before[0][0] + before[0][1] + before[1][0] + before[1][1] = 2 + 3 + 5 + 7 =  17

在矩阵具有以下参数之前完成函数find [n][m]之后：n x m整数数组

返回： int[n][m]表示before矩阵的n x m整数数组

约束

再输入一个示例

到目前为止我都试过了

n = gets.to_i
m = gets.to_i

arr = Array.new(n){Array.new(m,0)}
sum = 0
arr_last = 0
arr_first = 0
len = 0
a.each_with_index do |d, outer_index|
  len = d.length - 1
  d.each_with_index do |b, index|
    arr_sum = d[0..index].sum
    if index > 0
      arr[outer_index][index] = sum + arr_sum
    else
      arr[outer_index][index] = arr_first + b
    end
    arr_first += b if index == 0
    arr_last = arr_sum if index == len 
  end
  sum += arr_last
end

print arr

但对于少数测试用例，它没有在时间限制内执行，对于少数测试用例，我得到了错误的答案

“后”栅格中的每个值都是其“前”值及其左侧和/或上方所有“前”值的总和。在图中：

• B

  是红色区域中所有Before值的总和

• Y

  是绿色和红色区域中所有Before值的总和

• X

  是蓝色和红色区域中所有Before值的总和，以及

• A

  是紫色、蓝色、绿色和红色区域中所有Before值的总和

由于

X

和

Y

被

B

重叠，因此添加

X

和

Y

将使

B

计数两次。因此，如果我们从

A

开始，减去

X

和

Y

，然后加

B

（以抵消加倍），我们得到

A

的前值，如：

A'=A-X-Y+B

现在我们知道了，代码非常简单：

def前（后）
之前=[]
在.u之后，每个_与_索引do |行，j|
在[j]=[]之前
行。每个带有索引do | v，i的|
up=j这只是提到了另一种组织@Ouroborus优秀答案计算的方法

假设

after = [
  [ 2,  5,  4,  5],
  [ 7, 17, 13, 10],
  [11, 19, 14, 15]
]

通过首先构造以下数组，从

之后开始我们可以避免 需要检查元素是否位于

之后的
的第一行或第一列

aft = [
  [0,  0,  0,  0,  0],
  [0,  2,  5,  4,  5],
  [0,  7, 17, 13, 10],
  [0, 11, 19, 14, 15]
] 

这是因为，对于任何
i
，
j
，
i>0
，
j>0
，可以看出：

aft[i][j] = before[i-1][j-1] + aft[i][j-1] + aft[i-1][j] - aft[i-1][j-1]

意思是：

before[i-1][j-1] = aft[i][j] - aft[i][j-1] - aft[i-1][j] + aft[i-1][j-1]

实际上不需要构造数组
aft
，因为我们可以使用该方法返回元素
aft[i][j]

def aftmap(after, i, j)
  i.zero? || j.zero? ? 0 : after[i-1][j-1]
end

aftmap(after, 0, 0) #=>  0
aftmap(after, 1, 0) #=>  0
aftmap(after, 0, 1) #=>  0
aftmap(after, 2, 2) #=> 17
aftmap(after, 3, 4) #=> 15

这可以通过如下方法实现

def before(after)
  nrows = after.size
  ncols = after.first.size
  (1..nrows).each_with_object(Array.new(nrows) { Array.new(ncols) }) do |i,before|
    (1..ncols).each do |j|
      before[i-1][j-1] = aftmap(after,i,j) - aftmap(after,i,j-1) -
        aftmap(after,i-1,j) + aftmap(after,i-1,j-1)
    end
  end
end 

线路

(1..nrows).each_with_object(Array.new(nrows) { Array.new(ncols) }) do |i,before|

可以写

(1..nrows).each_with_object([]) do |i,before|

但我认为前者更有效，因为它避免了在
之前不断扩大数组的需要

在涉及描述矩形网格的数组的其他情况下（例如，游戏Mindcraft），可以通过概念上在第一行和/或最后一行之前和/或之后添加一行和/或在第一行和/或最后一列之前添加一列来进行类似的简化。
如果您使用Java，这是代码

使用基本方法

私有静态列表beforeFromAfter（）

List after=Arrays.asList（Arrays.asList（2,5），Arrays.asList（7,17））；
int s=0；
List before=new ArrayList（）；
对于（int i=0；i
在java中尝试了一些东西。只需在方法中传递矩阵后面的n和m作为参数。它将返回矩阵前面的值

publicstaticint[]getAfterMarix（int[]before，int n，int m）
{
int initiate=在[0][0]之前；
int temp=启动；
对于（int i=0；我将在上述代码中创建矩阵后的
或矩阵前的
？谜题的链接是什么？@Quroborus该链接说明给定的“矩阵后”有n行和m列（即，
arr.size#=>m
，
arr.first.size#=>m
），其中1此问题被专门标记为Ruby问题。请避免添加其他语言的答案，因为这会增加答案的噪音，并可能会给未来的读者造成混淆。
(1..nrows).each_with_object([]) do |i,before|

    List<List<Integer>> after = Arrays.asList(Arrays.asList(2,5), Arrays.asList(7,17));


    int s=0;
    List<List<Integer>> before = new ArrayList<List<Integer>>();
    for (int i = 0; i<=after.size()-1; i++) {
        
        List<Integer> bRow = new ArrayList<Integer>();
        for (int j=0; j<=after.get(i).size()-1; j++) {
            //bRow.add(j,after.get(i).get(j));
            if(i<1 && j<1) {
                bRow.add(j,after.get(i).get(j));
                s=s+after.get(i).get(j);
            } else if(i>0 && j>0) {
                bRow.add(j,after.get(i).get(j)-s);
            } else {
                bRow.add(j,after.get(i).get(j)-after.get(0).get(0));
                s=s+after.get(i).get(j)-after.get(0).get(0);
            }
            
        }
        
        before.add(i, bRow);
    }
    return before;
}

public static int[][] getAfterMarix(int[][] before,int n, int m)
{
    int initiate = before[0][0];
    int temp = initiate;
    for(int i=0; i<n ;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(before[i][j]!=initiate)
            {
                if(before[i][j] == before[n-1][m-1])
                {
                    before[i][j] = Math.abs(temp - before[i][j]) ;
                }
                else
                {
                    temp += before[i][j];
                    before[i][j] -= initiate; 
                }
            }
        }
    }
    return before;
}