Question

假设我有一组对象，我想要实现的函数接收更新值列表以更新我的对象。更新值可用于更新至多一个对象，但可以单独更新。

所以，例如，

我的对象是： [a，b，c] 。
使用参数 [d，e] 。

我想要的是我的对象（a，b，c）的更新与参数值的所有组合，其中顺序无关紧要（例如，[abce]和[eabc]中只有一个需要和应该发生）。一些可能的结果：

[一个;的 B'/强>; C

[ a e ; b d ; C

[ a d ;的 B'/强>; c e ]

[一个;的 B'/强>; c e ; d

[一个;的 B'/强>; C ; d ; ë

...

最简单的例子是两个列表的大小都是1（例如，[a]和[d]）：

[ a d ]

[一个

[ d

预先不知道对象的数量和更新值的数量。

我将如何实施此功能？谢谢！

对于任何好奇的人来说，背景是使用多假设跟踪来跟踪多个目标。我的对象是轨道，更新值是传感器事件。每个传感器事件要么更新单个现有轨道，要么产生新轨道，要么被视为噪声。

编辑：根据Jurgen在下面的回答，我实现了这样：

static LinkedList<String> update(List<String> trackLst, List<String> eventLst) { LinkedList<String> newTracks = new LinkedList<String>(); for ( int e = 0; e < eventLst.size(); e++ ) { String evt = eventLst.get( e ); for ( int i = 0; i < trackLst.size(); i++ ) { String trk = trackLst.get( i ); if ( trk == null ) trk = new String(""); trk = trk.concat( evt ); newTracks.add(trk); } // No update newTracks.add( eventLst.get(e) ); } return newTracks; }

在效果问题上进行一些扩展：实际上，在将其包含在最终假设列表中之前，我们会以性能或一致性度量的形式测试每个关联的有用性。它仍然是一个很大的数字，但是当物体经常重叠并且传感器分辨率很低时，需要进行耗尽的测试，以便我们可以延迟关联，直到稍后有更多有意义的数据可用。

Answer 1

这可以使用递归来完成。每个参数都有n + 1个选项可供选择。要么它可以与任何n个对象相关联，要么它可以独立存在。

因此，如果初始的“剩余列表对象”是对象列表[a，b，c，...]，剩下的参数列表是[d，e，...]，

可能的伪代码：

void recur( list<pair> soFar, list remainingObjects, list remainingParam ) {
  if ( remainingParam is empty ) {
    add remainingObjects to soFar;
    print soFar;
    return;
  }

  for parameter in remainingParam: {
    for object in remainingObject: {
      (remove object and parameter from remaining lists and add pair to soFar)
      recur(...);
    }

    (remove only parameter from remainingParam list and add it to soFar as sole object)
    recur(...);
  }

}

Answer 2

这样的事可能吗？

List<Tracks>  trackLst = ....;
List<SensorEvent>  eventLst = ....;

// Make the 2 lists equal in length
while ( trackLst.size() > eventLst.size() )  eventLst.add( null );
while ( eventLst.size() > trackLst.size() )  trackLst.add( null );

for ( int e = 0; e < eventLst.size(); e++ )
{
    for ( int i = 0; i < trackLst.size(); i++ )
    {
        SensorEvent  evt = eventLst.get( i );

        if ( evt != null )
        {
            Track  trk = trackLst.get( i );

            if ( trk == null )  trk = new Track();

            trk.update( evt );
        }
    }

    eventLst.add( eventLst.remove(0) );
}

Answer 3

当我背景正确时，你错过了，每个输入事件都可能是对任何其他输入事件的更新。

此外，我假设每个输入对象可以是对最近一个现有对象的更新。因此列出所有选项将是性能问题。当找到匹配时，任何算法都会中断。

因此，将问题分解为单个输入事件，即匹配为更新或创建新轨道。请注意，在这种情况下，根据匹配逻辑，输入顺序很重要！

回答你的问题：

你有N个曲目和M个输入。然后每个输入可以属于N + 1（噪声）+ 1（空轨道）选项。因此，您有(n+2)^m种不同的方式来分配选项上的输入。

M和N的顺序为10和1000，这已经是O(N^M)

的性能噩梦

假设所有事件都位于同一地点且可能属于一个或是噪声，问题将减少到O(N*2^M)

将未知数量的对象与未知数量的输入值组合在一起

3 个答案: