同餘最短路（洛谷P2371 墨墨的等式）

定義

• 同餘最短路常用於解決這樣一類問題：

  有$n$個正整數$a_1, a_2,a_3 , \cdots, a_n$，設：
  $x_1a_1+x_2a_2+x_3a_3+\cdots+x_na_n=k\;\;\;\;\;\;\;\;(x_1,x_2,x_3,\cdots,x_n\in N)$
  即 使用無限個$a_1,a_2,a_3,\cdots,a_n$進行拼湊，然後對$k$的可能值進行各種詢問（例如詢問$k$在$[l,r]$區間內的可能值個數，詢問$k$最大的無法拼湊的值，詢問某個定值$k$能否被拼湊出……）

---

算法思路

定義

取其中一個正整數作爲剩餘系，例如取$a_1$，設$f(i)=\min\{k | k \bmod a_1 = i\}$ ，其中$i =0,1,2,\cdots,a_1-1$，$f(i)$爲即 可拼湊出的 使得$k \bmod a_1 = i$ 的 最小的 $k$。

建圖

首先根據定義易知：$f((i+a_j)\bmod a_1 )=\min\{f(i)+a_j\}$ 且 $f(0)=0$，可以發現這和最短路的求法相同，

故可建圖$G=\{V,E\}$，其中$V=\{0,1,2,\cdots,a_1-1\}$，$E=\{<u,v,w>|(u+a_j) \bmod a_1 = v \land w=a_j\}$

然後從點$0$開始，求一遍最短路，到點$i$的最短路距離即爲$f(i)。$

結果

求得所有的$f(i)$後，

• 所有可拼湊出的值的集合即爲$\{k|k=f(i)+t\cdot a_1\;,t \in N \}$；
• 最大的無法拼湊出的值爲$\max\{k|k = f(i)-a_1\}$，若爲$-1$則表示所有值均可拼湊出來；
• 對於一個定值$k$，若需要知道其具體的拼湊方案，則還需記錄最短路的具體路徑。

時間複雜度

若$n$個正整數有重複值，則最好要去重，且應當取最小的$a_i$作爲剩餘系，這樣圖更小，求最短路的時間複雜度也更優。

結點數$|V| = \min \limits_{i=1}^n \{a_i\}$，邊數$|E|=n\times |V|$，利用堆優化Dijkstra算法求最短路時間複雜度爲$O(|E|+|V|\log|V|)$。

---

例題

洛谷P2371 墨墨的等式

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL, int> PLI;
const int INF = 0x3f3f3f3f;
const int LINF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 5e5 + 10;

int n, a[maxn];
LL l, r, dist[maxn];
struct edge
{
    int v;
    int w;
};
vector<edge> g[maxn];
bool vis[maxn];

void Dijkstra(int s)
{
    memset(dist, 0x3f, sizeof(dist));
    priority_queue<PLI, vector<PLI>, greater<PLI> > q;
    dist[s] = 0;
    q.push(make_pair(dist[s], s));
    while(!q.empty())
    {
        int u = q.top().second;
        q.pop();
        if(vis[u])
            continue;
        else
            vis[u] = true;
        for(auto e : g[u])
        {
            int v = e.v, w = e.w;
            if(!vis[v] && dist[u] + w < dist[v])
            {
                dist[v] = dist[u] + w;
                q.push(make_pair(dist[v], v));
            }
        }
    }
}
int main()
{
    scanf("%d %lld %lld", &n, &l, &r);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    sort(a + 1, a + n + 1);
    n = unique(a + 1, a + n + 1) - (a + 1);
    for(int i = 0; i < a[1]; i++)
        for(int j = 2; j <= n; j++)
            g[i].push_back(edge{(i + a[j]) % a[1], a[j]});
    Dijkstra(0);
    LL ans = 0;
    for(int i = 0; i < a[1]; i++)
    {
        if(r >= dist[i])
            ans += (r- dist[i]) / a[1] + 1;
        if(l - 1 >= dist[i])
            ans -= ((l - 1) - dist[i]) / a[1] + 1;
    }
    printf("%lld\n", ans);
	return 0;
}