8.16二分、位运算、前缀和

位运算

64位整数乘法

题意：
求 a 乘 b 对 p 取模的值。

主要思路：
利用快速幂的思想，来进行加法，防止越界。

#include<iostream>
using namespace std;
typedef long long ll;
int main()
{
    ll a,b,p;
    cin>>a>>b>>p;
    ll ans=0;
    while(b)
    {
        if(b&1) ans=(ans+a)%p;
        b>>=1;
        a=(a+a)%p;
    }
    cout<<ans<<endl;
    return 0;
}

牛牛的xor

题意：
链接：https://ac.nowcoder.com/acm/problem/21298
来源：牛客网

给你一个n个元素的数组x
你需要找到一个数组a, 0 ≤ a[i] ≤ x[i]
使得a[0] xor a[1]… xor a[n-1]最大
输出这个最大值

主要思路：
这是一道位运算+贪心的题目。
根据抑或运算的性质，对它按位进行处理。
从后往前枚举最末位1
如果ans当前位为0，那么x的当前位就取1，否则就将后边的所有位都变成1，然后进行或运算，得到的就是最优的情况。

#include<iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    int ans=0;
    while(n--)
    {
        int x;
        cin>>x;
        while(x)
        {
            int xx=x&-x;
            x-=xx;
            if(ans&xx) 
                ans|=xx-1;
            else ans|=xx;
        }
    }
    cout<<ans<<endl;
    return 0;
}

永夜的报应

题意：
辉夜手里有 nn 个非负整数 $a_i,a_2\dots \dots$ ，由于辉夜去打 Gal Game 去了，她希望智慧的你来帮忙。

你需要将这些数分成若干组，满足 nn 个数中的每一个数都恰好被分到了一个组中，且每一组至少包含一个数。
定义一组数的权值为该组内所有数的异或和。请求出一种分组方案，使得分出的所有组数的权值之和最小，输出权值之和的最小值。

主要思路：
根据抑或的性质，将所有的数分成一组，求异或值，得到的是最小值。

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
	int n;
	cin>>n;
	int ans=0;
	while(n--)
	{
		int x;
		cin>>x;
		ans^=x;
	}
	cout<<ans<<endl;
	return 0;
}

二分

最佳牛围栏

题意
农夫约翰的农场由 N 块田地组成，每块地里都有一定数量的牛，其数量不会少于 1 头，也不会超过 2000

头。

约翰希望用围栏将一部分连续的田地围起来，并使得围起来的区域内每块地包含的牛的数量的平均值达到最大。

围起区域内至少需要包含 F
块地，其中 F

会在输入中给出。

在给定条件下，计算围起区域内每块地包含的牛的数量的平均值可能的最大值是多少。

主要思路：
非常典型的二分答案的问题。
find函数处理的非常妙，前缀和是find函数的点睛之笔，还有寻找mina,都是绝妙之处。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1e5+10;
int n,m;
int a[N];
double s[N];
bool find(double x)
{
    for(int i=1;i<=n;i++)
        s[i]=s[i-1]+a[i]-x;
    double mina=0;
    for(int i=m;i<=n;i++)
    {
        mina=min(mina,s[i-m]);
        if(s[i]-mina>=0) return 1;
    }
    return 0;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    double l=0,r=2000;
    while(r-l>1e-5)
    {
        double mid=(l+r)/2.0;
        if(find(mid)) l=mid;
        else r=mid;
    }
    int ans=(double)r*1000;//因为取最大值，所以最好取左边界
    cout<<ans<<endl;
    return 0;
}

聪明的质监员

题意：

这批矿产的检验结果 Y

为各个区间的检验值之和。

即：Y = Y1+Y2+…+Ym

若这批矿产的检验结果与所给标准值 S

相差太多，就需要再去检验另一批矿产。

小 T
 不想费时间去检验另一批矿产，所以他想通过调整参数 W 的值，让检验结果尽可能的靠近标准值 S，即使得 S−Y

的绝对值最小。

请你帮忙求出这个最小值

