Java 计算从一开始浏览列表的次数

我正在尝试解决以下网站中的问题A（称为任务管理）：

基本上，我们得到一个从1到n的未排序整数列表，我们希望按顺序访问整数（即从1,2,3,4,5，….n）。在我们以递增的顺序访问从1到n的所有整数之前，我们必须转到列表的开头多少次

---

假设我们有这样一个列表：3 2 1。在第一次浏览列表期间，我们只访问数字1，在第二次浏览列表期间，我们只访问数字2，在第三次浏览期间，我们最终访问数字3。所以我们必须把这个清单翻三遍

这是我的密码：

import java.util.Scanner;
import java.util.ArrayList;


class TaskManagement{

// arr: array of tasks
static int countNumberOfLoops(ArrayList<Integer> arr){
    int targetTask = 1;
    // Last task to close
    int finalTask = arr.size();
    int index=0;
    int count =0;

    while(targetTask != finalTask+1){
        if(index%arr.size()==0) count++;
        if(arr.get(index%arr.size())==targetTask) targetTask++;
        index++;
    }
    System.out.println(count);
    return count;
}

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    // make a static array of size n
    ArrayList<Integer> arr = new ArrayList<Integer>();

    for (int i=0; i<n; i++) {
        int item = scan.nextInt();
        arr.add(item);
    }

    countNumberOfLoops(arr);
}
}

import java.util.Scanner；
导入java.util.ArrayList；
班级任务管理{
//arr：任务数组
静态int countNumberOfLoops（ArrayList arr）{
int targetTask=1；
//要关闭的最后一个任务
int finalTask=arr.size（）；
int指数=0；
整数计数=0；
while（targetTask！=最终任务+1）{
如果（索引%arr.size（）==0）计数++；
如果（arr.get（索引%arr.size（））==targetTask）targetTask++；
索引++；
}
系统输出打印项次（计数）；
返回计数；
}
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
int n=scan.nextInt（）；
//制作一个大小为n的静态数组
ArrayList arr=新的ArrayList（）；
对于（inti=0；i，已发布一篇社论：

考虑一个复杂度为O（n^2）的解决方案。使用变量跟踪
上一个已结束的任务，并从头到尾浏览任务列表
到最后。穿过元素时增加计数器
对应于下一个任务。约束非常大，所以
此解决方案不符合时间限制

当我们可以的时候是什么情况
在列表末尾没有找到任何合适的任务？只有
一个案例：任务编号（x + 1） 更接近世界的开始
然后列出关闭的任务编号x。因此，为了解决问题，我们
可以确定每个任务在任务列表中的位置并计算
不同数字的数量x，以便任务编号的位置
(十) + 1） 小于任务编号x的位置

别忘了
考虑通过任务列表的第一遍。最后的复杂性
解为O（n）

循环遍历所有数字，并将它们出现的索引存储在哈希表或普通数组中，因为数字介于1-n之间。
例如，如果数字是3、4、5、2、1
这将导致像这样的散列

{
1 -> 4,
2 -> 3,
3 -> 0,
4 -> 1,
5 -> 2
}

从1循环到n-1，找到第i个和（i+1）个元素的索引

循环计数=0

loopCount = 0;
for (int i=1; i<n; i++) {
    if (Index[i] > Index[i+1]) {
        loopCount++;
    }
}

loopCount=0；
对于（int i=1；i索引[i+1]）{
loopCount++；
}
}

时间复杂度O（n）
为什么不使用排序算法对输入进行排序？在没有额外信息的情况下对未排序的列表进行排序在
Omega（n*log（n））中工作
。还是我误解了你的问题？输入到底是什么，预期的输出是什么？假设我们有一个类似于：3 2 1的列表。在第一次运行列表时，我们只访问数字1，在第二次运行列表时，我们只访问数字2，在第三次运行期间，我们最终访问数字3。因此，我们必须把这个列表看3遍。让我重新表述一下，对我来说，听起来你想对给定的列表进行排序，你的排序算法在
O（n^2）
中工作，但是有更好的排序算法在
Omega（n*log（n））中工作
，例如Quicksort、MergeSort或HeapSort等等：。那么为什么不实施其中一种呢？目标不是对列表进行排序。目标是计算从开始到结束，直到我们按递增顺序访问所有数字之前，我们必须遍历列表的次数。具体的模型是什么？允许随机访问吗？I ask，因为您得到了一个允许随机访问的
ArrayList
，所以
list.get（i）
是可能的。或者您的模型只允许您从开始到结束进行迭代，而不是随机地遍历所有位置？或者允许您在已经允许的位置继续，就像
LinkedList
一样（还有
ArrayList
）。如果只允许从开始到结束进行迭代，那么当然没有更好的解决方案，
[3,2,1]
产生3次迭代…您的解决方案实际上可以工作，但循环计数必须以1而不是零开始。因为在1 2 3 4的情况下，您只会遍历列表一次，而不会增加循环计数。