Question

我有以下任务。我们得到了一个数字N-大小和一个用整数填充的数组，可以使用该算法。现在，数组中的每个数字基本上都是数组中的一个位置。每个阵列都有一个领导者。该点的值与其在数组中的位置相同。数组示例为：

1 2 4 5 4 1

在此数组中，leader的值为4，因为它位于第4位。在我们得到的数据中，必须始终只有一位领导者。现在我们建立一个层次结构。领导者得到的值是0，指向他的值是0，因此，在这种情况下，值为4则得到新的值1，依此类推。为了使其可视化，上面的数组变为：

3 2 1 4 0 3

领导者为0，在位置2我们也有一个4，因此它成为层次结构中编号为1的下一个。在位置1我们有一个2因此它指向第二个位置-层次结构中的新1它成为层次结构中的第二个，依此类推。原始数组中的其他2个也将变为2个。

输入数据将以txt文件形式给出。目前，我需要最好的算法来完成这项工作。我做了一个递归。在这里我也想问一下复杂性是什么。 N * logN吗？输入来自文件，N也是如此。示例输入file.txt是
4
1 2 3 3
6
1 2 4 5 4 1

以上（后）的输出：
3 2 1 0
3 2 1 4 0 3

这是我的代码（目前已固定输入）：

#include <iostream>
using namespace std;

int *T;

int nr(int x)
{
if (T[x] == x)
    return 0;
else
    return nr(T[x]) + 1;
}

int main()
{
    int n, m, leader;

    n = 6;
    T = new int[n];
    int T1[6];

    T[0] = 1;
    T[1] = 2;
    T[2] = 4;
    T[3] = 5;
    T[4] = 4;
    T[5] = 1;

    for (int i = 0; i < n; ++i)
    {   
        T1[i] = nr(i);  
    }

    for (int i = 0; i < n; ++i)
    {
        cout<<T1[i]<<" ";
    }
    cout << endl;

    delete[] T;
}

Answer 1

对于每个位置，我们想知道哪些单元格指向它。

1 2 4 5 4 1

5: 3
4: 2, 4 (leader)
3: None
2: 1
1: 0, 5
0: None

现在从领导者倒退：

Who's looking at 4?
  -> 2
[x, x, 1, x, 0, x]

Who's looking at 2?
  -> 1
[x, 2, 1, x, 0, x]

Who's looking at 1?
  -> 0 and 5
[3, 2, 1, x, 0, 3]

Who's looking at 0 or 5?
  -> 3
[3, 2, 1, 4, 0, 3]

伪代码：

// For each position, we'd like to know
// which cells are pointing to it
A = input array
leader = None
map = {}

for i=0 to length(A)-1:
  if i = A[i]:
    leader = i

  if i != leader:
    if A[i] in map:
      map[A[i]].append(i)
    else:
      map[A[i]] = [i]


//Now follow backwards from the leader
output = Array(length(A))
next = leader
output[leader] = 0
rank = 0

// Assumes the data provides
// for a straightforward solution.
// There may be edge cases to work
// out if that's not the case.
while next:
  for i in map[next]:
    next = None
    if i in map:
      next = i
      rank = rank + 1
      for j in map[next]:
        output[j] = rank
      break

在数组中建立位置层次

1 个答案: