public double FindBestPath(Graph2 g)
{
try
{
string start = "0";
// Dijkstra's (modified)
weights[start] = 1;
PriorityQueue2 pq = new PriorityQueue2(n);
pq.InsertOrChange(start, 1);
while (!pq.IsEmpty())
{
string u = pq.DeleteMax();
foreach (Edge2 e in g.GetNeighbors(u))
{
if (weights[e.GetEndVertex()] < weights[u] * e.GetFactor())
{
weights[e.GetEndVertex()] = (weights[u] * e.GetFactor());
pq.InsertOrChange(e.GetEndVertex(), weights[e.GetEndVertex()]);
}
}
}
}
catch (Exception e)
{
}
double best = weights[(n - 1).ToString()];
return(best);
}
public void PriorityQueueLinkedList()
{
var priorityQueue = new PriorityQueue2 <Employee>();
priorityQueue.EnqueueRange(_employees);
priorityQueue.Dequeue();
priorityQueue.Dequeue();
priorityQueue.Dequeue();
priorityQueue.Dequeue();
}
private static void PriorityQueueDemo()
{
Console.WriteLine("Begin Priority Queue demo\n");
Console.WriteLine("Creating priority queue of Employee items\n");
IPriorityQueue <Employee> pq = new PriorityQueue2 <Employee>();
var employees = new List <Employee>
{
new("Eason", 5.0),
new("Chung", 3.0),
new("Flynn", 6.0),
new("Dunne", 4.0),
new("Aiden", 1.0),
new("Baker", 2.0),
new("Aiden Jr.", 1.0)
};
foreach (var employee in employees)
{
Console.WriteLine($"Adding {employee} to priority queue");
pq.Enqueue(employee);
Console.WriteLine($"Peek front item: {pq.Peek()}");
Console.WriteLine(pq.ToString());
Console.WriteLine();
}
Console.WriteLine("\nPriory queue is: ");
Console.WriteLine(pq.ToString());
Console.WriteLine("\n");
Console.WriteLine($"\nPriority Count: {pq.Count}");
for (var i = 1; i <= 4; i++)
{
Console.WriteLine($"Removing employee #{i} from priority queue");
Employee e = pq.Dequeue();
Console.WriteLine($"Removed employee is {e}");
Console.WriteLine("\nPriory queue is now: ");
Console.WriteLine(pq.ToString());
Console.WriteLine("\n");
}
var test = pq.ToList();
#if DEBUG
Console.WriteLine("Testing the priority queue");
TestPriorityQueue(50000);
#endif
Console.WriteLine("\nEnd Priority Queue demo");
Console.ReadLine();
}
void Solve()
{
var I = G();
var E = I[0];
V = I[1] + 1;
es = new List <Edge> [V];
es[0] = new List <Edge>();
for (var i = 1; i < V; i++)
{
es[i] = new List <Edge> {
new Edge(i - 1)
}
}
;
for (var i = 0; i < E; i++)
{
I = G();
es[I[0]].Add(new Edge(I[1], I[2]));
}
Console.WriteLine(DijkstraFrom(0)[V - 1]);
}
long[] DijkstraFrom(int from)
{
var d = Enumerable.Repeat(long.MaxValue - int.MaxValue, V).ToArray();
var queue = new PriorityQueue2();
d[from] = 0;
queue.Enqueue(new Edge(from));
while (queue.Count > 0)
{
var p = queue.Dequeue();
var v = p.To;
if (d[v] < p.Cost)
{
continue;
}
foreach (var e in es[v])
{
var tmp = d[v] + e.Cost;
if (d[e.To] > tmp)
{
queue.Enqueue(new Edge(e.To, d[e.To] = tmp));
}
}
}
return(d);
}
long FirstBinary(long min, long max, Predicate <long> pred)
{
while (min < max)
{
var mid = min + (max - min) / 2;
if (pred(mid))
{
max = mid;
}
else
{
min = mid + 1;
}
}
return(min);
}
long GCD(long a, long b)
{
var n = (ulong)Math.Abs(a); var m = (ulong)Math.Abs(b);
if (n == 0)
{
return((long)m);
}
if (m == 0)
{
return((long)n);
}
int zm = 0, zn = 0;
while ((n & 1) == 0)
{
n >>= 1; zn++;
}
while ((m & 1) == 0)
{
m >>= 1; zm++;
}
while (m != n)
{
if (m > n)
{
m -= n; while ((m & 1) == 0)
{
m >>= 1;
}
}
else
{
n -= m; while ((n & 1) == 0)
{
n >>= 1;
}
}
}
return((long)n << Math.Min(zm, zn));
}
int FirstBinary(int min, int max, Predicate <int> pred)
{
while (min < max)
{
var mid = (min + max) / 2;
if (pred(mid))
{
max = mid;
}
else
{
min = mid + 1;
}
}
return(min);
}
Tuple <long, long> SolveLinear(long n, long m)
{
if (n < 0)
{
var p = SolveLinear(-n, m); return(p == null ? p : new Tuple <long, long>(-p.Item1, p.Item2));
}
if (m < 0)
{
var p = SolveLinear(n, -m); return(p == null ? p : new Tuple <long, long>(p.Item1, -p.Item2));
}
if (n < m)
{
var p = SolveLinear(m, n); return(p == null ? p : new Tuple <long, long>(p.Item2, p.Item1));
}
long a = 1, b = 0, c = 0, d = 1;
while (m > 0)
{
var r = n % m;
var q = n / m;
n = m;
m = r;
var tmp = a;
a = -a * q + b;
b = tmp;
tmp = c;
c = -c * q + d;
d = tmp;
}
return(n != 1 ? null : new Tuple <long, long>(d, b));
}
long Inverse(long a, long mod)
{
if (a < 0)
{
a %= mod; if (a < 0)
{
a += mod;
}
}
var t = SolveLinear(a, mod);
return(t.Item1 > 0 ? t.Item1 : t.Item1 + mod);
}
}
