CF1442C Graph Transpositions 分层图

• 题目链接：https://codeforces.com/problemset/problem/1442/C
• 解题思路：发现当反转18次的时候，代价是超过最大的m的，所以分开讨论，首先计算出从起点到达终点最少需要多少次反转，如果超过18次，按最少次数转移，同时计算出最少次数下的最短路，当小于18次时，这个时候，所需要的所有代价不会超过long long（所以取模后不会丢失大小关系），所以可以直接使用dijkstra求解

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 1000005;
const ll MOD = 998244353;
int n , m;
int head[N] , cnt;
struct Edge {
    int next, w, t;
}edge[N << 1];
void add (int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
struct node
{
    int v;
    int value;
    node(int a, int b):v(a),value(b){};
    //在堆中这样代表从小到大排序
    bool operator < (const node& no) const {
        return value > no.value;
    }
};
int dis[N][2];
int len[N][2];
void dijkstra(int s)
{
    mem (dis, INF);
    mem (len, INF);
    p_queue <node> q;
    dis[s][0] = len[s][0] = 0;
    q.push(node(s,0));
    while(!q.empty())
    {
        node no = q.top();
        q.pop();
        int u = no.v;
        for(int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].t , w = edge[i].w;
            if (w == 0)
            {
                if (dis[v][0] > min (dis[u][1] + 1, dis[u][0]))
                {
                    dis[v][0] = min(dis[u][1] + 1, dis[u][0]);
                    if (dis[u][1] + 1 < dis[u][0])
                        len[v][0] = len[u][1] + 1;
                    else if (dis[u][1] + 1 == dis[u][0])
                        len[v][0] = min (len[u][1], len[u][0]) + 1;
                    else
                        len[v][0] = len[u][0] + 1;
                    q.push (node(v,dis[v][0]));
                }
                else if (dis[v][0] == min (dis[u][0], dis[u][1] + 1))
                {
                    if (dis[v][0] == dis[u][1] + 1)
                        len[v][0] = min (len[v][0], len[u][1] + 1);
                    if (dis[v][0] == dis[u][0])
                        len[v][0] = min (len[v][0], len[u][0] + 1);
                }
            }
            else
            {
                if (dis[v][1] > min (dis[u][1] , dis[u][0] + 1))
                {
                    dis[v][1] = min (dis[u][1] , dis[u][0] + 1);
                    if (dis[u][1] < dis[u][0] + 1)
                        len[v][1] = len[u][1] + 1;
                    else if (dis[u][1] == dis[u][0] + 1)
                        len[v][1] = min (len[u][1], len[u][0]) + 1;
                    else
                        len[v][1] = len[u][0] + 1;
                    q.push (node(v,dis[v][1]));
                }
                else if (dis[v][1] == min (dis[u][1], dis[u][0] + 1))
                {
                    if (dis[v][1] == dis[u][0] + 1)
                        len[v][1] = min (len[v][1], len[u][0] + 1);
                    if (dis[v][1] == dis[u][1])
                        len[v][1] = min (len[v][1], len[u][1] + 1);
                }
            }
        }
    }
}
struct node2
{
    int v;
    int p;
    int k;
    int value;
    node2(int a, int b, int c , int d):v(a),value(b),k(c),p(d){};
    //在堆中这样代表从小到大排序
    bool operator < (const node2& no) const {
        return value > no.value;
    }
};
int dis2[N][50];
ll q_pow(ll a, ll p) {  //快速幂
    ll sum = 1;
    while(p) {
        if(p & 1) {
            sum = sum * a % MOD;
        }
        a = a * a % MOD;
        p >>= 1;
    }
    return sum;
}
int fac[25];
void init()
{
    fac[0] = 1;
    for (int i = 1 ; i <= 20 ; i ++)
        fac[i] = fac[i-1] * 2;
}
void dijkstra2(int s)
{
    mem(dis2,INF);
    p_queue <node2> q;
    dis2[s][0] = 0;
    q.push(node2(s,0,0, 0));
    while(!q.empty())
    {
        node2 no = q.top();
        q.pop();
        int now = no.p;
        int k = no.k;
        int u = no.v;
        if (k > 17) continue;
        for(int i = head[u] ; i != -1 ; i = edge[i].next)
        {
            int v = edge[i].t , w = edge[i].w;
            if (w == now)
            {
                if (k - 1 >= 0 && dis2[v][k] > min (dis2[u][k] + 1, dis2[u][k-1] + 1 + fac[k-1]))
                {
                    dis2[v][k] = min(dis2[u][k] + 1, dis2[u][k - 1] + 1 + fac[k-1]);
                    q.push (node2(v, dis2[v][k], k , now));
                }
                if (k - 1 < 0 && dis2[v][k] > dis2[u][k] + 1)
                {
                    dis2[v][k] = dis2[u][k] + 1;
                    q.push(node2(v, dis2[v][k], k, now));
                }
            }
            else
            {
                if (dis2[v][k+1] > dis2[u][k] + 1 +fac[k])
                {
                    dis2[v][k+1] = dis2[u][k] + 1 + fac[k];
                    q.push (node2(v, dis2[v][k + 1], k + 1, now^1));
                }
            }
        }
    }
}
int main ()
{
    init();
    mem (head, -1);
    read (n , m);
    for (int i = 1 ; i <= m ; i ++)
    {
        int u , v;
        read (u, v);
        add (u, v, 0);
        add (v, u, 1);
    }
    dijkstra (1);
    int k , l;
    if (dis[n][0] < dis[n][1])
        k = dis[n][0] , l = len[n][0];
    else if (dis[n][0] > dis[n][1])
        k = dis[n][1] , l = len[n][1];
    else
        k = dis[n][1] , l = min(len[n][1],len[n][0]);

    if (k > 17) {
        ll ans = (l+q_pow(2,k)-1+MOD)%MOD;
        write(ans), LF;
    }
    else
    {
        dijkstra2(1);
        int ans = INF;
        for (int i = 0 ; i <= 18 ; i ++)
            ans = min(ans,dis2[n][i]);
        cout << ans << endl;
    }
    return 0;

}