Java 如何找到能够执行任务的最大参与人数？

我正在尝试解决一个问题，该问题的描述如下：

一次只有一个人可以在舞台上表演，每个参与者的到达时间和持续时间以数组的形式给出。查找可以执行的最大参与者数

例如：

到达时间：[1,3,3,5,7]

持续时间：[2,2,1,2,1]

答案是4，即1-3；3-5或3-4；5-7; 7-8

因此，我可以从中找到每个参与者的退出时间。当计时存在重叠时，如何找到可能的最大事件数

我尝试过的代码是：

int count = 1;
        
for(int i=0;i<entry.size()-1;i++) {
    if(entry.get(i) < exit.get(i+1)) {
        count++;
    }
}
        
return count;

int count=1；
对于（int i=0；i更新了答案，因为添加了一个新的测试用例，这清楚地表明，如果执行者的到达时间相同，则可以重新排序。
第二次更新：根据每个执行者的结束时间（到达时间+持续时间）对输入进行排序。
保留当前执行者的结束时间。只有在当前执行者结束后到达的执行者才能执行

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LifeGig {

    public static class Performer {
        int arrival, duration;

        Performer(int arrival, int duration) {
            this.arrival = arrival;
            this.duration = duration;
        }

        @Override
        public String toString() {
            return "Performer [arrival=" + arrival + ", duration=" + duration + "]";
        }
    }

    public List<Performer> program(int[] entry,int[] duration)
    {
        List<Performer> performers=new ArrayList<>();
        for(int i=0;i<entry.length;i++)
        {
            performers.add(new Performer(entry[i],duration[i]));
        }
        Collections.sort(performers, new Comparator<Performer>() {
            @Override
            public int compare(Performer p1, Performer p2) {
                return Integer.compare(p1.arrival+p1.duration, p2.arrival+p2.duration);
            }
        });
        List<Performer> festival=new ArrayList<>();
        System.out.println(performers);
        int currentTime = 1;
        for (Performer p:performers) {
            if (p.arrival >= currentTime) {
                currentTime = p.arrival+p.duration;
                festival.add(p);
            }
        }
        return festival;
    }
    public static void test1()
    {
        int[] entry = new int[] {1,3,3,5,7};
        int[] duration = new int[] {2,2,1,2,1};
        List<Performer> festival=new LifeGig().program(entry,duration);
        System.out.println("Count (Expected=4): " + festival.size());
        System.out.println("lineup:"+festival);
    }

    public static void test2()
    {
        int[] entry = new int[] {1, 1, 1, 1, 4};
        int[] duration = new int[] {10, 3, 6, 4, 2};
        List<Performer> festival=new LifeGig().program(entry,duration);
        System.out.println("Count (Expected=2): " + festival.size());
        System.out.println("lineup:"+festival);
    }
    public static void test3()
    {
        int[] entry = new int[] {1,2,3,4};
        int[] duration = new int[] {10, 1,1,1,};
        List<Performer> festival=new LifeGig().program(entry,duration);
        System.out.println("Count (Expected=3): " + festival.size());
        System.out.println("lineup:"+festival);

    }

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }

}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.List；
公务舱救生艇{
公共静态类表演者{
int到达，持续时间；
执行者（整数到达，整数持续时间）{
这个。到达=到达；
这个。持续时间=持续时间；
}
@凌驾
公共字符串toString（）{
return“Performer[arrival=“+arrival+”，duration=“+duration+”]”；
}
}
公共列表程序（int[]条目，int[]持续时间）
{
List performers=new ArrayList（）；
for（int i=0；i=currentTime）{
currentTime=p.到达时间+p.持续时间；
添加（p）；
}
}
回归节；
}
公共静态void test1（）
{
int[]entry=newint[]{1,3,3,5,7}；
int[]duration=新的int[]{2,2,1,2,1}；
List festival=new LifeGig（）.程序（条目、持续时间）；
System.out.println（“计数（预期=4）：”+festival.size（））；
System.out.println（“阵容：+festival”）；
}
公共静态void test2（）
{
int[]entry=newint[]{1,1,1,4}；
int[]duration=新的int[]{10,3,6,4,2}；
List festival=new LifeGig（）.程序（条目、持续时间）；
System.out.println（“计数（预期=2）：”+festival.size（））；
System.out.println（“阵容：+festival”）；
}
公共静态void test3（）
{
int[]entry=newint[]{1,2,3,4}；
int[]duration=newint[]{10,1,1,1，}；
List festival=new LifeGig（）.程序（条目、持续时间）；
System.out.println（“计数（预期=3）：”+festival.size（））；
System.out.println（“阵容：+festival”）；
}
公共静态void main（字符串[]args）{
test1（）；
test2（）；
test3（）；
}
}
问题陈述不够具体。两个人到达3时会发生什么？他们会一个接一个地执行吗？或者他们中的一个只能执行吗？示例的答案是什么，为什么？@ThomasKläger一次只能执行一个，@user3386109我添加了answer@user3386109是的，我也这么认为，但我是一个DP有点弱，会从这方面的帮助中受益匪浅。仍然有一些测试用例失败，例如：[1,1,1,1,4]和持续时间[10,3,6,4,2]应该给出2，但这会给出1当您有这样的[1,2,3,4]和持续时间[10,1,1,1]时，这不会失败？应该给出3，但给出1