NOIP2011 Day1,Day2 T1 T2 题解

D1T1：铺地毯（carpet.cpp/c/pas）

【题目分析】

分析题目我们可以发现，本题是一个比较简单的枚举，我们可以从后向前扫描，找到的第一个覆盖这个点的地毯，这个地毯的编号就是最后一个覆盖这个点的地毯的编号。

【程序源代码】

//carpet.cpp by JerryXie

#include<cstdio>
using namespace std;
struct carpet
{
  int a,b,g,k;
};

carpet c[10001];
int main()
{
    freopen("carpet.in","r",stdin);
    freopen("carpet.out","w",stdout);
    int i,n,x,y,ans=-1;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
      scanf("%d%d%d%d",&c[i].a,&c[i].b,&c[i].g,&c[i].k);
    scanf("%d%d",&x,&y);
    for(i=n;i>=1;i--)
      if(c[i].a<=x && c[i].b<=y && c[i].a+c[i].g>=x && c[i].b+c[i].k>=y) //进行判定
      {
        ans=i;
        break;
      }
    printf("%d",ans);
    return 0;
}

D1T2：选择客栈（hotel.cpp/c/pas）

【题目分析】

分析题目，我们发现可以通过枚举咖啡厅的位置来从枚举的位置的左右寻找方案。但是这样的算法时间复杂度相当高，n的规模即使很低也难以承受，而且我们观察数据范围可以发现，n达到了20万的数据规模，O(n²)的算法都很难拿到满分。但是，我们可以换一个思路。

我的思路是枚举右侧客栈的位置，寻找中间的咖啡店，通过咖啡店的位置找到咖啡店之前的符合条件的客栈，与之进行配对，之后累加方案数量即可。由于20万的数据规模不能采用O(n²)的算法，我们可以通过以空间换时间的方式降低复杂度，即通过记忆化的方式来预先记录一些数据。

我是这样做的：先用一个数组lastp[i]记录一下i号客栈之前距离它最近的一家p小于等于最低消费的客栈（包括i本身）。然后枚举色调ki，用数组knum[i] 表示i之前（包括i）色调是ki的客栈数量。这样的话逐一扫描客栈，如果此客栈也满足ki的色调，那么就判断它的p是否小于等于旅客所能接受的最低消费，如果是则很明显lastp[i]=i，这样的话i之前的所有色调是ki的客栈都能与它配对，则ans+=knum[lastp[i]]-1（因为knum[lastp[i]]中有1个是i自己，不能配对）；如果大于最低消费，则lastp[i]之前的所有色调是ki的客栈可以与它配对，则ans+=knum[lastp[i]]。

【程序源代码】

//hotel.cpp by JerryXie

#include<cstdio>
using namespace std;
struct hotel //定义结构体用来表示客栈
{
       int k,p;
};

hotel h[200001];
int lastp[200001],knum[200001];
int main()
{
    freopen("hotel.in","r",stdin);
    freopen("hotel.out","w",stdout);
    int i,n,k,p;
    int ans;
    int work(int,int,int); //声明求解函数
    scanf("%d%d%d",&n,&k,&p);
    for(i=1;i<=n;i++)
      scanf("%d%d",&h[i].k,&h[i].p);
    ans=work(n,k,p);
    printf("%d",ans);
    return 0;
}

int work(int n,int k,int p) //求解函数
{
    int ki,i,j;
    int ans=0;
    for(i=1;i<=n;i++) //计算距离i最近的p小于等于最低消费的客栈编号
    {
      for(j=i;j>=1;j--)
        if(h[j].p<=p)
        {
          lastp[i]=j;
          break;
        }
    }
    for(ki=0;ki<k;ki++) //枚举色调
    {
      for(i=1;i<=n;i++) //计算i之前（包括i）符合色调ki的客栈数目
      {
        if(h[i].k==ki)
          knum[i]=knum[i-1]+1;
        else
          knum[i]=knum[i-1];
      }
      for(i=1;i<=n;i++) //枚举客栈
      {
        if(h[i].k!=ki) //如果色调不符合ki，则直接跳过
          continue;
        if(h[i].p<=p)  //如果小于等于最低消费
          ans+=knum[lastp[i]]-1;
        else  //如果大于最低消费
          ans+=knum[lastp[i]];
      }
    }
    return ans;
}

