AcWing Round #15

A. 青蛙跳

题目链接

---

一个青蛙位于 $x$ 轴的 $0$ 点。

它将进行 $k$ 次跳跃，其中：

第 $1,3,5\dots$ 次（奇数次）跳跃，向右跳 $a$ 单位长度，即从 $x$ 跳到 $x+a$。
第 $2,4,6\dots$ 次（偶数次）跳跃，向左跳 $b$ 单位长度，即从 $x$ 跳到 $x-b$。
请问，最终它将跳到哪个位置？

输入格式

第一行包含整数 $T$，表示共有 $T$ 组测试数据。

每组数据占一行，包含三个整数 $a,b,k$。

输出格式

每组数据输出一行结果，一个整数表示青蛙最终所在的位置坐标。

数据范围

前三个数据满足 $1\le T\le 10$。
所有数据满足 $1\le T\le 1000,1\le a,b,k\le 10^9$。

输入样例：

6
5 2 3
100 1 4
1 10 5
1000000000 1 6
1 1 1000000000
1 1 999999999

输出样例：

2 1
3 4
3 2
1 2
3 7

题目分析：

不开long long见祖宗。

Code

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        LL a, b, k;
        cin >> a >> b >> k;
        cout << (k + 1) / 2 * a - k / 2 * b << endl;
    }
    return 0;
}

---

B.最小正整数

题目链接

---

给定两个整数 $n$ 和 $k$。

请你计算，末尾至少有连续 $k$ 个 $0$，并且可以被 $n$ 整除的最小正整数。

例如，当 $n=375,k=4$ 时，满足条件的最小正整数为 $30000$。

输入格式

第一行包含整数 $T$，表示共有 $T$ 组测试数据。

每组数据占一行，包含两个整数 $n,k$。

输出格式

每组数据输出一行结果，表示满足条件的最小正整数。

数据范围

所有数据满足 $1\le T\le 10$，$1\le n\le 10^9$，$0\le k\le 8$。

输入样例：

6
375 4
10000 1
38101 0
123456789 8
1 0
2 0

输出样例：

30000
10000
38101
12345678900000000
1
2

题目分析：

1. 求一个数num，这个数一定是 $n$ 的倍数：$num=c\cdot n$

2. 末尾有 $k$ 个 $0$，表示num能被 $10^k$ 整除：$10^k|c\cdot n$

综上可得：

\begin{align}
c\cdot n &= 10^k\cdot t \\
&= 2^k\cdot 5^k\cdot t
\end{align}

$\text{TIPS:}$ $10$ 一定要拆开，不能整体来算，因为 $2$ 和 $5$ 有可能分别来自于 $c$ 和 $n$，不能整体算。

将 $n$ 分解成：$n=2^{\alpha }\cdot 2^{\beta }\cdot r$，$c$ 分解成：$2^{{\alpha }^{\prime }}\cdot 2^{{\beta }^{\prime }}\cdot r^{\prime }$，因为要让 $c\cdot n$ 的值尽可能小，故 $c$ 的系数 $r^{\prime }$ 直接为 $1$。

且有： α ′ = max ⁡ { k − α ,   0 } \alpha' = \max \lbrace k - \alpha,\ 0 \rbrace α′=max{k−α, 0}， β ′ = max ⁡ { k − β ,   0 } \beta' = \max \lbrace k - \beta ,\ 0 \rbrace β′=max{k−β, 0}。

由于等式右边 $2^k\cdot 5^k\cdot t$，$k$ 固定值，故最小的答案 $c\cdot n$ 就是 $2^{\alpha }\cdot 2^{\beta }\cdot r\cdot 2^{{\alpha }^{\prime }}\cdot 2^{{\beta }^{\prime }}$ 。

Code

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;
// 数 n 的 因数 p 的个数
int get_p(int n, int p)
{
    int res = 0;
    while (n % p == 0) res ++, n /= p;
    return res;
}
// a 的 b 次幂
int get_c(int a, int b)
{
    int res = 1;
    for (int i = 0; i < b; i ++ ) res *= a;
    return res;
}

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        int n, k;
        cin >> n >> k;
        // 2的个数为a， 5的个数为b
        int a = get_p(n, 2), b = get_p(n, 5);
        
        // 需要补充2和5的个数
        cout << n * (LL)get_c(2, k - a) * get_c(5, k - b) << endl;
    }
    return 0;
}

---

C.行走路径

题目链接

---

给定一个 $n\times m$ 的方格矩阵。

每个方格中都包含一个大写字母：$Q,W,E,R$ 之一。

