2017.1.18日测试题解

Problem A： 响子

题目大意：

求[1,n]中有多少个数x满足∃y>0,k>1使得x=y^k。 1≤n≤10^18

题目分析：

我们枚举k，k是不超过64的，然后算出有多少个y是满足题意的，假设有t个满足题意的y，则ans+=t*u[k]。（u是莫比乌斯函）
最后输出1-ans。

算有多少个满足题意的y的时候可以二分+快速幂，在算快速幂的时候变量最好用double来存，因为我们算的数是会爆long long 的。

至于为什么是对的：
莫比乌斯函数的定义是：

1. 莫比乌斯函数μ(n)的定义域是N
2. μ(1)=1
3. 当n存在平方因子时，μ(n)=0
4. 当n是素数或奇数个不同素数之积时，μ(n)=-1
5. 当n是偶数个不同素数之积时，μ(n)=1

我们枚举每一个k，如果把所有的答案都加在一起一定会有众多重复的东西，肯定是不对的，但是我们可以发现一些规律。

比如说k=4（k有平方因子）时，所有的x^12次方都可以拆成是(x^2)^2，这样的数都在k=2的时候计算过了，就不需要再计算了。

再比如当k=30（k为奇数个不同素数的积）时，对于任何一个x^30我们在之前的所有枚举中在加的时候加了它三次，也减掉它三次，相当于没有对它进行操作，所以我们要加上这个的答案。

这个过程其实就等同于容斥原理，加上所有k为奇数个不同素数的积的答案，减去所有k为偶数个不同素数的积的答案。

但是莫比乌斯函数恰好相反，当k为奇数个不同素数积的时候，u[k]为-1，偶数为1，所以我们最终计算的答案是-ans。而且我们每次计算答案都要避开1这个数，但是1最后也要被计算到答案中，所以答案还要+1，最后应该输出1-ans。

代码如下：

#include<cstdio>
#include<iostream>
#include<cmath>
using namespace std;
const double EPS=1e-9;
long long n,ans;
long long u[100];
int p[100],tot;
bool b[100];
void linear_sieve()
{
    u[1]=1;
    for(int i=2;i<=99;i++)
    {
        if(!b[i])
        {
            p[++tot]=i;
            u[i]=-1;
        }
        for(int j=1;p[j]*i<99 && j<=tot;j++)
        {
            b[i*p[j]]=true;
            if(!(i%p[j])) break;
            u[i*p[j]]=-u[i];
        }
    }
}
bool judge(long long x,long long k)
{
    double ans=1,cs=x;
    while(k)
    {
        if(k&1) ans*=cs;
        cs*=cs;
        if(ans>n) return false;
        k>>=1;
    }
    return true;
}
int main()
{
    linear_sieve();
    cin>>n;
    long long len=(long long)floor(log(n)/log(2)+0.5);
    long long radical=(long long)floor(sqrt(n)+0.5);
if(n==0) cout<<0<<endl;
else
{
    for(long long i=2;i<=len;i++)
    {
         long long l=2,r=radical;
         long long cs=0;
         while(l<=r)
         {
             long long mid=(l+r)>>1;
             if(judge(mid,i)) cs=mid,l=mid+1;
             else r=mid-1;
         }
         if(cs!=0) ans+=u[i]*(cs-1);
    }
    cout<<1-ans;
}
    return 0;
}

Problem B：千秋

题目大意：

有一个长度为n的序列h（花的高度），可以进行m次操作（浇水），每次选择一段长度为L的区间，使这段区间中的每一个数+1（花长高1）。希望最后这个序列中最小值最大（最矮的花最高），问这个最小值是多少。1≤N,M,L≤10^5,1≤h_i≤10^9。

题目分析：

一般来说这种最小值最大的问题都用二分来做。

这样我们就可以令l=序列中最小的值，r=l+m , 在l和r区间内二分答案。

检查答案可以O（n）扫一边，如果高度不够就浇水，如果浇水次数不够用了，就返回false，如果扫完这个序列就返回true。

