暑假集训日记——6.29（快速幂、前缀和、差分、二分、三分）

最新推荐文章于 2022-07-11 11:18:07 发布
最新推荐文章于 2022-07-11 11:18:07 发布
阅读量164 收藏
点赞数
分类专栏： 暑假集训 差分数组 二分查找法 三分查找 快速幂 前缀和
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43870114/article/details/94229195
版权

快速幂、前缀和、差分、二分、三分

目标：高效率的日常，cf rate++ (Fighing)

三分：求凹函数和凸函数的极值问题
模板：
凸函数求极大值：
int版： （解释：若求极大值，若judge(lm)更大，即 lm 更靠近极值点(但是不确定是在左侧还是右侧)，但可以保证 rm 一定在极值点右侧），保留左端点，缩右端点 r 到 rm

while(l+1<r)
{
    int lm=(l+r)>>1,rm=(lm+r)>>1;
    if(judge(lm)>judge(rm))
        r=rm;
    else
        l=lm;
}
//答案取 l

double版：

while(l+eps<r)
{
    double lm=(l+r)/2,rm=(lm+r)/2;
    if(judge(lm)>judge(rm))
        r=rm;
    else
        l=lm;
}
//答案取 l 或 (l+r)/2  (尽管此时 l 和 r 已经相等，但因为精度问题，取 r 可能会错)

凹函数求极小值：
int版：

while(l+1<r)
{
    int lm=(l+r)>>1,rm=(lm+r)>>1;
    if(judge(lm)>judge(rm))
        l=lm;
    else
        r=rm;
}
//答案取 r

double版：

while(l+eps<r)
{
    double lm=(l+r)/2,rm=(lm+r)/2;
    if(judge(lm)>judge(rm))
        l=lm;
    else
        r=rm;
}
//答案取 r 或 (l+r)/2  (尽管此时 l 和 r 已经相等，但因为精度问题，取 l 可能会错)

例题：
C -Elections
题解：（三分）
无单调性，多变量，适合三分 难点就是函数关系怎么确定
三分最终的票数，当有人比自己票数高时，从费用小的开始贿赂他的选民。剩下的从小开始买，用这个函数求得最小费用。
ps：三分的题，除了直接给函数外，真不好想

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<map>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
const int N=1e6+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll a[N];
char str[N];
vector<int>p[100005];
vector<int>ans;
int n,m,k,q;
int x,y,z;
int mx;

int judge(int x)
{
    ans.clear();
    int sum=0;
    int need=x-p[0].size();//需要贿赂的最少人数
    for(int i=1;i<=mx;i++)
    {
        for(int j=0;j<p[i].size();j++)
        {
            if(p[i].size()-j>=x)//不存在比自己的票多的选举者
            {
                need--;
                sum+=p[i][j];
            }
            else//虽然此竞选者票数少，但是便宜
            {
                ans.push_back(p[i][j]);
            }

        }
    }
    if(need<=0)//满足条件的范围
            return sum;
    int sss=0;
    sort(ans.begin(),ans.end());//找到最便宜的
    while(need--)
    {
        sum+=ans[sss++];
    }
    return sum;

}

int solve(int l,int r)//三分当我被选举时的人数，使得花费 最小
{
    while(l+1<r)
    {
        int lm=(l+r)>>1,rm=(lm+r)>>1;
        if(judge(lm)>judge(rm))
            l=lm;
        else
            r=rm;
    }
    return min(judge(l),judge(r));
}

int main()
{
   ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
   cin>>n;
    mx=0;
   for(int i=0;i<n;i++)
   {
       cin>>x>>y;
       p[x].push_back(y);
       if(mx<x)
        mx=x;
   }
   for(int i=0;i<=mx;i++)
   {
       sort(p[i].begin(),p[i].end());
   }
   cout<<solve(p[0].size(),n);

}

B - Monitor
题解：（差分）
由于数据的量比较大，所以二维数组存不下，所以采用二维指针动态分配内存解决
其余的就是基本的差分问题了

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<map>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
const int N=1e7+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll a[N];
int n,m;


