Codeforces Round #436 (Div. 2) F. Cities Excursions 字典序dfs+Tarjan判环

题目链接：Cities Excursions
题意：给你一个有向图，问任意两点间的字典序最小路径（如果存在）上的第k个节点是啥。
解法：提前存储好每个点能直接到达的点，并排序，因为这样遍历就是字典序的遍历。提前存储好q个询问，对q的f按从小到大排序，每次对f相同的询问做dfs，起始点是f，提前把起始点是f的询问用vector保存下来，这样在做dfs的过程中，一次性把具有共同起点的这部分询问给得出结果，这样做节约了时间。初始化res数组为-1，res作用保存结果，在dfs中，用Tarjan判环，栈stk存放路径。在遍历过程，只要能加入到栈的点，从起点必能到达；没被加入到栈的点，从起点走字典序最小路必不能到达该点（可能是环导致的），res还是-1。能被加入到栈的点，结果取决于从起点到达该点，字典序最小路径的长度（即当前栈的栈顶指针的值）和该查询的k大小比较，小于关系，说明k超出路径长度，res还是-1,；大于关系，说明询问的是该路径的第k个点，stk数组对应下标的值赋给res[当前询问]。

感觉思路理得比较清楚了，还不懂看代码吧，代码借鉴别人的。

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#define Max(a,b) a>b?a:b
#define Min(a,b) a>b?b:a
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
int dir[4][2]= {{1,0},{-1,0},{0,1},{0,-1}};
const double eps = 1e-6;
const double Pi = acos(-1.0);
const int INF=0x3f3f3f3f;

const int maxn = 3010;
const int maxq = 4e5+10;

vector<int> edge[maxn];
struct query{
    int id,f,t,k;
    query(int _id = -1, int _f = 0, int _t = 0, int _k = 0): id(_id), f(_f), t(_t), k(_k){}
}qs[maxq];
vector<query> Q[maxn];
int n,m,q;
int tot,top;
int res[maxq];
int dfn[maxn],low[maxn],instk[maxn],stk[maxn];
bool cmp(const query &a, const query &b){
    return a.f < b.f;
}

void dfs(int u, int ok){
    dfn[u] = ++tot;
    low[u] = INF;
    stk[top++] = u;
    instk[u] = 1;
    if(ok){
        for(int i = 0; i < Q[u].size(); i++){
            if(Q[u][i].k <= top) res[Q[u][i].id] = stk[Q[u][i].k-1];
        }
    }
    for(int i = 0; i < edge[u].size(); i++){
        int v = edge[u][i];
        if(!dfn[v]){
            dfs(v,ok && dfn[u] < low[u]);
            low[u] = min(low[u],low[v]);
        }
        else if(instk[v]){
            low[u] = min(dfn[v],low[u]);
        }
    }
    instk[u] = 0;
    --top;
}

int main(){
    while(~scanf("%d%d%d",&n,&m,&q)){
        int a,b;

        for(int i = 1; i <= n; i++){
            edge[i].clear();
        }

        for(int i = 0; i < m; i++){
            scanf("%d%d",&a,&b);
            edge[a].push_back(b);
        }
        for(int i = 1; i <= n; i++){
            sort(edge[i].begin(),edge[i].end());
        }
        for(int i = 0; i < q; i++){
            int f,t,k;
            scanf("%d%d%d",&f,&t,&k);
            qs[i] = query(i,f,t,k);
        }

        sort(qs,qs+q,cmp);
        memset(res,-1,sizeof(res));
        for(int i = 0; i < q; i++){
            Q[qs[i].t].push_back(qs[i]);
            if(qs[i].f != qs[i+1].f){
                memset(low,0,sizeof(low));
                memset(dfn,0,sizeof(dfn));
                memset(instk,0,sizeof(instk));
                tot = 0, top = 0;
                dfs(qs[i].f,1);
                for(int j = 1; j <= n; j++){
                    Q[j].clear();
                }
            }
        }
        for(int i = 0; i < q; i++){
            printf("%d\n",res[i]);
        }
    }
    return 0;
}