Recursive sequence——(hdu5950)_(矩阵快速幂)

本文介绍如何使用矩阵快速幂解决包含高次项的复杂递推问题,并给出了一段完整的C++代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:点击打开链接

题意:

F(1)=a,F(2)=b,F(N)=2F(N-2)+F(N-1)+N^4

给你N,a,b(N,a,b < 2^31)

求F(N)%2147493647

分析:

如果递推式是F(N)=2F(N-2)+F(N-1)就方便了许多,基本的矩阵快速幂

但是多了n^4;



这时,又产生了i^3,i^2,i这些新项需要我们计算



由推出的这些东西 我们就可以构造矩阵了

|1   2   1   4   6   4   1|     |f(n+1) |           | f(n+2) |
|1   0   0   0   0   0   0|     |f(n)   |              |f(n+1) |
|0   0   1   4   6   4   1|     |(n+1)^4|        |(n+2)^4|
|0   0   0   1   3   3   1|  *  |(n+1)^3|   = |(n+2)^3|
|0   0   0   0   1   2   1|     |(n+1)^2|         |(n+2)^2|
|0   0   0   0   0   1   1|     | n+1   |            | n+2   |
|0   0   0   0   0   0   1|     | 1     |               |  1    |

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const ll mod=2147493647;
int n,a,b;
struct matrix
{
    ll m[7][7];
    void init1()
    {
        m[0][0] = b,m[0][1] = 0,m[0][2] = 0,m[0][3] = 0,m[0][4] = 0,m[0][5] = 0,m[0][6] = 0;
        m[1][0] = a,m[1][1] = 0,m[1][2] = 0,m[1][3] = 0,m[1][4] = 0,m[1][5] = 0,m[1][6] = 0;
        m[2][0] = 16,m[2][1] = 0,m[2][2] = 0,m[2][3] = 0,m[2][4] = 0,m[2][5] = 0,m[2][6] = 0;
        m[3][0] = 8,m[3][1] = 0,m[3][2] = 0,m[3][3] = 0,m[3][4] = 0,m[3][5] = 0,m[3][6] = 0;
        m[4][0] = 4,m[4][1] = 0,m[4][2] = 0,m[4][3] = 0,m[4][4] = 0,m[4][5] = 0,m[4][6] = 0;
        m[5][0] = 2,m[5][1] = 0,m[5][2] = 0,m[5][3] = 0,m[5][4] = 0,m[5][5] = 0,m[5][6] = 0;
        m[6][0] = 1,m[6][1] = 0,m[6][2] = 0,m[6][3] = 0,m[6][4] = 0,m[6][5] = 0,m[6][6] = 0;
    }
    void init2()
    {
        m[0][0] = 1,m[0][1] = 2,m[0][2] = 1,m[0][3] = 4,m[0][4] = 6,m[0][5] = 4,m[0][6] = 1;
        m[1][0] = 1,m[1][1] = 0,m[1][2] = 0,m[1][3] = 0,m[1][4] = 0,m[1][5] = 0,m[1][6] = 0;
        m[2][0] = 0,m[2][1] = 0,m[2][2] = 1,m[2][3] = 4,m[2][4] = 6,m[2][5] = 4,m[2][6] = 1;
        m[3][0] = 0,m[3][1] = 0,m[3][2] = 0,m[3][3] = 1,m[3][4] = 3,m[3][5] = 3,m[3][6] = 1;
        m[4][0] = 0,m[4][1] = 0,m[4][2] = 0,m[4][3] = 0,m[4][4] = 1,m[4][5] = 2,m[4][6] = 1;
        m[5][0] = 0,m[5][1] = 0,m[5][2] = 0,m[5][3] = 0,m[5][4] = 0,m[5][5] = 1,m[5][6] = 1;
        m[6][0] = 0,m[6][1] = 0,m[6][2] = 0,m[6][3] = 0,m[6][4] = 0,m[6][5] = 0,m[6][6] = 1;
    }

};
matrix mul(matrix A,matrix B)
{
    matrix ans;
    memset(ans.m,0,sizeof(ans.m));
    for(int i=0; i<7; i++)
    {
        for(int j=0; j<7; j++)
        {
            for(int k=0; k<7; k++)
            {
                ans.m[i][j]=(ans.m[i][j]+A.m[i][k]*B.m[k][j]%mod)%mod;
            }
        }
    }
    return ans;
}
matrix pow(matrix A, ll p)
{
    matrix res;
    memset(res.m,0,sizeof(res.m));
    for(int i=0; i<7; i++)
        res.m[i][i]=1;
    while(p)
    {
        //cout<<"___"<<endl;
        if(p&1)
            res=mul(res,A);
        p>>=1;
        A=mul(A,A);
    }
    return res;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {

        scanf("%d%d%d",&n,&a,&b);
        if(n==1)
            printf("%lld\n",a%mod);
        else if(n==2)
            printf("%lld\n",b%mod);
        else
        {
            matrix ans,x;
            ans.init1();
            x.init2();
            x=pow(x,n-1);
            ans=mul(x,ans);
            printf("%lld\n",ans.m[1][0]);
        }

    }
    return 0;
}






