J. Walk This Way

1. J. Walk This Way

最短路径

题目

Description 
Rocking is a fat boy, and he does not like walking at all. Whenever he goes somewhere, he always tries to find a bus to take. But he lives in a city where he can not go everywhere by bus. So, he wants you to help him find the best way to his destination, which has the shortest distance for him to walk. 
Remember the places in the city are numbered from 0 to N-1. 
Input 
Input consists of T cases, with T in the first line. 
In each case, the first line contains two integers, N(2<=N<=100),the number of the places in Rocking's city, and M(0<=M<=N*(N-1)/2), the number of the roads. 
The next M lines each contains four integers: a,b,c,d(0<=a,b The last line contains two integers s,t(0<=s,tOutput 
For each case, output a integer in a single line, indicating the shortest distance he must walk. Note that Rocking can take as many buses as he wants, and he only focus on the roads he must walk on. 
If he can not get to his destination, please output -1.

大概意思就是能take bus的edge的weight为0, 然后找出一条最短路径的cost.

Code

下面给出Dijkstra和Floyd的代码

Dijkstra

  
  
  
  

   
   
   
   
#include <stdio.h>
   
   
   
   
#include <iostream>
   
   
   
   
#include <list>
   
   
   
   
#include <map>
   
   
   
   
#include <vector>
   
   
   
   
#include <string>
   
   
   
   
#include <cstring>
   
   
   
   
#include <string.h>
   
   
   
   

   
   
   
   
using namespace std;
   
   
   
   

   
   
   
   
const int N = 102;
   
   
   
   
const int M = N * N;
   
   
   
   
const int INF = 100000;
   
   
   
   

   
   
   
   
bool visit[N];
   
   
   
   
int edge[N][N];
   
   
   
   
int dist[N];
   
   
   
   
int parent[N];
   
   
   
   

   
   
   
   
// m: number of edge
   
   
   
   
// n: number of vertices
   
   
   
   
void init(const int m, const int n) {
   
   
   
   
 // memset(edge, INF, sizeof(edge));
   
   
   
   
 // memset(edge, INF, M * sizeof(int));
   
   
   
   
 for(int i = 0; i < n; i++) {
   
   
   
   
 for(int j = 0; j < n; j++) {
   
   
   
   
 if(i == j) {
   
   
   
   
 edge[i][j] = 0;
   
   
   
   
 continue;
   
   
   
   
 }
   
   
   
   
 edge[i][j] = INF;
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   

   
   
   
   
 int u, v, c, flag;
   
   
   
   
 for(int i = 0; i < m; i++) {
   
   
   
   
 cin >> u >> v >> c >> flag;
   
   
   
   

   
   
   
   
 edge[u][v] = flag != 0 ? 0 : c;
   
   
   
   
 edge[v][u] = edge[u][v];
   
   
   
   
 }
   
   
   
   
}
   
   
   
   

   
   
   
   
// m: number of edge
   
   
   
   
// n: number of vertices
   
   
   
   
// s: index of start place
   
   
   
   
// e: index destination
   
   
   
   
void dijkstra(const int m, const int n, const int s, 
   
   
   
   
 const int e, const bool isPath = false) 
   
   
   
   
{
   
   
   
   
 for(int i = 0; i < n; i++) {
   
   
   
   
 dist[i] = i == s ? 0 : INF;
   
   
   
   
 parent[i] = -1;
   
   
   
   
 }
   
   
   
   
 // 
   
   
   
   
 memset(visit, false, sizeof(visit));
   
   
   
   
 /*
   
   
   
   
 n iteration because there are n vertices
   
   
   
   
 each iteration t, select the t th vertex whose cost is t th smallest,
   
   
   
   
 then refresh the weights beteen it and other vertices
   
   
   
   
 */
   
   
   
   
 for(int i = 0; i < n; i++) {
   
   
   
   
 int u = -1, c = INF;
   
   
   
   
 for(int j = 0; j < n; j++) {
   
   
   
   
 if(!visit[j] && dist[j] <= c) {
   
   
   
   
 u = j;
   
   
   
   
 c = dist[j];
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   

   
   
   
   
 if(u == -1) {
   
   
   
   
 continue;
   
   
   
   
 // exit(1);
   
   
   
   
 }
   
   
   
   

   
   
   
   
 visit[u] = true;
   
   
   
   

   
   
   
   
 // relax, at the same time, record the path
   
   
   
   
 for(int v = 0; v < n; v++) {
   
   
   
   
 if(dist[v] > dist[u] + edge[u][v]) {
   
   
   
   
 dist[v] = dist[u] + edge[u][v];
   
   
   
   
 parent[v] = u;
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   

   
   
   
   
 if(dist[e] < INF) {
   
   
   
   
 std::cout << dist[e] << endl;
   
   
   
   
 }
   
   
   
   

   
   
   
   
 if(isPath) {
   
   
   
   
 int v = e;
   
   
   
   
 std::cout << "end <- ";
   
   
   
   
 while(parent[v] != -1) {
   
   
   
   
 std::cout << v << " <- ";
   
   
   
   
 v = parent[v];
   
   
   
   
 }
   
   
   
   
 std::cout << v << " <- start" << std::endl;
   
   
   
   
 }
   
   
   
   
}
   
   
   
   

   
   
   
   
int main() {
   
   
   
   
 /*
   
   
   
   
 test case:
   
   
   
   
 1
   
   
   
   
 5 6
   
   
   
   
 0 1 10 1
   
   
   
   
 1 2 20 1
   
   
   
   
 2 4 2 0
   
   
   
   
 0 3 1 0
   
   
   
   
 3 4 2 0
   
   
   
   
 0 2 40 1
   
   
   
   
 0 4
   
   
   
   
 ans: 2
   
   
   
   
 */
   
   
   
   
 int T;
   
   
   
   
 cin >> T;
   
   
   
   
 while(T--) {
   
   
   
   
 int m, n;
   
   
   
   
 int s, e;
   
   
   
   
 // get the numbers of vertices and edges
   
   
   
   
 cin >> n >> m;
   
   
   
   
 // inti the edges or weights and something else
   
   
   
   
 init(m, n);
   
   
   
   
 // get start place and destination
   
   
   
   
 cin >> s >> e;
   
   
   
   

   
   
   
   
 bool isPath = true;
   
   
   
   
 // find the shortest path and its corresponding cost
   
   
   
   
 dijkstra(m, n, s, e, isPath);
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

Floyd

  
  
  
  

   
   
   
   
#include <stdio.h>
   
   
   
   
#include <iostream>
   
   
   
   
#include <list>
   
   
   
   
#include <map>
   
   
   
   
#include <vector>
   
   
   
   
#include <string>
   
   
   
   
#include <cstring>
   
   
   
   
#include <string.h>
   
   
   
   

   
   
   
   
using namespace std;
   
   
   
   

   
   
   
   
const int N = 102;
   
   
   
   
const int M = N * N;
   
   
   
   
const int INF = 100000;
   
   
   
   

   
   
   
   
bool visit[N];
   
   
   
   
int edge[N][N];
   
   
   
   

   
   
   
   
// m: number of edge
   
   
   
   
// n: number of vertices
   
   
   
   
void init(const int m, const int n) {
   
   
   
   
 // memset(edge, INF, sizeof(edge));
   
   
   
   
 // memset(edge, INF, M * sizeof(int));
   
   
   
   
 for(int i = 0; i < n; i++) {
   
   
   
   
 for(int j = 0; j < n; j++) {
   
   
   
   
 if(i == j) {
   
   
   
   
 edge[i][j] = 0;
   
   
   
   
 continue;
   
   
   
   
 }
   
   
   
   
 edge[i][j] = INF;
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 memset(visit, false, sizeof(visit));
   
   
   
   

   
   
   
   
 int u, v, c, flag;
   
   
   
   
 for(int i = 0; i < m; i++) {
   
   
   
   
 cin >> u >> v >> c >> flag;
   
   
   
   

   
   
   
   
 edge[u][v] = flag ? 0 : c;
   
   
   
   
 edge[v][u] = edge[u][v];
   
   
   
   
 }
   
   
   
   
}
   
   
   
   

   
   
   
   
// m: number of edge
   
   
   
   
// n: number of vertices
   
   
   
   
void Floyd(const int m, const int n) {
   
   
   
   
 for(int k = 0; k < n; k++) {
   
   
   
   
 for(int i = 0; i < n; i++) {
   
   
   
   
 for(int j = 0; j < n; j++) {
   
   
   
   
 // if(edge[i][j] < INF && edge[i][k] < INF && edge[k][j] < INF) { 
   
   
   
   
 // error
   
   
   
   
 // if(edge[i][j] <= INF && edge[i][k] <= INF && edge[k][j] <= INF) { 
   
   
   
   
 // right, but no meaning
   
   
   
   
 // if(edge[i][j] < INF && edge[k][j] < INF) { 
   
   
   
   
 // error
   
   
   
   
 if(edge[i][j] < INF && edge[k][j] < INF) { 
   
   
   
   
 // right
   
   
   
   
 if(edge[i][j] > edge[i][k] + edge[k][j]) {
   
   
   
   
 edge[i][j] = edge[i][k] + edge[k][j];
   
   
   
   
 edge[j][i] = edge[i][j];
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
}
   
   
   
   

   
   
   
   
int main() {
   
   
   
   
 /*
   
   
   
   
 test case:
   
   
   
   
 1
   
   
   
   
 5 6
   
   
   
   
 0 1 10 1
   
   
   
   
 1 2 20 1
   
   
   
   
 2 4 2 0
   
   
   
   
 0 3 1 0
   
   
   
   
 3 4 2 0
   
   
   
   
 0 2 40 1
   
   
   
   
 0 4
   
   
   
   
 ans: 2
   
   
   
   
 */
   
   
   
   
 int T;
   
   
   
   
 cin >> T;
   
   
   
   
 while(T--) {
   
   
   
   
 int m, n;
   
   
   
   
 int s, e;
   
   
   
   
 // get the numbers of vertices and edges
   
   
   
   
 cin >> n >> m;
   
   
   
   
 // inti the edges or weights and something else
   
   
   
   
 init(m, n);
   
   
   
   
 // get start place and destination
   
   
   
   
 cin >> s >> e;
   
   
   
   

   
   
   
   
 std::cout << "s: " << s << ", e: " << e << std::endl;
   
   
   
   
 // find the shortest path and its corresponding cost
   
   
   
   
 Floyd(m, n);
   
   
   
   

   
   
   
   
 int cost = edge[s][e];
   
   
   
   
 if(cost < INF) {
   
   
   
   
 std::cout << cost << std::endl;
   
   
   
   
 } else {
   
   
   
   
 std::cout << "failed: ";
   
   
   
   
 std::cout << -1 << std::endl;
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
}