Algorithm 考虑持续时间和无重叠的最佳电影时间表

Algorithm 考虑持续时间和无重叠的最佳电影时间表,algorithm,Algorithm,我正在努力寻找解决这个问题的好策略。我曾考虑过按持续时间对电影集进行排序,但这似乎掩盖了重叠的情况。有什么想法吗 我考虑的另一件事是根据开始月份进行排序,然后将其作为 向演员提供一套特定(开始月份和结束月份)的电影 持续时间)。你必须选择演员应该做的电影 这位演员可以在一年中拍最多的电影,没有任何限制 重叠 假设电影从一个月的第一天开始,到第二天结束 最后一天。月数为30天(不需要?) 把你的电影列表按结束日期排序。对于每部电影,您需要解决“到本电影结束时,我可以演的电影的最大数量是多少”。这可

我正在努力寻找解决这个问题的好策略。我曾考虑过按持续时间对电影集进行排序,但这似乎掩盖了重叠的情况。有什么想法吗

我考虑的另一件事是根据开始月份进行排序,然后将其作为

向演员提供一套特定(开始月份和结束月份)的电影 持续时间)。你必须选择演员应该做的电影 这位演员可以在一年中拍最多的电影,没有任何限制 重叠

假设电影从一个月的第一天开始,到第二天结束 最后一天。月数为30天(不需要?)


把你的电影列表按结束日期排序。对于每部电影,您需要解决“到本电影结束时,我可以演的电影的最大数量是多少”。这可以递归地作为最新电影的结果的最大值,或者是一个加上在本电影开始之前结束的最新电影的结果的最大值


第一个案例对应于“我没有在这部电影中演出,所以在这段时间内我可以继续拍其他电影。”第二个案例对应于“我在这部电影中演出,但没有在这部电影开始之前结束的任何电影。”我写了一些代码来演示解决方案。整体的本质与什么相似。第一件事是按电影的结束时间对电影进行排序。现在,贪婪的第一个选择总是被选中

为什么选择第一个选项有效?

在我们的例子中,我们订购的
A
有第一部电影,一些
A
。假设有另一个排序
B
,其中第一部电影是一些
B
,例如
B
≠ <代码>a。必须有一个排序(我们已经知道
A
)这样,
A
={
B
-{
B
}}U{
A
}
。显然,在
B
的情况下,
B
的时间最短;自
b
≠ <代码>a
持续时间(
b
)>=持续时间(
a

public class Optimum_Movie_Schedule {

    public static void main(String[] args) {
        Movie[] movies = new Movie[] {
            new Movie("f", 5, 9),
            new Movie("a", 1, 2),
            new Movie("b", 3, 4),
            new Movie("c", 0, 6),
            new Movie("d", 5, 7),
            new Movie("e", 8, 9)
        };

        // sort by endMonth; startMonth if endMonth clash
        Arrays.sort(movies);
        System.out.println(Arrays.toString(movies));

        System.out.println("Final list: ");
        System.out.print(movies[0] + " ");

        int cur = 0;
        for(int i = 1 ; i < movies.length ; i++) {
            if(movies[i].startMonth > movies[cur].endMonth) {
                System.out.print(movies[i] + " ");
                cur = i;
            }
        }
    }

    static class Movie implements Comparable<Movie> {
        String name;
        int startMonth;
        int endMonth;
        int duration;
        public Movie(String name, int start, int end) {
            this.name = name;
            this.startMonth = start;
            this.endMonth = end;
            this.duration = (end + 1) - start;
        }

        public int compareTo(Movie o) {
            if(this.endMonth < o.endMonth)
                return -1;

            if(this.endMonth == o.endMonth)
                if(this.startMonth < o.startMonth)
                    return -1;

            return 1;
        }

        public String toString() {
            return name + "("+ startMonth + ", " + endMonth + ")";
        }
    }
}
公共课最佳电影时间表{
公共静态void main(字符串[]args){
电影[]电影=新电影[]{
新电影(“f”,5,9),
新电影(“a”,1,2),
新电影(“b”,3,4),
新电影(“c”,0,6),
新电影(“d”,5,7),
新电影(“e”,8,9)
};
//按endMonth排序;如果endMonth冲突,则开始每月
数组。排序(电影);
System.out.println(array.toString(movies));
System.out.println(“最终列表:”);
系统输出打印(电影[0]+“”);
int cur=0;
for(int i=1;imovies[cur].endMonth){
系统输出打印(电影[i]+“”);
cur=i;
}
}
}
静态类电影实现{
字符串名;
int startMonth;
月内;
int持续时间;
公共电影(字符串名称、整数开始、整数结束){
this.name=名称;
this.startMonth=开始;
this.endMonth=结束;
this.duration=(end+1)-开始;
}
公共int比较(电影o){
如果(本月底
从子问题的角度思考:我建议“他能参加的电影最多,在某个月结束。”@EdwardPeters我想我明白你的意思了。但是,在这种方法中,持续时间是如何适应的呢?在这里,我将给出一个完整的答案。这就是间隔调度问题。贪婪的方法是最优的-只需尝试按完成时间排序(按开始日期+持续时间计算)。挑选那些完成得最快的,并且与已经挑选的没有重叠的。@EdwardPeters谢谢你,伙计!我想我明白这是怎么回事了。谢谢你的回复+1刚刚添加了一些代码,从您的想法中获取线索。抱歉没有早点回到这个问题上来。