1

我想拆分这些数据，

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
4

1 回答 1

1

看来您的问题实际上是关于聚类的，并且 ID 列与确定哪些点对应于哪些点无关。

实现这一目标的常用算法是k-means clustering。但是，您的问题意味着您事先不知道集群的数量。这使事情变得复杂，并且在 StackOverflow 上已经有很多关于这个问题的问题：

  1. Kmeans 不知道集群的数量？
  2. 为 kmeans 自动计算 clustersize
  3. 使用 k-means 聚类时如何确定 k？
  4. 如何在 K 中优化 K - 均值算法
  5. K-Means 算法

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

不过，如果您正在寻找一些简单的东西（并且可能不准确），您可以使用欧几里得距离作为衡量标准。计算点之间的距离（例如使用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

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

于 2013-01-22T14:23:07.643 回答