Codeforces Round #271 (Div. 2) F ,E, D, C, B, A

前言：最近被线段树+简单递推DP虐的体无完肤！真是弱！

    A:简单题，照着模拟就可以，题目还特意说不用处理边界

   B：二分查找即可，用lower_lound()函数很好用

#include<string.h>
#include<math.h>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<string>
#include<iostream>
using namespace std;
#define N 200005
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1

int a[N],s[N];
int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
        scanf("%d",&a[i]);

    for (int i=1;i<=n;i++)
        a[i]+=a[i-1];
    int m;
    scanf("%d",&m);
    while (m--)
    {
        int x;
        scanf("%d",&x);
        int p=lower_bound(a+1,a+n+1,x)-a;
        printf("%d\n",p);
    }

C：没写，但是是一道比较难处理的模拟题吧，求每个点绕它中轴点顺时针旋转90度，求能形成的最小旋转次数，4^4次，还有面积要大于0这个坑点。

D：简单DP，居然推到数学公式，真是SB,我们要使连续的字符串里面个W个数为x*k;当时想到求排列组合，以为可以化简，结果自己掉坑里！

     正确做法，定义一维数组，就是求前导和。

   方程：DP[I]=DP[I-1]+DP[I-K];(i>=k)；（表示：I不为好的话，和为好的发时的总数）

           DP[I]=DP[I-1];

          s[i]=s[i-1]+DP[I]; (对前i段累加）

        中间有Mod 操作，有很多询问，所以要一次做，然后之间求区间值即可！

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;

#define mod  1000000007
#define N 100007
int a[N];
ll s[N];


int main()
{
    int k,t;
    scanf("%d%d",&t,&k);
    a[0]=1;
    for (int i=1;i<N;i++)
    {
        if (i>=k) {a[i]=a[i-1]+a[i-k];a[i]%=mod;}
        else {a[i]=a[i-1];a[i]%=mod;}
        
        s[i]=s[i-1]+a[i];
        s[i]%=mod;
        }

    while (t--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",(s[y]-s[x-1]+mod)%mod);
        }

    return 0;

E：题目简短，二维可以写出，但会TLE。

然后看到一个神奇骗AC代码，可以看看

include<bits/stdc++.h>
#define N 111111
using namespace std;
typedef long long ll;
int n;
ll h[N],ans[N],next[N];
ll d;
int main()
{
    cin>>n>>d;
    for (int i=1;i<=n;i++)
    {
        cin>>h[i];
        ans[i]=1;
        next[i]=-1;
    }
    int mx=1;
        int start=n;
        for (int i=n;i>=1;i--){
        for (int j=i+1;j<=min(i+300,n);j++)
        {
        if (abs(h[j]-h[i])>=d&&ans[j]+1>ans[i])
        {
            next[i]=j;
            ans[i]=ans[j]+1;
        }
     }


     if (ans[i]>mx)
     {
        mx=ans[i];
        start=i;
     }
   }

   cout<<mx<<endl;
   int    i=start;
   while (i!=-1)
   {
       cout<<i<<" ";
       i=next[i];
   }

   return 0;
}

它这里限制了第二重循环的次数，实际上可以第二重循环可以弄到300，或者更少，数据太弱吧！

正解：线段树单点跟新+二分！

分析写到代码里吧！

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define lson l, m,rt<<1
#define rson m+1,r,rt<<1|1
#define N 111111
ll h[N],hh[N],k;
int n;
int pre[N],ss[N];
int sum[N<<2];
int dp[N];

void pushup(int rt)//求区间最大值
{
    sum[rt]=max(sum[rt<<1],sum[rt<<1|1]);
}


void update(int p,int y,int l,int r,int rt)//单点更新
{

    if (l==r)
    {
        if (sum[rt]<y) sum[rt]=y;
        return;
    }
    int m=(l+r)>>1;
    if (p<=m) update(p,y,lson);
    else update(p,y,rson);
    pushup(rt);
}

//询问L，R区间最大值
int query(int L,int R,int l,int r,int rt)
{
    if (R<L) return 0;
    if (L<=l&&R>=r) return sum[rt];

    int m=(l+r)>>1;
    int ret=0;
    if (L<=m) ret=query(L,R,lson);
    if (m<R) ret=max(ret,query(L,R,rson));
    return ret;
}

int main()
{
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++)
        scanf("%I64d",&h[i]),hh[i]=h[i];
    sort(h+1,h+n+1);
    int len=0;
    for (int i=1;i<=n;i++)
    if (h[i]!=h[i-1]) h[++len]=h[i];//排序处理

    int ans=0;
    //整体说一下思路
    //我们先排序出去重，把每个数据抽象变成一个点，然后维护。
    //我们知道DP[I]=MAX(DP[J])+1,abs(h[i]-h[j])>=k;
    //于是我们在前面找到h[i]-h[j]>=k中左右区间然后跟新，这应该是线段树+DP的共同点
    //对H[J]-H[J]>=K同样处理。
    for (int i=1;i<=n;i++)
    {
        int l=lower_bound(h+1,h+len+1,hh[i]+k)-h;//这里的lower_bound与upper_bound不能弄错
        int r=len;
        int x=query(l,r,1,len,1);
        r=upper_bound(h+1,h+len+1,hh[i]-k)-h;//求出左右区间，这里得多看看
        
        x=max(x,query(1,r-1,1,len,1));
        dp[i]=x+1;
        int y=lower_bound(h+1,h+len+1,hh[i])-h;
        update(y,dp[i],1,len,1);
        ans=max(ans,dp[i]);
    }
    printf("%d\n",ans);
    ll hp=1e17;
    int inx=0;//输出的处理
    for (int i=n;i>=1;i--)
    {
        if (ans==0) break;
        if (dp[i]==ans&&abs(hh[i]-hp)>=k)
        {
            hp=hh[i];
            ans--;
            ss[++inx]=i;

        }
    }
    for (int i=inx;i>=1;i--) printf("%d ",ss[i]);
    return 0;
}

F：可以这么认为求出(L,R)区间的GCD，然后问（L,R)有多少个值=GCD();

   线段树求GCD()不是难点，

 求一段区间有多少值=GCD();要用到神奇处理

 int x=upper_bound(a+1,a+n+1,mp(mi,r))-lower_bound(a+1,a+n+1,mp(mi,l));

