Gym 100541 E ACM （线段树板子）

最新推荐文章于 2021-07-16 23:36:37 发布
最新推荐文章于 2021-07-16 23:36:37 发布
阅读量252 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43840511/article/details/104289563
版权

##2014 ACM-ICPC Vietnam National Second Round E

经典线段树lazytag+素数拆分

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <iostream>

#define lint long long
using namespace std;


const lint sushu[40]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,
67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149};

struct node
{
    lint shu[35];
    lint all[35];

}tree[300000];

node temp;

lint pow_mod(lint a, lint n, lint m)
{
    lint ans = 1;
    while(n)
    {
        if(n&1)
        {
            ans = (ans * a) % m;
        }
        a = (a * a) % m;
        n >>= 1;
    }
    return ans;
}


int jia(lint l,lint r,lint ll,lint rr,lint now)
{

    if(ll<=l&&rr>=r)
    {
        for(lint j=0;j<35;j++)
        {
            tree[now].shu[j]+=temp.shu[j];
            tree[now].all[j]+=temp.shu[j]*(r-l+1);
        }

        return 0;
    }

    lint mid=(l+r)/2;

    for(lint j=0;j<35;j++)
    {
        tree[now*2].shu[j]+=tree[now].shu[j];
        tree[now*2+1].shu[j]+=tree[now].shu[j];

        tree[now*2].all[j]+=(mid-l+1)*tree[now].shu[j];
        tree[now*2+1].all[j]+=(r-mid)*tree[now].shu[j];

        tree[now].shu[j]=0;
    }

    if(rr<=mid)
        jia(l,mid,ll,rr,now*2);
    else if(ll>=mid+1)
        jia(mid+1,r,ll,rr,now*2+1);
    else
    {
        jia(l,mid,ll,mid,now*2);
        jia(mid+1,r,mid+1,rr,now*2+1);
    }

    for(lint j=0;j<35;j++)
    {
        tree[now].all[j]=tree[now*2].all[j]+tree[now*2+1].all[j];
    }

    return 0;
}

node check(lint l,lint r,lint ll,lint rr,lint now)
{

    if(ll<=l&&rr>=r)
    {
        return tree[now];
    }

    lint mid=(l+r)/2;

    for(lint j=0;j<35;j++)
    {
        tree[now*2].shu[j]+=tree[now].shu[j];
        tree[now*2+1].shu[j]+=tree[now].shu[j];

        tree[now*2].all[j]+=(mid-l+1)*tree[now].shu[j];
        tree[now*2+1].all[j]+=(r-mid)*tree[now].shu[j];

        tree[now].shu[j]=0;
    }


    if(rr<=mid)
        return check(l,mid,ll,rr,now*2);
    else if(ll>=mid+1)
        return check(mid+1,r,ll,rr,now*2+1);
    else
    {
        node a=check(l,mid,ll,mid,now*2);
        node b=check(mid+1,r,mid+1,rr,now*2+1);

        for(lint j=0;j<35;j++)
        a.all[j]+=b.all[j];
        return a;
    }

}


int main()
{
    lint n,m,t,k,ans,the,a,b,c;


    scanf("%lld",&t);
    {
        while(t--)
        {
            scanf("%lld",&n);scanf("%lld",&m);
            memset(tree,0,sizeof tree);


            for(lint i=0;i<m;i++)
            {
                scanf("%lld",&k);

                if(k==0)
                {
                    scanf("%lld%lld%lld",&a,&b,&c);

                    if(a<=b)
                    {
                        node x=check(1,n,a,b,1);
                        ans=1;

                        for(lint j=0;j<35;j++)
                        {
                            if(x.all[j]>0)
                            {
                                ans*=1LL*pow_mod(sushu[j],x.all[j],c);
                                ans%=c;
                            }
                        }
                        ans%=c;
                        printf("%lld\n",(ans%c));
                    }
                    else
                    {
                        node x=check(1,n,a,n,1);
                        node y=check(1,n,1,b,1);

                        ans=1;

                        for(lint j=0;j<35;j++)
                        {
                            if(x.all[j]>0)
                            {
                                ans*=1LL*pow_mod(sushu[j],x.all[j],c);
                                ans%=c;
                            }
                            if(y.all[j]>0)
                            {
                                ans*=1LL*pow_mod(sushu[j],y.all[j],c);
                                ans%=c;
                            }
                        }
                        ans%=c;
                        cout<<ans<<endl;
                    }

                }
                else if(k==1)
                {
                    scanf("%lld%lld%lld",&a,&b,&c);

                    for(lint j=0;j<35;j++)
                    {
                        temp.shu[j]=0;
                        while(c%sushu[j]==0)
                        {
                            temp.shu[j]++;
                            c/=sushu[j];
                        }
                    }

                    if(a<=b)
                    jia(1,n,a,b,1);
                    else jia(1,n,a,n,1),jia(1,n,1,b,1);
                }
                else if(k==2)
                {
                    scanf("%lld%lld%lld",&a,&b,&c);

                    for(lint j=0;j<35;j++)
                    {
                        temp.shu[j]=0;
                        while(c%sushu[j]==0)
                        {
                            temp.shu[j]--;
                            c/=sushu[j];
                        }
                    }

                    if(a<=b)
                    jia(1,n,a,b,1);
                    else jia(1,n,a,n,1),jia(1,n,1,b,1);
                }
            }

        }


    }


    return 0;
}


#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <iostream>

#define lint long long
using namespace std;


const lint sushu[40]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,
67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149};

struct node
{
    lint shu[35];
    lint all[35];

}tree[300000];

node temp;

lint pow_mod(lint a, lint n, lint m)
{
    lint ans = 1;
    while(n)
    {
        if(n&1)
        {
            ans = (ans * a) % m;
        }
        a = (a * a) % m;
        n >>= 1;
    }
    return ans;
}


int jia(lint l,lint r,lint ll,lint rr,lint now)
{

    if(ll<=l&&rr>=r)
    {
        for(lint j=0;j<35;j++)
        tree[now].shu[j]+=temp.shu[j];

        if(l==r)
        {
            for(lint j=0;j<35;j++)
            {
                tree[now].all[j]+=tree[now].shu[j];
                tree[now].shu[j]=0;
            }
        }

        return 0;
    }

    for(lint j=0;j<35;j++)
    tree[now].all[j]+=temp.shu[j]*(rr-ll+1);

    for(lint j=0;j<35;j++)
    {
        tree[now*2].shu[j]+=tree[now].shu[j];
        tree[now*2+1].shu[j]+=tree[now].shu[j];

        tree[now].all[j]+=(r-l+1)*tree[now].shu[j];
        tree[now].shu[j]=0;
    }

    lint mid=(l+r)/2;
    if(rr<=mid)
        jia(l,mid,ll,rr,now*2);
    else if(ll>=mid+1)
        jia(mid+1,r,ll,rr,now*2+1);
    else
    {
        jia(l,mid,ll,mid,now*2);
        jia(mid+1,r,mid+1,rr,now*2+1);
    }

    return 0;
}

node check(lint l,lint r,lint ll,lint rr,lint now)
{

    if(ll<=l&&rr>=r)
    {
        if(l==r)
        for(lint j=0;j<35;j++)
        {
            tree[now].all[j]+=(r-l+1)*tree[now].shu[j];
            tree[now].shu[j]=0;
        }
        else
        for(lint j=0;j<35;j++)
        {
            tree[now*2].shu[j]+=tree[now].shu[j];
            tree[now*2+1].shu[j]+=tree[now].shu[j];

            tree[now].all[j]+=(r-l+1)*tree[now].shu[j];
            tree[now].shu[j]=0;
        }

        return tree[now];
    }

    for(lint j=0;j<35;j++)
    {
        tree[now*2].shu[j]+=tree[now].shu[j];
        tree[now*2+1].shu[j]+=tree[now].shu[j];

        tree[now].all[j]+=(r-l+1)*tree[now].shu[j];
        tree[now].shu[j]=0;
    }


    lint mid=(l+r)/2;
    if(rr<=mid)
        return check(l,mid,ll,rr,now*2);
    else if(ll>=mid+1)
        return check(mid+1,r,ll,rr,now*2+1);
    else
    {
        node a=check(l,mid,ll,mid,now*2);
        node b=check(mid+1,r,mid+1,rr,now*2+1);

        for(lint j=0;j<35;j++)
        a.all[j]+=b.all[j];
        return a;
    }

}


