Question

我想分割这些数据，

ID x    y
1  2.5  3.5
1  85.1 74.1
2  2.6  3.4
2  86.0 69.8
3  25.8 32.9
3  84.4 68.2
4  2.8  3.2
4  24.1 31.8
4  83.2 67.4

我能够和他们的伴侣匹敌，

ID x    y    ID x    y   
1  2.5  3.5  1  85.1 74.1
2  2.6  3.4  2  86.0 69.8
             3  25.8 32.9
             4  24.1 31.8

但是，正如您注意到ID 4中的某些新行被放错了，因为它刚刚在接下来的几行中添加。我想正确地拆分它们而不必使用我已经使用的复杂逻辑......有人可以给我一个算法或想法吗？

看起来应该是，

ID x    y    ID x    y      ID x    y 
1  2.5  3.5  1  85.1 74.1   3  25.8 32.9
2  2.6  3.4  2  86.0 69.8   4  24.1 31.8
4  2.8  3.2  3  84.4 68.2
             4  83.2 67.4

Answer 1

似乎您的问题实际上是关于群集，而ID列与确定哪些点对应哪个无关。

实现这一目标的常用算法是k-means clustering。但是，您的问题意味着您事先不知道群集的数量。这使问题复杂化，StackOverflow上就此问题已经提出了很多问题：

Kmeans without knowing the number of clusters?
compute clustersize automatically for kmeans
How do I determine k when using k-means clustering?
How to optimal K in K - Means Algorithm
K-Means Algorithm

不幸的是，没有“正确”的解决方案。一个特定问题中的两个集群可能确实被视为另一个问题中的一个集群。这就是为什么你必须自己决定。

尽管如此，如果您正在寻找简单（并且可能不准确）的东西，您可以使用欧几里德距离作为度量。计算点之间的距离（例如，使用pdist），以及距离低于某个阈值的组点。

实施例

%// Sample input
A = [1,  2.5,  3.5;
     1,  85.1, 74.1;
     2,  2.6,  3.4;
     2,  86.0, 69.8;
     3,  25.8, 32.9;
     3,  84.4, 68.2;
     4,  2.8,  3.2;
     4,  24.1, 31.8;
     4,  83.2, 67.4];

%// Cluster points
pairs = nchoosek(1:size(A, 1), 2); %// Rows of pairs
d = sqrt(sum((A(pairs(:, 1), :) - A(pairs(:, 2), :)) .^ 2, 2)); %// d = pdist(A)
thr = d < 10;                      %// Distances below threshold
kk = 1;
idx = 1:size(A, 1);
C = cell(size(idx));               %// Preallocate memory
while any(idx)
     x = unique(pairs(pairs(:, 1) == find(idx, 1) & thr, :));
     C{kk} = A(x, :);
     idx(x) = 0;                   %// Remove indices from list
     kk = kk + 1;
end
C = C(~cellfun(@isempty, C));      %// Remove empty cells

结果是一个单元格数组C，每个单元格代表一个集群：

C{1} =
    1.0000    2.5000    3.5000
    2.0000    2.6000    3.4000
    4.0000    2.8000    3.2000

C{2} =
    1.0000   85.1000   74.1000
    2.0000   86.0000   69.8000
    3.0000   84.4000   68.2000
    4.0000   83.2000   67.4000

C{3} = 
    3.0000   25.8000   32.9000
    4.0000   24.1000   31.8000

请注意，这种简单的方法存在将群集半径限制为阈值的缺陷。但是，您需要一个简单的解决方案，因此请记住，当您为算法添加更多“聚类逻辑”时，它会变得复杂。

拆分数据知道其共同ID

1 个答案:

实施例