这里用pair()容器，可以知道有多少个

#include<bits/stdc++.h>

#define lson l,m,rt<<1
#define rson m+1,r, rt<<1|1
#define N 111111

#define mp make_pair
using namespace std;
pair<int,int>a[N];

int s[N<<2];

int gcd(int x,int y)
{
    if (y==0) return x;
    if (x%y==0) return y;
    return gcd(y,x%y);
    }

void pushup(int rt)
{
    s[rt]=gcd(s[rt<<1],s[rt<<1|1]);
    }

void build(int l,int r,int rt)
{
    if (l==r)
    {
       s[rt]=a[l].first;
       return;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    pushup(rt);
}

int query(int L,int R,int l,int r,int rt)
{
    if (L<=l&&R>=r)
        return s[rt];
    int m=(l+r)>>1;
    int ret=0;
    if (L<=m)  ret=gcd(ret,query(L,R,lson));
    if (R>m)   ret=gcd(ret,query(L,R,rson));
    return ret;
}

int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&a[i].first),a[i].second=i;
    build(1,n,1);
    sort(a+1,a+n+1);

    int Q;
    scanf("%d",&Q);
    while (Q--)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        int mi=query(l,r,1,n,1);
        int x=upper_bound(a+1,a+n+1,mp(mi,r))-lower_bound(a+1,a+n+1,mp(mi,l));
        printf("%d\n",r-l+1-x);
    }
    return 0;
}