超出时间异常java时间限制的问题

我必须解决一个问题，函数“Thor”接收3个数组列表和一个int，算法必须上传到一个页面，以确认函数是否正确，在第一次测试中，页面返回预期的结果，但在继续测试时，返回“超出时间限制，代码使用了太多CPU”。我需要帮助解决这个问题，谢谢

import java.util.*;

public class microondas {
    public static long thor(ArrayList<Integer> a, ArrayList<Integer> f, ArrayList<Integer> p, int D) {
        long acumu,peso,altura,fuerza,distancia;
        acumu=0;
        for(int i=0;i<a.size();i++) {
                for(int s=0;s<p.size();s++) {
                    peso=p.get(s);
                    altura=a.get(i);
                    fuerza=f.get(i);
                    distancia=(altura*fuerza)/peso;
                    if(distancia>=D) {
                    acumu+=1;   
                }
            }
        }
        return acumu;
    }
}

import java.util.*；
公共级微型恐龙{
公共静态长thor（ArrayList a、ArrayList f、ArrayList p、int D）{
长阿库姆、比索、阿尔图拉、富尔扎、距离；
acumu=0；
对于（int i=0；i，在本代码中，只有基本的微观优化是可能的：不需要在嵌套循环中计算
altura
/
fuerza
，因为这些变量取决于第一个循环。
此外，可以将除以常量值的操作移到嵌套循环之外：

a.get(i) * f.get(i) / f.get(s) >= D is the same as a.get(i) * f.get(i) / D >= f.get(s)

publicstaticlongthor（arraylista、arraylistf、arraylistp、intd）{
长acumu=0；
int-iters=0；
对于（int i=0，n=a.size（）；i=比索）{
acumu++；
}
iters++；
}
}
System.out.println（“thor迭代：+iters”）；
归穴；
}

然而，它不太可能帮助解决TLE，因为该代码无论如何都具有复杂性
O（N*M）
，其中
N
是
a
/
f
的大小，
M
是
p
的大小

进一步优化可以是：


对产品清单进行预计算和排序
排序列表
p
当迭代list
p
时，记住最后一个有效的
peso
的索引，以丢弃包含小值的尾部
一些快捷方式是可能的：

如果最大的产品小于最小的
比索
，则可能会丢弃所有产品，并返回0
如果最大的比索小于或等于最小乘积，则结果为
product.size（）*p.size（）



publicstaticlong（列表a、列表f、列表p、int D）{
集合排序（p）；
列表产品=新的ArrayList（）；
对于（int i=0，n=a.size（）；iList<Integer> a = Arrays.asList(1, 0, 2, 3, 4, 5, 8);
List<Integer> f = Arrays.asList(2, 3, 4, 4, 6, 1, 0);
List<Integer> p = Arrays.asList(3, 4, 5, 8, 10);

System.out.println("thor: " + thor(a, f, p, 2));
System.out.println("thorFaster: " + thorFaster(a, f, p, 2));

thor iterations: 35
thor: 10
thorFaster iterations: 13
thorFaster: 10