Tiago/master

GreedySolver.py

@@ -0,0 +1,29 @@
+class GreedySolver:
+
+    def __init__(self, endpoints, requests, caches):
+        self.endpoints = endpoints
+        self.requests = requests
+        self.caches = caches
+
+    def solve(self, req_eval_function):
+
+        for req in sorted(self.requests, key=req_eval_function):
+            end_point = req.endpoint()
+            caches_arrays = end_point.sorted_caches
+
+            # print("Processing req: {}".format(req))
+
+            for c in caches_arrays:
+
+                if req.to_video.number in self.caches[c.cache_number].videos:
+                    # print("repeated vid already in cache")
+                    break
+
+                cap = self.caches[c.cache_number].capacity
+                # print(c.cache_number, cap, req.size())
+                if cap - req.size() >= 0:
+                    self.caches[c.cache_number].add_video(req.to_video.number)
+                    self.caches[c.cache_number].capacity = cap - req.size()
+                    break
+
+        return self.caches

data/me_at_the_zoo.in

@@ -0,0 +1,144 @@
+100 10 100 10 100
+20 11 50 26 5 3 6 32 40 22 4 20 50 27 49 44 1 37 35 27 14 33 6 22 23 48 44 14 26 9 46 44 15 32 31 8 39 27 39 27 1 17 1 47 44 42 16 3 44 48 5 25 4 39 39 7 24 28 14 44 22 11 27 37 11 16 50 33 22 26 7 12 17 30 12 12 4 32 12 46 43 4 12 34 11 7 47 29 24 40 41 10 5 22 22 24 37 34 50 5
+1013 3
+0 170
+1 22
+2 224
+696 2
+0 7
+1 50
+1114 3
+1 202
+4 175
+5 2
+464 2
+1 24
+8 25
+522 5
+3 216
+5 155
+6 139
+7 208
+8 145
+321 4
+0 26
+2 70
+8 159
+9 92
+1288 2
+2 163
+9 153
+226 1
+7 86
+316 5
+4 236
+5 79
+6 9
+7 53
+8 67
+365 5
+2 225
+3 62
+5 141
+6 147
+9 66
+27 4 340
+13 8 249
+1 1 449
+24 4 279
+0 2 924
+8 4 862
+1 5 51
+0 9 837
+30 9 927
+0 8 167
+3 4 214
+0 4 59
+2 3 986
+7 2 785
+0 4 424
+16 9 996
+8 5 719
+89 1 297
+0 9 580
+19 5 748
+31 0 585
+2 5 853
+0 1 961
+8 0 186
+5 5 676
+81 2 120
+3 8 247
+16 5 620
+0 4 584
+8 5 935
+32 2 717
+8 2 396
+8 6 300
+34 3 752
+13 0 459
+4 9 997
+7 0 214
+13 2 934
+21 8 880
+0 3 158
+0 8 704
+1 6 988
+62 6 8
+1 8 300
+16 6 939
+7 1 116
+5 1 554
+17 2 605
+7 7 204
+0 6 264
+2 4 906
+16 8 93
+0 4 277
+99 0 772
+23 6 262
+1 7 552
+26 4 10
+1 0 884
+2 9 546
+0 8 583
+10 1 128
+3 3 899
+2 7 861
+1 8 211
+3 2 103
+74 7 885
+54 4 621
+0 1 930
+0 8 977
+30 8 882
+15 0 737
+0 3 931
+0 8 865
+44 8 267
+65 7 109
+4 8 859
+0 2 817
+0 4 306
+1 7 228
+26 0 194
+0 3 865
+10 9 280
+0 6 400
+5 9 537
+1 9 116
+2 9 179
+4 9 266
+46 1 435
+5 7 314
+4 6 512
+6 3 577
+10 2 709
+65 0 926
+82 5 720
+54 7 671
+16 3 70
+43 6 331
+10 3 849
+11 7 301
+1 3 409

input_parser.py

@@ -1,75 +1,129 @@
 # ----- CLASSES
+import GreedySolver
+from collections import OrderedDict
 
 class Video:
-	def __init__(self, number, size):
-		self.number = number
-		self.size = size
+    def __init__(self, number, size):
+        self.number = int(number)
+        self.size = int(size)
 
-	def __repr__(self):
-		return "number: %s, size: %s" % (self.number, self.size)
+    def __str__(self):
+        return "{} s: {}".format(self.number, self.size)
 
 class Endpoint:
-	def __init__(self, number, datacenter_latency):
-		self.number = number
-		self.datacenter_latency = datacenter_latency
-		self.caches = []
+    def __init__(self, number, datacenter_latency):
+        self.number = number
+        self.datacenter_latency = int(datacenter_latency)
+        self.caches = []
 
-	def __repr__(self):
-		return "number: %s, datacenter_latency: %s, caches: %s" % (self.number, self.datacenter_latency, self.caches)
+    def __str__(self):
+        return "{}".format(self.number)
+
+    def sort_caches(self):
+        self.sorted_caches = sorted(self.caches, key=lambda c: c.latency)
 
 class CacheConnection:
-	def __init__(self, cache_number, latency):
-		self.cache_number = cache_number
-		self.latency = latency
+    def __init__(self, cache_number, latency, capacity):
+        self.cache_number = cache_number
+        self.latency = int(latency)
+        self.capacity = int(capacity)
+        self.videos = []
+
+    def __repr__(self):
+        return "id: {} - lat: {}".format(self.cache_number, self.latency)
+
+    def add_video(self, vid):
+        self.videos.append(vid)
+
+    def get_videos(self):
+        return self.videos
 
-	def __repr__(self):
-		return "cache_number: %s, latency: %s" % (self.cache_number, self.latency)
+    def id(self):
+        return self.cache_number
 
 class Request:
-	def __init__(self, amount, to_video, from_endpoint):
-		self.amount = amount
-		self.to_video = to_video
-		self.from_endpoint = from_endpoint
+    def __init__(self, amount, to_video, from_endpoint):
+        self.amount = int(amount)
+        self.to_video = to_video
+        self.from_endpoint = from_endpoint
 
-	def __repr__(self):
-		return "amount: %s, to_video: %s, from_endpoint: %s" % (self.amount, self.to_video, self.from_endpoint)
+    def __str__(self):
+        return "endpoint:{} - vid {} - times: {}".format(self.from_endpoint, self.to_video, self.amount)
+
+    def endpoint(self):
+        return self.from_endpoint
+
+    def size(self):
+        return self.to_video.size
 
 # -------------
 
 class InputParser():
-	def parse(self):
-		# Getting how many things there are of each
-		self.n_videos, self.n_endpoints, self.n_requests, self.n_caches, self.size_caches = input().split(" ")
+    def parse(self):
+        # Getting how many things there are of each
+        self.n_videos, self.n_endpoints, self.n_requests, self.n_caches, self.size_caches = raw_input().split(" ")
+
+        # Getting videos
+        self.video_sizes = raw_input().split(" ")
+        self.videos = []
+        for video_number, video_size in enumerate(self.video_sizes):
+            self.videos.append(Video(video_number, video_size))
+
+        # Getting endpoints and connections to cache
+        self.endpoints = []
+        self.caches = OrderedDict()
+        for i in range(int(self.n_endpoints)):
+            datacenter_latency, n_connected_caches = raw_input().split(" ")
+            endpoint = Endpoint(i, datacenter_latency)
+            for j in range(int(n_connected_caches)):
+                cache_number, latency = raw_input().split(" ")
+                endpoint.caches.append(CacheConnection(cache_number, latency, self.size_caches))
+                self.caches[cache_number] = CacheConnection(cache_number, latency, self.size_caches)
+
+            self.endpoints.append(endpoint)
+
+        for e in self.endpoints:
+            e.sort_caches()
+
+        # Getting all requests
+        self.requests = []
+        for i in range(int(self.n_requests)):
+            video_number, endpoint_number, latency = raw_input().split(" ")
+            self.requests.append(Request(latency, self.videos[int(video_number)], self.endpoints[int(endpoint_number)]))
+
+        # print(self.videos, self.endpoints, self.requests)
+
+		# for v in self.videos:
+		#     print("Video: {}".format(v))
+
+		# print("Cache size: {}".format(self.size_caches))
+
+        solver = GreedySolver.GreedySolver(self.endpoints, self.requests, self.caches)
 
-		# Getting videos
-		self.video_sizes = input().split(" ")
-		self.videos = []
-		for video_number, video_size in enumerate(self.video_sizes):
-			self.videos.append(Video(video_number, video_size))
+        # greed on the number of times a video is requested
+        assigned_caches = solver.solve(lambda r: -r.amount)
 
-		# Getting endpoints and connections to cache
-		self.endpoints = []
-		for i in range(int(self.n_endpoints)):
-			datacenter_latency, n_connected_caches = input().split(" ")
-			endpoint = Endpoint(i, datacenter_latency)
-			for j in range(int(n_connected_caches)):
-				cache_number, latency = input().split(" ")
-				endpoint.caches.append(CacheConnection(cache_number, latency))
+        # print("-- Solution -- ")
+		# for k, ac in sorted(assigned_caches.items(), key=lambda t: int(t[0])):
+		#     print("cache {: 3d} : videos {}".format(int(k), sorted(ac.get_videos())))
+		# print("--")
 
-			self.endpoints.append(endpoint)
+        total_savings = 0
+        total_requests = 0
 
-		# Getting all requests
-		self.requests = []
-		for i in range(int(self.n_requests)):
-			video_number, endpoint_number, latency = input().split(" ")
-			self.requests.append(Request(latency, self.videos[int(video_number)], self.endpoints[int(endpoint_number)]))
+        for r in self.requests:
+            latency_used = min([ac.latency for ac in assigned_caches.values() if r.to_video.number in ac.videos] + [r.from_endpoint.datacenter_latency ])
+            gain = r.from_endpoint.datacenter_latency - latency_used
+            # print("req {} - DC Lat {} - Used Lat {} - gain {} * {}".format(r, r.from_endpoint.datacenter_latency, latency_used, gain, r.amount))
 
-		print(self.videos, self.endpoints, self.requests)
+            total_savings += gain * r.amount
+            total_requests += r.amount
 
+        print("SCORE: {}".format(total_savings * 1000 / total_requests))
 
 def main():
-	parser = InputParser()
-	parser.parse()
+    parser = InputParser()
+    parser.parse()
 
 if __name__ == '__main__':
-	main()
+    main()