【算法讲19：同余最短路】跳楼机 | 墨墨的等式 | Lazy Running

最新推荐文章于 2023-07-09 16:26:53 发布

溢流眼泪

最新推荐文章于 2023-07-09 16:26:53 发布

阅读量254

点赞数 1

分类专栏：【算法/知识点浅谈】【各类ACM真题】文章标签：算法最短路同余最短路

本文链接：https://blog.csdn.net/weixin_45775438/article/details/114637658

版权

【各类ACM真题】同时被 2 个专栏收录

130 篇文章 20 订阅

订阅专栏

【算法/知识点浅谈】

65 篇文章 10 订阅

订阅专栏

【算法讲19：同余最短路】

补充
例题一
思路一：动态规划
$\lceil$ 同余最短路 $\rfloor$
- 核心代码 $\color{green}Accepted$
例题二
例题三

补充

同余最短路 是一个集 数学同余表达 与 图论最短路 结合的算法。
不是很难，需要尽早掌握。

例题一

【链接】
跳楼机 | 洛谷 P3403
【题意】
你一开始在第一层。一共有 $h$ 层。
你每一次操作，可以向上 $x$ 层，或向上 $y$ 层，或向上 $z$ 层，或回到第一层。
问你一共有多少层楼是你可以到达的。
【范围】
$1\le h\le 2^{63}-1$
$1\le x,y,z\le 10^5$

思路一：动态规划

设 $d p [x]$ ，其中 $d p [x] = 1$ 表示能到达这一层楼，否则表示不能到达这一层楼。
我们得到简单的状态转移方程：
$dp[t]=dp[t-x]\ |\ dp[t-y] \ |\ dp[t-z]$
简单的初始化： $d p [1] = 1, d p [t < 1] = 0$ ，这里下标记作可以为负。
但是由于我们的 $h$ 达到了很大的数量级，故这种做法时间复杂度为 $O (h)$ ，只能得到 $\color{red}TLE$

$\lceil$ 同余最短路 $\rfloor$

考虑到，如果我们通过某些操作到达了第 $i$ 层，那么我们可以到达 $i + a x$ 层，其中 $a\in \mathbb{N}$
那么，如果我们能到达 $i$ 层，这一层及上面还可以到达的层数为 $\lfloor\dfrac{h-i}{x}\rfloor+1$ 层。
容易得到，如果能到达 $i + a x$ 层，其中 $a\in \mathbb{N}$ ，那么必然能到达 $i$ 层。
不妨，我们求出最小的一些 $i$ ，使得 $i$ 层为不用操作 $x$ 就能到达的最小楼层。
从同余的角度分析，即求出每一个 $i\in[0,a)$ ，算出到达 $t\%a=i$ 层的最小的 $t$ 。
我们设 $d p [i]$ 表示 $\min_t\{t\%a=i\quad 满足\quad t=by+cz，其中 b,c\in \mathbb{N}\}$
式子按照数学的角度设出来比较合理，但是做起来比较复杂。此时我们要按照图论的角度去分析了。
如果我们能到达 $i$ 层，那么我们还能到达 $i + y$ 层和 $i + z$ 层，当然前提是层数 $\le h$
按照 $d p$ 式子建图，即 $i\overset{边权为y}{\rightarrow}(i+y)\%a$ 和 $i\overset{边权为z}{\rightarrow}(i+z)\%a$
容易得到这就是跑一个最短路。点数和边数都是 $1 e 5$ 级别的，用 $d i j k s t r a$ 即可。

核心代码 $\color{green}Accepted$

时间复杂度： $O(a\log a)$

/*
 _            __   __          _          _
| |           \ \ / /         | |        (_)
| |__  _   _   \ V /__ _ _ __ | |     ___ _
| '_ \| | | |   \ // _` | '_ \| |    / _ \ |
| |_) | |_| |   | | (_| | | | | |___|  __/ |
|_.__/ \__, |   \_/\__,_|_| |_\_____/\___|_|
        __/ |
       |___/
*/
ll h;int a,b,c;
ll dp[MAX];
vector<int>V[MAX],G[MAX];
priority_queue<pair<ll,ll> >Q;

