[JSOI2012][bzoj4332] 分零食 [FFT]

本文介绍了一种使用动态规划(DP)结合快速傅立叶变换(FFT)优化算法解决大规模问题的策略。通过倍增和卷积操作,实现时间效率为O(mlogmlogn)的解决方案。

题面

传送门

思路

首先,这个数据如果没有这么大,我们还是可以做朋友的......

设$dp\left[i\right]\left[j\right]$代表前j个零食分给了前i个人的方案数

那么dp方程显然:

$dp\left[i\right]\left[j\right]=\sum_{k=1}^{j-1} dp\left[i-1\right]\left[k\right]+f\left(j-k\right)$

其中$f\left(x\right)$就是题目里给的那个二次函数

同时有一个性质:

$dp\left[i\right]\left[j\right]=dp\left[\frac i2\right]\left[k\right]\ast dp\left[\frac i2\right]\left[j-k\right]$

显然这道题不能直接O(nm)递推......那我们换个办法来想

n辣么大,为什么我们不考虑 一下用倍增的方法呢?正好上面那个性质可以利用一下

并且还应当注意,我们最后要求的是$\sum_{i=1}^n dp\left[i\right]\left[m\right]$

所以我们设$p\left[i\right]\left[j\right]=\sum_{k=1}^n dp\left[k\right]\left[j\right]$

$p\left[i\right]\left[j\right]=p\left[\frac i2\right]\left[j\right]+\sum_{k=1}^{\frac i2}dp\left[k+\frac i2\right]\left[j\right]$

$p\left[i\right]\left[j\right]=p\left[\frac i2\right]\left[j\right]+\sum_{k=1}^{\frac i2}\sum_{l=1}^{j-1}dp\left[k\right]\left[l\right]dp\left[\frac i2\right]\left[j-l\right]$

$p\left[i\right]\left[j\right]=p\left[\frac i2\right]\left[j\right]+\sum_{l=1}^{j-1}\sum_{k=1}^{\frac i2}dp\left[k\right]\left[l\right]dp\left[\frac i2\right]\left[j-l\right]$

$p\left[i\right]\left[j\right]=p\left[\frac i2\right]\left[j\right]+\sum_{l=1}^{j-1}dp\left[\frac i2\right]\left[j-l\right]\sum_{k=1}^{\frac i2}dp\left[k\right]\left[l\right]$

$p\left[i\right]\left[j\right]=p\left[\frac i2\right]\left[j\right]+\sum_{l=1}^{j-1}dp\left[\frac i2\right]\left[j-l\right]p\left[\frac i2\right]\left[l\right]$

也就是说p可以由上一层的p加上一层的dp与p的卷积得到,而dp可以由上一层的dp自乘得到

那么自然可以用倍增p的第一层参数的方法,用FFT优化一下,一直做到n

时间效率为$O\left(mlogmlogn\right)$

注意:将n转化为二进制,那么为一的那些位,要在倍增完以后再推一层

