Leetcode 787. K 站中转内最便宜的航班

有 n 个城市通过一些航班连接。给你一个数组 flights ，其中 flights[i] = [fromi, toi, pricei] ，表示该航班都从城市 fromi 开始，以价格 pricei 抵达 toi。

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到出一条最多经过 k 站中转的路线，使得从 src 到 dst 的 价格最便宜 ，并返回该价格。 如果不存在这样的路线，则输出 -1。

示例 1：

输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
输出: 200
解释: 
城市航班图如下

从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图中红色所示。
示例 2：

输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
输出: 500
解释: 
城市航班图如下

从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500，如图中蓝色所示。
 

提示：

1 <= n <= 100
0 <= flights.length <= (n * (n - 1) / 2)
flights[i].length == 3
0 <= fromi, toi < n
fromi != toi
1 <= pricei <= 104
航班没有重复，且不存在自环
0 <= src, dst, k < n

src != dst

最开始用的BFS。初始状态只有src点在队列中，每次将可达到的点进入队列并且更新到达各个点的cost，最后找到dst的最小cost即可。

需要注意的是进入队列时的剪枝，共有3点：1）对于到达不了的点；2）k-1次中转，并且下一个点不是dst；3）用一个ans数组记录到达各个点的最小cost，只有能够使得这个数组更新的点能够进入队列

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        int vis[105][105] = {0};
        int ans[105];
        int len = flights.size();
        for (int i = 0; i < len; ++i) {
            vis[flights[i][0]][flights[i][1]] = flights[i][2];
        }
        memset(ans, 0x3f3f3f3f, sizeof(ans));
        int res = 0x3f3f3f3f;
        struct node {
            int pos;
            int cost;
            int num_k;
        };
        queue<node> q;
        node start = node{src, 0, -1};
        q.push(start);
        while (!q.empty()) {
            node tmp = q.front();
            q.pop();
            if (tmp.pos == dst) {
                res = res < tmp.cost ? res : tmp.cost;
            }
            for (int i = 0; i < n; ++i) {
                if (vis[tmp.pos][i] == 0) continue;
                if ((tmp.num_k == (k-1)) && i != dst) continue;
                if (tmp.cost + vis[tmp.pos][i] < ans[i]) {
                    ans[i] = tmp.cost + vis[tmp.pos][i];
                    node next = node{i, ans[i], tmp.num_k+1};
                    q.push(next);
                }
            }
        }
        if (res == 0x3f3f3f3f) res = -1;
        return res;
    }
};

后来试了一下DP，用DP写了。

遇到了一个问题就是状态转移方程，起初状态转移方程为：“第k次中转的时候到达各个点的费用(还是距离什么的来着，总之是一个值)，是由上一次已经在这个点或者下次能到达这个点的值之间比较而来”，但是错了。

ans[i][flights[j][1]] = min(ans[i-1][flights[j][1]], ans[i-1][flights[j][0]] + flights[j][2]);

 后来思考发现，这样比较是不平等的2个状态之间的比较，即上次就能到达这个点的距离与下次到达这个点的距离之间的比较；换句话说，这次for循环里面更新的值会被替换掉，什么意思呢？比如在j=0的时候发现了一个更小的值并且进行了更新，在此后的j=1,j=2,j=3,...的操作中，都会去更新这个等式左端的值，因为我们比较的2个值中的左端的值ans[i][flights[j][1]]并没有因为j=0时候的更新而更新，她是上个状态的值，是不变的。

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        int len = flights.size();
        int ans[105][105];
        int res = 0x3f3f3f3f;
        memset(ans, 0x3f3f3f3f, sizeof(ans));
        ans[0][src] = 0;
        for (int i = 0; i < len; ++i) {
            if (flights[i][0] == src) {
                ans[0][flights[i][1]] = flights[i][2];
                if (flights[i][1] == dst && ans[0][flights[i][1]] < res)
                    res = flights[i][2];
            }
        }
        for (int i = 1; i <= k; ++i) {
            ans[i][src] = 0;
            for (int j = 0; j < len; ++j) {
                ans[i][flights[j][1]] = min(ans[i][flights[j][1]], ans[i-1][flights[j][0]] + flights[j][2]);
                if (flights[j][1] == dst && ans[i][flights[j][1]] < res)
                    res = ans[i][flights[j][1]];
            }
        }
        if (res == 0x3f3f3f3f) res = -1;
        return res;
    }
};