private static void SolutionOne(int simulationTime, List <Street> streets, List <Car> cars, StringBuilder outputBuilder)
{
cars = cars.Where(x => x.MinimumTravelTime() < simulationTime).ToList();
var trafficLights = streets
.GroupBy(x => x.End)
.ToDictionary(x => x.Key, x => x.ToList());
var streetUsage = cars
.SelectMany(c => c.Streets.SkipLast(1))
.GroupBy(x => x)
.ToDictionary(x => x.Key, x => x.ToList().Count);
var firstStreets = cars.Select(x => x.FirstStreet());
var countFirstStreets = firstStreets.GroupBy(c => c)
.ToDictionary(x => x.Key, x => x.ToList().Count);
var schedules = new List <IntersectionSchedule>();
foreach (var trafficLight in trafficLights)
{
if (trafficLight.Value.Where(x => streetUsage.ContainsKey(x)).Any())
{
var schedule = new IntersectionSchedule();
schedule.Intersection = trafficLight.Key;
var prioStreets = trafficLight.Value.Select(x => new
{
Street = x,
count = countFirstStreets.ContainsKey(x) ? countFirstStreets[x] : 0
}).OrderByDescending(x => x.count);
foreach (var street in prioStreets)
{
if (streetUsage.ContainsKey(street.Street))
{
schedule.Schedule.Add(new Street
{
Name = street.Street.Name,
Seconds = Math.Max(Math.Min(streetUsage[street.Street], street.Street.Seconds), 1)
});
}
}
schedules.Add(schedule);
}
}
WriteOutput(outputBuilder, schedules);
}
private static OutPutFile ScheduleIntersection(TrafficLights trafficLights)
{
OutPutFile outPutFile = new OutPutFile();
List <IntersectionSchedule> intersectionScheduleList = new List <IntersectionSchedule>();
int intersections = trafficLights.NumOfIntersection;
int streets = trafficLights.NumOfStreets;
int cars = trafficLights.NumOfCars;
var UniqueIntersections = trafficLights.streets.Select(p => p.IntersectionEndStreet).Distinct().ToList();
for (int i = 0; i < UniqueIntersections.Count; i++)
{
bool intersectionNotUsed = false;
int currentIntersection = UniqueIntersections[i];
var allcarPaths = trafficLights.carPaths;
var allStreets = trafficLights.streets.Where(p => p.IntersectionEndStreet == currentIntersection).ToList();
IntersectionSchedule intersectionSchedule = new IntersectionSchedule();
intersectionSchedule.NumberncomingOfStreets = 0;
intersectionSchedule.NumberncomingOfStreets = allStreets.Count;
intersectionSchedule.IntersectionID = currentIntersection;
foreach (var street in allStreets)
{
var beginStreet = allcarPaths.Where(p => p.StreetName.IndexOf(street.StreetName) == 0).ToList();
var endStreet = allcarPaths.Where(p => p.StreetName.IndexOf(street.StreetName) == p.StreetName.Count - 1).ToList();
if (beginStreet.Count == 0 &&
endStreet.Count == allStreets.Count)
{
intersectionNotUsed = true;
}
if (intersectionNotUsed)
{
intersectionSchedule = null; continue;
}
//for (int j = 0; j < cars; j++)
//{
// var path = trafficLights.carPaths[j];
// var firstStreetName = path.StreetName[0];
var currentStreet = street;// trafficLights.streets.Where(p => p.StreetName == firstStreetName).FirstOrDefault();
//var intersectionStreets = trafficLights.streets.Where(p => p.IntersectionEndStreet == intersectionSchedule.IntersectionID).ToList(); // || p.IntersectionStartStreet == intersectionSchedule.IntersectionID
//foreach (var istreet in intersectionStreets)
{
OrderNDurationGreenLight orderNDurationGreenLight = new OrderNDurationGreenLight();
orderNDurationGreenLight.StreetName = currentStreet.StreetName;
//second + 1 for car passing
int isStartofPath = 0;
foreach (var carPath in allcarPaths)
{
if (carPath.StreetName[0] == currentStreet.StreetName)
{
isStartofPath = 1;
}
}
//orderNDurationGreenLight.GreenSeconds = currentStreet.TimeStartEndStreet + isStartofPath;
orderNDurationGreenLight.GreenSeconds = 1 + isStartofPath;
intersectionSchedule.orderNDurationGreenLights.Add(orderNDurationGreenLight);
}
//}
}
if (intersectionSchedule != null)
{
intersectionSchedule.orderNDurationGreenLights = intersectionSchedule.orderNDurationGreenLights.OrderByDescending(p => p.GreenSeconds).ToList();
intersectionScheduleList.Add(intersectionSchedule);
intersectionScheduleList = intersectionScheduleList.OrderByDescending(p => p.NumberncomingOfStreets).ToList();
decimal IntersectionPercentage = (decimal)intersectionScheduleList.Count / (decimal)UniqueIntersections.Count;
Console.WriteLine(intersectionScheduleList.Count + " / " + UniqueIntersections.Count +
" = " + IntersectionPercentage);
}
}
outPutFile.intersectionSchedules = intersectionScheduleList;
outPutFile.NumIntersectionHasSchedule = intersectionScheduleList.Count;
return(outPutFile);
}
public static void SubMain()
{
var file = "a.txt";
var input = $@"input\{file}";
var lines = File.ReadAllLines(input);
var line0 = lines[0].Split(" ");
int D = int.Parse(line0[0]); // the duration of the simulation, in seconds
int I = int.Parse(line0[1]); // the number of intersections (with IDs from 0 to I -1 )
int S = int.Parse(line0[2]); // the number of streets
int V = int.Parse(line0[3]); // the number of cars
int F = int.Parse(line0[4]); // the bonus points for each car that reaches its destination before time
//Console.WriteLine($"Duration: {D}");
//Console.WriteLine($"Intersections: {I}");
//Console.WriteLine($"Streets: {S}");
//Console.WriteLine($"Cars: {V}");
//Console.WriteLine($"Bonus: {F}");
var streets = lines.Skip(1).Take(S).Select(x => x.Split(" "))
.Select(S => new Street {
B = int.Parse(S[0]), E = int.Parse(S[1]), Name = S[2], L = int.Parse(S[3])
})
.ToDictionary(k => k.Name, vv => vv);
var cars = lines.Skip(S + 1).Take(V).Select(x => x.Split(" "))
.Select(S => new Car(streets.Values.ToArray(), S.Skip(1).ToArray())
{
P = int.Parse(S[0])
}).ToArray();
//streets.All(S => { Console.WriteLine(S); return true; });
foreach (var c in cars)
{
var carStreet = streets[c.Names[0]];
carStreet.CarsAtEnd.Enqueue(c);
}
//cars.All(S => { Console.WriteLine(S); return true; });
var intersections = new List <Intersection>();
foreach (var inter in streets.Values.Select(x => x.E).Union(streets.Values.Select(xx => xx.B)).Distinct())
{
intersections.Add(new Intersection {
Id = inter
});
}
foreach (var inters in intersections)
{
inters.Incoming.AddRange(streets.Values.Where(S => S.E == inters.Id));
inters.Outgoing.AddRange(streets.Values.Where(S => S.B == inters.Id));
}
var travellingCars = new List <Car>();
var greenIntersections = new List <IntersectionSchedule>();
for (int i = 0; i < D; i++)
{
foreach (var trCar in travellingCars.Where(x => !x.IsFinito).ToArray())
{
trCar.TimeToEnd--;
if (trCar.TimeToEnd == 0)
{
streets[trCar.Names[trCar.Position]].CarsAtEnd.Enqueue(trCar);
travellingCars.Remove(trCar);
}
}
foreach (var ins in intersections)
{
var greenStreet = ins.Incoming.SingleOrDefault(x => x.IsGreen);
if (greenStreet != null)
{
var dqCar = greenStreet.CarsAtEnd.Dequeue();
dqCar.NextStreet();
travellingCars.Add(dqCar);
greenStreet.GreenTime--;
}
var costs = ins.Incoming.Where(x => x.Cost > 0).Select(x => x.Cost).ToList();
if (costs.Count > 0)
{
var minCost = costs.Min();
var selectedStreet = ins.Incoming.Where(i => i.Cost == minCost).FirstOrDefault();
if (selectedStreet != null)
{
selectedStreet.GreenTime = 1;
var schedule = greenIntersections.FirstOrDefault(x => x.IntersectionId == ins.Id);
if (schedule == null)
{
schedule = new IntersectionSchedule {
IntersectionId = ins.Id,
};
greenIntersections.Add(schedule);
}
if (schedule.StreetGreenTime.ContainsKey(selectedStreet.Name))
{
schedule.StreetGreenTime[selectedStreet.Name].GreenTime += 1; //nie moga byc naprzemiennie
}
else
{
schedule.StreetGreenTime.Add(selectedStreet.Name, new GreenTimeAndOrder {
GreenTime = 1, Order = i
});
}
}
}
}
}
// RESULT
var sb = new StringBuilder();
int A = greenIntersections.Select(x => x.IntersectionId).Distinct().Count(); // number of intersections with schedule
sb.AppendLine(A.ToString());
foreach (var gi in greenIntersections)
{
sb.AppendLine(gi.IntersectionId.ToString());
sb.AppendLine(gi.StreetGreenTime.Count.ToString());
foreach (var st in gi.StreetGreenTime.OrderBy(x => x.Value.Order))
{
sb.AppendLine($"{st.Key} {st.Value.GreenTime.ToString()}");
}
}
File.WriteAllText($@"output\output_{file}", sb.ToString());
}
