传送门

题意：求最短路，多了一个约束条件，可以将一条边的花费变为0或者两条相连的边的花费都变为0。

废话：很早在OJ上看到的题，当时不会做，现在终于可以把这道题干掉了(结果自己疯狂WA，居然是多组输入！！！！！)

解题思路：
 表示三种状态
 表示还没有使用过免费边
 表示还可以接着上一条边再使用一次免费边
 已经把免费边用光了

代码：

///#include<bits/stdc++.h>
///#include<unordered_map>
///#include<unordered_set>
#include<iostream>
#include<cstring>
#include<cmath>
#include<queue>

#define MT(a, b) memset(a,b,sizeof(a)
#define lowbit(x) (x&(-x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai = acos(-1.0);
const double E = 2.718281828459;
const ll mod = 998244353;
const ll INF = 0x3f3f3f3f3f3f;
const int maxn = 1e3 + 5;

int dis[maxn][3];
/// dis[i][0] 表示还没使用过免费边
/// dis[i][1] 表示还可以接着上一次使用一条免费边
/// dis[i][2] 表示免费边已经使用过了
int head[maxn], sign;

struct node {
    int e, c;
    int state;

    bool friend operator<(node a, node b) {
        return a.c > b.c;
    }
} load[maxn * maxn];

void add_edge(int s, int e, int c) {
    load[++sign] = node{e, c, head[s]};
    head[s] = sign;
}

void init() {
    sign = 0;
    memset(dis, 127, sizeof(dis));
    memset(head, -1, sizeof(head));
}

int main() {
    int n, c;
    while (~scanf("%d", &n)) {
        init();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                scanf("%d", &c);
                if (c) add_edge(i, j, c);
            }
        }
        priority_queue<node> q;
        dis[1][0] = dis[1][1] = dis[1][2] = 0;
        q.push(node{1, 0, 0});
        while (!q.empty()) {
            node w = q.top();
            q.pop();
            if (w.e == n) {
                printf("%d\n", w.c);
                break;
            }
            for (int u = head[w.e], i; ~u; u = load[u].state) {
                i = load[u].e;
                if (w.state == 0) {
                    if (dis[i][0] > w.c + load[u].c) {
                        dis[i][0] = w.c + load[u].c;
                        q.push(node{i, dis[i][0], 0});
                    }
                    if (dis[i][1] > w.c) {
                        dis[i][1] = w.c;
                        q.push(node{i, dis[i][1], 1});
                    }
                } else if (w.state == 1) {

                    if (dis[i][2] > w.c) {
                        dis[i][2] = w.c;
                        q.push(node{i, dis[i][2], 2});
                    }
                } else {
                    if (dis[i][2] > w.c + load[u].c) {
                        dis[i][2] = w.c + load[u].c;
                        q.push(node{i, dis[i][2], 2});
                    }
                }
            }
        }
    }
    return 0;
}