BestCoder No.11 总结

这算是我们集训队第一次集体做吧，主要写给其他人看的。

A题：

没啥说的，判断所给的x,y是不是分别是n与m的二分之一即可。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int n,m,x,y;
int main()
{
    while(scanf("%d%d%d%d",&n,&m,&x,&y)!=EOF)
    {
        if(x*2==n&&y*2==m)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}

B题：

这个题要求求出所给一些数能够组成的最大的，并且没有前导0，并且是奇数的数。

思路：

1、首先我们应该从小到大排序（因为所求最大，贪心），然后将最后一个与最小的奇数进行交换（如果是最后一个是奇数的话没有影响）

2、在做第一个处理以后，如果找不到这样的奇数那么输出-1，对于交换后的数我们需要对除最后一个外的所有数进行排序，因为交换后可能不满足大小排序了，想一想？

3、再次排序后还需要判断下最大的是否为0（除去前导0），若最大的为0，则为-1，否则从大到小输出即可。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=110;
int n,a[maxn];
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        sort(a,a+n);
        int pos=-1;
        for(int i=0;i<n;i++)
            if(a[i]&1)
            {
                pos=i;
                break;
            }
        if(pos==-1)
        {
            printf("-1\n");
            continue;
        }
        swap(a[pos],a[0]);
        sort(a+1,a+n);
        if(a[n-1]==0)
        {
            printf("-1\n");
            continue;
        }
        for(int i=n-1;i>=0;i--)
            printf("%d",a[i]);
        printf("\n");
    }
    return 0;
}

C题：

这个题要求求出出现字符不超过k次的子串个数（不用去重）:

思路：

1、对于一个长度为n的字符串它的子串个数很明显是1+2+....+n的和。

2、有了1的结论，那么我们可以预处理长度为n的子串为多少。然后我们设置前后points，保证所指向的区间的字符重复数不超过k，那么可以直接算出这个区间的所有子串，然后通过移动前后points调整到下一个区间。

3、经过2计算的话我们会算了重复的子串，设前后points分别为pre和last，那么当pre移动后，last移动向下一个合法区间设为last2，那么计算的时候很明显pre->last（上次的last）是重复计算了的，如果我们按照pre->last2区间计算子串的话，那么我们只需要把这个重复的减去即可。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=1e5+100;
long long num[maxn];
char str[maxn];
int cnt[30],k;
void Init()
{
    num[1]=1;
    for(int i=2;i<=1e5;i++)
        num[i]=num[i-1]+i;
}
int main()
{
    Init();
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%s",str);
        scanf("%d",&k);
        memset(cnt,0,sizeof(cnt));
        int len=strlen(str);
        int pre=0,last=0,prlast=0;
        long long ans=0;
        while(last<len)
        {
            prlast=last;
            while(last<len)
            {
                if(cnt[str[last]-'a']+1>k)
                    break;
                cnt[str[last++]-'a']++;
            }
            ans+=num[last-pre]-num[prlast-pre];
            while(pre<last&&cnt[str[last]-'a']>=k)
            {
                cnt[str[pre]-'a']--;
                pre++;
            }
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

D题：

这个很明显是个单点更新区间查询的题，也就说给你一些初始值，然后每次可以改变其中的一个值，查询的时候需要查询[L,R]中第D位数值为P的个数。

思路：

1、如果没有求某位的数值是多少或者数据量稍小点，那么直接用线段树或者树状数组可以解决。（现在所需要数组的大小为1e7，稍大），如果直接写线段树的话应该会超时。那么我们可以考虑分治思想，将10位分别处理，每次处理就转换成单调更新、区间查询了（典型的树状数组）。

2、想到1的话就需要离线处理，将所有的更新和查询保存下来（注意保存先后关系，即每次查询操作一定要保证之前的更新全部完成），我的处理方法是把每位的查询保存下来，然后依次枚举每一位，注意查询的时候更新之前所有的操作，然后就交给二维树状数组就行了，t[x][y]：x表示的是位置，y表示的是该位置数值为y。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
using namespace std;
const int maxn=1e5+100;
int n,m,a[maxn],b[maxn],t[maxn][11],ans[maxn];
int num[12]={1,1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
struct Node
{
    int l;
    int r;
    int num;
    int nth;
    Node(){}
    Node(int sl,int sr,int snum,int sth)
    {
        l=sl;r=sr;num=snum;nth=sth;
    }
};
struct Set
{
    int pos;
    int val;
    int nth;
    Set(){}
    Set(int spos,int sval,int snth)
    {
        pos=spos;
        val=sval;
        nth=snth;
    }
};
vector<Node> q[11];
vector<Set> s;
int lowbit(int x)
{
    return x&(-x);
}
void Update(int x,int val,int pos)
{
    for(;x<=n;t[x][pos]+=val,x+=lowbit(x));
}
int Sum(int x,int pos)
{
    int ans=0;
    for(;x>0;ans+=t[x][pos],x-=lowbit(x));
    return ans;
}
void Init()
{
    for(int i=0;i<=10;i++)
        q[i].clear();
    s.clear();
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        Init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=0;i<m;i++)
        {
            char op[2];
            scanf("%s",op);
            if(op[0]=='Q')
            {
                int l,r,pos,num;
                scanf("%d%d%d%d",&l,&r,&pos,&num);
                q[pos].push_back(Node(l,r,num,i));
            }
            else
            {
                int pos,val;
                scanf("%d%d",&pos,&val);
                s.push_back(Set(pos,val,i));
            }
        }
        memset(ans,-1,sizeof(ans));
        for(int i=1;i<=10;i++)
        {
            int l=q[i].size(),k=0;
            if(l==0)
                continue;
            memset(t,0,sizeof(t));
            for(int j=1;j<=n;j++)
            {
                Update(j,1,a[j]/num[i]%10);
                b[j]=a[j];
            }
            for(int j=0;j<l;j++)
            {
                while(k<s.size()&&s[k].nth<q[i][j].nth)
                {
                    Update(s[k].pos,-1,b[s[k].pos]/num[i]%10);
                    Update(s[k].pos,1,s[k].val/num[i]%10);
                    b[s[k].pos]=s[k].val;
                    k++;
                }
                ans[q[i][j].nth]=Sum(q[i][j].r,q[i][j].num)-Sum(q[i][j].l-1,q[i][j].num);
            }
        }
        for(int i=0;i<m;i++)
            if(ans[i]!=-1)
                printf("%d\n",ans[i]);
    }
    return 0;
}