JAVA代码—算法基础：航线问题

航线问题

题目描述：

给出一行数据，包含两个整数N（2<=N<=500），M（1<=M<=2000），用单个空格隔开。

其表示共有N个空港，M条航线，起点为1，终点为N。

接下来给出M行数据，每行包含5个整数：

P、Q（1<=P,Q<=n）、K（1<=K<=1000）、X、Y（0<=X，Y<=10000），

代表P、Q两个空港有航线并需要K天，并且该航线在第X天到第Y天天气恶劣不可通行。

计算最快需要多少天到达目的空港。

输入样例：

4 4

2 1 1 7 13

4 3 2 10 11

1 3 8 9 12

2 3 3 2 10

输出样例：

14

算法设计：

package com.bean.algorithmbasic;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

public class AirLineProblem {

/*
* 一行包含两个整数N（2<=N<=500），M（1<=M<=2000），用单个空格隔开。
* 表示共有N个空港，M条航线，起点为1，终点为N。
* 接下来M行，每行包含5个整数：
* P、Q（1<=P,Q<=n）、K（1<=K<=1000）、X、Y（0<=X，Y<=10000），
* 代表P、Q两个空港有航线并需要K天，并且该航线在第X天到第Y天天气恶劣不可通行。
*
* 输入样例：
*
* 4  4
* 2 1 1 7 13
* 4 3 2 10 11
* 1 3 8 9 12
* 2 3 3 2 10
*
* 输出样例：
* 14
*
* */

static class Flight {
public int P, Q, K, X, Y;

public Flight(int P, int Q) {
this.P = Math.min(P, Q);
this.Q = Math.max(P, Q);
}

public Flight(int P, int Q, int K, int X, int Y) {
this.P = Math.min(P, Q);
this.Q = Math.max(P, Q);
this.K = K;
this.X = X;
this.Y = Y;
}

@Override
public boolean equals(Object o) {
Flight f = (Flight) o;

return this.P == f.P && this.Q == f.Q;
}
}

public static void main(String[] args) throws FileNotFoundException {
System.setIn(new FileInputStream("G:\\AirLineProblem.txt"));
Scanner sc = new Scanner(System.in);

String s[] = sc.nextLine().split(" ");
int N = Integer.parseInt(s[0]);
int M = Integer.parseInt(s[1]);
ArrayList<Flight> flights = new ArrayList<Flight>();
int f[] = new int[N + 1];

for (int i = 0; i < M; i++) {
s = sc.nextLine().split(" ");
int P = Integer.parseInt(s[0]);
int Q = Integer.parseInt(s[1]);
int K = Integer.parseInt(s[2]);
int X = Integer.parseInt(s[3]);
int Y = Integer.parseInt(s[4]);

Flight flight = new Flight(P, Q, K, X, Y);
flights.add(flight);
}

for (int i = 2; i <= N; i++) {
f[i] = Integer.MAX_VALUE;

for (int j = 1; j < i; j++) {
Flight flight = new Flight(j, i);
int index = flights.indexOf(flight);

if (index != -1) {
flight = flights.get(index);

if (f[j] + flight.K < flight.X || f[j] > flight.Y) {
f[i] = Math.min(f[i], f[j] + flight.K + 1);
} else {
f[i] = Math.min(f[i], flight.Y + flight.K + 1);
}
}
}
}

System.out.println(f
);
}

}

（完）