D2T1：计算系数（factor.cpp/c/pas）

【题目分析】

从题目上来分析，很明显能发现此题可以通过使用二项式定理（杨辉三角）进行解决，但是，从数据量来看，a,b∈[0,1000000]，中间项将会很大，64位整数都可能无法存下，要用高精度来解决，但是仔细阅读题目就会发现，题目要求答案对10007取模，这样的话可以通过模运算的性质，来避免高精度的使用。

在本题中我们要使用的模运算性质：(a+b)%p=(a%p+b%p)%p，a^b%p=(a%p)^b，(a*b)%p=[(a%p)*(b%p)]%p

而对二项式定理的应用，则可以通过二维数组递推或者直接应用组合公式进行计算，我们在此使用递推方法。

【程序源代码】

//factor.cpp by JerryXie

#include<cstdio>
#include<cmath>
using namespace std;
int tri[1001][1001];  //存储杨辉三角的二维数组
int main() //主函数
{
    freopen("factor.in","r",stdin);
    freopen("factor.out","w",stdout);
    int a,b,k,n,m;
    int i;
    double res;
    void triangle(int);  //声明初始化杨辉三角的函数
    double pownew(int,int); //声明乘方函数
    double work(int,int,int,int,int); //声明计算函数
    scanf("%d%d%d%d%d",&a,&b,&k,&n,&m);
    triangle(k); //用k初始化杨辉三角
    res=work(a,b,k,n,m);
    printf("%.0lf",res);
    return 0;
}

void triangle(int k) //初始化杨辉三角
{
     int i,j;
     for(i=0;i<=k;i++) //初始化边界
     {
       tri[i][0]=1;
       tri[i][i]=1;
     }
     for(i=2;i<=k;i++) //递推求解
       for(j=1;j<i;j++)
       {
         tri[i][j]=tri[i-1][j-1]+tri[i-1][j];
         tri[i][j]%=10007; //进行取模运算
       }
     return;
}

double pownew(int a,int n) //乘方函数
{
    int i,temp;
    double res=a;
    if(n==0)
      return (double)1;
    else if(n==1)
      return (double)a;
    else
    {
        temp=a;
        res=fmod(res,10007);
        for(i=2;i<=n;i++)
        {
          res*=temp;
          res=fmod(res,10007);
        }
        return res;
    }
}

double work(int a,int b,int k,int n,int m) //计算函数
{
       double res;
       res=tri[k][n]*pownew(a,n);
       res=fmod(res,10007);
       res*=pownew(b,m);
       res=fmod(res,10007);
       return res;
}

D2T2：聪明的质监员（qc.cpp/c/pas）

【题目分析】

从题目上看，很容易可以想到通过枚举W的值逐个计算检验值的大小，从而选出最小值，但是从数据规模上来看如果如此做可能连一半的测试点都无法通过，必须进行优化。我们可以通过二分的思想进行优化。

观察题目，我们可以发现随着W的不断增大，每次选取的矿石数量会减少，即检验值也会减小。所以，我们可以先对w进行排序，然后w的最小值和最大值为区间二分W：

若当前二分值所计算出的Y>S，则代表当前W的取值过小，二分区间的起点变化为当前W，维护当前最小值，继续二分；

若当前二分值所计算出的Y<S，则代表当前W的取值过大，二分区间的终点变化为当前W，维护当前最小值，继续二分；

若当前二分值所计算出的Y=S，则代表当前W取值已经为最优。