但是因为对一个位置进行操作的时候还会影响到其他的位置，所以我们可以维护一个序列，dl[i]代表在第i个位置我们操作了几次。然后我们维护一个sum，sum为从当前位置往前数L个长度这段区间内操作次数的总和，每次sum加上dl[i]减去dl[i-L]即可，这样当前位置的高度就为h[i]+sum。

时间复杂度O（nlogn）可过。

代码如下：

#include<cstdio>
#define N 120000
using namespace std;
inline int Min(int x,int y) { return x<y?x:y; }
int n,m,L,ans;
int l=2147483647,r;
int a[N];
bool check(int x)
{
    static int dl[N];
    int sum=0,k=m;
    for(int i=1;i<=n;i++)
    {
        int tmp=0;
        if(a[i]+sum<x)
        {
            tmp=x-a[i]-sum;
            k-=tmp;
            if(k<0) return false;
        }
        sum+=tmp;
        dl[i]=tmp;;
        if(i-L>0) sum-=dl[i-L];
    }
    return true;
}
int main()
{
    scanf("%d%d%d",&n,&m,&L);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        l=Min(l,a[i]);
    }
    r=l+m;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(check(mid))
        {
            ans=mid;
            l=mid+1;
        }
        else r=mid-1;
    }
    printf("%d",ans);
    return 0;
}

Problem C： 千莎

题目大意：

给你N个物品，每个物品有价值、体积和一个玄学数（一个没有用的数）。总共有M组询问，每次询问删掉其中一个物品，在给定背包体积上限的情况下，剩下N-1个物品放进背包最多能达到的价值是多少。注意物品的体积和不能超过背包的体积上限。

对于50%的数据，1≤NM≤100。
对于100%的数据，1≤N≤1000,1≤M≤3×〖10〗^5，背包的体积上限是1000，每个物品的体积、价值和玄学数均不超过100。

题目分析：

首先让我吐槽一句：那个玄学数（一个没有用的数）真的什么用都没有，数据范围1000连输入都不卡啊……不知道是不是出题人想跟我们卖个萌……

这道题的前50分随便背个包就能过了。
空间复杂度O（n^2）,时间复杂度O（n^3）。

但是100分的话时间是承受不了的，所以我们需要把一个n降成logn。
可以线段树分治来做(就是按照时间分治啦，会CDQ分治的同学可能比较好理解)。

我们要处理出没有第i个物品时的dp数组，我们定义在时间i时删掉第i个物品，那么第i个物品存在的时间就是[0，i) 和 （i，n）也就是说一个物品影响的范围是它左边的所有位置和它右边的所有位置。

那么我们每次把这个区间二分，然后用左区间的物品去右区间做dp，用右区间的物品去左区间的做dp，到叶子节点的时候，统计答案。

这样我们保证每个物品都不会更新自己答案，而且会更新到所有其他位置的答案。
时间复杂度O（n* 1000 *log（n））

代码如下：

#include<cstdio>
#define N 1001
using namespace std;
inline int Max(int x,int y) {return x>y?x:y;}
struct QAQ{
    int val,w;
}a[N];
int f[N<<2][N];
int ans[N][N];
int n,m,x,y,z;
void bag(int l,int r,int dp[])
{
    for(int i=l;i<=r;i++)
        for(int j=1000;j>=a[i].w;j--)
            dp[j]=Max(dp[j],dp[j-a[i].w]+a[i].val);
    return;
}
void make_tree(int c,int l,int r)
{
    if(l==r)
    {
        for(int i=1;i<=1000;i++)
            ans[l][i]=f[c][i];
        return;
    }
    for(int i=0;i<=1000;i++)
    {
        f[c*2][i]=f[c][i];
        f[c*2+1][i]=f[c][i];
    }
    int mid=(l+r)>>1;
    bag(l,mid,f[c*2+1]); bag(mid+1,r,f[c*2]);
    make_tree(c*2,l,mid); make_tree(c*2+1,mid+1,r);
    return;
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d%d%d",&a[i].w,&a[i].val,&x);
    make_tree(1,0,n-1);
    scanf("%d",&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        printf("%d\n",ans[x][y]);
    }
    return 0;
}