Of course you'll need to. That's the only way you get O(n log n) complexity instead of O(n^2) which gives it an edge over Bellman Ford.

Also, it ain't that tough to implement once you understand the algorithm and leverage STL.

Here's my code:

typedef pi pair<int>;
const int n=1e5;
vector<vector<pi> > G;
int dist[n+1];
 
void dijkstra(int src)
{
	priority_queue<pi, vector<pi>, greater<pi> > Q;
	int dist[n+1];
	fill(dist, dist + n + 1, INT_MAX);
	dist[src] = 0;
	Q.push(make_pair(0, src));
 
	while (!Q.empty())
	{

Can you elaborate Hint 3 a little? As in how do we find the ideal positions to buy and sell?

Thanks :")

Hints

Full Solution

No it won't.

Computing the connected computing takes linear time i.e. O(m + n) and iterating over all vertices takes time O(n)

Total running time: O(n*(m+n))

As per the constraints, n <= 300 and m <= 50000

Time limit is 3 seconds. Fair enough ?

We don't require Tarjan's Algorithm to solve this problem because the graph is undirected. A simple BFS/DFS will do. Here's the solution -

Oh yes, although that's kind of obvious but still you need to explicitly specify it.

As far as I remember, the problem goes like this -

Lasers

In an m x n grid, there are 3 types of cells -

1. ‘.’ - empty
2. ‘B’ - black
3. ‘W’ - white

A laser starts from an empty cell towards right. Its power reduces when it encounters a white cell such that it stops when it encounters a second white cell. On encountering a black cell, it stops immediately. L(i, j) denotes the length of the laser starting at (i, j). 

Suppose a laser starts from (i, j) and ends at (i, k), length = k - j + 1. Note that the length is inclusive of both the columns

Find the sum of L(i,j) for all i, j