现在，小明要在方格矩阵中进行移动。

具体移动规则如下：

1. 最初，小明应选择某个包含字母 $Q$ 的方格作为起点。
2. 小明每次移动可以沿上下左右四个方向，移动一格距离。当然不能出界。
3. 小明在移动时，必须遵循：从包含字母 $Q$ 的方格只能移动到包含字母 $W$ 的方格，从包含字母 $W$ 的方格只能移动到包含字母 $E$ 的方格，从包含字母 $E$ 的方格只能移动到包含字母 $R$ 的方格，从包含字母 $R$ 的方格只能移动到包含字母 $Q$ 的方格。
4. 小明每走过一个完整的 QWER，就称小明走过了一个轮次。小明需要走过尽可能多的轮次。即统计路径中完整的 QWER的个数，例如 WERQWERQ中仅有 $1$ 个 QWER。

请问小明最多可以走过多少轮次？

输入格式

第一行包含两个整数 $n,m$。

接下来 $n$ 行，每行包含 $m$ 个字符，每个字符为 $Q,W,E,R$ 之一。

输出格式

如果小明无法成功走过任何轮次，则输出 none。

如果小明可以成功走过无穷多轮次，则输出 infinity。

如果小明可以成功走过有限多轮次，则输出他能走过的最多轮次。

数据范围

前六个测试点满足 $1\le n,m\le 5$。
所有测试点满足 $1\le n,m\le 1000$。

输入样例1：

1 2
QW

输出样例1：

none

输入样例2：

2 2
ER
WQ

输出样例2：

infinity

输入样例3：

5 5
QWERQ
QWERW
QWERE
QQERR
RREWQ

输出样例3：

4

题目分析：

本题十分类似：AcWing 901. 滑雪，但与滑雪有一点不同的是，本题的移动路径可能会存在环，而滑雪中，移动路径是一定按照高度严格递减的，如果没有环，本题可以直接套用滑雪的记忆化搜索方式解，首先枚举每一个起点，然后求从每一个起点出发，所能走的路径的最大值，然后由于路径中 Q W E R是连续的，故只要求得路径长度，就可以得到 Q W E R轮次个数。

但由于环的存在，我们首先需要判环。

一般来说，判环的方法有以下几种：

1、DFS
2、Topsort
3、强连通分量（Tarjan）

DFS 判环很容易，我们只需对所走过的路径中每一个点进行标记，一旦后续走到的路径中出现已经标记过的点，就证明存在环。

因此，我们可以采用记忆化搜索 + DFS 判环的方式求解。

Code

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char g[N][N];
bool st[N][N]; // 表示当前这个点有没有在递归路径中
int f[N][N];
bool is_inf; // 全局标记，是否存在环
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

int dp(int x, int y)
{
    if (is_inf) return -1;
    int &v = f[x][y];
    if (v != -1) return v; // 如果不等于-1，表示当前状态已经被计算过了，直接返回
    
    st[x][y] = true;// 标记当前点(x, y)已经走过
    
    v = 1; // 从当前点出发，路径长度为1
    for (int i = 0; i < 4; i ++ )
    {
        int a = x + dx[i], b = y + dy[i];
        // 若在边界内，且能够走到下一步
        if (a >= 0 && a < n && b >= 0 && b < m && g[a][b] == (g[x][y] + 1) % 4)
        {
            if (st[a][b])
            {
                // 如果说明已经标记的点重新出现在路径当中，说明存在环
                is_inf = true;
                return -1;
            }
            v = max(v, dp(a, b) + 1);
        }
    }
    st[x][y] = false;
    return v;
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i ++ )
    {
        scanf("%s", g[i]);
        for (int j = 0; j < m; j ++ )
        {
        // 为了方便，将 Q W E R 转化为 0 1 2 3
            auto& c = g[i][j];
            if (c == 'Q') c = 0;
            else if (c == 'W') c = 1;
            else if (c == 'E') c = 2;
            else c = 3;
        }
    }
    
    memset(f, -1, sizeof f);
    int res = 0;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < m; j ++ )
        {
            int t = dp(i, j); // 从(i, j)这个点出发的最长路径
            // 如果起点从0开始，直接 t / 4 下取整就是整个轮次个数
            // 如果起点从1开始，那么 1 2 3需要掠过，就是减3
            // 从2开始，减2
            // 从3开始，减1
            if (g[i][j]) t -= 4 - g[i][j];
            res = max(res, t / 4);
        }
    
    if (is_inf) puts("infinity");    
    else if (!res) puts("none");
    else printf("%d\n", res);
    return 0;
}