private static void MaxTest()
{
Console.WriteLine("This section is to test the MAX HEAP class.\n");
string sort_error = "The current value is not less than the next value on the array.";
string pop_error = "The current value is not grater than the next value on the array";
string invariant_error = "The invariants have been broken.";
MaxHeap<int> myHeap = new MaxHeap<int>();
int[] numberList = new int[] { 2, 5, 9, 2, 8, 1, 4, 7, 3, 6 };
Console.WriteLine("Adding the following numbers to the heap: [{0}]\n",
string.Join(", ", numberList));
foreach (int number in numberList)
myHeap.Add(number);
Console.WriteLine("New Heap: [{0}]\n", string.Join(", ", myHeap));
Console.WriteLine("Performing Heap Sort...\n");
myHeap.Sort();
TestMaxSort(myHeap, sort_error);
Console.WriteLine("New Heap: [{0}]\n", string.Join(", ", myHeap));
Console.WriteLine("Rebuilding Heap...\n");
myHeap.BuildHeap();
Console.WriteLine("New Heap: [{0}]\n", string.Join(", ", myHeap));
Console.WriteLine("Poping the top value until heap is empty...\n");
TestMaxPop(myHeap, pop_error);
int elements = 20000;
myHeap = new MaxHeap<int>(elements);
int[] random_list = RandomIntArray(elements);
Console.WriteLine("Adding {0} values to a new heap and verifying the invariants...\n", elements);
Console.WriteLine("This part will take a while...\n");
foreach (int number in random_list)
{
myHeap.Add(number);
TestMaxInvariant(myHeap, invariant_error);
}
Console.WriteLine("Heap too big to print on console, current elements in heap: {0}\n", myHeap.Count);
Console.WriteLine("Going to pop half of the values out of the heap and verifying the invariants...\n");
Console.WriteLine("Again... This part will take a while...\n");
for (int i = 0; i < elements / 2; i++)
{
myHeap.PopMax();
TestMaxInvariant(myHeap, invariant_error);
}
Console.WriteLine("Heap too big to print on console, current elements in heap: {0}\n", myHeap.Count);
Console.WriteLine("----------------------------------------------------");
}
// public int LastStoneWeight(int[] stones)
// {
// var sortedList = stones.ToList();
// sortedList.Sort();
//
// while (sortedList.Count > 1)
// {
// var newStone = Math.Abs(sortedList[^1] - sortedList[^2]);
// sortedList.RemoveAt(sortedList.Count - 1);
// sortedList.RemoveAt(sortedList.Count - 1);
// if (newStone != 0)
// sortedList.InsertIntoSortedList(newStone);
// }
//
// return sortedList.Count switch
// {
// 0 => 0,
// 1 => sortedList[0],
// _ => 0
// };
// }
public int LastStoneWeight(int[] stones)
{
// Insert all the stones into a Max-Heap.
MaxHeap <int> heap = new MaxHeap <int>();
foreach (var stone in stones)
{
heap.Add(stone);
}
// While there is more than one stone left, we need to remove the two largest
// and smash them together. If there is a resulting stone, we need to put into
// the heap.
while (heap.Count > 1)
{
var stone1 = heap.ExtractDominating();
var stone2 = heap.ExtractDominating();
if (stone1 != stone2)
{
heap.Add(stone1 - stone2);
}
}
// Check whether or not there is a stone left to return.
return(heap.Count == 0 ? 0 : heap.ExtractDominating());
}
public void AddNum(int num)
{
if (maxH.GetSize() > 0 && num >= maxH.Peek()) // If num is bigger than the 1st half it goes to the 2nd half
{
minH.Add(num);
}
else
{
maxH.Add(num);
}
if (Math.Abs(maxH.GetSize() - minH.GetSize()) > 1) // If there are more than one number of difference
{
if (maxH.GetSize() > minH.GetSize())
{
int number = maxH.Pull();
minH.Add(number);
}
else
{
int number = minH.Pull();
maxH.Add(number);
}
}
}
public PointSet GetKNN(Point p, int K, DimWeight dw)
{
var pc = new PointCompare(dw, p);
var heap = new MaxHeap <Point>(pc);
for (int i = 0; i < pointset.Points.Count(); i++)
{
if (heap.Count < K)
{
heap.Add(pointset.Points[i]);
}
else if (pc.Compare(heap.GetMin(), pointset.Points[i]) > 0)
{
heap.ExtractDominating();
heap.Add(pointset.Points[i]);
}
}
PointSet ps = new PointSet(p.NumDim);
while (heap.Count > 0)
{
ps.AddPoint(heap.ExtractDominating());
}
return(ps);
}
public int[][] KClosest(int[][] points, int K)
{
var heap = new MaxHeap(K);
foreach (var point in points)
{
if (heap.Count < K)
{
heap.Add(new Node(point));
}
else
{
var dist = point[0] * point[0] + point[1] * point[1];
if (dist >= heap.Peek().Dist)
{
continue;
}
heap.Pop();
heap.Add(new Node(point));
}
}
var result = new Stack <int[]>(K);
while (heap.Count > 0)
{
result.Push(heap.Pop().Point);
}
return(result.ToArray());
}
public static int Run(int[] input)
{
if (input == null || input.Length == 0)
{
throw new InvalidOperationException();
}
var root = input[0];
var left = new MaxHeap <int>();
var right = new MinHeap <int>();
for (var i = 1; i < input.Length; i++)
{
var current = input[i];
if (current <= root)
{
if (left.Count > right.Count)
{
if (left.GetRoot() > current)
{
right.Add(root);
root = left.Pop();
left.Add(current);
}
else
{
right.Add(root);
root = current;
}
}
else
{
left.Add(current);
}
}
else
{
if (right.Count + 1 > left.Count)
{
if (right.GetRoot() < current)
{
left.Add(root);
root = right.Pop();
right.Add(current);
}
else
{
left.Add(root);
root = current;
}
}
else
{
right.Add(current);
}
}
}
return(root);
}
public void TestRemove_TenItems()
{
MaxHeap <int> maxHeap = new MaxHeap <int>();
int items = 10;
maxHeap.Add(10);
maxHeap.Add(1);
maxHeap.Add(9);
maxHeap.Add(2);
maxHeap.Add(8);
maxHeap.Add(3);
maxHeap.Add(7);
maxHeap.Add(4);
maxHeap.Add(6);
maxHeap.Add(5);
StringBuilder actual = new StringBuilder();
for (int i = 0; i < items; i++)
{
actual.Append(maxHeap.Remove());
}
string expected = "10987654321";
Assert.AreEqual(expected, actual.ToString());
}
public int LastStoneWeight(int[] stones)
{
// insert stones into max-heap
// while heap.size() is greater than or equal to 2
// y = extract_max
// x = extract_max
// diff = y-x
// if (diff > 0), insert diff into heap
var heap = new MaxHeap(stones.Length);
foreach (var stone in stones)
{
heap.Add(stone);
}
int x, y, diff;
while (heap.Size() >= 2)
{
y = heap.Poll();
x = heap.Poll();
diff = Math.Abs(y - x);
if (diff > 0)
{
heap.Add(diff);
}
}
return(heap.Peek());
}
public void TestComparer()
{
MaxHeap <int> maxHeap = new MaxHeap <int>(new ReverseIntComparer());
int items = 10;
maxHeap.Add(10);
maxHeap.Add(1);
maxHeap.Add(9);
maxHeap.Add(2);
maxHeap.Add(8);
maxHeap.Add(3);
maxHeap.Add(7);
maxHeap.Add(4);
maxHeap.Add(6);
maxHeap.Add(5);
StringBuilder actual = new StringBuilder();
for (int i = 0; i < items; i++)
{
actual.Append(maxHeap.Remove());
}
string expected = "12345678910";
Assert.AreEqual(expected, actual.ToString());
}
public int[][] KClosest(int[][] points, int k)
{
int n = points.Length;
var dists = new double[n];
MaxHeap heap = new MaxHeap(k);
for (int i = 0; i < n; i++)
{
dists[i] = Math.Sqrt(points[i][0] * points[i][0] + points[i][1] * points[i][1]);
if (heap.Add(dists[i]))
{
continue;
}
else if (heap.GetMax() > dists[i])
{
heap.ExtractMax();
heap.Add(dists[i]);
}
}
var disk = heap.GetMax();
int[][] ans = new int[k][];
int t = 0;
for (int i = 0; i < n; i++)
{
var dis = Math.Sqrt(points[i][0] * points[i][0] + points[i][1] * points[i][1]);
if (dis <= disk)
{
ans[t++] = points[i];
}
}
return(ans);
}
public void Ctor1Test()
{
var heap = new MaxHeap <int>();
heap.Add(3);
heap.Add(10);
Assert.AreEqual(10, heap.Max);
}
public void Ctor2Test()
{
var heap = new MaxHeap <int>(Comparer <int> .Create((x, y) => x * x - y * y));
heap.Add(3);
heap.Add(-4);
Assert.AreEqual(-4, heap.Max);
}
// 6
public static void D_ConstructingTheArray()
{
int t;
string s = Console.ReadLine().Trim();
t = int.Parse(s);
for (int j = 0; j < t; j++)
{
s = Console.ReadLine().Trim();
int n = int.Parse(s);
int[] a = new int[n];
if (n == 1)
{
Console.WriteLine(1);
continue;
}
MaxHeap <Interval> heap = new MaxHeap <Interval>(new IntervalComparer());
heap.Add(new Interval {
l = 0, r = n - 1, len = n
});
int counter = 1;
while (heap.Count > 0)
{
Interval v = heap.ExtractDominating();
if (v.len < 1)
{
continue;
}
int ind = (v.l + v.r) / 2;
a[ind] = counter;
counter++;
if (v.len > 1)
{
var v1 = new Interval
{
l = v.l,
r = ind - 1
};
var v2 = new Interval
{
l = ind + 1,
r = v.r
};
v1.len = v1.r - v1.l + 1;
v2.len = v2.r - v2.l + 1;
heap.Add(v1);
heap.Add(v2);
}
}
Console.WriteLine(PrintList(a));
}
}
private void AddTest()
{
MaxHeap maxHeap = new MaxHeap(100);
maxHeap.Add(4);
maxHeap.Add(9);
maxHeap.Add(5);
Assert.AreEqual(3, maxHeap.Count);
Assert.AreEqual()
}
public void TestCount(int[] values, int expected)
{
for (int i = 0; i < values.Length; i++)
{
sut.Add(values[i]);
}
var actual = sut.Count;
Assert.Equal(expected, actual);
}
// Use Prim's algorithm to generate a MST of edges.
private IEnumerable <Edge> TrimEdges(ICollection <int>[] adjacency, IList <Room> rooms)
{
// Comparator for MapVertex is defined to give negated, so this is actually a minheap
MaxHeap <MapVertex> pq = new MaxHeap <MapVertex>(rooms.Count);
var(firstX, firstY) = rooms[0].Center;
pq.Add(new MapVertex(0, firstX, firstY, 0));
bool[] inMst = new bool[rooms.Count];
double[] weight = new double[rooms.Count];
int[] parent = new int[rooms.Count];
for (int i = 0; i < rooms.Count; i++)
{
weight[i] = double.MaxValue;
parent[i] = -1;
}
while (pq.Count > 0)
{
MapVertex min = pq.PopMax();
inMst[min.ID] = true;
foreach (int neighborID in adjacency[min.ID])
{
if (inMst[neighborID])
{
continue;
}
var(neighborX, neighborY) = rooms[neighborID].Center;
double newWeight = Distance.EuclideanDistanceSquared(min.X, min.Y,
neighborX, neighborY);
if (weight[neighborID] > newWeight)
{
weight[neighborID] = newWeight;
pq.Add(new MapVertex(neighborID, neighborX, neighborY, newWeight));
parent[neighborID] = min.ID;
}
}
}
ICollection <Edge> graph = new HashSet <Edge>();
for (int i = 0; i < rooms.Count; i++)
{
if (parent[i] != -1)
{
graph.Add(new Edge(i, parent[i]));
}
}
return(graph);
}
public void GetMaxTest()
{
var heap = new MaxHeap <int, int>();
heap.Add(42, -1);
heap.Add(5, 6);
var max = heap.Max;
Assert.AreEqual(5, max.Key);
Assert.AreEqual(6, max.Value);
}
public void TestExtractAndCount()
{
var maxHeap = new MaxHeap<string>();
maxHeap.Add("Ivan");
maxHeap.Add("George");
var expected = "Pesho";
maxHeap.Add(expected);
var actual = maxHeap.ExtractDominating();
Assert.AreEqual(expected, actual);
Assert.AreEqual(2, maxHeap.Count);
}
private MaxHeap <int> getExampleHeap()
{
MaxHeap <int> h = new MaxHeap <int>();
h.Add(4);
h.Add(5);
h.Add(3);
h.Add(1);
h.Add(2);
return(h);
}
public void TestPeek_NonEmptyHeap()
{
MaxHeap <int> maxHeap = new MaxHeap <int>();
maxHeap.Add(5);
maxHeap.Add(90);
maxHeap.Add(15);
maxHeap.Add(89);
Assert.AreEqual(90, maxHeap.Peek());
}
static void GetMedian(Stream ip)
{
int val;
MinHeap <int> rHeap = new MinHeap <int>();
MaxHeap <int> lHeap = new MaxHeap <int>();
double runningMedian = 0.0;
while ((val = ip.Next()) != -1)
{
if (rHeap.Count == lHeap.Count)
{
if (val < runningMedian)
{
lHeap.Add(val);
runningMedian = lHeap.Peek();
}
else
{
rHeap.Add(val);
runningMedian = rHeap.Peek();
}
}
else if (lHeap.Count > rHeap.Count)
{
if (val < runningMedian)
{
rHeap.Add(lHeap.Delete());
lHeap.Add(val);
}
else
{
rHeap.Add(val);
}
runningMedian = (lHeap.Peek() + rHeap.Peek()) / 2.0;
}
else
{
if (val < runningMedian)
{
lHeap.Add(val);
}
else
{
lHeap.Add(rHeap.Delete());
rHeap.Add(val);
}
runningMedian = (lHeap.Peek() + rHeap.Peek()) / 2.0;
}
}
}
public void Add8_6_5_3_4()
{
var maxHeap = new MaxHeap <int>();
maxHeap.Add(8);
maxHeap.Add(6);
maxHeap.Add(5);
maxHeap.Add(3);
maxHeap.Add(4);
Assert.AreEqual(5, maxHeap.Count);
}
public void WhenMaxHeap_ThenThePeekNodeMustBeTheMaxElement()
{
var maxHeap = new MaxHeap <int>();
maxHeap.Add(3);
maxHeap.Add(1);
maxHeap.Add(4);
maxHeap.Add(2);
maxHeap.Add(5);
Assert.AreEqual(5, maxHeap.Peek());
}
public void TestClear()
{
MaxHeap <int> maxHeap = new MaxHeap <int>();
maxHeap.Add(1);
maxHeap.Add(2);
maxHeap.Add(3);
maxHeap.Clear();
Assert.AreEqual(0, maxHeap.Count);
maxHeap.Peek();
}
private void CheckPoint(int K, MaxHeap <Point> heap, PointCompare pc)
{
if (heap.Count < K)
{
heap.Add(point);
}
else if (pc.Compare(heap.GetMin(), point) > 0)
{
heap.ExtractDominating();
heap.Add(point);
}
}
private List <Tuple <int, int> > GenerateSkyline(int[][] input, List <Tuple <int, int, int> > horizontalList)
{
var result = new List <Tuple <int, int> >();
horizontalList.Sort();
var hasStarted = new bool[input.Length];
var maxHeap = new MaxHeap <Tuple <int, int, bool> >();
for (int i = 0; i < horizontalList.Count; i++)
{
var coord = horizontalList[i];
if (hasStarted[coord.Item3])
{
var target = new Tuple <int, int, bool>(coord.Item2, coord.Item3, true);
if (maxHeap.Contains(target))
{
// remove this from heap and log start //
maxHeap.Remove(target);
result.Add(new Tuple <int, int>(input[coord.Item3][0], input[coord.Item3][2]));
}
else
{
maxHeap.Remove(new Tuple <int, int, bool>(coord.Item2, coord.Item3, false));
}
// log end
if (maxHeap.Count == 0)
{
result.Add(new Tuple <int, int>(coord.Item1, 0));
}
else if (coord.Item2 > maxHeap.Peek().Item1)
{
result.Add(new Tuple <int, int>(coord.Item1, maxHeap.Peek().Item1));
}
}
else
{
if (maxHeap.Count == 0 || maxHeap.Peek().Item1 < coord.Item2)
{
maxHeap.Add(new Tuple <int, int, bool>(coord.Item2, coord.Item3, true));
}
else
{
maxHeap.Add(new Tuple <int, int, bool>(coord.Item2, coord.Item3, false));
}
hasStarted[coord.Item3] = true;
}
}
return(result);
}
public void AddEmptyRemove()
{
var heap = new MaxHeap();
heap.Add(10);
Assert.AreEqual(10, heap.Peek());
var res = heap.Pop();
Assert.AreEqual(10, res);
heap.Add(20);
Assert.AreEqual(20, heap.Peek());
}
public void WhenPollElement_ThenNextMaxElementUp()
{
var maxHeap = new MaxHeap <int>();
maxHeap.Add(3);
maxHeap.Add(1);
maxHeap.Add(4);
maxHeap.Add(2);
maxHeap.Add(5);
maxHeap.Poll();
Assert.AreEqual(4, maxHeap.Peek());
}
public void ExecuteMaxHeap()
{
MaxHeap myHeap = new MaxHeap();
myHeap.Add(1);
myHeap.Add(6);
myHeap.Add(3);
value = myHeap.PopMax();
Console.WriteLine(value);
value = myHeap.PopMax();
Console.WriteLine(value);
}
public void HeapWorks() {
var heap = new MaxHeap<int>();
heap.Add(5);
heap.Add(6);
heap.Add(4);
heap.Add(1);
heap.Add(-1);
Assert.AreEqual(6, heap.Remove());
Assert.AreEqual(5, heap.Remove());
Assert.AreEqual(4, heap.Remove());
Assert.AreEqual(1, heap.Remove());
Assert.AreEqual(-1, heap.Remove());
}
//https://leetcode.com/problems/ipo/
public int FindMaximizedCapital(int k, int W, int[] Profits, int[] Capital)
{
var projects = new List <Project>(Profits.Length);
for (int i = 0; i < Profits.Length; i++)
{
projects.Add(new Project(Profits[i], Capital[i]));
}
var projectsByCapital = projects.OrderBy(x => x.Capital).ToArray();
var projectIndex = 0;
var currentCandidates = new MaxHeap <Project>(new Project(0, int.MaxValue));
while (projectIndex < projectsByCapital.Length)
{
if (projectsByCapital[projectIndex].Capital <= W)
{
currentCandidates.Add(projectsByCapital[projectIndex]);
}
else
{
break;
}
projectIndex++;
}
while (k > 0 && currentCandidates.Count > 0)
{
var bestProject = currentCandidates.ExtractMax();
if (bestProject.Capital > W)
{
break;
}
W += bestProject.Profit;
while (projectIndex < projectsByCapital.Length)
{
if (projectsByCapital[projectIndex].Capital <= W)
{
currentCandidates.Add(projectsByCapital[projectIndex]);
}
else
{
break;
}
projectIndex++;
}
k--;
}
return(W);
}
private void NoCapacityTest()
{
MaxHeap maxHeap = new MaxHeap(1);
try
{
maxHeap.Add(3);
maxHeap.Add(5);
Assert.Fail();
}
catch (Exception)
{
}
}
public void Add_Two_Elements_And_Remove_Top()
{
var maxHeap = new MaxHeap <int>();
maxHeap.Add(8);
maxHeap.Add(10);
Assert.AreEqual(2, maxHeap.Count);
var top = maxHeap.RemoveTop();
Assert.AreEqual(10, top);
Assert.AreEqual(1, maxHeap.Count);
}
public static IEnumerable<int> GetMedians(IEnumerable<int> sequence)
{
var enumerator = sequence.GetEnumerator();
var smallestNumbers = new MaxHeap<int>();
var largestNumbers = new MinHeap<int>();
if (enumerator.MoveNext())
{
var number = enumerator.Current;
smallestNumbers.Add(number);
yield return smallestNumbers.Max;
}
while (enumerator.MoveNext())
{
var number = enumerator.Current;
if (smallestNumbers.Count <= largestNumbers.Count)
{
if (number > largestNumbers.Min)
{
var min = largestNumbers.ExtractMin();
smallestNumbers.Add(min);
largestNumbers.Add(number);
}
else
{
smallestNumbers.Add(number);
}
}
else
{
if (number < smallestNumbers.Max)
{
var max = smallestNumbers.ExtractMax();
largestNumbers.Add(max);
smallestNumbers.Add(number);
}
else
{
largestNumbers.Add(number);
}
}
yield return smallestNumbers.Max;
}
}