int main()
{
   ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int x,y,x1=0,y1=0,x2=0,y2=0;

    while(scanf("%d%d",&m,&n)!=EOF)
{
    int **ptr=new int*[n+5];//
    int **ps=new int*[n+5];//
    for(int i=0;i<=n+1;i++)//
    {
        ptr[i]=new int[m+5];//
        ps[i]=new int[m+5];//
    }
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            ps[i][j]=0;
            ptr[i][j]=0;
        }
    }
    scanf("%d",&x);
    while(x--)
    {
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        ps[y1][x1]+=1;
        ps[y2+1][x2+1]+=1;
        ps[y2+1][x1]-=1;
        ps[y1][x2+1]-=1;
    }
    int flag=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            ps[i][j]=ps[i][j]+ps[i-1][j]+ps[i][j-1]-ps[i-1][j-1];//关键
            //cout<<ps[i][j]<<" ";
        }
       // cout<<endl;
    }
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            if(ps[i][j]>=1) ps[i][j]=1;
            else ps[i][j]=0;
            //cout<<ps[i][j]<<" ";
        }
        //cout<<endl;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            ps[i][j]=ps[i][j]+ps[i-1][j]+ps[i][j-1]-ps[i-1][j-1];
            //cout<<ps[i][j]<<" ";
        }
        //cout<<endl;
    }
    scanf("%d",&y);
    while(y--)
    {
        flag=0;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        if(ps[y2][x2]+ps[y1-1][x1-1]-ps[y1-1][x2]-ps[y2][x1-1]!=(x2-x1+1)*(y2-y1+1))//关键
            flag=1;
        if(flag==0)
        cout<<"YES"<<endl;
        else if(flag==1)
        cout<<"NO"<<endl;

    }
    for(int i=0;i<=n+1;i++)
    {
        delete[]ptr[i];
        delete[]ps[i];
    }
    delete[]ptr;
    delete[]ps;
}
}

G - Molly’s Chemicals
题解：（前缀和）
就是前缀和来判断某个连续区间是否是p的非负幂级数
开始用的是p[i+1]-p[i]=k^m,暴力的话复杂度太高
然后化简一下p[i+1]=k^m+p[i],把p[i+1]的值标记，判断p[i+1]是否等于k ^ m+p[i]

这注意：一开始我是从开始就把p[i+1]的值全部标记了，就出现问题
1.由于数据的无序性，可能造成不满足一段连续区间的情况。
2.如果p[i+1]相同的值有很多，计算结果又不对。

然而展开为p[i+1]-k^m=p[i]，并且对于不同的k ^m，就把p[i+1]的值重新标记一边。就不会出现上述问题，我果然还是太菜了…详细见代码

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<map>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
const int N=1e7+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll a[N];
ll vis[N];
ll p[N];
int n,m;

map<ll,int>d;
ll slove(ll x)
{
    ll sum=0;
    map<ll,int>c;
    c[0]=1;
    for(int i=1;i<=n;i++)
    {
        sum+=c[p[i]-x];
        c[p[i]]++;
            //cout<<c[p[i]-x]<<endl;
    }
    return sum;
}

int main()
{
   ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    //int x,y,x1,y1,x2,y2;
    ll sum=0,mx=0;
    cin>>n>>m;
    ll ans=1;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        p[i]=p[i-1]+a[i];
    }
    if(m==1)
    {
        ll an=slove(1);
        if(an>0) sum+=an;
    }
    else if(m==-1)
    {
        ll an=slove(1);
        if(an>0) sum+=an;
         an=slove(-1);
        if(an>0) sum+=an;
    }
    else
    for(int i=0;abs(ans)<1e15;i++)
    {
            ll an=slove(ans);
            if(an>0) sum+=an;
            ans*=m;
    }
    cout<<sum<<endl;
}

E - DNA Alignment
题解：（快速幂）
题目不难就是要找到规律：
最多且相同数目字母的个数^字符串长度
剩下就是快速幂就好了。

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<map>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
const int N=1e7+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll a[N];
int n;
char s[N];

ll mul(ll a,ll b,ll mod){//快速乘
	ll ans=0,res=a;
	while(b){
		if(b&1) ans=(ans+res)%mod;
		res=(res+res)%mod;
		b>>=1;
	}
	return ans;
}

ll quickPower(ll a,ll b,ll mod){
    ll ans=1,base=a;
    while(b>0){
        if(b&1)
            ans=mul(ans,base,mod);
        base=mul(base,base,mod);
        b>>=1;
    }
    return ans;
}

