Question

If I have a matrix:

0   0   3   4  
4   3   2   0  
2   0   2   0  

I want to extract the non-zero elements into some batches, with respect to a rule: if an element is already taken, the other element in the same row/column is not allowed. So the extracted matrix will be:
1st batch:

0   0   3   0  
4   0   0   0  
0   0   0   0  

2nd batch:

0   0   0   4  
0   3   0   0  
0   0   2   0  

3rd batch:

0   0   0   0  
0   0   2   0  
2   0   0   0  

Any other combination of batches is also accepted, as long as all non-zero elements are covered, and the rule is conformed. How would you do that in MATLAB/Octave?

Answer 1

Gunther was already on the right track. You want to select an element, if

1. the row cumsum of the non-zeros is 1 AND
2. the column cumsum of the non-zeros is 1 AND
3. the element itself is non-zero.

The following code solves the problem:

A = [0, 0, 3, 4;
     4, 3, 2, 0;
     2, 0, 2, 0];

batches = cell(0);
while any(A(:)~=0)
    selector = cumsum(A~=0, 1) .* cumsum(A~=0, 2) .* (A~=0) == 1;
    batches{end+1} = A .* selector;
    A(selector) = 0;
end

Note however that the returned solution is not optimal because its 2nd batch is

0   0   0   4  
0   3   0   0  
2   0   0   0 

which means that the remaining matrix elements are from the same column:

0   0   0   0
0   0   2   0  
0   0   2   0 

Unfortunately, you cannot draw them in the same batch. So you end up with four batches instead of just three.

Edit: Probably, it is a good idea, to select first those elements, which appear in rows/columns with a lot of non-zeros. For example, one could use these weights

weight = repmat(sum(A~=0, 1), size(A, 1), 1) ...
         .* repmat(sum(A~=0, 2), 1, size(A, 2)) .* (A~=0)

weight =
     0     0     6     2
     6     3     9     0
     4     0     6     0

The following algorithm

batches = cell(0);
while any(A(:)~=0)
    batch = zeros(size(A));
    weight = repmat(sum(A~=0, 1), size(A, 1), 1) ...
             .* repmat(sum(A~=0, 2), 1, size(A, 2)) .* (A~=0);
    while any(weight(:)~=0)
        [r,c] = find(weight == max(weight(:)), 1);
        batch(r,c) = A(r,c);
        A(r,c) = 0;
        weight(r,:) = 0;
        weight(:,c) = 0;
    end
    batches{end+1} = batch;
end

returns those batches.

batches{:}
ans =
     0     0     0     4
     0     0     2     0
     2     0     0     0

ans =
     0     0     3     0
     4     0     0     0
     0     0     0     0

ans =
     0     0     0     0
     0     3     0     0
     0     0     2     0

So it worked at least for this small test case.