[Luogu 2169] 正则表达式

[Luogu 2169] 正则表达式

<题目链接>

---

感谢 0xis 推题。

记忆中很久没有过一遍写过一题了…

别被题目名称蒙骗！这不是正则表达式题目！和字符（串）处理一点关系都没有！这是个图论题啊喂！

题都没急，Capella 你急啥？

由题意得，能够本地传输的机子们处于同一强连通分量，于是 Tarjan 一遍，缩点。缩的过程中，对于两个 SCC 之间的边，选短的加。

我这里用一个 map，记录边（pair<int, int>）到边权（int）的映射，然后用 map 判断是否加边就好了。

最短路，跑一个 Dijkstra 即可（珍爱生命，远离某死亡算法不解释）。

输出 1 所在的 SCC 到 n 所在的 SCC 的路径。

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <map>
#include <queue>
#include <stack>

#define nullptr NULL

const int MAXN = 200010; 

int n, m; 

namespace SCC
{
    bool exist[MAXN], vis[MAXN]; 
    int num, sum, DFN[MAXN], low[MAXN], SCC[MAXN], dist[MAXN]; 
    std :: stack<int> S; 
    struct Node
    {
        int index, dist; 
        Node(int index, int dist): index(index), dist(dist) {}
        bool operator <(const Node& rhs) const
        {
            return dist > rhs.dist; 
        }
    }; 
    struct Graph
    {
        struct Edge
        {
            int to, w; 
            Edge *next; 
            Edge(int to, int w, Edge* next): to(to), w(w), next(next) {}
            ~Edge(void)
            {
                if(next != nullptr)
                    delete next; 
            }
        }*head[MAXN]; 
        Graph(int n)
        {
            std :: fill(head + 1, head + n + 1, (Edge*)nullptr); 
        }
        ~Graph(void)
        {
            for(int i = 1; i <= n; ++i)
                delete head[i]; 
        }
        void AddEdge(int u, int v, int w)
        {
            head[u] = new Edge(v, w, head[u]); 
        }
    }*G, *Gnew; 
    void Tarjan(int u)
    {
        S.push(u); 
        exist[u] = true; 
        DFN[u] = low[u] = ++num; 
        int v; 
        for(Graph :: Edge *i = G -> head[u]; i != nullptr; i = i -> next)
            if(!DFN[v = i -> to])
            {
                Tarjan(v); 
                low[u] = std :: min(low[u], low[v]); 
            }
            else if(exist[v])
                low[u] = std :: min(low[u], DFN[v]); 
        if(DFN[u] == low[u])
        {
            ++sum; 
            do
            {
                exist[v = S.top()] = false; 
                S.pop(); 
                SCC[v] = sum; 
            }
            while(u ^ v); 
        }
    }
    void Shrink(void)
    {
        std :: map<std :: pair<int, int>, int> QAQ; 
        std :: pair<int, int> t; 
        Gnew = new Graph(sum); 
        for(int u = 1, v; u <= n; ++u)
            for(Graph :: Edge *i = G -> head[u]; i != nullptr; i = i -> next)
                if(!QAQ.count(t = std :: make_pair(SCC[u], SCC[v = i -> to])) || i -> w < QAQ[t])
                {
                    Gnew -> AddEdge(SCC[u], SCC[v], i -> w); 
                    QAQ[t] = i -> w; 
                }
    }
    void Dijkstra(int S)
    {
        std :: priority_queue<Node> Q; 
        memset(dist, 0x3f, sizeof dist); 
        Q.push(Node(S, dist[S] = 0)); 
        while(!Q.empty())
        {
            int u = Q.top().index, v; 
            Q.pop(); 
            if(!vis[u])
            {
                vis[u] = true; 
                for(Graph :: Edge *i = Gnew -> head[u]; i != nullptr; i = i -> next)
                    if(dist[v = i -> to] > dist[u] + i -> w)
                        Q.push(Node(v, dist[v] = dist[u] + i -> w)); 
            }
        }
    }
    void Solve(void)
    {
        for(int i = 1; i <= n; ++i)
            if(!DFN[i])
                Tarjan(i); 
        Shrink(); 
        Dijkstra(SCC[1]); 
        printf("%d\n", dist[SCC[n]]); 
    }
}

int main(void)
{
    scanf("%d %d", &n, &m); 
    SCC :: G = new SCC :: Graph(n); 
    for(int i = 1, u, v, w; i <= m; ++i)
    {
        scanf("%d %d %d", &u, &v, &w); 
        SCC :: G -> AddEdge(u, v, w); 
    }
    SCC :: Solve(); 
    return 0; 
}

---

谢谢阅读。