void dijkstra(int s){
    Q.push(make_pair(-1,s));
    while(!Q.empty()){
        int x = Q.top().second;
        ll t = -Q.top().first;
        Q.pop();
        if(t > dp[x])continue;
        for(auto it : V[x]){
            if(dp[it] > dp[x] + a && dp[x] + a <= h){
                dp[it] = dp[x] + a;
                Q.push(make_pair(-dp[it],it));
            }
        }
        for(auto it : G[x]){
            if(dp[it] > dp[x] + b && dp[x] + b <= h){
                dp[it] = dp[x] + b;
                Q.push(make_pair(-dp[it],it));
            }
        }
    }
}

int main()
{
    cin >> h >> a >> b >> c;

    for(int i = 0;i < c;++i)dp[i] = LINF;
    dp[1] = 1;
    for(int i = 0;i <= c;++i){
        V[i].push_back((i+a)%c);
        G[i].push_back((i+b)%c);
    }
    dijkstra(1);
    ll res = 0;
    for(int i = 0;i < c;++i){
        if(dp[i] == LINF)continue;
        res = res + ((h - dp[i]) / c) + 1;
    }
    cout << res;
    return 0;
}

例题二

【链接】墨墨的等式 | 洛谷 P2371
【题意】
给定 $n,a_1,\cdots,a_n,l,r$
问你有多少组非负解向量 $x_1,\cdots,x_n$ ，满足：
$\sum_{i=1}^na_ix_i\in[l,r]$
【范围】
$n\le 12$
$0\le a_i\le 5\times 10^5$
$1\le l\le r\le 10^{12}$
【思路】
首先和第一题的跳楼机非常非常像。跳楼机的每种操作次数相当于这里的解向量的元素 $x_i$ 的值。
为了方便，设 $d p [i]$ 表示 $\min_h\{h\%a_1=i\quad并且\quad h可以到达\}$
然后正常地去建图貌似就没区别了。
不过它让你求 $[l, r]$ 范围内解的数量，我们只要求出 $[1, r]$ 数量减去 $[1, l - 1]$ 数量即可。
【代码】 $\color{green}Accepted$
时间复杂度： $O(n\times a_1\log a_1)$

/*
 _            __   __          _          _
| |           \ \ / /         | |        (_)
| |__  _   _   \ V /__ _ _ __ | |     ___ _
| '_ \| | | |   \ // _` | '_ \| |    / _ \ |
| |_) | |_| |   | | (_| | | | | |___|  __/ |
|_.__/ \__, |   \_/\__,_|_| |_\_____/\___|_|
        __/ |
       |___/
*/
int n;
int aa[20];
ll dp[MAX];
ll V[MAX][17];
priority_queue<pair<ll,ll> >Q;

void dijkstra(int s,ll h){
    Q.push(make_pair(0,s));
    while(!Q.empty()){
        int x = Q.top().second;
        ll t = -Q.top().first;
        Q.pop();
        if(t > dp[x])continue;
        for(int i = 2;i <= n;++i){
            int it = V[x][i];
            if(dp[it] > dp[x] + aa[i] && dp[x] + aa[i] <= h){
                dp[it] = dp[x] + aa[i];
                Q.push(make_pair(-dp[it],it));
            }
        }

    }
}
ll solve(ll h){
    for(int i = 0;i < aa[1];++i)dp[i] = LINF;
    dp[0] = 0;
    for(int i = 0;i < aa[1];++i){
        for(int j = 2;j <= n;++j){
            V[i][j] = (i+aa[j]) % aa[1];
        }
    }
    dijkstra(0,h);
    ll res = 0;
    for(int i = 0;i < aa[1];++i){
        if(dp[i] == LINF)continue;
        res = res + ((h - dp[i]) / aa[1]) + 1;
    }
    return res;
}
int main()
{
    ll l,r;
    cin >> n >> l >> r;
    for(int i = 1;i <= n;++i)cin >> aa[i];
    ll res = solve(r) - solve(l-1);
    cout << res;
    return 0;
}

例题三