而对于区间的问题，我们可以通过建立两个数组a,b，a_i表示1-i这些矿石中，w_i>W的矿石数量；b_i表示1-i这些矿石中，w_i>W的矿石的v_i值之和。这样，我们可以通过简单的减法来获得任意区间的值。

但是还是有一个问题，观察数据量我们会发现，在逐步累加每个区间累乘积的过程中，累加和在极限数据（即都取到最大值）的情况下会超过64位整数所能存下的最大值（即200000个区间、200000个矿石、最大长度200000、最大价值1000000等）。但是我们也可发现，超过64位整数范围的数与S做减法（大于10¹⁹）肯定会比其它取值所计算的绝对值要大，这样的话所有超过64位整数范围的 数我们都可以忽略。因此我们可以进行一个判断，判断64位整数最大值减去当前的乘积是否小于当前累加和，若小于则代表相加后将会溢出，则可以视为累乘和大于s直接退出进行处理。

【程序源代码】

//qc.cpp by JerryXie

#include<cstdio>
#include<climits> //调用long long,int的最大值
using namespace std;
struct stone //定义结构体用来表示石头
{
       int w,v;
};

struct section //定义结构体用来表示区间
{
       int l,r;
};

stone sto[200001]; //石头数组
section sec[200001]; //区间数组
long long a[200001]={0},b[200001]={0}; //用来存储1-i的数据

int main()
{
    freopen("qc.in","r",stdin);
    freopen("qc.out","w",stdout);
    int i,n,m,l,r,w,maxw=0,minw=INT_MAX;
    long long s,tempa,tempb,tempmulti,tempans,abstempans,minys=LONG_LONG_MAX;
    bool overflowed=false;
    void count(int,int); //声明处理a，b数组的函数
    scanf("%d%d%lld",&n,&m,&s);
    for(i=1;i<=n;i++) //读入+预处理，获得w的最大值和最小值
    {
      scanf("%d%d",&sto[i].w,&sto[i].v);
      if(sto[i].w>maxw)
        maxw=sto[i].w;
      if(sto[i].w<minw)
        minw=sto[i].w;
    }
    for(i=1;i<=m;i++)
      scanf("%d%d",&sec[i].l,&sec[i].r);
    l=minw;
    r=maxw;
    while(l<=r) //二分求解
    {
      w=(l+r)/2; //取中点
      count(w,n); //初始化a，b数组
      tempans=0;
      overflowed=false;
      for(i=1;i<=m;i++) //计算总区间的检验值
      {
        tempa=a[sec[i].r]-a[sec[i].l-1];
        tempb=b[sec[i].r]-b[sec[i].l-1];
        tempmulti=tempa*tempb;
        if(LONG_LONG_MAX-tempmulti<tempans) //检验是否溢出，溢出则修改标记
        {
          overflowed=true;
          break;
        }
        tempans+=tempmulti;
      }
      if(overflowed==true) //如果溢出则按大于s处理
      {
        l=w+1;
        continue;
      }
      if(tempans>=s)
        abstempans=tempans-s;
      else
        abstempans=s-tempans;
      if(minys>abstempans)
        minys=abstempans;
      if(tempans==s) //如果检验值等于s则直接为最优解
      {
        minys=0;
        break;
      }
      else if(tempans>s) //大于s则修改左端点
        l=w+1;
      else //小于s则修改右端点
        r=w-1;
    }
    printf("%lld",minys); //输出结果
    return 0;
}

void count(int w,int n) //处理a，b数组
{
     int i;
     if(sto[1].w>=w) //初始化起始项
     {
       a[1]=1;
       b[1]=sto[1].v;
     }
     else
     {
         a[1]=0;
         b[1]=0;
     }
     for(i=2;i<=n;i++) //逐个初始化
       if(sto[i].w>=w)
       {
         a[i]=a[i-1]+1;
         b[i]=b[i-1]+sto[i].v;
       }
       else
       {
           a[i]=a[i-1];
           b[i]=b[i-1];
       }
     return;
}

欢迎鄙视。