### just_for_one's blog

By just_for_one, history, 12 months ago, Hi, I just came along this problem. But couldn't think of any solution hence reaching out to the community.

Problem Description

You live in orange town. There are a lot of markets around that are connected with roads. These markets sell oranges at some prices. The town is not very well developed and they still use carts to transport goods from one place to the other. The roads connect two markets together and have two attributes associated with them. One is the price to go from one market to the other in an empty cart and the other is the tax factor. The tax factor is the number by which the price associated with a road needs to be multiplied, so it can go from one market to the other if you are carrying oranges in your cart. So if a road's original price was 5 coins and tax factor was 6, then in an empty cart it would take 5 coins to travel the road, but if the cart contained oranges, it would cost 5*6=30 coins.

You wonder what would be the cheapest way to buy oranges if you were initially at each market. You can either buy at the market you are at or travel to some other market, buy oranges there, and travel back to the original market

You are given an integer A denoting the number of total markets in orange town, an integer array B denoting the price of purchasing oranges at each market and a 2-D array C containing the information about the roads. First two values denote the market numbers that are bi-directionally connected via a road, 3rd value is the price, while the 4th one is the tax factor.

Find and return the required array. The minimum cost to buy oranges at each market such that the starting and ending point is that market.

Problem Constraints

2 <= A <= 1e5
B.size() == A
1 <= B[i] <= 1e7
1 <= C.size() <= 2e5
1 <= C <= A
1 <= C <= A
1 <= C <= 1e3
1 <= C <= 5


Input Format

The first argument is the integer A. The second argument is the integer array B, and the third argument is the 2-D integer array C.

Output Format

Return an integer array as per the given problem.

Example Input

Input 1:

A = 2 B = [11 1] C = [ [2 1 1 2] ]

Input 2:

A = 2 B = [1 1] C = [ [2 1 2 4] ]

Example Output

Output 1: [4 1] Output 2: [1 1]

Explanation

Explanation 1:

For the first market, you can travel to the second market (1 cost), buy oranges there (1 cost) and return back to the first market (1*2 cost) for a total of 4 cost. For the second market, 1 is already the lowest you can get.

Explanation 2:

For both markets, 1 is the lowest so it is the best answer.

My thoughts

This is very similar to the question asked in Codeagon 2020. If we had no taxes associated then this would have been normal multisource dijkstra with path weights doubled as forward and return journey have same paths. But in this problem we can choose different paths for forward and return journey.

If anyone can help it will be much appreciated. Comments (10)
 » 12 months ago, # | ← Rev. 2 →   I don't know if my aproach is correct but:Step 0: Initialy set the minimum for each market to its price for oranges(example 1: min={11, 1})Step 1: Take the market with the best price so far(can be stored with a priority_queue or a heap) and try to update its neighbours(min={min+(factor+1)*road.tax(see code), 1}={4, 1}).Step 2: Repeat Step 1. Code in C++struct edge { int node, tax, factor; }; struct auxStruct { int node, cost; friend bool operator<(auxStruct a, auxStruct b) {return a.cost }; std::vector solve(int A, std::vector& B, std::vector >&C) { std::vector road; std::vector minimum(A); std::priority_queue q; int i, x; bool checked; for(i=0;i x=C[i]; road[x].node=x; road[x].tax=x; road[x].factor=x; road[x].node=x; road[x].tax=x; road[x].factor=x; } for(i=0;i
•  » » This will not work I guess. That's where the problem begins, you are assuming same forward and backward path, but that might not be the case. Your method would have worked if tax=1.
 » 12 months ago, # | ← Rev. 3 →   Hi, I just came along this problem. But couldn't think of any solution hence reaching out to the community.If you haven't got a solution, you haven't got a problem. One can invent a dozen of problems without solutions.
•  » » Excuse me, First of all thanks for the valuable comment. Secondly you are acting like I have invented the complete problem myself after carefully selecting the constraints, test cases, even a beautiful story XD. If I would have invented the problem it is better to contribute to some codeforces or codechef round rather than posting here. And does the wordings of the problem really suggest I have created the story and everything just to post here.
 » just_for_one, did you find any solution or approach?
 » @just_for_one did you find the solution?
 » It's original question from media.net campus hiring tests.Though I have not reached to the solution but I will try to roll out what I thought.We have to make 2 graph , 1st graph A , will have forward edges with value c[I] i.e the road without any taxes2nd graph B , will have all backward edges with the value equal to c[I]*tax.Also Every node i in graph A Will be connected to corresponding same i' node in graph B , with the edge having value 0,For eg . For node1 in graph A duplicate node will be node1' in graph B. think like one flat graph has been duplicated and put on top !.Now the question changes to find the shortest path from node1 to node1'.
•  » » 6 weeks ago, # ^ | ← Rev. 3 →   You are assuming that the forward path and the backward path will be same, but they might not same.
 » 6 weeks ago, # | ← Rev. 2 →   The same question was asked today in the media.net test again. Hope I would have seen this before and prepared the solution. Anyway, @just_for_one, have you found any solution?
 » ## taking input from txt file, you can replace the code with input() with open('input.txt') as f: lines = f.readlines() from heapq import * class solve(): def __init__(self,a,b,c): self.a = a self.b = b self.c = c self.ans = [float("inf")]*a self.m = {i:[] for i in range(a)} self.cost = {} for a,b,c,t in c: self.m[a].append([b,c,t]) self.m[b].append([a,c,t]) #dijkstra algo def dk(self,s): pq = [[0,s]] visited = set() self.ans[s] = min(self.ans[s],self.b[s]) while pq: w,cur = heappop(pq) if cur in visited: continue visited.add(cur) for node,c,t in self.m[cur]: cost = (w+c)*(1+t) + self.b[node] print(cost) self.ans[cur] = min(cost,self.ans[cur]) heappush(pq,[w+c,node]) def solution(self): for i in range(self.a): # applying for each node, not very optimized self.dk(i) return self.ans for _ in range(1): a = int(lines) b = list(map(int,lines.split())) c = [] for i in range(a-1): row = list(map(int,lines.split())) c.append(row) obj = solve(a,b,c) print(obj.solution())