P4779 【模板】单源最短路径（标准版）
题目背景
2018 年 7 月 19 日，某位同学在 NOI Day 1 T1 归程 一题里非常熟练地使用了一个广为人知的算法求最短路。
然后呢？
100→60；
Ag→Cu；
最终，他因此没能与理想的大学达成契约。
小 F 衷心祝愿大家不再重蹈覆辙。
题目描述
给定一个 n 个点，m 条有向边的带非负权图，请你计算从 s 出发，到每个点的距离。
数据保证你能从 s 出发到任意点。
输入格式
第一行为三个正整数 n,m,s。 第二行起 m 行，每行三个非负整数 ui,vi,wi，表示从 ui 到 vi 有一条权值为 wi 的有向边。
输出格式
输出一行 n 个空格分隔的非负整数，表示 s 到每个点的距离。
输入输出样例
输入 #1复制
4 6 1
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4输出 #1复制
0 2 4 3说明/提示
样例解释请参考 数据随机的模板题。
1≤n≤105；
1≤m≤2×105；
s=1；
1≤ui,vi≤n；
0≤wi≤109,
0≤∑wi≤109。
本题数据可能会持续更新，但不会重测，望周知。
2018.09.04 数据更新 from @zzq
实现代码：
cpp
#include<bits/stdc++.h>
const int MaxN = 100010, MaxM = 500010;
struct edge
{
int to, dis, next;
};
edge e[MaxM];
int head[MaxN], dis[MaxN], cnt;
bool vis[MaxN];
int n, m, s;
inline void add_edge( int u, int v, int d )
{
cnt++;
e[cnt].dis = d;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
struct node
{
int dis;
int pos;
bool operator <( const node &x )const
{
return x.dis < dis;
}
};
std::priority_queue<node> q;
inline void dijkstra()
{
dis[s] = 0;
q.push( ( node ){0, s} );
while( !q.empty() )
{
node tmp = q.top();
q.pop();
int x = tmp.pos, d = tmp.dis;
if( vis[x] )
continue;
vis[x] = 1;
for( int i = head[x]; i; i = e[i].next )
{
int y = e[i].to;
if( dis[y] > dis[x] + e[i].dis )
{
dis[y] = dis[x] + e[i].dis;
if( !vis[y] )
{
q.push( ( node ){dis[y], y} );
}
}
}
}
}
int main()
{
scanf( "%d%d%d", &n, &m, &s );
for(int i = 1; i <= n; ++i)dis[i] = 0x7fffffff;
for( register int i = 0; i < m; ++i )
{
register int u, v, d;
scanf( "%d%d%d", &u, &v, &d );
add_edge( u, v, d );
}
dijkstra();
for( int i = 1; i <= n; i++ )
printf( "%d ", dis[i] );
return 0;
}P4568 [JLOI2011] 飞行路线
题目描述
Alice 和 Bob 现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在 n 个城市设有业务，设这些城市分别标记为 0 到 n−1，一共有 m 种航线，每种航线连接两个城市，并且航线有一定的价格。
Alice 和 Bob 现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多 k 种航线上搭乘飞机。那么 Alice 和 Bob 这次出行最少花费多少？
输入格式
第一行三个整数 n,m,k，分别表示城市数，航线数和免费乘坐次数。
接下来一行两个整数 s,t，分别表示他们出行的起点城市编号和终点城市编号。
接下来 m 行，每行三个整数 a,b,c，表示存在一种航线，能从城市 a 到达城市 b，或从城市 b 到达城市 a，价格为 c。
输出格式
输出一行一个整数，为最少花费。
输入输出样例
输入 #1复制
5 6 1
0 4
0 1 5
1 2 5
2 3 5
3 4 5
2 3 3
0 2 100输出 #1复制
8说明/提示
数据规模与约定
对于 30% 的数据，2≤n≤50，1≤m≤300，k=0。
对于 50% 的数据，2≤n≤600，1≤m≤6×103，0≤k≤1。
对于 100% 的数据，2≤n≤104，1≤m≤5×104，0≤k≤10，0≤s,t,a,b<n，a=b，0≤c≤103。
另外存在一组 hack 数据。
实现代码：
cpp
#include<cstdio>
#include<cctype>
#include<cstring>
#include<queue>
#include<algorithm>
#include<vector>
#include<utility>
#include<functional>
int Read()
{
int x=0;char c=getchar();
while(!isdigit(c))
{
c=getchar();
}
while(isdigit(c))
{
x=x*10+(c^48);
c=getchar();
}
return x;
}
using std::priority_queue;
using std::pair;
using std::vector;
using std::make_pair;
using std::greater;
struct Edge
{
int to,next,cost;
}edge[2500001];
int cnt,head[110005];
void add_edge(int u,int v,int c=0)
{
edge[++cnt]=(Edge){v,head[u],c};
head[u]=cnt;
}
int dis[110005];
bool vis[110005];
void Dijkstra(int s)
{
memset(dis,0x3f,sizeof(dis));
dis[s]=0;
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > points;
points.push(make_pair(0,s));
while(!points.empty())
{
int u=points.top().second;
points.pop();
if(!vis[u])
{
vis[u]=1;
for(int i=head[u];i;i=edge[i].next)
{
int to=edge[i].to;
if(dis[to]>dis[u]+edge[i].cost)
{
dis[to]=dis[u]+edge[i].cost;
points.push(make_pair(dis[to],to));
}
}
}
}
}
int main()
{
int n=Read(),m=Read(),k=Read(),s=Read(),t=Read();
int u,v,c;
for(int i=0;i<m;++i)
{
u=Read(),v=Read(),c=Read();
add_edge(u,v,c);
add_edge(v,u,c);
for(int j=1;j<=k;++j)
{
add_edge(u+(j-1)*n,v+j*n);
add_edge(v+(j-1)*n,u+j*n);
add_edge(u+j*n,v+j*n,c);
add_edge(v+j*n,u+j*n,c);
}
}
for(int i=1;i<=k;++i)
{
add_edge(t+(i-1)*n,t+i*n);
}
Dijkstra(s);
printf("%d",dis[t+k*n]);
return 0;
}P3385 【模板】负环
题目描述
给定一个 n 个点的有向图，请求出图中是否存在从顶点 1 出发能到达的负环。
负环的定义是：一条边权之和为负数的回路。
输入格式
本题单测试点有多组测试数据。
输入的第一行是一个整数 T，表示测试数据的组数。对于每组数据的格式如下：
第一行有两个整数，分别表示图的点数 n 和接下来给出边信息的条数 m。
接下来 m 行，每行三个整数 u,v,w。
- 若 w≥0，则表示存在一条从 u 至 v 边权为 w 的边，还存在一条从 v 至 u 边权为 w 的边。
- 若 w<0，则只表示存在一条从 u 至 v 边权为 w 的边。
输出格式
对于每组数据，输出一行一个字符串，若所求负环存在，则输出 YES，否则输出 NO。
输入输出样例
输入 #1复制
2
3 4
1 2 2
1 3 4
2 3 1
3 1 -3
3 3
1 2 3
2 3 4
3 1 -8输出 #1复制
NO
YES说明/提示
数据规模与约定
对于全部的测试点，保证：
- 1≤n≤2×103，1≤m≤3×103。
- 1≤u,v≤n，−104≤w≤104。
- 1≤T≤10。
提示
请注意，m 不是图的边数。
实现代码：
cpp
#include<cstdio>
#include<cstring>
#include<queue>
#define inf 0x3f3f3f3f
using namespace std;
const int MAXN=2010;
const int MAXM=3010;
int n,m;
int en=-1,eh[MAXN];
struct edge
{
int u,v,w,next;
edge(int U=0,int V=0,int W=0,int N=0):u(U),v(V),w(W),next(N){}
};edge e[MAXM<<1];
inline void add_edge(int u,int v,int w)
{
e[++en]=edge(u,v,w,eh[u]);eh[u]=en;
}
void input()
{
scanf("%d %d",&n,&m);
en=-1;
memset(eh,-1,sizeof(eh));
int u,v,w;
for(int i=1;i<=m;++i)
{
scanf("%d %d %d",&u,&v,&w);
add_edge(u,v,w);
if(w>=0)add_edge(v,u,w);
}
}
int dis[MAXN],cnt[MAXN];
bool vis[MAXN];
queue<int> q;
void spfa()
{
fill(dis+1,dis+n+1,inf);
memset(cnt,0,sizeof(cnt));
memset(vis,0,sizeof(vis));
while(!q.empty())q.pop();
dis[1]=0;vis[1]=1;q.push(1);
int u,v,w;
while(!q.empty())
{
u=q.front();vis[u]=0;q.pop();
for(int i=eh[u];i!=-1;i=e[i].next)
{
v=e[i].v;w=e[i].w;
if(dis[u]+w<dis[v])
{
dis[v]=dis[u]+w;
if(!vis[v])
{
if(++cnt[v]>=n)//注意就是这个位置的判断。一定要保证在判vis之后，即判入队次数；而不是在判vis之前，即判松弛次数！！！
{
printf("YES\n");return;
}
vis[v]=1;q.push(v);
}
}
}
}
printf("NO\n");
}
int main()
{
// freopen("in.txt","r",stdin);
int t;
scanf("%d",&t);
for(int i=1;i<=t;++i)
{
input();
spfa();
}
return 0;
}P5960 【模板】差分约束
题目描述
给出一组包含 m 个不等式，有 n 个未知数的形如：
⎩⎨⎧xc1−xc1′≤y1xc2−xc2′≤y2⋯xcm−xcm′≤ym
的不等式组，求任意一组满足这个不等式组的解。
输入格式
第一行为两个正整数 n,m，代表未知数的数量和不等式的数量。
接下来 m 行，每行包含三个整数 c,c′,y，代表一个不等式 xc−xc′≤y。
输出格式
一行，n 个数，表示 x1,x2⋯xn 的一组可行解，如果有多组解，请输出任意一组，无解请输出 NO。
输入输出样例
输入 #1复制
3 3
1 2 3
2 3 -2
1 3 1输出 #1复制
5 3 5说明/提示
样例解释
⎩⎨⎧x1−x2≤3x2−x3≤−2x1−x3≤1
一种可行的方法是 x1=5,x2=3,x3=5。
⎩⎨⎧5−3=2≤33−5=−2≤−25−5=0≤1
数据范围
对于 100% 的数据，1≤n,m≤5×103，−104≤y≤104，1≤c,c′≤n，c=c′。
评分策略
你的答案符合该不等式组即可得分，请确保你的答案中的数据在 int 范围内。
如果并没有答案，而你的程序给出了答案，SPJ 会给出 There is no answer, but you gave it，结果为 WA；
如果并没有答案，而你的程序输出了 NO，SPJ 会给出 No answer，结果为 AC；
如果存在答案，而你的答案错误，SPJ 会给出 Wrong answer，结果为 WA；
如果存在答案，且你的答案正确，SPJ 会给出 The answer is correct，结果为 AC。
实现代码：
cpp
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
using i64 = long long;
const int maxn = 5'000;
const int maxm = 10'000;
struct edge {
int v, w, next;
} e[maxm + 5];
int head[maxn + 5], tot[maxn + 5], vis[maxn + 5], cnt, n, m;
i64 dis[maxn + 5];
void addedge(int u, int v, int w) {
e[++cnt].v = v;
e[cnt].w = w;
e[cnt].next = head[u];
head[u] = cnt;
}
bool spfa(int s) {
queue<int> q;
memset(dis, 63, sizeof(dis));
dis[s] = 0, vis[s] = 1;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
if (!vis[v]) {
vis[v] = 1, tot[v]++;
if (tot[v] == n + 1) return false;
q.push(v);
}
}
}
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) addedge(0, i, 0);
for (int i = 1; i <= m; i++) {
int v, u, w;
cin >> v >> u >> w;
addedge(u, v, w);
}
if (!spfa(0))
cout << "NO" << endl;
else
for (int i = 1; i <= n; i++) cout << dis[i] << ' ';
return 0;
}