function stairs(n) {
     // implement this
}

function swap(arr, i, j) {
    const temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

class Heap {

    constructor() {
        this.data = [];
        this.size = 0;
    }

    bubbleUp(index = this.size - 1) {
        const parentIndex = Math.floor((index - 1) / 2);
        if (this.data[index] > this.data[parentIndex]) {
            swap(this.data, index, parentIndex);
            this.bubbleUp(parentIndex);
        }
    }

    push(val) { // instead of val we will have { label, prio } object
        this.data.push(val);
        this.size++;
        this.bubbleUp();
    }

    maxHeapify(index = 0) {
        let leftChildIndex = index * 2 + 1;
        let rightChildIndex = index * 2 + 2;
        let maxIndex = index;

        if (leftChildIndex < this.size && this.data[leftChildIndex] > this.data[maxIndex]) {
            maxIndex = leftChildIndex;
        }
        if (rightChildIndex < this.size && this.data[rightChildIndex] > this.data[maxIndex]) {
            maxIndex = rightChildIndex;
        }

        if(maxIndex !== index){
            swap(this.data, maxIndex, index);
            this.maxHeapify(maxIndex);
        }
        return this;
    }

    pop() {
        const res = this.data[0];
        const last = this.data.pop();
        this.data[0] = last;

        this.maxHeapify();

        this.size--;
        return res;
    }

    buildMaxHeap(arr = []) {
        this.data = arr;
        this.size = arr.length;

        for(let i = Math.floor(this.size / 2); i >= 0; i--) {
            this.maxHeapify(i);
        }

        return this;

    }

    print() { console.log(this.data) }

}

class PriorityQueue {
    constructor() {
        this.data = []
    }

    enqueue(value, prio) {
        this.data.push({ value, prio });
        this.data.sort((v1, v2) => v1.prio - v2.prio);
    }

    dequeue() {
        return this.data.shift();
    }
}

class WeightedGraph {
    constructor() {
        this.adjacencyList = {};
    }

    addVertex(node) {
        this.adjacencyList[node] = [];
        return this;
    }

    addEdge(vrt1, vrt2, weight) {
        if(this.adjacencyList[vrt1] && this.adjacencyList[vrt2]) {
            this.adjacencyList[vrt1].push({ node: vrt2, weight });
            this.adjacencyList[vrt2].push({ node: vrt1, weight });
        }
        return this;
    }

    dfs(from = 'A') {
        const visited = { [from]: true };
        const res = [];
        const stack = [ from ];

        while(stack.length > 0) {
            const curr = stack.pop();
            res.push(curr);
            this.adjacencyList[curr].forEach(edge => {
                if (!visited[edge.node]) {
                    visited[edge.node] = true;
                    stack.push(edge.node);
                }
            })
        }
        return res;
    }

    shortestPath(from, to) {
    	// 1 declare variables 
        // distance, prev, queue
    
        // 2 init
        // for reach node in adjacencyList
        // count set it distance to 0 if its a starting node or Infinity in other case
        // set dist map
        // set prev to null
        // enqueue node to PriorityQueue

        // 3 iterate over queue
        // pop curr item
        // iterate over curr adjacencylist
        // count dist using table + weight
        // if dist < than existing intable - override it
        

        // 4 calc path using prev nodes table
    }
}



const weightedGraph = new WeightedGraph();

/*

    A -- 100 -- B -- 1 -- C
     \        /
      1     1
       \  /
        D

*/


weightedGraph
    .addVertex('A')
    .addVertex('B')
    .addVertex('C')
    .addVertex('D')
    .addEdge('A', 'B', 100)
    .addEdge('B', 'C', 1)
    .addEdge('A', 'D', 1)
    .addEdge('D', 'B', 1);

console.log(weightedGraph.shortestPath('A', 'C'));