POJ 2387 Til the Cows Come Home
贝西在牧场,他想回谷仓,在John叫他早上挤奶之前,尽多的睡美容觉。贝西想尽快回去。 John的牧场有N个地标,地标1是谷仓(终点),地标N是贝西所在的苹果树林(起点)。牛通过牧场里T条双向的牛道。 贝西对自己的航行能力不自信,所以一旦开始,她总是在牛道行走。 根据地标之间的小径,确定贝西最少走多远才能回到谷仓。保证有这样的路线存在。 输入 T(路的条数) N(贝西的出发点) 接下来是T行描述两个地标之间的距离。 |
// <3> 优先队列优化的djk求单源最短路,链式前向星存图 时间复杂度o(E * log(V))
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
typedef pair<int, int>pii;//first是最短距离,second是顶点的编号
const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11;
const int INF = (int) 0x3f3f3f3f;
struct Edge
{ // 边的定义
int to, val, next;
Edge(){}
Edge(int _to, int _val, int _next)
{
to = _to;
val = _val;
next = _next;
}
}edge[M << 1]; // !!如果是双向图的话,边的数量是题目中描述的二倍
int n, m; // n 是图中的点数,m是图中的边数
int head[N], top;
void init(int n)// 初始化
{
memset(head, -1, sizeof(int) * (n + 1));
top = 0;
}
void Add(int u, int v, int val)// 加单向边
{
edge[top] = Edge(v, val, head[u]);
head[u] = top++;
}
void getmap(int m) // 建图
{
int u, v, val;
while(m--)
{
scanf("%d%d%d",&u , &v, &val); // u->v有边
Add(u, v, val);
Add(v, u, val); // 如果是双向图,加上这个代码 v->u有边
}
}
int dis[N];//某点到起点的最短距离
void djk(int st, int ed) // 核心代码,点的序号可以从0-(n-1)或者1-n
{
memset(dis, 0x3f, sizeof(int) * (n + 1));
//通过指定 greater<pii>参数,堆按照first从小到大的顺序取出值
priority_queue<pii, vector<pii>, greater<pii> > que; // make_pair(dis, v) 表示v到起点的距离为dis
dis[st] = 0;
que.push(make_pair(0, st));
while(!que.empty())
{
pii p = que.top(); que.pop(); // 每次取离起点最近的
int v = p.second;
if(dis[v] < p.first) continue; // 如果 没有更优,跳过
for(int i = head[v]; ~i; i = edge[i].next)//~按位取反
{
Edge e = edge[i];
if(dis[e.to] > dis[v] + e.val) // 是否可以进行松弛
{
dis[e.to] = dis[v] + e.val;
que.push(make_pair(dis[e.to], e.to));
}
}
}
printf("%d\n", dis[ed] == INF ? -1 : dis[ed]);
}
int main(){
int t; scanf("%d%d", &t, &n);
init(n);
getmap(t);
djk(n, 1);
return 0;
}
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
// <2> djk求单源最短路,邻接矩阵存图 时间复杂度o(n^2)
const int N = (int) 1000 + 11; // 最大点数
const int INF = (int) 0x3f3f3f3f;
int n, m; // n是点的个数,m是边的个数
int mp[N][N];
void init(int n){// 初始化
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
if(i == j) mp[i][j] = 0;
else mp[i][j] = mp[j][i] = INF;
}
}
}
void getmap(int m){ // 建图
int u, v, val;
while(m--)
{
scanf("%d%d%d", &u, &v, &val);
u--; v--;
mp[u][v] = mp[v][u] = min(mp[u][v], val); // 如果是双向图写这句
// mp[u][v] = min(mp[u][v], val); // 如果是单向图写这句
}
}
bool vis[N]; int dis[N];
void djk(int st, int ed)// 核心代码,点的序号是从0-(n-1)
{
for(int i = 0; i < n; i++)
{
vis[i] = false;
dis[i] = mp[st][i];
}
vis[st] = true;
for(int i = 1; i < n; i++)
{
int mn = INF, id = -1; // 找到离起点最近的未访问过得点
for(int j = 0; j < n; j++)
{
if(!vis[j] && dis[j] < mn)
{
mn = dis[j]; id = j;
}
}
if(id == -1) break;
vis[id] = true; // 标记
for(int j = 0; j < n; j++){
if(!vis[j] && mp[id][j] != INF) // 如果未访问且 id->j有边
{
if(dis[j] > dis[id] + mp[id][j]) // 是否可以松弛
dis[j] = dis[id] + mp[id][j];
}
}
}
printf("%d\n", (dis[ed] == INF) ? -1 : dis[ed]);
}
int main()
{
int t; scanf("%d%d", &t, &n);
init(n);
getmap(t);
djk(n - 1, 0);
return 0;
}
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
// <1> spfa求单源最短路,链式前向星存图 时间复杂度o(kE) k是常数,大多数情况下为2
const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11; // 最大边数
const int INF = (int) 0x3f3f3f3f;
struct Edge{ // 边的定义
int to, val, next;
Edge(){}
Edge(int _to, int _val, int _next)
{
to = _to; val = _val; next = _next;
}
}edge[M << 1]; // !!如果是双向图的话,边的数量是题目中描述的二倍
int n, m; // n 是图中的点数,m是图中的边数
int head[N], top;
void init(int n)
{ // 初始化
memset(head, -1, sizeof(int) * (n + 1));
top = 0;
}
void Add(int u, int v, int val)
{ // 加单向边
edge[top] = Edge(v, val, head[u]);
head[u] = top++;
}
void getmap(int m){ // 建图
int u, v, val;
while(m--)
{
scanf("%d%d%d",&u , &v, &val); // u->v有边
Add(u, v, val);
Add(v, u, val); // 如果是双向图,加上这个代码
}
}
bool vis[N]; int dis[N];
void spfa(int st, int ed){ // 核心代码,点序号从0-(n-1)或者1-n都可以
memset(dis, 0x3f, sizeof(int) * (n + 1));
memset(vis, false, sizeof(bool) * (n + 1)); // 清空和初始化
queue<int>que; que.push(st);
vis[st] = true; dis[st] = 0;
while(!que.empty()){
int u = que.front(); que.pop(); vis[u] = false;
for(int i = head[u]; ~i; i = edge[i].next)
{
Edge e = edge[i];
if(dis[e.to] > dis[u] + e.val) //是否可以进行松弛
{
dis[e.to] = dis[u] + e.val;
if(!vis[e.to]) // 是否在队列中,如果在可以跳过
{
que.push(e.to);
vis[e.to] = true;
}
}
}
}
printf("%d\n", dis[ed] == INF ? -1 : dis[ed]); // st到不了ed输出-1
}
int main()
{
int t; scanf("%d%d", &t, &n);
init(n);
getmap(t);
spfa(n, 1);
return 0;
}
TLE
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
// <4> floyd求多源最短路,邻接矩阵存图 时间复杂度o(n^3),可求得任意两个点之间的最短距离
const int N = (int) 1000 + 11;
const int INF = (int) 0x3f3f3f3f;
int n, m;
int mp[N][N];
void init(int n) // 初始化
{
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
if(i == j)
mp[i][j] = 0;
else mp[i][j] = mp[j][i] = INF;
}
}
}
void getmap(int m) // 建图
{
int u, v, val;
while(m--)
{
scanf("%d%d%d", &u, &v, &val); u--; v--;
mp[u][v] = mp[v][u] = min(mp[u][v], val); // 双向图写这行。min(mp[u][v], val)防止重边导致错误
//mp[u][v] = min(mp[u][v], val); // 单向图写着行
}
}
void floyd(int n)// 核心代码,点的序号为0-n-1
{
for(int k = 0; k < n; k++)
{
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]); // dp
}
}
}
}
int main()
{
int t; scanf("%d%d", &t, &n);
init(n);
getmap(t);
floyd(n);
printf("%d\n", mp[n - 1][0] == INF ? -1 : mp[n - 1][0]);
return 0;
}