TACTQUER- editorial

cook74
dynamic-programming
editorial
graph
hard
tactquer

#1

PROBLEM LINK:

Practice
Contest

Author: Tuấn Anh Trần Đặng
Tester: Kamil Dębowski
Editorialist: Tuấn Anh Trần Đặng

DIFFICULTY:

Hard

PREREQUISITES:

Graph, Dynamic Programming

Problem

Given a weighted vertex-catus of N vertices answer Q queries about the shortest path between a pair of arbitrary vertices u and v.

Assumptions

We will mainly work on the DFS tree of the catus eg. performing DFS from 1 and only take the edges that connect a vertex to the unvisited vertex during the process.

Sub-problem 1

Calculate the shortest path from 1 to every vertex u.

Solution

Let’s call this d. We can get d by doing a dynamic programming in the DFS process. When we visit u there are two situations:

  1. u is not belong to any cycle: d = d[parent] + length of the edge from parent to u.
  2. u is in a cycle C. In this case let top[C] is the vertex closest to the root in C. d = d[top[C]] + shortest path from top[C] to u.

Note that there are exactly two ways to go between two vertices in the same cycle C so the shortest path from top[C] to u is just either the distance L from top[C] to u in the DFS tree or length of cycle C - L. top[C] should be pre calculated.

Sub-problem 2

Calculate the distance disTopDown(u, v) between u and one of it descendants v (in the DFS tree).

Solution

  • If u is not belongs to any cycle then disTopDown(u, v) = d[v] - d. This is correct since when we go from 1 to v we must go to u first.
  • If u is belong to the cycle C. When go from 1 to v we may not go to u since we have two ways to pass through the cycle C. However we will have to go to the vertex b that is the vertex closest to v in C. We have that disTopDown(u, v) = d[v] - d** + shortest distance from b to u. Again since b and u are in the same cycle the distance between them can be easily calculated.

So it seems like our solution is quite obvious now: distance between two vertices u and v is disTopDown(lca(u, v), u) + disTopDown(lac(u, v), v) where lca(u, v) is the lowest common ancester of u and v in the DFS tree. But we still missing one more piece: how to find b. Let get to the final sub-problem.

Sub-problem 3

We will make the problem a bit more genernal. Given the cycle C and the vertex v find the first vertex of C in the path from v to the root of the DFS tree.

solution

Hint: we can use the similar technique that we used in finding LCA.

Order the cycle in the way that if cycle A lies on the path from root to cycle B then cycle A will get the larger order. One way is to use the order of the DFS completion of the top vertex eg. if the DFS process at top** finished later then B got larger order. Now you may already guessed the solution. We trying to go from v toward the top as far as possible making sure that we never enter the cycle C. Let order[C] is the order of cycle C we have to make sure that the maximum order of cycles that has a vertex in the path from v toward the root does not larger or equal to order[C].

Recall the problem of finding LCA, we have to prepare f* is the 2^i th parent of u. The formular is quite simple:

  • f[0] = parent
  • f* = f[f[i - 1]][i - 1]

Apply the same technique let maxOrder* is the maximum label from u to its 2^ith parent:

  • maxOrder[0] = max(order, order[parent]) where order is the order of the cycle contain u or -1 if is does not belong to any cycle.
  • maxOrder* = max(maxOrder[i - 1], maxOrder[f[i - 1]][i - 1]);

With maxOrder calculated we try to jump from v toward the root and makesure that we never go a vertex with a order larger than or equal to order[C]. If b exist it will be the parent of the vertex we ended up at since we tried to go as close to C as possible but never enter it.

Summary

The solutions contains three part:

  1. Initial DFS to prepare infomation of the cycles eg. top vertex, label …
  2. Second DFS to calculate d[] and maxLabel[][].
  3. Answer the queries: (distance from u to v) = disTopDown(lca(u, v), u) + disTopDown(lca(u, v), v);

Complexity: O((N + M)logN)

Author’s/Tester’s Solutions:

Setter’s solution
Tester’s solution


#2

I was very disappointed solving that problem, it is very sad that in Codechef you are giving such well-known and messy problem. For example, “BZOJ 2125” is the exactly the same problem. I had also seen a lot of variations of such problem. I’d love to see much more fresh problems here.


#3

my solution using dijkstra … output is ok… but why it shows sigsev … please anyne tell :slight_smile:
#include<bits/stdc++.h>
using namespace std;

#define max 200009
#define INF 300100

vectorG[max];
vectorcost[max];
int d[max];

struct data
{

int city,dist;
data(int a,int b)
{
    city = a;
    dist = b;

}
bool operator < (const data& p) const
{

    return dist>p.dist;
}

};

int Dijkstra(int start,int node,int end)
{
int i,j,u,v;

for(j=0; j<=node; j++)
    d[j] = INF;

priority_queue<data>Q;

Q.push(data(start,0));

d[start] =0;

while(!Q.empty())
{
    data top = Q.top();
    Q.pop();

    u = top.city;

    if( u == end ) return ( d[end] );

    for(i=0; i<G.size(); i++)
    {
        v = G*;

        if(d+cost*<d[v])
        {
            d[v] = d+cost*;

            Q.push(data(v,d[v]));
        }
    }
}

}

int main()
{
int node,edge,i,j,k,l,m,x,y,z,start,end,cas;

    scanf("%d%d",&node,&edge);

    for(i=0; i<edge; i++)
    {
        cin>>x>>y>>z;

        G[x].push_back(y);
        G[y].push_back(x);

        cost[x].push_back(z);
        cost[y].push_back(z);
    }

  

    scanf("%d",&cas);
    while( cas-- )
    {

    scanf("%d%d",&start,&end);
    printf( "%d

",Dijkstra(start,node,end) );

    memset(d,0,sizeof(d));



    }


return 0;

}


#4

Please move the problem to practice, the given link doesn’t work.