G-Lexicographically Minimum Walk[CF-Gym-102391][2019-2020 XX Open Cup, Grand Prix of Korea]

原题传送门

题面

Lexicographically Minimum Walk

                             time limit per test2 secondsmemory limit per test1024 megabytesinput standard inputoutput standard output

problem descride

There is a directed graph G with N nodes and M edges. Each node is numbered 1 through N, and each edge is numbered 1 through M. For each i (1≤i≤M) , edge i goes from vertex ui_{i}i to vertex vi_{i}i and has a unique color ci_{i}i .

A walk is defined as a sequence of edges eee1_{1}1 , eee2_{2}2, ⋯, eeel_{l}l where for each 1≤k<l, vek_{ek}ek (the tail of edge ek) is the same as uek+1_{ek+1}ek+1 (the head of edge ek+1_{k+1}k+1). We can say a walk e1_{1}1,e2_{2}2,⋯,el_{l}l starts at vertex uuue1_{e1}e1 and ends at vertex vvvel_{el}el. Note that the same edge can appear multiple times in a walk.

The color sequence of a walk eee1_{1}1 , eee2_{2}2 , ⋯ , eeel_{l}l is defined as ccce1_{e1}e1 , ccce2_{e2}e2 , ⋯ , cccel_{el}el.

Consider all color sequences of walks of length at most 1010010^{100}10100 from vertex S to vertex T in G . Write a program that finds the lexicographically minimum sequence among them.

Input

The first line of the input contains four space-separated integers N , M , S , and T (1≤N≤1000001≤N≤1000001≤N≤100000 , 0≤M≤3000000≤M≤3000000≤M≤300000 , 1≤S≤N1≤S≤N1≤S≤N , 1≤T≤N1≤T≤N1≤T≤N , S≠TS≠TS=T).

Then M lines follow: the j (1≤j≤M1≤j≤M1≤j≤M)-th of them contains three space-separated integers uiu_{i}ui, viv_{i}vi and cic_{i}ci (1≤uiu_{i}ui, viv_{i}vi≤N, uiu_{i}ui≠viv_{i}vi, 1≤cic_{i}ci≤10910^9109); it describes a directional edge from vertex uiu_{i}ui to vertex viv_{i}vi with color cic_{i}ci.

The graph doesn’t have multiple edges and each edge has a unique color. Formally, for any 1≤i<j≤M1≤i<j≤M1≤i<j≤M, cic_{i}ci≠cjc_{j}cj and (uiu_{i}ui,viv_{i}vi)≠(uju_{j}uj,vjv_{j}vj) holds.

Output

If there is no walk from vertex S to vertex T, print “IMPOSSIBLE”. (without quotes)

Otherwise, let’s say a1a_{1}a1 , a2a_{2}a2 , ⋯ , ala_{l}al is the lexicographically minimum sequence among all color sequences of length at most 1010010^{100}10100 from vertex S to vertex T.

If l≤106l≤10^6l≤106, print a1a_{1}a1 , a2a_{2}a2 , ⋯ , ala_{l}al in the first line. There should be a space between each printed integer.
If l>106l>10^6l>106, print “TOO LONG”. (without quotes)

Sample Input

3 3 1 3
1 2 1
2 3 7
1 3 5

Sample Output

1 7

题意描述

给一张有向图，带边权且每条边的边权唯一。问从 S 到 T 的路径中，字典序最小的路径。输出该路径的边权。

题目分析

思维+贪心。当前点选边时总是选取能够到达 T 且边权最小的边即可。先建一个反图，从 T 出发跑BFS，将所有能到达 T 的点都跑出来，然后从 S 出发跑原图的DFS，若跑到之前已经过的点则说明存在环，则是TOO LONG的情况。

具体代码

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <string.h>
#include <cstdio>
#include <cstdlib>
#include <queue>using namespace std;const int maxn = 1e5 + 7;
const int inf = 1e9 + 7;int n, m, s, t, dd;
bool vis[maxn];
bool can[maxn];
vector < pair < int , int > > G[maxn];
vector < pair < int, int > > RG[maxn];
vector < int > ans;void bfs(int u)
{queue < int > que;que.push(u);while (!que.empty()){u = que.front();que.pop();can[u] = 1;for (int i = 0; i < RG[u].size(); i++){int v = RG[u][i].first;if (!can[v])que.push(v);can[v] = 1;}}
}bool dfs_2(int u)
{vis[u] = 1;if (u == t) return 1;int nxt = -1, val = inf;for (int i = 0; i < G[u].size(); i++){if (G[u][i].second < val && can[G[u][i].first]){nxt = G[u][i].first;val = G[u][i].second;}}if (vis[nxt]) return 0;ans.push_back(val);return dfs_2(nxt);
}int main()
{dd = 0;cin >> n >> m >> s >> t;for (int i = 1; i <= m; i++){int u, v, val;cin >> u >> v >> val;G[u].push_back({ v , val });RG[v].push_back({ u , val });}bfs(t);if (!can[s]){cout << "IMPOSSIBLE" << endl;}else{if (!dfs_2(s)) cout << "TOO LONG" << endl;elsefor (int tmp : ans)cout << tmp << " ";}return 0;
}