int main()
{
    lint n,m,t,k,ans,the,a,b,c;


    scanf("%lld",&t);
    {
        while(t--)
        {
            scanf("%lld",&n);scanf("%lld",&m);
            memset(tree,0,sizeof tree);


            for(lint i=0;i<m;i++)
            {
                scanf("%lld",&k);

                if(k==0)
                {
                    scanf("%lld%lld%lld",&a,&b,&c);

                    if(a<=b)
                    {
                        node x=check(1,n,a,b,1);
                        ans=1;

                        for(lint j=0;j<35;j++)
                        {
                            if(x.all[j]>0)
                            {
                                ans*=1LL*pow_mod(sushu[j],x.all[j],c);
                                ans%=c;
                            }
                        }
                        ans%=c;
                        printf("%lld\n",(ans%c));
                    }
                    else
                    {
                        node x=check(1,n,a,n,1);
                        node y=check(1,n,1,b,1);

                        ans=1;

                        for(lint j=0;j<35;j++)
                        {
                            if(x.all[j]>0)
                            {
                                ans*=1LL*pow_mod(sushu[j],x.all[j],c);
                                ans%=c;
                            }
                            if(y.all[j]>0)
                            {
                                ans*=1LL*pow_mod(sushu[j],y.all[j],c);
                                ans%=c;
                            }
                        }
                        ans%=c;
                        cout<<ans<<endl;
                    }

                }
                else if(k==1)
                {
                    scanf("%lld%lld%lld",&a,&b,&c);

                    for(lint j=0;j<35;j++)
                    {
                        temp.shu[j]=0;
                        while(c%sushu[j]==0)
                        {
                            temp.shu[j]++;
                            c/=sushu[j];
                        }
                    }

                    if(a<=b)
                    jia(1,n,a,b,1);
                    else jia(1,n,a,n,1),jia(1,n,1,b,1);
                }
                else if(k==2)
                {
                    scanf("%lld%lld%lld",&a,&b,&c);

                    for(lint j=0;j<35;j++)
                    {
                        temp.shu[j]=0;
                        while(c%sushu[j]==0)
                        {
                            temp.shu[j]--;
                            c/=sushu[j];
                        }
                    }

                    if(a<=b)
                    jia(1,n,a,b,1);
                    else jia(1,n,a,n,1),jia(1,n,1,b,1);
                }
            }

        }


    }


    return 0;
}
监心司
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于gym的q-learning强化学习实践
07-18
在本实践项目中，我们探讨了如何利用OpenAI的Gym库进行Q-learning强化学习算法的应用。Gym是一个广泛使用的Python库，它为各种环境提供了一个标准接口，这些环境可以用于训练和测试强化学习算法。这里，我们专注于...
Gym 101028J 100541D
Akahieveman的博客
08-07 635
Gym 100499I 这题当理解题意的时候就出现一个难题，循环小数怎么转化为分数，果断百度下。 普及知识：1,纯循环小数:小数点后有几位数,分母就有几个9,分子为一个循环节.如:0.345(345循环)=345／999 该化简就化简即可.2,混循环小数:小数点后到第一个循环减去非循环小数部分作为分子,循环节内有几位数,分母就有几个9,然后接着写几个0,0的个数为第一个循环节前面非循环小数
线段树（简单模板）
ojzha的博客
10-02 323
#define LL long long struct hh { int l,r,ls,rs;//l,r为边界，ls,rs为左右儿子的编号 LL date;//权值 }t[800000]; LL n,m,num=0,x,y,v,pd,a[200010],add[200010];//add为标记要增大的值的数组 void pushup(int i)//重新求权值 { t
线段树基础板子
Little_Match_Boy的博客
07-16 134
线段树最基础板子题 B - Multiply game Tired of playing computer games, alpc23 is planning to play a game on numbers. Because plus and subtraction is too easy for this gay, he wants to do some multiplication in a number sequence. After playing it a few times, he has
Gym 100541 D. Treasure Box 循环(散乱的前缀+循环体)
ProLights的博客
07-26 1261
在纸上写几组数据， 发现当k一定大以后就会出现循环， 这可以归类于 循环(散乱的前缀+循环体) 哈哈 Hash[x] 表示但值为 x 时 增加的值 先全部初始化为 -1, 但 x 再次出现时说明开始循环了 找到周期， 然后一次性处理掉在周期内的， 然后处理剩余部分
gym-0.13.1.tar.gz
07-29
《gym：开启强化学习之旅》 gym，全称为OpenAI Gym，是一个开源的Python库，用于开发和比较强化学习算法。这个“gym-0.13.1.tar.gz”文件是gym库的一个版本0.13.1的压缩包，包含了安装gym所需的所有组件，方便用户...
OpenAI Gym环境.md
02-10
OpenAI Gym是强化学习的一部分，强化学习的环境列出了可以在其上运行算法的Gym环境。通用包装的列出的环境。它们可以对代理与环境之间交换的数据执行预处理/后处理。包含与Gym环境兼容的代理列表。代理有助于针对...
gym-master
10-29
**gym：OpenAI Gym详解** OpenAI Gym是一款强大的开源工具包，专为强化学习（Reinforcement Learning，RL）研究而设计。它的主要目标是提供一个标准的环境，使得研究者可以方便地测试和比较不同的RL算法。"gym-...
Gym - 100541D 找规律
an94460061的博客
03-08 178
Your team was exploring an ancient city. Suddenly you found an old scroll with 2 integer numbersNandK, which encrypts the secret code to open a treasure box. Considering a transformation on an int...
励志2024龙年筑梦前行共创未来PPT模板，适用于工作计划，工作总结
07-15
【作品名称】：励志2024龙年筑梦前行共创未来PPT模板，适用于工作计划，工作总结 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
内蒙古医科大学考研17个学院，57个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
07-15
内蒙古医科大学考研17个学院，57个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
齐齐哈尔医学院考研，57个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
07-15
齐齐哈尔医学院考研，57个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
长三角城市及各区县数据集.txt
07-15
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。样例数据及详细介绍参见文章：https://blog.csdn.net/m0_65541699/article/details/140428710
简约工作述职PPT模板
07-15
【作品名称】：简约工作述职PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
山东师范大学考研，55个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
最新发布
07-15
山东师范大学考研，55个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
数据库技术(SQLServer)习题与参考答案.doc
07-15
数据库
用友erp常用SQL语句.doc
07-15
数据库
anaconda gym
09-15
引用提到了安装gym的步骤和命令，需要先激活gym环境，然后安装一些相关组件，如pandas、tensorflow、gym和matplotlib。引用中提到，anaconda中已有4个环境，其中包括gym环境。引用讲解了Anaconda的作用和与Pycharm的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值