2012-11-07 16:00:00 UTC

# The art of mergers

by Fel

Status: Passed
Results: 1381 (cyc: 6, node: 1774)
CPU Time: 25.339
Score: 1448.75
Submitted at: 2012-11-03 20:45:34 UTC
Scored at: 2012-11-03 20:49:20 UTC

Current Rank: 1176th (Highest: 77th )
Based on: The art of mergers (diff)
Basis for: The art of mergers (diff)
Basis for: The art of mergers (diff)
Basis for: The art of mergers (diff)

Code
```function xyOut = solver(a, xyIn, wts)

% Place nodes in radial pattern
xy{1}       = solver_alfonso  (a, xyIn, wts);
xy{2}       = solver_hannes   (a, xyIn);
xy{3}       = solver_jonathan (a);
[~,best]    = min(N);
xyOut       = xy{best};

end

function xyOut = solver_alfonso(a, xyIn, wts)

N=length(wts);

deg=diag(sum(a));
[V,~]=eig(deg-a,deg);
xyOut=V(:,2:3);

for ncut=1:2
Mbeta=(0.9*eye(N)+0.1*bsxfun(@rdivide,a+eye(N),sum(a,2)+1))^10;
for n1=1:119
xyOut=Mbeta*xyOut;
[c1,D]=svd(cov(xyOut,1));
xyOut=(bsxfun(@minus,xyOut,mean(xyOut)))*c1*diag(1./sqrt(.1+diag(D)))*c1';
end
[i,j]=find(a>0.009);
dd=sum((xyOut(i,:)-xyOut(j,:)).^2,2);
k=find(dd>3.5*mean(dd));
if isempty(k), break; end
a(i(k)+N*(j(k)-1))=0.009;
end

xyOut0=sqrt(N)*detrend(xyOut,'constant')*diag(1./std(xyOut,1,1));
k=5;
[sxyOut0,idxequal]=sortrows(round(15*xyOut0)/15);
idxequal=idxequal(all(~diff(sxyOut0,1,1),2));
xyOut=round(xyOut0);
while size(unique(xyOut,'rows'),1)~=N
k=k*1.1;
xyOut=xyOut0*k;
xyOut(idxequal,:)=(xyOut0(idxequal,:)+randn(numel(idxequal),2)/10)*k;
xyOut=round(xyOut);
end
if N<35 % small map knot lines
xyOut=3*xyOut+randi([-1,1],N,2);
end

xyOut = bsxfun(@minus,xyOut,round(wts*(xyOut-xyIn)./sum(wts))); % AV's
end

function xyOut = solver_hannes(a, xyIn)
% Entry 67561: 2503 (cyc: 2, node: 166) CPU Time: 1.536 Score: 2505.98

sz      = size(a,1);
deg     = diag(sum(a));
L       = deg-a;
[V,~]   = eig(L,deg);
xyOut   = 0;
outdiam = norm(max(V(:,2:3)) - min(V(:,2:3)));
indiam  = norm(max(xyIn)     - min(xyIn));
mult    = indiam/outdiam;

while size(unique(xyOut,'rows'),1) < sz

xyOut      = round(V(:,2:3)*mult);
[~,i]      = unique(xyOut,'rows');
m          = setdiff(1:sz,i);
xyOut(m,:) = xyOut(m,:) + round(rand(length(m),2))*2 - 1;
mult       = mult*1.5;

end

end

function X = solver_jonathan(a)
% Entry 67763: 2523 (cyc: 4, node: 180) CPU Time: 1.371 Score: 2526.46

% JLS solver; Based on spectral graph theory.

L = diag(sum(a)) - a; % graph laplacian

% get eigenvectors of interest
[U, ~, ~] = svd(L);
U         = U(:, end-2:end-1);

% scale to integers, with truncation
X = U;
n = size(X, 1);
k = max(fix(log10(abs(U(:))))) + ceil(log10(n));
X = round(U .* 10^k);

% resolve repeated rows arbitrarily
[~, m, ~] = unique(X, 'rows');
m         = numel(m);
while m ~= n
for row1 = 1:size(X, 1)
idx = find(X(:, 1) == X(row1, 1) & X(:, 2) == X(row1, 2));
for row2 = 2:numel(idx)
X(idx(row2), 2) = X(idx(row2), 2) + row2;
end
end
[~, m, ~] = unique(X, 'rows');
m         = numel(m);
end

end

N = numKnots(XYnew,a);
d = sqrt(sum((XYnew-XYold).^2,2));
A = bsxfun(@minus,XYold',mean(XYold',2));
S = full(dot(A,A,1));
D = bsxfun(@plus,S,S')-full(2*(A'*A));
D = sqrt(max(max(D)));
S = N + sum(d.*wts')/D/sum(wts);

end

function N = numKnots(XY,A)

A         = triu(A,1);
nLines    = nnz(A);
[p1i,p2i] = find(A);
pick      = tril(true(nLines),-1);
x1        = pickCoordinates(XY(p1i,1) ,1,nLines,pick);
y1        = pickCoordinates(XY(p1i,2) ,1,nLines,pick);
x2        = pickCoordinates(XY(p2i,1) ,1,nLines,pick);
y2        = pickCoordinates(XY(p2i,2) ,1,nLines,pick);
x3        = pickCoordinates(XY(p1i,1)',nLines,1,pick);
y3        = pickCoordinates(XY(p1i,2)',nLines,1,pick);
x4        = pickCoordinates(XY(p2i,1)',nLines,1,pick);
y4        = pickCoordinates(XY(p2i,2)',nLines,1,pick);
N         = sum(areIntersecting(x1,y1,x2,y2,x3,y3,x4,y4));

end

function x = pickCoordinates(xy,n,m,pick)
x         = repmat(xy,n,m);
x         = x(pick);
end

function bool = areIntersecting(x1,y1,x2,y2,x3,y3,x4,y4)
% Determine if two line segments intersect.
%
% line1 = [x1, y1, x2, y2]
% line2 = [x3, y3, x4, y4]
%
% This function is robust to floating point precision issues assuming all
% input coordinates are integer-valued. If all coordinates have absolute
% values that do not exceed x, then the arithmetic operations used in this
% function could, as an intermediate step, produce a value with magnitude
% as large as 8*x^4. For double-precision floating point, this implies
% that the following must be satisfied:
%
% 8*x^4 < 2^53
%
% or equivalently, x < 5792.
%
% http://en.wikipedia.org/wiki/Line-line_intersection

bool = false(size(x1));
gen  = true(size(x1));

% Test to see if the lines share exactly one endpoint. If so, the lines
% intersect if either of the free points lies on the line segment formed by
% the other two points.

s13         = find((x1==x3)&(y1==y3));
bool(s13)   = (isPointOnSegment(x2, y2, x1, y1, x4, y4, s13)|isPointOnSegment(x4, y4, x1, y1, x2, y2, s13));
gen(s13)    = false;
s14         = find((x1==x4)&(y1==y4));
bool(s14)   = (isPointOnSegment(x2, y2, x1, y1, x3, y3, s14)|isPointOnSegment(x3, y3, x1, y1, x2, y2, s14));
gen(s14)    = false;
s23         = find((x2==x3)&(y2==y3));
bool(s23)   = (isPointOnSegment(x1, y1, x2, y2, x4, y4, s23)|isPointOnSegment(x4, y4, x1, y1, x2, y2, s23));
gen(s23)    = false;
s24         = find((x2==x4)&(y2==y4));
bool(s24)   = (isPointOnSegment(x1, y1, x2, y2, x3, y3, s24)|isPointOnSegment(x3, y3, x1, y1, x2, y2, s24));
gen(s24)    = false;

% Next we check for parallel and coincident lines. Parallel lines
% obviously don't intersect. Coincident lines intersect if an endpoint from
% one of the lines lies on the other segment.

ss          = find(gen&haveSameSlope(x1, y1, x2, y2, x3, y3, x4, y4, 1:numel(x1)));
gen(ss)     = false;
si          = ss(haveSameIntercept(x1, y1, x2, y2, x3, y3, x4, y4,ss));
UNO         = ones(size(x1));
bool(si)    = ((isPointBetween(x3, x4, x1, UNO, si) & isPointBetween(y3, y4, y1, UNO, si)) | ...
(isPointBetween(x3, x4, x2, UNO, si) & isPointBetween(y3, y4, y2, UNO, si)) | ...
(isPointBetween(x1, x2, x3, UNO, si) & isPointBetween(y1, y2, y3, UNO, si)) | ...
(isPointBetween(x1, x2, x4, UNO, si) & isPointBetween(y1, y2, y4, UNO, si)));

% If we get this far, we're in the general case of two well-defined
% non-parallel lines. The lines formed by the two segments must intersect
% somewhere. Find this intersection point and determine if it lies on the
% segments.

gen  = find(gen);

Px_n = (x1.*y2 - y1.*x2).*(x3 - x4) - (x1 - x2).*(x3.*y4 - y3.*x4);
Px_d = (x1 - x2).*(y3 - y4) - (y1 - y2).*(x3 - x4);

Py_n = (x1.*y2 - y1.*x2).*(y3 - y4) - (y1 - y2).*(x3.*y4 - y3.*x4);
Py_d = (x1 - x2).*(y3 - y4) - (y1 - y2).*(x3 - x4);

bool(gen) = (isPointBetween(x1, x2, Px_n, Px_d, gen) & ...
isPointBetween(y1, y2, Py_n, Py_d, gen) & ...
isPointBetween(x3, x4, Px_n, Px_d, gen) & ...
isPointBetween(y3, y4, Py_n, Py_d, gen));

end

function bool = haveSameIntercept(x1, y1, x2, y2, x3, y3, x4, y4, ii)
bool = (x4(ii) - x3(ii)).*(y1(ii).*(x2(ii) - x1(ii)) - x1(ii).*(y2(ii) - y1(ii))) == ...
(x2(ii) - x1(ii)).*(y3(ii).*(x4(ii) - x3(ii)) - x3(ii).*(y4(ii) - y3(ii)));
end

function bool = haveSameSlope(x1, y1, x2, y2, x3, y3, x4, y4, ii)
bool = (y2(ii) - y1(ii)).*(x4(ii) - x3(ii)) == (x2(ii) - x1(ii)).*(y4(ii) - y3(ii));
end

function bool = isPointOnSegment(x1, y1, x2, y2, x3, y3, ii)
% Determine if point (x1, y1) is on the segment formed by (x2, y2) and (x3, y3).
UNO = ones(size(x1));
bool = haveSameSlope(x2, y2, x1, y1, x1, y1, x3, y3, ii) & ...
isPointBetween(x2, x3, x1, UNO, ii) & ...
isPointBetween(y2, y3, y1, UNO, ii);
end

function bool = isPointBetween(pt1, pt2, num, den, ii)
% Determine if either of the following is satisfied:
% pt1 <= num/den <= pt2
% pt1 >= num/den >= pt2

bool = ((pt1(ii).*den(ii) <= num(ii)) & (num(ii) <= pt2(ii).*den(ii))) | ...
((pt1(ii).*den(ii) >= num(ii)) & (num(ii) >= pt2(ii).*den(ii)));
end
```