Question

我是codechef的新手，我试图解决以下问题但是我的代码在我的机器上运行正常，我也在某些情况下进行了测试。

问题如下： -

在Byteland，军官的主要担心是正确地命令他的士兵参加游行。幸运的是，订购士兵并不是真正的问题。如果一个排由n个人组成，他们都有不同的级别（从1 - 最低到n - 最高），并且在游行中，他们应该按照排名的顺序从左到右排列。

听起来很简单，不是吗？好吧，约翰尼中士也这么想，直到有一天他面对一个新命令。他很快发现他的精英突击队员更愿意做战斗，并将思想留给他们的上级。因此，当第一次报道时，士兵们以相当随意的顺序排队，这不是因为他们缺乏纪律，而仅仅是因为他们无法确定如何按照正确的排名顺序排队。约翰尼中士并不觉得好笑，特别是因为他很快就发现没有一个士兵记得他自己的等级。经过多年的服务，每个士兵都只知道其他士兵中的哪一个是他的上级。但是，在面对真正的军事挑战时，约翰尼中士并不是一个容易放弃的人。经过片刻的思考，一个聪明的简单解决方案击中了他，他发出了以下命令：“男人，从左边开始，一个接一个地做:(向前走;向左走，直到你左边没有上司;得到重新排队。“这确实让男人在几分钟内排序。这个问题暂时解决了。

第二天，士兵们按照与前一天完全相同的顺序进入，并且必须使用相同的方法重新排列。历史重演。几个星期后，约翰尼中士设法迫使他的每个士兵记住他离开时经过多少人，从而使分拣过程更快。

如果你知道每个人要向左走多少个位置，你能否试着找出士兵最初排队的等级顺序？

输入

第一行输入包含整数t <= 50，即测试用例的数量。接下来是t个测试用例，每个测试用例由2行组成。第一行包含单个整数n（1 <= n <= 200000）。第二行包含n个空格分隔的整数wi，表示当应用Sgt Johnny算法时，第i个在线士兵必须向左走多远。

输出

对于每个测试用例，输出一行由n个空格分隔的整数组成 - 士兵的等级，在初始安排时从左到右给出。

实施例

输入： 2 3 0 1 0 五 0 1 2 0 1

输出： 2 1 3 3 2 1 5 4 警告：输入/输出数据较大，请注意某些语言

#include <iostream>
#include <string.h>

 using namespace std;

 int main ()
 {
 int t,n;
 cin >> t;

  while(t>0){

    cin >> n;
    int array[n+1];
    int stepsmoved,i;

    for(i = 1; i <= n; i++){
        array[i] = i;
    }


    for(i = 1; i <=n; i++){
        cin >> stepsmoved;
        if(stepsmoved == 0){}
        else{
            int x;
            x = array[i];
            for (int j = i; j> i- stepsmoved; j--){
                array[j] = array[j-1];
            }
            array[i-stepsmoved] = x;
        }

    }

    for(i = 1; i <= n; i++){
        cout<<array[i]<<" ";
    }
  cout<<endl;
  t--;
  }

  return 0;
 }

那么逻辑或语法错误是什么？

Answer 1

'展开'排序的顺序是相关的。以下是演示上述语句的代码（排名从1开始，1 - 最高，10 - 最低，数组索引从0开始）：

#include <stdio.h>

void dump(int *a) {
    int i;
    for (i = 0; i < 10; i++)
      printf("%d ", a[i]);
      printf("\n");
}

int main() {
    int array[10] = {0}, steps[10] = {0};
    int i,j;
    srand(0);

    // Assign ranks in random order
    for (i = 0; i < 10;) {
        j = rand() % 10;
        if (!array[j])
        array[j] = ++i;
    }

    dump(array);

    // Sort according to the Sgt Johnny's initial idea
    for (i = 1; i < 10; i++) {
        for (j = 0; array[j] < array[i]; j++);
        if (j < i) {
            int k, temp = array[i];
            for (k = i; k > j; k--) {
                array[k] = array[k-1];
                steps[temp-1]++;
            }
            array[j] = temp;
            dump(array);
        }
    }
    printf("Steps:\n");
    dump(steps);
    printf("\n");

    // reconstruct the origina order
#if 1
    for (i = 10-1; i >= 0; i--)
#else
    for (i = 0; i < 10; i++)
#endif
    {
        int s = steps[array[i]-1];
        for (j = i; s; s--, j++) {
            int temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
        }
        dump(array);
    }
}

如果以相反的顺序完成重建，那么我们得到一个与原始序列匹配的序列：

8 7 5 1 10 4 2 3 9 6 
7 8 5 1 10 4 2 3 9 6 
5 7 8 1 10 4 2 3 9 6 
1 5 7 8 10 4 2 3 9 6 
1 4 5 7 8 10 2 3 9 6 
1 2 4 5 7 8 10 3 9 6 
1 2 3 4 5 7 8 10 9 6 
1 2 3 4 5 7 8 9 10 6 
1 2 3 4 5 6 7 8 9 10 
Steps:
3 5 5 4 2 4 1 0 1 0 

1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 10 9 
1 2 3 4 5 6 7 8 10 9 
1 2 3 4 5 6 8 7 10 9 
1 2 3 4 5 8 7 10 9 6 
1 2 3 4 8 7 5 10 9 6 
1 2 3 8 7 5 10 4 9 6 
1 2 8 7 5 10 4 3 9 6 
1 8 7 5 10 4 2 3 9 6 
8 7 5 1 10 4 2 3 9 6

否则，重建的顺序与原始顺序不匹配：

8 7 5 1 10 4 2 3 9 6 
7 8 5 1 10 4 2 3 9 6 
5 7 8 1 10 4 2 3 9 6 
1 5 7 8 10 4 2 3 9 6 
1 4 5 7 8 10 2 3 9 6 
1 2 4 5 7 8 10 3 9 6 
1 2 3 4 5 7 8 10 9 6 
1 2 3 4 5 7 8 9 10 6 
1 2 3 4 5 6 7 8 9 10 
Steps:
3 5 5 4 2 4 1 0 1 0 

2 3 4 1 5 6 7 8 9 10 
2 4 1 5 6 7 3 8 9 10 
2 4 5 6 7 1 3 8 9 10 
2 4 5 7 1 3 8 6 9 10 
2 4 5 7 3 8 6 1 9 10 
2 4 5 7 3 8 6 1 9 10 
2 4 5 7 3 8 1 9 10 0 
2 4 5 7 3 8 1 10 9 0 
2 4 5 7 3 8 1 10 0 9 
2 4 5 7 3 8 1 10 0 6

Codechef拒绝我的解决方案

1 个答案: