Job at Todechef Problem Code: JOBCHF ~ Multiplex Coder

Preface:

There is no need for introduction of uses of shortest path algorithms in real life. Used intensively in industrial applications like GPS, finding shortest path has been of interest to many researchers.

However, the most important, yet undervalued aspect for shortest path algorithm is the graph itself. Often, due to some special properties of the graph needed in our application, we can make certain assumptions $-$ which would otherwise be wrong in general. This opens up a new world of optimizing the graph algorithms because certain invalid algorithms might also produce correct results because of the earlier assumptions…

Statement:

In a far away Galaxy of Tilky Way, there was a planet Tarth where the sport of Tompetitive Toding was very popular. According to legends, there lived a setter who gave out interview questions asked at Todechef and Tirecti.

Tima and Tuchika were giving their interview for the role of developers at Todechef. Their interviewers, Ms Teha, Ms Tamesh and Ms Takkoth were die hard fans of selfies, food and graph algorithms. Hence, they asked Tima and Tuchika to find the shortest path in the given un-directed graph. They said that this graph has a very special property - The edges will have weight of EITHER $k_{1}$ OR $k_{2}$ .

Tima, who was too busy dating, to study properly for interview, said that she would apply $0 - 1$ $B F S$ on it by taking the minimum weight to correspond to weight $0$ and maximum weight to correspond to weight $1$ in the algorithm. Tuchika, who studied very very hard to impress her crush, said that she'd apply $B e l l m a n$ $F o r d$ algorithm to it and report the answer directly.

Ms Teha, Ms Tamesh and Ms Takkoth were not happy. They expected better answers for this job with salary of $10^{18}$ Todechef Kaddus per month. Hence, now its upto you to make both Tima and Tuchika realize their mistake!!

You need to report $3$ things - the correct answer, and the absolute differences between correct answer and answers given by Tima and Tuchika respectively. You need to report this assuming starting node to be $S_{t}$ and taking every node as target node one by one.

(Note- If multiple edges lead to some node $V$ , then Tima will visit all the edges, and see which one gives minimum distance. This is the core step of $0 - 1$ $B F S$ )

Input:

The first line contains $3$ integers - $N$ $M$ $S_{t}$ , i.e. number of nodes, number of edges and starting node respectively.
Next $M$ lines contain $3$ integers $u$ $v$ and $W$ denoting that there is an edge between node $u$ and node $v$ of weight $W$

Output:

Output $N$ lines $-$ where $i^{'} t h$ line denotes answer if node $i$ was the target node. Each line should be containing $3$ integers- $A_{c}$ $D_{1}$ and $D_{2}$ - where $A_{c}$ is the correct answer for shortest path, $D_{1}$ is absolute difference between correct answer and Tima's answer, and $D_{2}$ is similarly absolute difference between Tuchika's and correct answer.

Constraints

$1 \leq N \leq 10^{5}$
$1 \leq M \leq 1.5 * 10^{5}$
$1 \leq S_{t}, u, v \leq N$
$0 \leq W \leq 10^{9}$
$W$ will have at most $2$ distinct values in the graph. It is very much possible that $k_{1} = k_{2}$ , making the graph have only $1$ distinct value.

Note- Input can be huge. Prefer fast IO methods.

Subtasks:

5% points - Given graph is a tree.
8% points - $N \leq 100$
8% points - One of the weights is $0$
9% points - $N \leq 5000$
70% points - Original Constraints

Sample Input:

2 1 1
1 2 5

Sample Output:

0 0 0
5 0 0

EXPLANATION:

We see that it is a simple graph with node $1$ connected to node $2$ by a simple edge of weight $5$ . We can verify that the shortest path from node $1$ to node $2$ must use this edge, and hence be of weight $5$ . Also, for this particular graph, both algorithms give correct answer.

(Note- Distance of a node to itself is always $0$ ).

NOTES:

The $0 - 1$ $B F S$ algorithm can be

for all v in vertices:
    dist[v] = inf
dist[source] = 0;
deque d
d.push_front(source)
while d.empty() == false:
    vertex = get front element and pop as in BFS.
    for all edges e of form (vertex , u):
        if travelling e shortens distance to u:
            update(dist[u]);
            if e.weight = 1:
                d.push_back(u)
            else:
                d.push_front(u)

Click here