[Swift]LeetCode729.我的日程安排表I|MyCalendarI

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› 移动开发›Swift 教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10518737.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Implement a MyCalendar class to store your events. A new event can be added if adding the event will not cause a double booking.

Your class will have the method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A double booking happens when two events have some non-empty intersection (ie., there is some time that is common to both events.)

For each call to the method MyCalendar.book, return true if the event can be added to the calendar successfully without causing a double booking. Otherwise, return false and do not add the event to the calendar.

Your class will be called like this: MyCalendar cal = new MyCalendar();MyCalendar.book(start, end)

Example 1:

MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false
MyCalendar.book(20, 30); // returns true
Explanation: 
The first event can be booked.  The second can't because time 15 is already booked by another event.
The third event can be booked, as the first event takes every time less than 20, but not including 20.

Note:

The number of calls to MyCalendar.book per test case will be at most 1000.
In calls to MyCalendar.book(start, end), start and end are integers in the range [0, 10^9].

实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排，则可以存储这个新的日程安排。

MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end。

当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生重复预订。

每次调用 MyCalendar.book方法时，如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true。否则，返回 false 并且不要将该日程安排添加到日历中。

请按照以下步骤调用 MyCalendar 类: MyCalendar cal = new MyCalendar();MyCalendar.book(start, end)

示例 1:

MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false
MyCalendar.book(20, 30); // returns true
解释: 
第一个日程安排可以添加到日历中.  第二个日程安排不能添加到日历中，因为时间 15 已经被第一个日程安排预定了。
第三个日程安排可以添加到日历中，因为第一个日程安排并不包含时间 20 。

说明:

每个测试用例，调用 MyCalendar.book 函数最多不超过 100次。
调用函数 MyCalendar.book(start, end)时， start 和 end 的取值范围为 [0, 10^9]。

552ms

 1 class MyCalendar {
 2     var root: Node?
 3     init() {}
 4     
 5     func book(_ start: Int, _ end: Int) -> Bool {        
 6         if self.root == nil{
 7             self.root = Node(start, end)
 8             return true
 9         }
10         return self.root?.insert(start: start, end: end) ?? false
11     }
12 }
13 
14 class Node {
15     var start = 0
16     var end = 0
17     var smallLeft: Node?
18     var bigRight: Node?
19     init(_ start:Int, _ end:Int) {
20         self.start = start
21         self.end = end
22     }  
23     unc insert(start:Int, end:Int) -> Bool {           
24         if end <= self.start {
25             if self.smallLeft == nil {
26                 self.smallLeft = Node(start, end)
27                 return true
28             }
29             return self.smallLeft?.insert(start: start, end: end) ?? false
30         }
31         else if start >= self.end {
32             if self.bigRight == nil {
33                 self.bigRight = Node(start, end)
34                 return true            
35             }
36             return self.bigRight?.insert(start: start, end: end) ?? false
37         }  
38         return false
39     }
40 }
41 /**
42  * Your MyCalendar object will be instantiated and called as such:
43  * let obj = MyCalendar()
44  * let ret_1: Bool = obj.book(start, end)
45  */

556ms

 1 class MyCalendar {
 2     var root: Node?
 3     
 4     init() {
 5         root = nil
 6     }
 7     
 8     func book(_ start: Int, _ end: Int) -> Bool {
 9         var event = Event.init(start, end)        
10         if (root == nil) {
11             root = Node.init(event)
12             return true
13         }        
14         return root!.insert(root!, event)
15     }
16 }
17 
18 struct Event {
19     var start: Int = 0
20     var end: Int = 0
21     
22     init(_ start: Int, _ end: Int) {
23         self.start = start
24         self.end = end
25     }
26     
27     func overlaps(_ input: Event)-> Bool {
28         if (self.end <= input.start) || (self.start >= input.end) {
29             return true
30         }
31         else {
32             return false
33         }
34     }
35 }
36 
37 class Node {
38     var event: Event
39     var left: Node?
40     var right: Node?
41     
42     init(_ event: Event) {
43         self.event = event
44         self.left = nil
45         self.right = nil
46     }
47     
48     func insert(_ node: Node, _ event: Event)-> Bool {
49         if (event.end <= node.event.start) {
50             if node.left == nil {
51                 node.left = Node.init(event)
52                 return true
53             }
54             else {
55                 return insert(node.left!, event)
56             }
57         }
58         else if (event.start >= node.event.end) {
59             if (node.right == nil) {
60                 node.right = Node.init(event)
61                 return true
62             }
63             else {
64                 return insert(node.right!, event)
65             }
66         }
67         else {
68             return false
69         }
70     }
71 }

564ms

 1 class MyCalendar {
 2     var tree = Tree()
 3     
 4     init() {
 5         
 6     }   
 7 
 8     func book(_ start: Int, _ end: Int) -> Bool {
 9         guard start >= 0, end >= 0, end > start else {
10             return false 
11         } 
12         
13         let node = Node((start,end))
14         return tree.insert(node)        
15     }
16 }
17 
18 class Node {
19     var start: Int
20     var end: Int 
21     var left: Node?
22     var right: Node?
23     init(_ book: (Int, Int)) {
24         start = book.0
25         end = book.1
26     }
27 }
28 
29 class Tree {    
30     var root: Node?
31 
32     func insert(_ node: Node, at root: Node) -> Bool {    
33         if node.start  >= root.start && node.start < root.end {
34             return false 
35         }
36         
37         if node.end <= root.start, let left = root.left {
38             return insert(node, at: left)
39         } else if node.start >= root.end, let right = root.right {
40             return insert(node, at: right)
41         } else {
42             if node.end <= root.start {
43                 root.left = node
44                 return true
45             }
46             
47             if node.start >= root.end {
48                 root.right = node
49                 return true
50             }
51         }
52         return false
53     }
54     
55     func insert(_ node: Node) -> Bool {
56         guard let root = self.root else {
57             self.root = node
58             return true
59         }        
60         return insert(node, at: root)                
61     }    
62 }

Runtime: 1104 ms

Memory Usage: 20.1 MB

 1 class MyCalendar {
 2     var cal:[(Int,Int)]
 3 
 4     init() {
 5         cal = [(Int,Int)]()        
 6     }
 7     
 8     func book(_ start: Int, _ end: Int) -> Bool {
 9         for val in cal
10         {
11             if max(val.0, start) < min(val.1, end)
12             {
13                 return false
14             }            
15         }
16         cal.append((start, end))
17         return true      
18     }
19 }
20 /**
21  * Your MyCalendar object will be instantiated and called as such:
22  * let obj = MyCalendar()
23  * let ret_1: Bool = obj.book(start, end)
24  */