Question

我正在尝试编写一个R代码来返回矩阵中最大的连续数字对。连续对可以是水平，垂直和两个对角线。

例如，

如果我有矩阵：

ma = array(c(8,4,3,1,7,5,9,15,6,10,16,11,2,14,12,13), dim = c(4,4))

（1）水平的最高连续对：16和12; （2）垂直：16和11（3）对角线（）：16和13; （4）对角线（/）：16和15。

我怎样才能在R？中做到这一点？

Answer 1

这是一个使用矩阵算法的解决方案，它比行和列上的嵌套循环更高效，尤其是在大型矩阵上。

directionalSums <- function(x){
  stopifnot(is.matrix(x))

  # padding functions to allow matrix addition
  padL  <- function(x) cbind(-Inf,x)
  padR  <- function(x) cbind(x,-Inf)
  padU  <- function(x) rbind(-Inf,x)
  padD  <- function(x) rbind(x,-Inf)

  # these padding functions are just for readability
  padLU <- function(x) padL(padU(x))
  padLD <- function(x) padL(padD(x))
  padRU <- function(x) padR(padU(x))
  padRD <- function(x) padR(padD(x))

  m <- nrow(x)
  n <- ncol(x)

  sumR <- padR( (padL(x) + padR(x))[1:m,2:n] )
  sumD  <- padD( (padU(x) + padD(x))[2:m,1:n])
  sumRD <- padRD( (padLU(x) + padRD(x))[2:m,2:n] )
  sumRU <- padRU( (padRU(x) + padLD(x))[2:m,2:n] )

  list(`right`=sumR, 
       `down`=sumD,
       `right and down`=sumRD,
       `right and up`=sumRU)

}

我们试一试。

(sumList <- directionalSums(ma))

maxLocList <- lapply(sumList, function(x) which(x==max(x), arr.ind=TRUE))

for (i in 1:length(maxLocList) ){
  nameD <- names(maxLocList)[i]
  startCell <- maxLocList[[i]]
  maxSum <- sumList[[i]][startCell]
  x1 <- ma[startCell]
  x2 <- maxSum - x1
  writeLines(paste0('The max-sum consec. pair going ',
                    nameD, ' starts at [',
                    paste(startCell, collapse=', '),
                    '], with sum ', maxSum,
                    ' and components ', x1, ' and ',x2)
             )
}

返回：

$right
     [,1] [,2] [,3] [,4]
[1,]   15   13    8 -Inf
[2,]    9   15   24 -Inf
[3,]   12   25   28 -Inf
[4,]   16   26   24 -Inf

$down
     [,1] [,2] [,3] [,4]
[1,]   12   12   16   16
[2,]    7   14   26   26
[3,]    4   24   27   25
[4,] -Inf -Inf -Inf -Inf

$`right and down`
     [,1] [,2] [,3] [,4]
[1,]   13   17   20 -Inf
[2,]   13   21   22 -Inf
[3,]   18   20   29 -Inf
[4,] -Inf -Inf -Inf -Inf

$`right and up`
     [,1] [,2] [,3] [,4]
[1,] -Inf -Inf -Inf -Inf
[2,]   11   11   12 -Inf
[3,]    8   19   30 -Inf
[4,]   10   31   23 -Inf

The max-sum consec. pair going right starts at [3, 3], with sum 28 and components 16 and 12
The max-sum consec. pair going down starts at [3, 3], with sum 27 and components 16 and 11
The max-sum consec. pair going right and down starts at [3, 3], with sum 29 and components 16 and 13
The max-sum consec. pair going right and up starts at [4, 2], with sum 31 and components 15 and 16

Answer 2

这是一种使用简单（但很长）代码的方法。

由于您正在寻找具有最大连续值的对，因此您应该首先创建一个函数，该函数接收单元格并查找所有连续总和。

consec <- function(ma,y,x){
  return(
    c(if(x<ncol(ma))              ma[y,x] + ma[y,x+1],
      if(x>1)                     ma[y,x] + ma[y,x-1],
      if(y<nrow(ma))              ma[y,x] + ma[y+1,x],
      if(y>1)                     ma[y,x] + ma[y-1,x],
      if(x<ncol(ma) & y<nrow(ma)) ma[y,x] + ma[y+1,x+1],
      if(x>1 & y<nrow(ma))        ma[y,x] + ma[y+1,x-1],
      if(x<ncol(ma) & y>1)        ma[y,x] + ma[y-1,x+1],
      if(x>1 & y>1)               ma[y,x] + ma[y-1,x-1])
  )
}

此函数的左半部分（if语句）确保我们不会超出界限，因为边界处的单元格将少于8个邻居以形成连续的对。然后右半部分得到连续对的总和并将其添加到列表中。

现在，如果您使用consec(ma, 3, 2)，它会为您提供ma[3,2]的连续总和的向量。

接下来，我们想要填充每个单元格具有最高连续总和的第二个矩阵。您可以使用以下代码创建具有正确尺寸的空白矩阵。

ma2 <- matrix(0, nrow = nrow(ma), ncol = ncol(ma))

现在使用循环和之前创建的consec函数填充它。

for(i in 1:nrow(ma)){
  for(j in 1:ncol(ma)){
    ma2[i,j] <- max(consec(ma,i,j)) 
  }
}

现在我们有了连续和的矩阵，我们可以在其中找到最大的和，并且它的坐标将对应于我们想要在原始矩阵中查找的位置。

ma.max <- which(ma2 == max(ma2), arr.ind = TRUE)

现在，如果只有一对数字是最大数，那么ma.max将有两行（同一对的两个排列）。您可以使用：

ma[ma.max[1,1], ma.max[1,2]]; ma[ma.max[2,1], ma.max[2,2]]

显示它们。在这种情况下，我们得到15和16，因此它有效。

如果你有更多的最大值，那么增加上面代码中的数字以获得下一对（3和4），依此类推。您甚至可以调整consec函数，例如，如果您不想要对角线连续，则删除列表的最后四行。

R：返回矩阵中最大的连续数字对

2 个答案: