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

定义

• 同余最短路常用于解决这样一类问题：

  有$n$个正整数$a_1,a_2,a_3,\cdots ,a_n$，设：
  $$x_1{a}_1+x_2{a}_2+x_3{a}_3+\cdots +x_n{a}_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\mathrm{m}\mathrm{o}\mathrm{d}{a}_1=i\}$ ，其中$i=0,1,2,\cdots ,a_1-1$，$f(i)$为即 可拼凑出的 使得$k\mathrm{m}\mathrm{o}\mathrm{d}{a}_1=i$ 的 最小的 $k$。

建图

首先根据定义易知：$f((i+a_j)\mathrm{m}\mathrm{o}\mathrm{d}{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)\mathrm{m}\mathrm{o}\mathrm{d}{a}_1=v\wedge 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|=\underset{i=1}{\overset{n}{\min }}\{a_i\}$，边数$|E|=n\times |V|$，利用堆优化Dijkstra算法求最短路时间复杂度为$O(|E|+|V|\log |V|)$。

---

例题

洛谷P2371 墨墨的等式

#include
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;
}