快速幂

n 个小伙伴（编号从 00 到 n-1n−1）围坐一圈玩游戏。按照顺时针方向给 nn 个位置编号，从 00 到 n-1n−1。最初，第 00 号小伙伴在第 00 号位置，第 11 号小伙伴在第 11 号位置，……，依此类推。

游戏规则如下：每一轮第 00 号位置上的小伙伴顺时针走到第 mm 号位置，第 11 号位置小伙伴走到第 m+1m+1 号位置，……，依此类推，第 n-mn−m 号位置上的小伙伴走到第 00 号位置，第 n-m+1n−m+1 号位置上的小伙伴走到第 11 号位置，……，第 n-1n−1 号位置上的小伙伴顺时针走到第 m-1m−1 号位置。

现在，一共进行了 10^k10
k
轮，请问 xx 号小伙伴最后走到了第几号位置。

输入格式

输入共 11 行，包含 44 个整数 nn、mm、kk、xx，每两个整数之间用一个空格隔开。

输出格式

输出共 11 行，包含 11 个整数，表示 10^k10
k
轮后 xx 号小伙伴所在的位置编号。

数据范围

对于 3030% 的数据，0 < k < 70<k<7；

对于 8080% 的数据，0 < k < 10^70<k<10
7
；

对于 100100% 的数据，1 < n< 1,000,0001<n<1,000,000，0 <m <n0<m<n，0 \le x \le n0≤x≤n，0 < k< 10^90<k<10
9
。

输出时每行末尾的多余空格，不影响答案正确性

样例输入
10 3 4 5
样例输出
5
题意很简单只需要 x+m*10的k次方对n取余 但数据太大 要用到快速幂的知识

1. ( a + b ) % c = ( ( a % c ) + ( b % c ) ) % c
2. ( a * b ) % c = ( ( a % c ) * ( b % c ) ) % c
3. ( a – b ) % c = ( ( a % c ) – ( b % c ) ) % c
4. 但是如果 2^100000000次方 就需要循环好多次 会时间超限
5. 2^100000000=2²*^50000000=16^25000000……;
6. 但如果指数是奇数就不能进行除以2的操作 5^3
7. 不能变成 1.5次方 因为 小数不好参与幂运算
8. 所以 就需要把 5^3
9. 变成 55^2 —> 525的1次方 结果就变成 125的 1次方
   10.时间已经很短了 但还可以在次压缩
   比如一个 求 n的m 次方结果后3 位的题
   起初写成

long long normalPower(long long n,long long m){
    long long sum=1;
    for(int i=1;i<=m;i++){
        sum=sum*n;
    }
    return sum%1000;
    }
```cpp

然后通过( a * b ) % c = ( ( a % c ) * ( b % c ) ) % c可以改成

```long long normalPower(long long n, long long m) {
    long long sum = 1;
    for (int i = 1; i <= m; i++) {
        sum = sum * n;
        sum = sum% 1000;
    }
    return sum % 1000;
    }
```cpp
在这里插入代码片

根据上述456可以改成

在这里插入代码片
```ong long fastPower(long long n, long long m)
   {
    long long sum = 1;
    while (m> 0) {
        if (m % 2 == 0)
         {
            //如果指数为偶数
            m = m / 2;//把指数缩小为一半
            n= n * n % 1000;//底数变大成原来的平方
        } else {
            //如果指数为奇数
            m = m - 1;//把指数减去1，使其变成一个偶数
            sum = sum * n % 1000;//此时记得要把指数为奇数时分离出来的底数的一次方收集好
            m= m / 2;//此时指数为偶数，可以继续执行操作
            n = n * n % 1000;
        }
    }
    return sum;
    }
```cpp
在这里插入代码片

我们发现 上诉if 和 else 语句 有重复代码
m= m / 2;
n= n * n % 1000;
而
m=m-1;
m=m/2;
可以整合为一句 m=m/2;
那么代码就成了这样

在这里插入代码片
long long fastPower(long long n, long long m) {
    long long sum = 1;
    while (m > 0) {
        if (m % 2 == 1) {
            sum = sum * n % 1000;
        }
        m = m / 2;
        n = (n * n) % 1000;
    }
    return sum;
}

再次优化
在C语言中 m%2==1可以用更快的“位运算”来代替，例如：m&1。因为如果m为偶数，则其二进制表示的最后一位一定是0；如果m是奇数，则其二进制表示的最后一位一定是1。将他们分别与1的二进制做“与”运算，得到的就是m二进制最后一位的数字了，是0则为偶数，是1则为奇数。例如5是奇数，则5&1=1；而6是偶数，则6&1=0；因此奇偶数的判断就可以用“位运算”来替换了。
同样，对于m=m/2来说，也可以用更快的“位运算”进行替代，我们只要把m的二进制表示向右移动1位就能变成原来的一半了。

在这里插入代码片
long long fastPower(long long n, long long m) {
    long long sum= 1;
    while (m> 0) {
        if (m & 1) {//此处等价于if(m%2==1)
            sum = sum * n % 1000;
        }
       m>>= 1;//此处等价于m=m/2
        n = (n * n) % 1000;
    }
    return sum;
    }
```cpp
在这里插入代码片

好了 了解了幂运算 我们的题就好做了
代码如下

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
typedef long long ll;
ll qpow(ll n,ll m,ll c)
{
    ll sum=1;
    while(m>0)
    {
        if(m&1)
        sum=sum*n%c;
        m>>=1;
        n=n*n%c;
    }
    return sum;
}
int main()
{
    ll n,m,k,x;
 scanf("%lld%lld%lld%lld",&n,&m,&k,&x);
    ll y=qpow(10,k,n);
    printf("%lld\n",(x+y*m)%n);//最后的位置为（起始位置+10的k次*每次走m）
    return 0;
}

参考博客 https://blog.csdn.net/qq_19782019/article/details/85621386