算法设计与分析: 3-10 汽车加油行驶问题

3-10 汽车加油行驶问题

---

问题描述

给定一个 N*N的方形网格，设其左上角为起点◎，坐标为（ 1，1），X轴向右为正， Y轴向下为正，每个方格边长为 1，如图所示。一辆汽车从起点◎出发驶向右下角终点▲，其坐标为（ N，N）。在若干个网格交叉点处，设置了油库，可供汽车在行驶途中加油。汽车在行驶过程中应遵守如下规则：
(1)汽车只能沿网格边行驶，装满油后能行驶 K条网格边。出发时汽车已装满油，在起点与终点处不设油库。
(2)汽车经过一条网格边时，若其 X坐标或 Y坐标减小，则应付费用 B，否则免付费用。
(3)汽车在行驶过程中遇油库则应加满油并付加油费用 A。
(4)在需要时可在网格点处增设油库，并付增设油库费用 C（不含加油费用 A）。
(5)(1)～(4)中的各数 N、K、A、B、C均为正整数，且满足约束：2 ≤ N ≤ 100，2 ≤ K ≤ 10。设计一个算法，求出汽车从起点出发到达终点的一条所付费用最少的行驶路线。

数据输入：
文件的第一行是 N，K，A，B，C的值。第二行起是一个 N*N的 0-1方阵，每行 N个值，至 N+1行结束。方阵的第 i行第 j列处的值为 1表示在网格交叉点（ i，j）处设置了一个油库，为 0时表示未设油库。各行相邻两个数以空格分隔。

---

Java

import java.util.Scanner;

public class QiCheJiaYouXingShi {
    private static int N;  //方形网络规模
    private static int A;  //汽车在行驶过程中遇到油库应加满油并付加油费A
    private static int C;  //在需要时可在网格点处增设油库，并付增设油库费用C（不含加油费A）
    private static int B;  //当汽车行驶经过一条网格边时，如果其x坐标或y坐标减少，应付费用B
    private static int K;  //装满油后，能行驶K条边

    private static int[][][] f = new int[50][50][2];
    private static int[][] s = {{-1,0,B},{0,-1,B},{1,0,0},{0,1,0}};

    private static int[][] a = new int[50][50];  //方形网络

    private static int MAX = 100000;
    private static int leastFee;

    public static void main(String[] args){

        /*
        f[i][j][0]表示汽车从网格点(1,1)行驶至网格点(i,j)所需的最少费用
        f[i][j][1]表示汽车行驶至网格点(i,j)后还能行驶的网格边数

        s[i][0]表示x轴方向
        s[i][1]表示y轴方向
        s[i][2]表示行驶费用

        f[i][j][0] = min{f[ i+s[k][0] ] [ [j+s[k][1] ][0] + s[k][2]}
        f[i][j][1] = f[ i+s[k][0] ][ [j+s[k][1] ][1] - 1

        f[1][1][0] = 0
        f[1][1][1] = K
        f[i][j][0] = f[i][j][0] + A , f[i][j][1] = K   如果(i, j)是油库
        f[i][j][0] = f[i][j][0] + C + A, f[i][j][1] = K  (i, j)不是油库，且f[i][j][1] = 0
        */

        /*
        input data:
        9 3 2 3 6
        0 0 0 0 1 0 0 0 0
        0 0 0 1 0 1 1 0 0
        1 0 1 0 0 0 0 1 0
        0 0 0 0 0 1 0 0 1
        1 0 0 1 0 0 1 0 0
        0 1 0 0 0 0 0 1 0
        0 0 0 0 1 0 0 0 1
        1 0 0 1 0 0 0 1 0
        0 1 0 0 0 0 0 0 0
        */
        Scanner input = new Scanner(System.in);
        N = input.nextInt();//方格规模
        K = input.nextInt();//装满油后能行驶的网格边数
        A = input.nextInt();//加油费
        B = input.nextInt();//坐标减少时应付的费用
        C = input.nextInt();//增设油库费用

        for(int i=1; i<=N; i++){//输入方形网络
            for(int j=1; j<=N; j++){
                a[i][j] = input.nextInt();
            }
        }

        leastFee = dynamic();
        System.out.println(leastFee);//最优行驶路线所需的费用，即最小费用
    }

    private static int dynamic(){
        int i, j, k;
        for (i=1;i<=N;i++){
            for (j=1;j<=N;j++){
                f[i][j][0]=MAX;
                f[i][j][1]=K;
            }
        }

        f[1][1][0] = 0;
        f[1][1][1] = K;

        boolean finish = false;
        int tx, ty;
        while(!finish){
            finish = true;
            for(i=1; i<=N; i++){
                for(j=1; j<=N; j++){
                    if(i==1 && j==1)
                        continue;
                    int minFee = MAX;
                    int driveEdges = MAX;
                    int fee, canDriveEdges;
                    for(k=0; k<4; k++){ //可走的四个方向
                        tx = i + s[k][0];
                        ty = j + s[k][1];
                        if(tx<1 || ty<1 || tx>N || ty>N)  //如果出界
                            continue;

                        fee = f[tx][ty][0] + s[k][2];
                        canDriveEdges = f[tx][ty][1] - 1;
                        if(a[i][j] == 1){  //如果是油库
                            fee += A;
                            canDriveEdges = K;
                        }
                        if(a[i][j]==0 && canDriveEdges == 0 && (i!=N||j!=N)){  //如果不是油库,且油已经用完
                            fee += A + C;
                            canDriveEdges = K;
                        }
                        if(fee < minFee){  //记录更少费用
                            minFee = fee;
                            driveEdges = canDriveEdges;
                        }
                    }

                    if(f[i][j][0] > minFee){  //如果有更优解
                        finish = false;
                        f[i][j][0] = minFee;
                        f[i][j][1] = driveEdges;
                    }
                }
            }
        }
        return f[N][N][0];//汽车从网格点(1,1)行驶至网格点(N,N)所需的最少费用（亦即从起点到终点），此为所求
    }
}

---

Input & Output

9 3 2 3 6
0 0 0 0 1 0 0 0 0
0 0 0 1 0 1 1 0 0
1 0 1 0 0 0 0 1 0
0 0 0 0 0 1 0 0 1
1 0 0 1 0 0 1 0 0
0 1 0 0 0 0 0 1 0
0 0 0 0 1 0 0 0 1
1 0 0 1 0 0 0 1 0
0 1 0 0 0 0 0 0 0
12

---

Reference

王晓东《计算机算法设计与分析》（第3版）P92