#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int maxn=1010;
struct edge{
int v,next,w;
}e[maxn*10];
int t,head[maxn],n,m,k,vis[maxn],f[maxn][maxn];
void add(int u,int v,int w){
t++;
e[t].v=v;
e[t].w=w;
e[t].next=head[u];
head[u]=t;
}
int spfa_dp() {
memset(f, 0x3f, sizeof(f));
f[1][0] = 0;
vis[1] = 1;
queue<int> q;
q.push(1);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
for (int j = 0; j <= k; j++) {
int tt = f[v][j];
if (j) f[v][j] = min(f[v][j], f[u][j - 1]);
f[v][j] = min(f[v][j], max(f[u][j], e[i].w));
if (tt != f[v][j] && vis[v] == 0) {
vis[v] = 1;
q.push(v);
}
}
}
vis[u] = 0;
}
if (f[n][k] == 0x3f3f3f3f) return -1; else return f[n][k];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
printf("%d\n", spfa_dp());
return 0;
}
#include <bits/stdc++.h>
using namespace std;
const int maxn=1010;
typedef pair<int,int>PII;
struct edge {
int v, w;
edge(int _v, int _w) : v(_v), w(_w) {};
};
vector<edge>G[maxn];
int d[maxn],n,m,k;
int dij(int x) {
priority_queue<PII, vector<PII>, greater<PII> > q;
memset(d, 0x3f, sizeof(d));
d[1] = 0;
q.push(PII(0, 1));
while (!q.empty()) {
PII p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first) continue;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
int new_d = d[v] + (e.w >= x ? 1 : 0);
if (d[e.v] > new_d) {
d[e.v] = new_d;
q.push(PII(d[e.v], e.v));
}
}
}
return d[n];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(edge(v, w));
G[v].push_back(edge(u, w));
}
int l = 0, r = 10000002;
while (r-l>1) {
int mid = (l + r) >> 1;
if (dij(mid) > k)
l = mid;
else r = mid;
}
if (l > 10000000) printf("-1\n"); else printf("%d\n", l);
}
#include <bits/stdc++.h>
using namespace std;
const int maxn=100010;
const int maxm=500010;
typedef pair<int,int>PII;
struct edge{
int v,w,next;
}e1[maxm],e2[maxm];
int t,head1[maxn],head2[maxn],w[maxn],m,n,mi[maxn],vis[maxn],mx[maxn],t1,t2;
priority_queue<PII,vector<PII> ,greater<PII> >q1;
priority_queue<PII>q2;//big
void add1(int u,int v){
t1++;
e1[t1].v=v;
e1[t1].next=head1[u];
head1[u]=t1;
}
void add2(int u,int v){
t2++;
e2[t2].v=v;
e2[t2].next=head2[u];
head2[u]=t2;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d", &w[i]);
for (int i = 1, u, v, z; i <= m; i++) {
scanf("%d%d%d", &u, &v, &z);
if (z==1) {
add1(u, v);
add2(v, u);
}else{
add1(u, v);
add2(v, u);
add1(v, u);
add2(u, v);
}
}
memset(mi, 0x3f3f3f, sizeof(mi));
mi[1] = w[1];
q1.push(PII(w[1], 1));
while (!q1.empty()) {
int u = q1.top().second;
q1.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head1[u]; i; i = e1[i].next) {
int v = e1[i].v;
int mn = min(w[v], mi[u]);
if (mi[v] > mn) {
mi[v] = mn;
q1.push(PII(mi[v], v));
}
}
}
for (int i = 1; i <= n; i++)
vis[i] = 0;
mx[n] = w[n];
q2.push(PII(w[n], n));
while (!q2.empty()) {
int u = q2.top().second;
q2.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head2[u]; i; i = e2[i].next) {
int v = e2[i].v;
int mn = max(w[v], mx[u]);
if (mx[v] < mn) {
mx[v] = mn;
q2.push(PII(mx[v], v));
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, mx[i] - mi[i]);
}
printf("%d\n", ans);
}
#include <bits/stdc++.h>
using namespace std;
const int maxn=25010;
struct edge{
int v,w,next;
}e[maxn*8];
int head[maxn],tot,t,d[maxn],vis[maxn],s,r,p;
void add(int u,int v,int w) {
tot++;
e[tot].v = v;
e[tot].w = w;
e[tot].next = head[u];
head[u] = tot;
}
void spfa() {
vis[s] = 1;
deque<int> q;
memset(d, 0x3f3f3f, sizeof(d));
d[s] = 0;
q.push_front(s);
while (!q.empty()) {
int u = q.front();
q.pop_front();
vis[u] = 0;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (d[v] > d[u] + e[i].w) {
d[v] = d[u] + e[i].w;
if (vis[v] == 0) {
vis[v] = 1;
if (!q.empty() && d[q.front()] > d[v]) q.push_front(v); else q.push_back(v);
}
}
}
}
}
int main() {
scanf("%d%d%d%d", &t, &r, &p, &s);
for (int i = 1, u, v, w; i <= r; i++) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
for (int i = 1, u, v, w; i <= p; i++) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
}
spfa();
for (int i = 1; i <= t; i++) {
if (d[i] == 0x3f3f3f3f) printf("NO PATH\n"); else printf("%d\n",d[i]);
}
}
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
char s[10];
int n,m,a[100][100],f[100][100];
int flody() {
memcpy(f, a, sizeof(f));
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
f[i][j] |= f[i][k] & f[k][j];
if (f[i][j] && f[i][j] == f[j][i] && i != j) return -1;
}
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
f[i][j] |= f[i][k] & f[k][j];
if (f[i][j] == 0 && f[i][j] == f[j][i] && i != j) return 0;
}
}
}
return 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
if (n == 0 && m == 0) break;
int flag = 1;
memset(a, 0, sizeof(a));
for (int i = 1; i <= m; i++) {
scanf("%s", s);
a[s[0] - 'A'][s[2] - 'A'] = 1;
if (flag) {
int now = flody();
if (now == -1) {
flag = 0;
printf("Inconsistency found after %d relations.\n", i);
}
if (now == 1) {
flag = 0;
pair<int, char> ans[100];
for (int j = 0; j < n; j++) {
ans[j].second = j + 'A';
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (f[j][k]) {
ans[k].first++;
}
}
}
sort(ans, ans + n);
printf("Sorted sequence determined after %d relations: ", i);
for (int j = 0; j < n; j++) {
putchar(ans[j].second);
}
puts(".");
}
}
}
if (flag)printf("Sorted sequence cannot be determined.\n");
}
return 0;
}
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn=103;
int ans=0x3f3f3f3f,a[maxn][maxn],d[maxn][maxn],pos[maxn][maxn];
int n,m;
vector<int>path;
void getpath(int i,int j){
if (!pos[i][j]) return;
getpath(i,pos[i][j]);
path.push_back(pos[i][j]);
getpath(pos[i][j],j);
}
int main() {
scanf("%d%d", &n, &m);
memset(a, 0x3f, sizeof(a));
for (int i = 1; i <= n; i++)
a[i][i] = 0;
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
a[u][v] = a[v][u] = min(a[u][v], w);
}
memcpy(d, a, sizeof(d));
for (int k = 1; k <= n; k++) {
for (int i = 1; i < k; i++) {
for (int j = i + 1; j < k; j++) {
if ((ll)d[i][j] + a[j][k] + a[k][i] < ans) {
ans = d[i][j] + a[j][k] + a[k][i];
path.clear();
path.push_back(i);
getpath(i, j);
path.push_back(j);
path.push_back(k);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (d[i][j] > d[i][k] + d[k][j]) {
d[i][j] = d[i][k] + d[k][j];
pos[i][j] = k;
}
}
}
}
if (ans == 0x3f3f3f3f) printf("No solution.\n");
else {
for (int i = 0; i < path.size()-1; i++) {
printf("%d ", path[i]);
}
printf("%d\n",path[path.size()-1]);
}
}
#include <cstdio>
#include <cstring>
#include <map>
using namespace std;
map<int,int>mp;
int n,m,s,t,k;
struct node {
int a[205][205];
node operator*(const node &b) const {
node res;
memset(res.a,0x3f, sizeof(res.a));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
res.a[i][j] = min(res.a[i][j],a[i][k] + b.a[k][j]);
}
}
}
return res;
}
}st,res;
void pow(){
res=st;
k--;
while (k) {
if (k & 1) {
res = res * st;
}
k >>= 1;
st = st * st;
}
}
int main() {
scanf("%d%d%d%d", &k, &m, &s, &t);
memset(st.a, 0x3f, sizeof(st.a));
while (m--) {
int x, y, z;
scanf("%d%d%d", &z, &x, &y);
if (mp[x]) x = mp[x]; else x = mp[x] = ++n;
if (mp[y]) y = mp[y]; else y = mp[y] = ++n;
st.a[x][y]=st.a[y][x] = z;
}
pow();
printf("%d\n", res.a[mp[s]][mp[t]]);
}