主要思路：
这是一道二分答案+前缀和的问题
重点①：
利用dp的思想预处理出前缀和，然后在O（1）的时间就可以求出区间的值。
重点②：
二分模板的选取以及了解求出来的是哪一个边界。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=2e5+10;
typedef long long ll;
int n,m;
ll s;
typedef pair<int,int> pa;
pa a[N],q[N];
ll num[N],sum[N];
ll find(ll w)
{
    for(int i=1;i<=n;i++)
    {
        if(a[i].first>=w)
        {
            num[i]=num[i-1]+1;
            sum[i]=sum[i-1]+a[i].second;
        }
        else
        {
            num[i]=num[i-1];
            sum[i]=sum[i-1];
        }
    }
    ll ans=0;
    for(int i=1;i<=m;i++)
        ans+=(num[q[i].second]-num[q[i].first-1])*(sum[q[i].second]-sum[q[i].first-1]);
    return ans;
}

int main()
{
    cin>>n>>m>>s;
    for(int i=1;i<=n;i++)
        cin>>a[i].first>>a[i].second;
    for(int i=1;i<=m;i++)
        cin>>q[i].first>>q[i].second;
    ll l=0,r=1e6+1;//+1是因为可能一个都不选的时候
    while(l<r)
    {
        ll mid=(l+r)>>1;
        if(find(mid)<=s) r=mid;
        else l=mid+1;
    }
    ll ans=min(find(l-1)-s,s-find(l));
    cout<<ans<<endl;
    return 0;
}

整除分块

利用整除分块求约数个数：

for(int l=1,r;l<=n;l=r+1)
{
	r=n/(n/l);
	ans+=(r-l+1)*(n/l);
}

利用整除分块求约数和：

for(int l=1,r;l<=n;l=r+1)
{
	r=n/(n/l);
	ans+=(r-l+1)*(n/l)*(r+l)/2;//区域含有的数的个数*该区域的每个数的因子个数*因子值
}

小G的约数

链接：https://ac.nowcoder.com/acm/contest/11160/C
来源：牛客网

小G定义了两个函数F(n)为n的约数和，G(n)为F(1)+F(2)+…+F(n-1)+F(n)
小G想知道G(G(n))等于多少

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
ll G(ll n)
{
    ll ans=0;
//    int x=n;
//     for(int i=1;i<=x;i++)
//         ans+=n/i*i;
    for(ll l=1,r;l<=n;l=r+1)
    {
        r=n/(n/l);
        ans+=(r-l+1)*(n/l)*(l+r)/2;
    }
    return ans;
}
int main()
{
    int n;
    cin>>n;
    cout<<G(G(n))<<endl;
    return 0;
}

前缀和

灵能传输

变换为前缀和后可以找到规律，然后贪心地去排序。

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
const int N=3e5+10;
typedef long long ll;
ll s[N],a[N];
bool book[N];
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        s[0]=0;
        memset(book,0,sizeof(book));
        int n;
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>s[i];
            s[i]+=s[i-1];
        }
        ll s0=0,sn=s[n];
        if(s0>sn) swap(s0,sn);
        sort(s,s+n+1);
        ll l=0,r=n;
        ll x,y;
        for(int i=0;i<=n;i++)
        {
            if(s[i]==s0)
            {
                x=i;
                break;
            }
        }
        for(int i=n;i>=0;i--)
        {
            if(s[i]==sn)
            {
                y=i;
                break;
            }
        }
        for(int i=x;i>=0;i-=2)
        {
                book[i]=1;
                a[l++]=s[i];
        }
        for(int i=y;i<=n;i+=2)
        {
                book[i]=1;
                a[r--]=s[i];
        }
        for(int i=0;i<=n;i++)
        {
            if(!book[i])
                a[l++]=s[i];
        }
        ll ans=0;
        for(int i=1;i<=n;i++)
        {
            ans=max(ans,abs(a[i]-a[i-1]));
        }
        cout<<ans<<endl;
    }
    return 0;
}