<think>好的,用户的问题是如何使用迭代器递归遍历Python字典。我需要结合他们提供的引用内容来构建答案。首先,用户提到的引用[1]中有一个生成器函数`flatten`,用于处理嵌套结构,但排除了字符串。这可能对处理字典有帮助,不过字典的结构可能更复杂,因为包含键值对。 然后,引用[3]提到,字符串、列表等本身不是可迭代对象,但for循环调用了它们的`__iter__`方法。而字典在Python中默认迭代的是键,所以需要考虑如何处理值或者键值对。 用户的需求是递归遍历字典,可能需要访问所有的嵌套键、值或者键值对。我需要设计一个生成器函数,使用递归来处理字典的嵌套结构。例如,当遇到字典类型的值时,继续递归下去。同时,需要避免迭代字符串,因为字符串本身也是可迭代的,但用户可能不希望拆开字符串的每个字符。 根据引用[1]中的方法,可以尝试将对象与字符串拼接来检测是否是字符串类型,防止递归到字符串里。这可能需要在生成器中加入类似的检查。 接下来,可能需要遍历字典的每个键值对,然后对值进行递归处理。例如,如果值是字典,继续遍历;否则,生成该值或键值对。 需要确保生成器正确处理各种数据类型,如列表、元组、字典,并且不处理字符串的可迭代性。可能需要使用类似引用[1]中的异常处理来排除字符串。 另外,用户可能需要示例代码,展示如何实现这样的递归遍历。结合这些,可以写出一个生成器函数,使用递归来遍历字典的所有嵌套元素,并处理不同类型的值。 可能还需要考虑如何处理其他可迭代对象,比如列表或元组中的元素,是否需要递归遍历。例如,字典中的某个值可能是列表,而列表中的元素可能又是字典,这时候需要继续递归。 最后,根据引用[4],字典是键值对结构,所以在遍历时可能需要同时处理键和值,或者只处理值。根据用户的需求,可能需要生成所有的值,或者键值对。 总结步骤:检查当前元素是否是字典,如果是,遍历其所有值,并对每个值递归调用生成器。如果值是可迭代对象且不是字符串,继续递归。否则,生成该元素。需要处理不同数据类型的检测,确保字符串不被拆开。</think>要使用迭代器递归遍历嵌套字典,可以通过生成器函数结合递归实现。核心思路是检查元素类型,若为字典则继续展开迭代,同时排除字符串等不可展开对象。以下是具体实现方法: ### 实现步骤 1. **类型检查**:使用`isinstance()`判断当前元素是否为字典 2. **字符串过滤**:通过尝试拼接字符串来检测字符串类型(参考引用[^1]) 3. **递归处理**:对字典值进行递归遍历,其他可迭代对象根据需求处理 4. **生成器设计**:使用`yield from`实现递归生成器模式(参考引用[^2]) ```python def recursive_dict_iter(obj): # 检测字符串类型(引用方法) try: obj + '' except TypeError: pass else: if isinstance(obj, str): yield obj return # 处理字典类型 if isinstance(obj, dict): for value in obj.values(): yield from recursive_dict_iter(value) # 处理其他可迭代对象(列表/元组等) elif isinstance(obj, (list, tuple)): for item in obj: yield from recursive_dict_iter(item) else: yield obj # 测试用例 data = { "a": {"b": [1, {"c": "d"}, 3]}, "e": ("f", ["g", {"h": 5}]) } print(list(recursive_dict_iter(data))) # 输出:[1, 'd', 3, 'f', 'g', 5] ``` ### 关键点解析 1. **字符串检测**:通过尝试与空字符串拼接来识别字符串对象,避免将字符串作为可迭代对象拆分 2. **递归处理**:对字典使用`values()`获取所有值,对列表/元组直接迭代 3. **生成器优势**:内存效率高,适用于处理大型嵌套结构(引用迭代器优势) 4. **类型扩展**:可根据需求添加对其他容器类型(如集合)的支持
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值