你有一个i by j矩阵。出于此示例的目的，请采用以下（非常小）矩阵。但是，该算法应该快速且可扩展。
values <- c(2,5,3,6,7,
9,5,4,9,9,
1,5,4,8,1,
3,1,5,6,2,
2,9,4,7,4)
my.mat <- matrix(values, nrow = 5, byrow = TRUE)
目标：迭代删除my.mat中的行或列，使其意味着（c（apply（my.mat，1，min），apply（my.mat，2，min）））在删除行数和列数的情况下最小化。贪婪地这样做（因此一旦删除了一列或一行，它就永远不会返回到矩阵）。换句话说，只需删除具有最大最小值的行或列。以下警告适用。
首先，如果删除行或列会更改列或行的最小值（即，如果它们是彼此的最小值），则删除（行，列）对。如果行或列与多个列或行配对，请迭代删除其他列或行，直到配对为1：1，然后同时删除其余对。第二，有关系的地方，随机选择。
输出：根据此目标指示删除顺序的向量。它可以引用行/列名称，也可以引用单元格值，只要它暗示正确的删除顺序即可。
因此对于上面的矩阵，正确答案是......
(Column 4), (Row 2), (Column 3), (Either Row 1 or Row 5), (Row 5 or Row 1), (Column 1 or Column 5), (Row 4 and Column 2), (Column 5 or Column 1 AND Row 3)
但是，实际的实施不应该是不确定的。例如，它应该随机选择第5行或第1行，然后在适当的时候在后续步骤中删除剩余的行。
很容易想象一个非常草率的问题解决方案。但是，很难想象一个快速的矢量化解决方案。
如果没有关系，其中列和行没有相互配对，并且如果没有多个行或列的实例与单个列或行配对，则可以简单地对唯一的行和列最小值进行排序，然后迭代地删除行和列，其最小值等于已排序最小值中的 i 值。但是，如果存在联系，例如在my.mat中，则会中断，因为它会不必要地删除不会更改相应列或行的最小值的行和列。例如，如果一行与两列配对，它们都将具有相等的最小值，因此这个粗略算法将删除行和两列，当正确答案是随机删除其中一列时，然后删除两列剩余的列和行。这个问题的一个潜在解决方案是抖动值，以便暗示正确的排序，但随着矩阵变大，很难确保抖动不会导致错误的排序。
编辑1 ：解释示例
AndrewMacDonald提出了一个关于这个例子的问题，所以我将解释这个顺序。
每行和每列的最小值如下，其中Ci，Ri是 i 列，行。
C4 R2 C3 R1 R5 R3 R4 C1 C2 C5
6 4 3 2 2 1 1 1 1 1
前三个步骤很简单。 C4，R2和C3不是其他行或列的最小值，也没有任何关系。所以，步骤1 - 3 ......
完整矩阵：
C1 C2 C3 C4 C5
R1 2 5 3 6 7
R2 9 5 4 9 9
R3 1 5 4 8 1
R4 3 1 5 6 2
R5 2 9 4 7 4
1）删除C4。
C1 C2 C3 C5
R1 2 5 3 7
R2 9 5 4 9
R3 1 5 4 1
R4 3 1 5 2
R5 2 9 4 4
2）删除R2
C1 C2 C3 C5
R1 2 5 3 7
R3 1 5 4 1
R4 3 1 5 2
R5 2 9 4 4
3）删除C3
C1 C2 C5
R1 2 5 7
R3 1 5 1
R4 3 1 2
R5 2 9 4
然后，R1和R5之间存在联系（两者都至少为2）。它们显然没有相互配对，也不是任何列的最小值，因此我们可以一次删除它们而不更改任何其他行或列的最小值。我们在两者之间随机选择以确定顺序。
4）第1行或第5行（我随意选择第1行）
C1 C2 C5
R3 1 5 1
R4 3 1 2
R5 2 9 4
5）第5行或第1行（在第4步中没有选择）
C1 C2 C5
R3 1 5 1
R4 3 1 2
其余的行和列绑定= 1.您无法移除R3，因为C1或C5会变得更糟。但你可以删除C1或C5而不会使R3更糟。同样，你不能删除R4或C2而不会使另一个更糟。所以我们必须同时删除R4和C2。
最后几步是移除C1或C5中的一个，然后剩下的两对（R4和C2，R3以及剩余的C1或C5）。
6）C1或C5（I＆＃39;任意选择C5）
C1 C2
R3 1 5
R4 3 1
7）R4和C2
C1
R3 1
8）R3和剩余的C1或C5
[]
注意：步骤7和8实际上是可以互换的。再次，随机选择它们之间。
答案 0 :(得分：1)
实际上不需要迭代地做任何事情，因为当移除某些东西时，矢量的最小值不会改变。因此，我们可以减少此问题，仅考虑行和列的最小值。这样可以减少问题的大小，并且可以使解决方案更快，并且可扩展
在这个答案中，我使用了dplyr和tidyr两个用于处理数据的包。
第一步是找到每行和每列的最小值，并将它们保存在data.frame中。可能有更优雅的方法，但这是一种方法：
library(dplyr)
library(tidyr)
colmins <- lapply(1:ncol(my.mat),function(s){col <- my.mat[,s,drop = FALSE]
which(col == min(col), arr.ind = TRUE)}
)
cs_pos <- data.frame(name = rep(paste0("c",1:ncol(my.mat)),
times = sapply(colmins,nrow)),
do.call(rbind,colmins),
stringsAsFactors = FALSE)
rowmins <- lapply(1:nrow(my.mat),function(s){row <- my.mat[s,,drop = FALSE]
which(row == min(row), arr.ind = TRUE)}
)
rs_pos <- data.frame(name = rep(paste0("r",1:nrow(my.mat)),
times = sapply(rowmins,nrow)),
do.call(rbind,rowmins),
stringsAsFactors = FALSE)
cs_val <- data.frame(type = "c", name = paste0("c",1:ncol(my.mat)),
val = apply(my.mat,2,min),
stringsAsFactors = FALSE)
rs_val <- data.frame(type = "r", name = paste0("r",1:ncol(my.mat)),
val = apply(my.mat,1,min),
stringsAsFactors = FALSE)
cs <- cs_pos %>%
mutate(col = col + (extract_numeric(name)-1)) %>%
left_join(cs_val)
rs <- rs_pos %>%
mutate(row = row + (extract_numeric(name)-1)) %>%
left_join(rs_val)
my.df <- rbind(cs,rs)
结果是data.frame，每行“或最小”行有一行，并且有额外的行数。：
my.df
name row col type val
1 c1 3 1 c 1
2 c2 4 2 c 1
3 c3 1 3 c 3
4 c4 1 4 c 6
5 c4 4 4 c 6
6 c5 3 5 c 1
7 r1 1 1 r 2
8 r2 2 3 r 4
9 r3 3 1 r 1
10 r3 3 5 r 1
11 r4 4 2 r 1
12 r5 5 1 r 2
这些重复的行很重要，因为当它们存在时，我们知道行或列a）具有两个彼此相等的最小值或b）行和列具有相同的最小值或c）两者。
我们可以设置一些便利功能来找到这些值对：
findpairs <- function(var) xor(duplicated(var,incomparables = NA),
duplicated(var,fromLast = TRUE,incomparables = NA))
my.df.dup <- my.df %>%
mutate(coord = paste(row,col,sep = ",")) %>%
select(coord,name,type) %>%
spread(type,name) %>%
mutate(cdup = findpairs(c),
rdup = findpairs(r)) %>%
group_by(coord) %>%
mutate(nval = sum(!is.na(c),!is.na(r)),
dup = any(cdup,rdup)) %>%
mutate(grp = ifelse(nval == 1 & !dup, 1, 0),
grp = ifelse(nval == 1 & dup, 2, grp),
grp = ifelse(nval == 2 & !dup, 3, grp),
grp = ifelse(nval == 2 & dup, 4, grp)) %>%
arrange(grp) %>%
select(coord,c,r,grp)
my.df.dup
coord c r grp
1 1,1 NA r1 1
2 1,3 c3 NA 1
3 2,3 NA r2 1
4 5,1 NA r5 1
5 1,4 c4 NA 2
6 4,4 c4 NA 2
7 4,2 c2 r4 3
8 3,1 c1 r3 4
9 3,5 c5 r3 4
my.df.dup对于矩阵中的每个位置都有一行，它具有最小值。两列c和r，分别保存此位置的值为最小值的列和行的名称。请注意，目前我们正在考虑
grp列很方便 - 根据它们是否“共享”来确定分为四类的最小值：
## nval = 1, dup = FALSE : unique minima
## nval = 1, dup = TRUE : duplicated minima, unshared
## nval = 2, dup = FALSE : a row-column pair
## nval = 2, dup = TRUE : >=2 columns share minima with a row (or vice-versa)
根据上面的步骤6到8，grp = 4中的唯一最小值将需要“拆分”。为了简单（和速度），我将这些与主数据分开，编辑，然后替换：
my.df.not4 <- my.df.dup %>%
filter(grp != 4) %>%
ungroup %>%
filter(!(grp == 2 & duplicated(c)))
my.df.4 <- my.df.dup %>%
ungroup %>%
filter(grp == 4) %>%
group_by(c) %>%
mutate(c_new = ifelse(sample(!duplicated(c)),c,NA)) %>%
ungroup %>%
group_by(r) %>%
mutate(r_new = ifelse(sample(!duplicated(r)),r,NA)) %>%
ungroup %>%
select(coord, c = c_new, r = r_new)
对mutate的最终调用将所有重复值替换为“NA”;这是我对上面步骤6-8的解释。 我不确定如果有时跨列，有时跨行共享最小值，这将如何工作。 YMMV。
最后，我们将上面的答案转换为两个数据帧：一个最小“名称”（实际上是删除的行和列）和一个实际的最小值。后者给出了删除的顺序，前者应该删除的组：
my.df.names <- rbind(my.df.not4,my.df.4) %>%
gather(type,name,c:r,na.rm = TRUE) %>%
group_by(coord) %>%
mutate(size = n(),
name = ifelse(size == 2, paste(name,collapse = ","), name)) %>%
select(coord,name) %>%
ungroup
my.df.mins <- my.df %>%
mutate(coord = paste(row,col,sep = ",")) %>%
select(coord,val) %>%
arrange(val %>% desc) %>%
ungroup
my.df.names
coord name
1 1,3 c3
2 1,4 c4
3 4,2 c2,r4
4 3,1 c1
5 3,5 c5,r3
6 1,1 r1
7 2,3 r2
8 5,1 r5
9 4,2 c2,r4
10 3,5 c5,r3
my.df.mins
coord val
1 1,4 6
2 4,4 6
3 2,3 4
4 1,3 3
5 1,1 2
6 5,1 2
7 3,1 1
8 4,2 1
9 3,5 1
10 3,1 1
11 3,5 1
12 4,2 1
最后一步很简单：合并两个数据帧，按val排序，并返回将被删除的行或列的名称。如果您想随意断开关系，只需在sample()的每个唯一值中使用val：
output <- left_join(data.frame(my.df.names),my.df.mins) %>%
unique %>%
arrange(desc(val)) %>%
group_by(val) %>%
mutate(namesamp = sample(name))
output$namesamp
"c4" "r2" "c3" "r1" "r5" "c5,r3" "c1" "c2,r4"