int main()
{
   ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int x,y,x1=0,y1=0,x2=0,y2=0;
    ll sum=0,mx=0;
    ll mod=1e9+7;
    cin>>n;
    scanf("%s",s);
    for(int i=0;i<n;i++)
    {
        if(s[i]=='A')
            x1++;
        if(s[i]=='T')
            x2++;
        if(s[i]=='G')
            y1++;
        if(s[i]=='C')
            y2++;
    }
    mx=max(x1,max(x2,max(y1,y2)));
    if(mx==x1) sum++;
    if(mx==y1) sum++;
    if(mx==x2) sum++;
    if(mx==y2) sum++;
    cout<<quickPower(sum,n,mod)<<endl;
}

D - Vasya and Robot
题解：（二分+前缀和）
二分答案，枚举 （用前缀和表示的区间）判断是否符合条件，并找到满足条件的最小值。

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<map>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
const int N=1e6+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll a[N];
char str[N];
int xtr[N];
int ytr[N];
int n,dis;
int x,y;
int slove(int sta,int len)
{
    int x1=xtr[n]-xtr[sta+len-1]+xtr[sta-1];
    int y1=ytr[n]-ytr[sta+len-1]+ytr[sta-1];
    int redis=abs(x-x1)+abs(y-y1);//计算除了区间以外所需要的步数
    //cout<<sta<<" "<<len<<endl;
    //cout<<x1<<" "<<y1<<endl;
    //cout<<redis<<" "<<len<<endl;
    //cout<<endl;
    if(redis<=len&&redis%2==len%2)//临界条件：当可以操作的步数大于距离时满足条件
        return 1;
    return 0;
}

int main()
{
   ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);

   cin>>n;
   scanf("%s",str+1);
   for(int i=1;i<=n;i++)//分别计算x，y的前缀和
   {
       xtr[i]=xtr[i-1];
       ytr[i]=ytr[i-1];
       if(str[i]=='U') xtr[i]=xtr[i-1]+1;
       if(str[i]=='D') xtr[i]=xtr[i-1]-1;
       if(str[i]=='L') ytr[i]=ytr[i-1]-1;
       if(str[i]=='R') ytr[i]=ytr[i-1]+1;
   }
   //cout<<xtr[n]<<" "<<ytr[n]<<endl;
   cin>>y>>x;
    dis=abs(x)+abs(y);
   if(dis>n||(n-dis)%2!=0)// 特判
    {
        cout<<-1<<endl;
        return 0;
    }
    int l=0,r=n,mid;
    int ans=0;
    while(l<=r)
    {
        mid=(l+r)>>1;
        int flag=0;
        for(int i=1;i<=(n-mid+1);i++)//区间起点的覆盖范围
        {
            if(slove(i,mid))
            {
                flag=1;
                break;
            }

        }
        if(flag==1)
        {
            ans=mid;
            r=mid-1;
        }
        else
        l=mid+1;
    }
    cout<<ans<<endl;

}

Monitor
题解：（二分+前缀和）
提醒注意下变量的范围…太粗心了吧
以及初始话的问题（也是范围的因素…）

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<map>
#include<iterator>
#include<queue>
#include<vector>
#include<string>
using namespace std;

typedef long long ll;
const int N=1e6+10;
const long long INF=1e18;
const double eps=0.0000001;
const ll mod=1e9+7;
ll a[N];
char str[N];
int mapp[1000][1000];
int maps[1000][1000];
int n,m,k,q;
int x,y,z;
int slove(int x)
{
    memset(maps,0,sizeof(maps));
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            if(mapp[i][j]<=x&&mapp[i][j]!=-1)
                maps[i][j]=1;
            maps[i][j]=maps[i][j]+maps[i-1][j]+maps[i][j-1]-maps[i-1][j-1];

            if(i>=k&&j>=k&&maps[i][j]-maps[i-k][j]-maps[i][j-k]+maps[i-k][j-k]==k*k)
                return 1;
        }
    return 0;
}

