Codechef拒绝我的解决方案

Codechef is rejecting my solution

本文关键字：解决方案 我的 拒绝 Codechef      更新时间：2023-10-16

我是codechef的新手，我试图解决以下问题，但是我的代码在我的机器上运行良好，我还在某些情况下测试了它。

问题如下:-

在英国，军官们最担心的事情就是正确地指挥士兵们参加阅兵。幸运的是，命令士兵并不是一个真正的问题。如果一个排由n个人组成，他们都有不同的等级(从1 -最低到n -最高)，在游行中他们应该从左到右排列，按等级递增的顺序排列。

听起来很简单，不是吗?嗯，约翰尼军士也是这么想的，直到有一天他面临一个新的命令。他很快发现他的精英突击队员更喜欢战斗，而把思考留给他们的上级。所以，当第一次点名时，士兵们以相当随机的顺序排列，这并不是因为他们缺乏纪律，而仅仅是因为他们不知道如何以正确的顺序排列。约翰尼中士一点也不觉得好笑，尤其是他很快发现，没有一个士兵记得他自己的军衔。经过多年的服役，每个士兵都只知道谁是他的上级。但是，当面对真正的军事挑战时，约翰尼中士并不是一个轻易放弃的人。他想了一会儿，想到了一个非常简单明了的办法，于是下达了下面的命令:"大家从左边开始，一个接一个地向前走;向左走，直到没有人在你的左边;回去排队)。这确实在几分钟内就把这些人整理好了。问题解决了……暂时。

第二天，士兵们的顺序和前一天完全一样，必须用同样的方法重新安排。历史重演。几个星期后，约翰尼军士设法迫使他的每个士兵记住他离开时经过了多少人，从而使分类过程更快。

如果你知道每个人必须向左走多少个位置，你能试着找出士兵最初排队的顺序吗?

输入

第一行输入包含一个整数t<=50，测试用例的数量。后面是t个测试用例，每个用例由2行组成。第一行包含一个整数n (1<=n<=200000)。第二行包含n个以空格分隔的整数wi，表示当应用Sgt Johnny的算法时，队列中的第i个士兵必须向左走多远。

输出

对于每个测试用例，输出由n个空格分隔的整数组成的单行——士兵的军衔，按初始排列从左到右给出。

例子

输入:23.0 1 050 1 2 0 1

输出:２ １ ３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;
 }

那么在逻辑上或语法上有什么错误吗?

排序的'unwind '顺序是相关的。下面的代码演示了上面的语句(排名以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
相关文章：