Code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
inline int read(){
    int re=0,flag=1;char ch=getchar();
    while(ch>'9'||ch<'0'){
        if(ch=='-') flag=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
    return re*flag;
}
struct complex{
    double x,y;
    complex(double xx=0,double yy=0){x=xx;y=yy;}
    complex operator +(const complex &b){return complex(x+b.x,y+b.y);}
    complex operator -(const complex &b){return complex(x-b.x,y-b.y);}
    complex operator *(const complex &b){return complex(x*b.x-y*b.y,x*b.y+y*b.x);}
}A[100010],B[100010];
const double pi=acos(-1.0);
int n,m,limit=1,cnt=0,r[100010];
int MOD;
void fft(complex *a,double type){
    int i,j,k,mid;complex x,y,wn,w;
    for(i=0;i<limit;i++) if(i<r[i]) swap(a[i],a[r[i]]);
    for(mid=1;mid<limit;mid<<=1ll){
        wn=complex(cos(pi/mid),type*sin(pi/mid));
        for(j=0;j<limit;j+=(mid<<1ll)){
            w=complex(1,0);
            for(k=0;k<mid;k++,w=w*wn){
                x=a[j+k];y=a[j+k+mid]*w;
                a[j+k]=x+y;a[j+k+mid]=x-y;
            }
        }
    }
}
int now=1,w=0,g[100010]={0},p[100010]={0},f[100010]={0};
int a1,a2,a3;
void solve1(){
    int i;
    for(i=0;i<=limit;i++) A[i]=B[i]=complex(0,0);
    for(i=0;i<=limit;i++) A[i].x=p[i],B[i].x=g[i];
    fft(A,1);fft(B,1);
    for(i=0;i<=limit;i++) A[i]=A[i]*B[i];
    fft(A,-1);
    for(i=1;i<=m;i++) p[i]=(p[i]+(int)(A[i].x/limit+0.5)%MOD)%MOD;
    
    for(i=0;i<=limit;i++) A[i]=complex(0,0);
    for(i=0;i<=limit;i++) A[i].x=g[i];
    fft(A,1);
    for(i=0;i<=limit;i++) A[i]=A[i]*A[i];
    fft(A,-1);
    for(i=1;i<=m;i++) g[i]=(int)(A[i].x/limit+0.5)%MOD;
}
void solve2(){
    int i;
    for(i=0;i<=limit;i++) A[i]=B[i]=complex(0,0);
    for(i=1;i<=m;i++) A[i].x=f[i],B[i].x=g[i];
    fft(A,1);fft(B,1);
    for(i=0;i<=limit;i++) A[i]=A[i]*B[i];
    fft(A,-1);
    for(i=1;i<=m;i++) g[i]=(int)(A[i].x/limit+0.5)%MOD,p[i]=(p[i]+g[i])%MOD;
}
int main(){
    m=read();MOD=read();n=read();a1=read();a2=read();a3=read();
    int i;
    a1%=MOD;a2%=MOD;a3%=MOD;
    for(i=1;i<=m;i++) g[i]=p[i]=f[i]=((((((a1*i)%MOD)*i)%MOD)+a2*i%MOD)+a3)%MOD;
    while(limit<=(m<<1ll)) limit<<=1ll,cnt++;
    for(i=0;i<limit;i++) r[i]=((r[i>>1ll]>>1ll)|((i&1ll)<<(cnt-1ll)));
    while((now<<1ll)<=n) now<<=1ll,w++;
    while(w){
        w--;
        solve1();//倍增
        if(n&(1<<w)) solve2();//这一位应该是个奇数的,再推一层
    }
    printf("%lld\n",p[m]%MOD);
}

转载于:https://www.cnblogs.com/dedicatus545/p/8833123.html

内容概要:本文系统研究了基于动态三维环境下的Q-Learning算法在无人机自主避障路径规划中的应用,依托Matlab代码实现,深入剖析了强化学习在复杂、时变空间中实现智能决策的机制。研究构建了三维网格化状态空间模型,设计了合理的动作集合与奖励函数,充考虑静态与动态障碍物的存在,使无人机能够通过与环境持续交互,自主学习规避障碍并趋近目标的最优策略。文章不仅展示了Q-Learning算法在路径规划中的具体实现流程,还涵盖了状态表示、策略迭代、收敛性析等关键环节,并通过仿真实验验证了算法的有效性与鲁棒性,为智能体在动态环境中的自主导航提供了理论依据和技术参考。; 适合人群:具备人工智能、自动化、计算机科学或机器人学等相关专业背景,熟悉Matlab编程语言和基本的强化学习概念,从事无人机控制、智能导航、路径规划算法研究的研究生、科研人员及工程技术人员。; 使用场景及目标:①应用于城市峡谷、灾害现场等复杂动态三维场景中无人机的自主飞行与紧急避障;②作为强化学习解决实际路径规划问题的教学实例,帮助理解Q-Learning的核心思想、状态-动作值函数更新过程及探索-利用权衡策略;③为后续研究更先进的深度强化学习算法(如DQN、PPO)在无人机控制中的应用奠定基础和提供对比基准。; 阅读建议:建议读者结合所提供的Matlab代码进行动手实践,通过调整学习率、折扣因子、探索率(ε-greedy)等超参数,观察其对算法收敛速度和最终路径规划质量的影响,并尝试修改环境复杂度(如增加障碍物密度或动态性)以评估算法的泛化能力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值