int main()
{
   ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin>>n>>m>>k>>q;
    int mx=0;
     for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            mapp[i][j]=-1;
        }
    for(int i=0;i<q;i++)
    {
        cin>>x>>y>>z;
        mapp[x][y]=z;
        if(z>mx)
            mx=z;
    }

    int l=0,r=mx,mid;
    int ans=mod;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(slove(mid))
        {
            ans=mid;
            r=mid-1;
        }
        else
        l=mid+1;
    }
    if(ans==mod)
        cout<<-1<<endl;
    else
        cout<<ans<<endl;

}
THE END GAME
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前缀和、差分、快速幂（取模）、矩阵快速幂
zzqwtc的博客
03-09 1800
前缀和 void Prefix_sum(const int a[], const int n) {//获得前缀和数组 for (int i = 1;i <= n;++i) { Prefix__sum[i] = a[i] + Prefix__sum[i - 1]; } } 差分 void Difference(const int a[], const int n) {//获得差分数组...
快速幂、前缀和、差分、二分、三分
qq_30445397的博客
07-10 167
快速幂、前缀和、差分、二分、三分 快速幂、前缀和、差分、二分、三分 A CF 457C Elections B HDU 6514 Monitor C CF 1073C Vasya and Robot D CF 520C DNA Alignment E CF 348A Mafia F CF 776C Molly’s Chemicals G HDU 6276 Easy hhh-index H CF 779D String Game I CF 846D Monito
二分与三分与二分快速幂
weixin_30417487的博客
07-17 110
　　二分是一种常用而且非常精妙的算法，常常是我们解决问题的突破口。二分的基本用途是在单调序列或单调函数中做查找操作。因此，当问题的答案具有单调性时，就可以通过二分把求解转化为判定（根据复杂度理论，判定的难度小于求解）。进一步的，我们还可以通过三分（适用于求解凸性函数）解决单峰函数的极值以及相关问题。 二分 　　思想：分而治之。将一个规模为n的问题分解为k个规模较小的子问题，这些子问题互...
NCST CCPC赛前训练1 位运算、状态压缩、快速幂、二分、差分与前缀和
紫藤&code的博客
04-13 341
A : [算法竞赛进阶指南]A^B 每一个整数可以唯一表示为若干指数不重复的2的次幂的和。 比如：3^5:5可以表示为:101,3^(1*2^2+0*2^1+1*2^0) #include <iostream> #include <algorithm> using namespace std; using ll = long long; // 快速幂 int Pow(int...
快速幂+差分的综合用法
qq_62362934的博客
11-17 235
其实是做了一道同时融合了快速幂与差分两个知识点的题，就想发一篇博客，使我和看到这篇博客的你都能把这两个知识点掌握扎实，就废话少说，直接看题吧！！ 例题：对于一个元素全部是1的数列，对这个长度为n的数列做一系列操作之后，再求这个数列的最大公约数，操作如下：首先会找到一个操作的初始位置l，再找到一个操作的终止位置r，最后，给一个操作数x，然后，将数列中l到r的数据都乘上x（即：对于l<=i<=r，都会做操作a[i] = a[i] *x），为了防止数据过大x只会取2或者3,要进行m次操作。（...
BANDZIOP.6.29版本：文件压缩包，免费无广版本，望给个点赞
04-14
bandzip是一款轻量级、快速且整合程度较高很好用的解压缩软件。bandzip具备非常快速的压缩与解压缩算法，支持鼠标拖拽操作以及多线程操作。而且bandzip支持目前主流的解压缩文件格式。 它的功能非常全面，支持...
ipykernel-6.29.3.tar.gz
05-26
ipykernel是IPython项目的一部分，主要用于构建Jupyter Notebook和JupyterLab等交互式计算环境的核心组件——内核。IPython内核负责处理用户的代码输入，执行这些代码，并返回结果。当用户在Jupyter环境中运行Python...
ipykernel-6.29.4.tar.gz
05-26
ipykernel是IPython项目的一部分，主要用于构建Jupyter Notebook和JupyterLab等交互式计算环境的核心组件——内核。IPython内核负责处理用户的代码输入，执行代码，并将结果返回到用户界面。ipykernel支持多种语言，...
ipykernel-6.29.2.tar.gz
05-26
标题中的"ipykernel-6.29.2.tar.gz"表明这是一个包含ipykernel 6.29.2版本的压缩包文件，采用的是常见的tar.gz格式，这种格式广泛用于Linux和Unix系统中，用于存储和传输文件。 首先，我们需要理解ipykernel是什么...
ipykernel-6.29.1.tar.gz
最新发布
05-26
这个资源“ipykernel-6.29.1.tar.gz”提供了ipykernel的6.29.1版本，它是一个压缩包文件，包含了该库的所有源代码和其他必要文件，供用户下载和使用。 ipykernel，全称为IPython Kernel，是IPython项目的一部分，...
二分（三分）+快速幂
weixin_30593443的博客
01-27 88
之前学习的二分，现在感觉突然理解许多，补一下总结 首先，二分能够解决什么样的问题呢，个人认为，二分能够快速解决已经知道答案范围（线性）但是不知道确切答案的问题，例如在一个有序序列中查找某一元素出现的（最早，最晚）位置，求某单调（或在给定区间上单调）函数的零点，最大化最小值或者最小化最大值等等 二分的模板大体如下： int l=x;//x表示元素可能出现的最小（最左边）的情况 in...
快速幂，二分，三分模板
red_red_red的博客
11-03 157
//快速幂 long long Mood(long long a,long long b) { long long ans=1; a%=Mod; while(b) { if(b&1)//取二进制最后一位 ，如果是一就进行下一步，是0 就跳过这一步 ans=ans*a%Mod; b=b>>1;//b右移一位 a=a*a%Mod; } return ...
二分三分矩阵快速幂
Leo9344的博客
02-17 155
二分三分矩阵快速幂 2020.2.17 二分法 lower_bound upper_bound(begin,end,val) 返回指针 解决问题 具有单调性/连续性的问题二分查找 最大最小问题/最小最大问题二分答案 小数 规定精度 double l,r,mid; while(right - left > eps)1e-8 mid = (right + left)/2; if(judge...
7/10 每日 小模板（快速幂，gcd，二分，三分）
zhao_xin_ran的博客
07-11 60
一些实用小模版
2019南昌网络赛【 Max answer】【单调栈+ST表】
qq_39921637的博客
04-22 210
一开始的思路只是单调栈+前缀和就好了，后来发现当最小值为负数的时候并不能找到最优解。 比如-3 7 -1 -2 -1这种情况 正确的想法是对前缀和建立st表，还是单调队列求最近的小于x的编号。 当最小值<0的时候，应该求【i, R[i]】范围内的前缀和的最小 减去 【L[i], i-1】范围内前缀和最大。 反之求【i, R[i]】范围内的前缀和的最大 减去 【L[i], i-1】范围内前缀和...
二分幂和快速幂
BaiJJMM的博客
05-23 994
对于a^n计算，二者都是为了实现高效率的幂运算，且思路相似。二分幂，当n为偶数时，将a^n分为（a^(n/2)）*(a^(n/2))；当n为奇数时，将a^n分为(a^((n-1)/2))*(a^((n-1)/2))*a；然后递归计算。快速幂，将n化为二进制，当二进制位为1时，累乘结果，当二进制位为0时，累乘过程；从n的个位开始&amp;1运算，运算结束后，n&gt;&gt;1，思路其实类似二分幂。...
暑假集训日记——7.13（单调栈/单调队列+codeforce）
weixin_43870114的博客
07-13 959
C. Tokitsukaze and Discard Items 按照题意模拟即可…可惜B题就做懵了 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int MAX=1e5+10; ll p[MAX]; int main() { ll n,m,k; scanf("%lld%lld%l...
暑假集训日记——7.7（月赛+scc习题）
weixin_43870114的博客
07-08 432
A - 迷宫城堡 题解： 两两可达，就是判断一下这个图是否是一个强联通图，模板题。 #include<bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int, int> pii; typedef pair<ll, int> pli; typedef pair<...
暑假集训日记——7.15（ST表+单调栈/单调队列+codeforce）
weixin_43870114的博客
07-16 424
C. From S To T 模拟题 #include<algorithm> #include<cstdio> #include<cmath> #include<iostream> #include<cstring> #include<functional> #include<set> #include<ma...
bandzip 6.29
09-12
Bandizip 6.29是一款免费的解压软件，被认为是最好用的免费解压软件之一。它没有广告，因此用户使用起来非常舒适。除此之外，它还有一个7.x版本，也是免费的，但是有广告。[1] 如果你想下载Bandizip 6.29，你可以在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值