c - Monk 和 Power of Time DataStructure 查询

Question

问题描述如下: 由于你是 Monk 最喜欢的学生，因此有 N 个过程需要你(被选中的人)完成。所有进程都分配有一个唯一的编号，从 1 到 N。

现在，你有两件事: - 调用所有进程的调用顺序。 - 所有进程执行的理想顺序。

现在，让我们通过一个例子来演示这一点。假设有3个进程，进程的调用顺序是:3 - 2 - 1。理想的顺序是:1 - 3 - 2，即进程号3只有在进程号1完成后才会执行；进程号2只有在进程号3执行完之后才会被执行。

-迭代#1:由于理想的顺序是首先执行进程#1，所以调用顺序发生了变化，即第一个元素必须被推送到最后一个地方。改变元素的位置需要1个时间单位。新的调用顺序是:2 - 1 - 3。第 1 步花费的时间:1。

-迭代#2:由于理想的订单首先要执行流程#1，因此必须再次更改调用顺序，即第一个元素具有被推到最后一个位置。新的调用顺序是:1 - 3 - 2。第 2 步花费的时间:1。

-迭代#3:由于调用顺序的第一个元素与理想顺序相同，因此将执行该过程。它就会这样弹出来。第 3 步所用时间:1。

-迭代#4:由于调用顺序的新第一个元素与理想顺序相同，因此将执行该过程。第 4 步所用时间:1。

-迭代#5:由于调用顺序的最后一个元素与理想顺序相同，因此将执行该过程。步骤 #5 所用时间: 1. 总时间:5 个单位。

PS:执行一个进程需要1个时间单位。改变位置需要1个时间单位。

输入格式: 第一行数字N，表示进程数。第二行包含进程的调用顺序。第三行包含进程的理想顺序。 输出格式: 打印要执行的整个进程队列所花费的总时间。 限制: 1<=N<=100

但是我的输出是这样的:我哪里做错了!!!!!!

输入 3 3 2 1 1 3 2

代码的输出 73

预期正确输出 5

编译日志 编译成功。

 #include <stdio.h>
    int *move_last(int a[],int n1)
    {
        int temp,i;
        temp=a[0];
        for(i=1;i<n1;i++)
        {
            a[i-1]=a[i];
        }
        a[n1-1]=temp;
        return a;
    }
    int *remove_first(int a[],int n2)
    {
        int temp,i;
        temp=a[0];
        for(i=1;i<n2;i++)
            a[i-1]=a[i];
        return a;
    }
    int main()
    {
        //co:calling order array io:ideal order array
        //ptime:process time**strong text**
        int co[100],io[100];
        int n,i,j,count=0,ptime=0;
        scanf("%d",&n);
        for(i=0;i<n;i++)
            scanf("%d",&co[i]);
        for(i=0;i<n;i++)
            scanf("%d",&io[i]);
        while(count!=n)
        {
            while(co[0]!=io[0])
            {
                int *p;
                int size=sizeof(co)/sizeof(co[0]);
                p=move_last(co,size);
                for ( i = 0; i < size; i++ ) 
                    co[i]=*(p + i);
                ptime++;
            }
            if(co[0]==io[0])
            {
                int *p;
                int size=sizeof(co)/sizeof(co[0]);
                p=remove_first(co,size);
                size=size-1;
                for ( i = 0; i < size; i++ ) 
                    co[i]=*(p + i);
                count++;
                ptime++;
            }

        }

        printf("%d",ptime);
        `enter code here`return 0;
    }

Answer 1

这是java中的解决方案

import java.io.*;
import java.util.LinkedList;
import java.util.Queue;

public class Monk_and_Power_of_Time {
public static void main(String[] args) throws IOException
{
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    int n=Integer.parseInt(br.readLine());
    String s[]=br.readLine().trim().split(" ");
    Queue<Integer> q=new LinkedList<Integer>();
    for(int i=0;i<n;i++)
    {
        q.add(Integer.parseInt(s[i]));
    }
    String s2[]=br.readLine().trim().split(" ");
    Queue<Integer> q2=new LinkedList<Integer>();
    for(int i=0;i<n;i++)
    {
        q2.add(Integer.parseInt(s2[i]));
    }
    check(n,q,q2);

}
private static void check(int n, Queue<Integer> q, Queue<Integer> q2) 
{
    int c=0;
    while(true)
    {   if(q.peek()!=q2.peek())
        {
            int a=q.peek();
            q.remove();
            q.add(a);               
            c++;
        }
        if(q.peek()==q2.peek())
        {
            q.remove();
            q2.remove();
            c++;
        }
        if(q.isEmpty()  )
        {
            break;
        }
    }
    System.out.println(c);  
}    
}