【链接】
Lazy Running | HDU 6071
【题意】
有四个点。给出 $d_{1,2}$ ， $d_{2,3}$ ， $d_{3,4}$ ， $d_{4,1}$ ，表示两个点之间的无向边的长度。
问你，从点二出发到点二结束，路径距离和 $\ge K$ 的最小值为多少。
【范围】
$1\le d\le 3\times 10^4$
$1\le K\le 10^{18}$
【思路】
设 $w=\min(d_{1,2},d_{2,3})$ 。
如果你跑到 $2$ 号点已经走了 $x$ 距离的话，你可以通过来回跳跃，每次增加 $2 w$ 的方式到达 $2$ 号点。
于是，此时最短路长度为： $x+2wt\ge K$ ，满足 $t\ge0$
就跟跳楼机类似。
我们只需要求出 $i\in[0,2w)$ ，到每个节点 $v$ 的路径长模 $i$ 的最小值 $d p [x] [i]$ 即可。
然后我们需要求得所有的 $d p [2] [i]$ ，然后求出最小的 $t\ge0$ 满足 $x+2wt\ge K$
那么答案即为 $min\{x+2wt\}$
一些小细节：
虽然我们对于每一个点都有 $2 w$ 个状态，那么我们优先队列是不是需要存 ${x,i,dp[x][i]\}$ 呢？这里不需要，因为根据定义得到 $dp[x][i]\%2w=i$ ，我们少存一维状态，可以节省许多时间和内存，防止代码超时。
【代码】 $\color{green}Accepted$
时间复杂度： $O(d\log d)$

/*
 _            __   __          _          _
| |           \ \ / /         | |        (_)
| |__  _   _   \ V /__ _ _ __ | |     ___ _
| '_ \| | | |   \ // _` | '_ \| |    / _ \ |
| |_) | |_| |   | | (_| | | | | |___|  __/ |
|_.__/ \__, |   \_/\__,_|_| |_\_____/\___|_|
        __/ |
       |___/
*/
ll K;
int aa[5][5];
ll dp[10][MAX];
struct node{
    int x;
    ll shu;
    bool operator < (const node &ND)const{
        return shu > ND.shu;
    }
};
priority_queue<node>Q;

vector<pair<int,int> >V[5];

void dijkstra(int s,ll w){
    Q.push({s,0});
    while(!Q.empty()){
        int x = Q.top().x;
        int y = Q.top().shu % w;
        ll t = Q.top().shu;
        Q.pop();
        if(t > dp[x][y])continue;
        for(auto it : V[x]){
            int to = it.first;
            int  d = it.second;
            if(dp[to][(t + d) % w] > t + d){
                dp[to][(t + d) % w] = t + d;
                Q.push({to,dp[to][(t + d) % w]});
            }
        }
    }
}
ll solve(){
    ll w = min(aa[1][2],aa[2][3]);
    w = w * 2;
    if(w >= K)return w;
    for(int i = 1;i <= 4;++i)
        for(int j = 0;j < w;++j)
            dp[i][j] = LINF;
    dp[2][0] = 0;
    dijkstra(2,w);
    ll res = LINF;
    for(int i = 0;i < w;++i){
        if(dp[2][i] == LINF)continue;
        if(dp[2][i] >= K){				/// 我们不能允许 t 为负数
            res = min(res,dp[2][i]);
            continue;
        }								/// 简单使用 floor 函数会导致精度出现错误
        res = min(res,dp[2][i] + w * (((K - dp[2][i]) / w) + ((K - dp[2][i]) % w != 0 ? 1LL : 0LL)));
    }
    return res;
}
int main()
{

    int T;cin >> T;
    while(T--){
        cin >> K >> aa[1][2] >> aa[2][3] >> aa[3][4] >> aa[4][1];
        aa[2][1] = aa[1][2];
        aa[3][2] = aa[2][3];
        aa[4][3] = aa[3][4];
        aa[1][4] = aa[4][1];
        for(int i = 1;i <= 4;++i)V[i].clear();

        for(int i = 1;i <= 4;++i){
            int to = i % 4 + 1;
            V[i].push_back(make_pair(to,aa[i][to]));
            V[to].push_back(make_pair(i,aa[i][to]));
        }
        cout << solve() << endl;
    }
    return 0;
}

溢流眼泪

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【算法讲19：同余最短路】跳楼机 | 墨墨的等式 | Lazy Running

【算法讲19：同余最短路】补充例题一思路一：动态规划⌈\lceil⌈同余最短路⌋\rfloor⌋核心代码 Accepted\color{green}AcceptedAccepted例题二例题三补充同余最短路是一个集数学同余表达与图论最短路结合的算法。不是很难，需要尽早掌握。例题一【链接】跳楼机 | 洛谷 P3403【题意】你一开始在第一层。一共有 hhh 层。你每一次操作，可以向上 xxx 层，或向上 yyy 层，或向上 zzz 层，或回到第一层。问你一共有多少层楼是你可
复制链接

扫一扫