Extract matrix elements - matlab

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

For just the rows, I'd do it as follows:
A = [ 0 0 3 4 ;
4 3 2 0 ;
2 0 2 0 ];
Checking if numbers are nonzero:
Anonzero=A~=0;
>> Anonzero
0 0 1 1
1 1 1 0
1 0 1 0
Take cumsum along the rows of Anonzero:
Aidx=cumsum(A,[],2);
>> Aidx
0 0 1 2
1 2 3 3
1 1 2 2
numbatches=max(Aidx(:,end));
Set indices of zero values back to zero, so they won't get selected
A(~Anonzero)=0;
Extract batches:
batch=cell(numbatches,1);
for ii=1:numbatches
batch{ii}=A.*(Aidx==ii);
end
resulting in:
>>batch{1}
0 0 3 0
4 0 0 0
2 0 0 0
>>batch{2}
0 0 0 4
0 3 0 0
0 0 2 0
>>batch{3}
0 0 0 0
0 0 2 0
0 0 0 0
I assume there can be done something similar for a row and column rule, but I don't see it right away.. I'll think about it ;)

Answer 2

Gunther was already on the right track. You want to select an element, if
the row cumsum of the non-zeros is 1 AND
the column cumsum of the non-zeros is 1 AND
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.

Answer 3

An interesting problem no doubt...My guess is that #GuntherStruyf's method will eventually be the one you should select. However, here's a simplistic solution using loops:
A = [
0 0 3 4
4 3 2 0
2 0 2 0 ];
C = {};
nz = A ~= 0;
while any(nz(:))
tmpNz = nz;
tmpA = A;
newNz = false(size(nz));
while true
[i,j] = find(tmpNz, 1);
if isempty(i) || isempty(j), break; end
tmpNz(i,:) = false;
tmpNz(:,j) = false;
newNz(i,j) = true;
end
tmpA(~newNz) = false;
C{end+1} = tmpA;
nz(newNz) = false;
end
This should be quite fast once you get rid of the growing cell-array, e.g., by pre-allocating it with a large number of initial elements, and then removing unused elements afterwards.
Nevertheless, I'd wait until #GuntherStruyf figures his thing out!