private List <Tuple <Video, CachedServer, double> > GetBestVideoAssignments(int bulkSize)
{
var bestVideos = new List <Tuple <Video, CachedServer, double> >();
foreach (var video in _videoToDescription.Keys)
{
CachedServer bestServer = null;
double bestValue = 0;
foreach (var server in _input.CachedServers)
{
if (!IsServerAvailableForVideo(server, video))
{
continue;
}
var value = CalculateImprovement(video, server);
if (value > bestValue)
{
bestValue = value;
bestServer = server;
}
}
if (bestServer != null)
{
bestVideos.Add(new Tuple <Video, CachedServer, double>(video, bestServer, bestValue));
}
}
bestVideos.Sort((x, y) => - CalculateActualValue(x).CompareTo(CalculateActualValue(y)));
return(bestVideos.Take(bulkSize).ToList());
}
private void AssignVideoToServer(CachedServer selectedServer, Video video)
{
assigned++;
if (assigned % 200 == 0)
{
Console.WriteLine("Assigned " + assigned);
}
if (_output.ServerAssignments.GetOrDefault(selectedServer, new List <Video>()).Contains(video))
{
return;
}
selectedServer.Capacity -= video.Size;
_output.ServerAssignments.GetOrCreate(selectedServer, _ => new List <Video>()).Add(video);
foreach (var rr in _videoToDescription[video])
{
if (rr.Endpoint.ServersLatency.ContainsKey(selectedServer))
{
_currentTime.Remove(rr);
}
}
foreach (
var rr in
_serverToRequests.GetOrDefault(selectedServer, new HashSet <RequestsDescription>())
.Where(rrr => selectedServer.Capacity < rrr.Video.Size)
.ToList())
{
_bestTime.Remove(rr);
_serverToRequests[selectedServer].Remove(rr);
}
}
private double CalculateImprovement(Video video, CachedServer server)
{
double improvement = 0;
foreach (var req in _videoToDescription[video])
{
var current = _currentTime.GetOrCreate(req, CalculateCurrentTime);
var newTime = CalculateServerTimeForRequest(server, req);
improvement += req.NumOfRequests * (current - newTime);
}
return(improvement);
}
public override ProblemOutput GetResultFromReader(ProblemInput input, TextReader reader)
{
ProblemOutput output = new ProblemOutput {
ServerAssignments = new Dictionary <CachedServer, List <Video> >()
};
var n = reader.GetInt();
for (int i = 0; i < n; i++)
{
var vals = reader.GetIntList();
var server = new CachedServer(vals[0]);
output.ServerAssignments.Add(server, new List <Video>());
foreach (var v in vals.Skip(1))
{
output.ServerAssignments[server].Add(new Video(v));
}
}
return(output);
}
private double CalculateServerTimeForRequest(CachedServer cachedServer, RequestsDescription request)
{
return(request.Endpoint.ServersLatency.GetOrDefault(cachedServer, request.Endpoint.DataCenterLatency));
}
private bool IsServerAvailableForVideo(CachedServer cachedServer, Video video)
{
return(video.Size <= cachedServer.Capacity);
}
protected override ProblemInput ParseFromStream(TextReader reader)
{
ProblemInput input = new ProblemInput();
string[] firstLineSplited = reader.ReadLine().Split(' ');
input.NumberOfVideos = int.Parse(firstLineSplited[0]);
input.NumberOfEndpoints = int.Parse(firstLineSplited[1]);
input.NumberOfRequestDescription = int.Parse(firstLineSplited[2]);
input.NumberOfCachedServers = int.Parse(firstLineSplited[3]);
input.ServerCapacity = int.Parse(firstLineSplited[4]);
input.CachedServers = new List <CachedServer>();
for (int i = 0; i < input.NumberOfCachedServers; i++)
{
input.CachedServers.Add(new CachedServer(i)
{
Capacity = input.ServerCapacity
});
}
string[] videos = reader.ReadLine().Split(' ');
input.Videos = new List <Video>();
for (int i = 0; i < videos.Length; i++)
{
Video video = new Video(i);
video.Size = int.Parse(videos[i]);
input.Videos.Add(video);
}
input.Endpoints = new List <_2017_Qualification.EndPoint>();
for (int index = 0; index < input.NumberOfEndpoints; index++)
{
string[] currDescription = reader.ReadLine().Split(' ');
EndPoint endPoint = new _2017_Qualification.EndPoint(index);
input.Endpoints.Add(endPoint);
endPoint.DataCenterLatency = int.Parse(currDescription[0]);
endPoint.ServersLatency = new Dictionary <CachedServer, int>();
for (int i = 0; i < int.Parse(currDescription[1]); i++)
{
string[] latencyServer = reader.ReadLine().Split(' ');
CachedServer server = input.CachedServers[int.Parse(latencyServer[0])];
int latency = int.Parse(latencyServer[1]);
endPoint.ServersLatency.Add(server, latency);
}
}
input.RequestsDescriptions = new List <RequestsDescription>();
for (int i = 0; i < input.NumberOfRequestDescription; i++)
{
string[] reqDesc = reader.ReadLine().Split(' ');
RequestsDescription desc = new _2017_Qualification.RequestsDescription(i);
desc.NumOfRequests = int.Parse(reqDesc[2]);
desc.Video = input.Videos[int.Parse(reqDesc[0])];
desc.Endpoint = input.Endpoints[int.Parse(reqDesc[1])];
input.RequestsDescriptions.Add(desc);
}
return(input);
}
