走格子

题意(原题):
一排n个格子,每步可以走1-k个格子。求走到最后一个格子的方案数。
k<=10,n<=2^31-1
思路:
矩阵乘法。
比如,n=5,k=2的时候序列为[1 2 4 8 15]。
解式子:
[?]x[1]=[2]
[?]..[2]..[3]
大概就是这样。小数据不能体现出规律,自己试着解诸如k=3,k=4的时候就能发现第一个矩阵的规律。
将此矩阵^n后再乘以一个竖着的长k宽1,最后一个是1其他都是0的矩阵,即可得出结果。
懒得放图片,抱歉。
代码:

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#define GETMOD %7777777
#define LL long long
using namespace std;
struct node
{
    int xcnt,ycnt;LL a[110][110];
    node()
    {
        xcnt=ycnt=0;memset(a,0,sizeof(a));
    }
    void setxy(int x,int y)
    {
        xcnt=x;ycnt=y;
    }
};
node dw(int x)
{
    node ans;ans.setxy(x,x);
    for(int i=1;i<=x;i++)ans.a[i][i]=1;
    return ans;
}
node cf(node x,node y)
{
    node ans;ans.setxy(x.xcnt,y.ycnt);
    for(int i=1;i<=ans.xcnt;i++)
        for(int j=1;j<=ans.ycnt;j++)
            for(int k=1;k<=x.ycnt;k++)
                ans.a[i][j]=(ans.a[i][j]+x.a[i][k]*y.a[k][j]GETMOD)GETMOD;
    return ans;
}
node power(node x,int k)
{
    node ans=dw(x.xcnt);
    while(k)
    {
        if(k&1)ans=cf(ans,x);
        x=cf(x,x);
        k/=2;
    }
    return ans;
}
int main()
{
    int n,k;
    scanf("%d%d",&k,&n);
    node opt;
    opt.setxy(k,k);
    for(int i=1;i<k;i++)opt.a[i][i+1]=1;
    for(int i=1;i<=k;i++)opt.a[k][i]=1;
    opt=power(opt,n);
    node ans;ans.setxy(k,1);ans.a[k][1]=1;
    ans=cf(opt,ans);
    printf("%d\n",ans.a[k][1]);
    return 0;
}
### 动态规划解决格子问题 格子问题的核心在于通过动态规划(Dynamic Programming, DP)来寻找从起点到终点的路径数量或最短路径。以下是基于动态规划算法的实现,结合引用内容[^2]。 #### 1. 算法思想 动态规划的核心是将问题分解为若干个子问题,并通过状态转移方程递推解最终结果。对于格子问题,假设从左上角 `(0, 0)` 到右下角 `(n, m)` 的网格,每次只能向下或向右移动一步,则状态转移方程可以表示为: - `dp[i][j] = dp[i-1][j] + dp[i][j-1]` 其中,`dp[i][j]` 表示到达位置 `(i, j)` 的路径总数。边界条件为: - 当 `i == 0` 或 `j == 0` 时,`dp[i][j] = 1`,因为只有一条路径可到达这些边界点。 #### 2. Python 实现代码 以下是基于上述状态转移方程的 Python 实现: ```python def uniquePaths(m, n): # 初始化 dp 数组,大小为 (m+1) x (n+1) dp = [[0] * n for _ in range(m)] # 边界条件初始化 for i in range(m): dp[i][0] = 1 for j in range(n): dp[0][j] = 1 # 动态规划填表 for i in range(1, m): for j in range(1, n): dp[i][j] = dp[i-1][j] + dp[i][j-1] return dp[m-1][n-1] # 测试代码 m = 3 n = 7 print(uniquePaths(m, n)) # 输出结果为 28 ``` #### 3. 时间与空间复杂度分析 - **时间复杂度**:O(m * n),需要遍历整个二维数组。 - **空间复杂度**:O(m * n),用于存储中间结果。如果采用滚动数组优化,空间复杂度可降为 O(n)[^2]。 #### 4. 滚动数组优化 为了降低空间复杂度,可以使用一维数组代替二维数组: ```python def uniquePathsOptimized(m, n): dp = [1] * n # 初始化第一行为 1 for i in range(1, m): for j in range(1, n): dp[j] += dp[j-1] return dp[-1] # 测试代码 m = 3 n = 7 print(uniquePathsOptimized(m, n)) # 输出结果为 28 ``` #### 5. 注意事项 在实际应用中,可能需要考虑障碍物的影响。例如,某些格子不可通行时,需对状态转移方程进行调整。此外,动态规划方法适用于小规模网格,对于大规模网格问题,可能需要结合其他优化算法[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值