题解

A：

由于保证了边界情况，所以直接对于每个字符暴力找即可。

#include<stdio.h>
using namespace std;
char s[110];
char a[50]={"qwertyuiopasdfghjkl;zxcvbnm,./"};
int main()
{
    char c[10];
    while(scanf("%s",c)==1)
    {
        scanf("%s",s);
        int k;///k代表坐标偏移，-1代表左边的字符，+1代表右边的字符
        if(c[0]=='R') k=-1;
        else k=1;
        for(int i=0;s[i];i++)
        {
            for(int j=0;j<30;j++)
            {
                if(a[j]==s[i])
                {
                    printf("%c",a[j+k]);
                    break;
                }
            }
        }
        puts("");
    }
    return 0;
}

B:

找出三个正整数a，b，c，使得1<=a<=b<=c<=n，而且a^2 + b^2 == c^2，给你n，问你能找出多少a，b，c

由于n<=10^4,暴力枚举其中两条边，判断第三条边是否满足即可，由于都是正整数，因此不可能有两条边相等

判断一个数开根号以后是不是整数，我们可以先预处理，开一个bool数组ok[10010]，全部初始化为false

那么就可以循环跑答案了,这个方法在数组能开下的情况下是比较靠谱的，没有浮点的困扰

for(int i=0;i*i<=10000;i++)
    ok[i*i]=true;

#include<bits/stdc++.h>
using namespace std;
int main()
{
    bool ok[10010];
    memset(ok,false,sizeof(ok));
    for(int i=0;i*i<=10000;i++) ok[i*i]=true;
    int n;
    while(~scanf("%d",&n))
    {
        int ans=0;
        for(int c=1;c<=n;c++)
        {
            for(int b=1;b<c;b++)
            {
                int x=c*c-b*b;
                if(ok[x]&&b*b>x) ans++;///保持好大小关系 以免算重
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int ans=0;
        for(int c=1;c<=n;c++)
        {
            for(int b=1;b<c;b++)
            {
                int x=c*c-b*b;
                int a=sqrt(x);//开根号后向下取整
                if(a*a==x&&a<b) ans++;//如果a*a==x，那么代表x开根号以后是一个整数
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

C:

递增子序列变形题，让你找出先不递减然后不递增的连续子序列的最长长度。

正向扫一次就可以统计出以位置 i 结尾的不递减的连续子序列的最长长度，存入数组L[ i ]中。

反向扫一次就可以统计出以位置 i 开始的不递增的连续子序列的最长长度，存入数组R[ i ]中。

然后最后扫一次统计答案ans=max(L[ i ] +R[ i ] -1)  ， 由于i位置被计算了两次 ，-1就行

#include<bits/stdc++.h>
using namespace std;
int a[1010];
int l[1010],r[1010];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        ///接下来求出以i结尾的最长不递减序列长度
        l[1]=1;
        for(int i=2;i<=n;i++)
        {
            if(a[i]>=a[i-1]) l[i]=l[i-1]+1;
            else l[i]=1;
        }
        ///接下来求出以i开始的最长不递增长度
        r[n]=1;
        for(int i=n-1;i>=1;i--)
        {
            if(a[i]>=a[i+1]) r[i]=r[i+1]+1;
            else r[i]=1;
        }
        
        int ans=0;
        for(int i=1;i<=n;i++)
            ans=max(ans,l[i]+r[i]-1);///i位置多加了1，所以要减去
        printf("%d\n",ans);
    }
    return 0;
}

D：

二分匹配模板题，还是没做出来的可能就学的不到位了，对于每个题有两种锦囊，那我们建图时，左边为题目，右边为锦囊，然后有关联的连边，跑二分匹配，只是此题还需要注意一个细节，他说题目是挨着做的，即从第1题开始，中途哪个题没做出来就立刻淘汰，那么我们只需在二分匹配时判断一下，如果当前这个点i没有找到匹配点，那么直接停止，输出答案即可。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=1010;
const int maxm=1000010;
int cnt,p[maxn];
struct node
{
    int v,next;
}E[maxm];
int n,m;
void init()
{
    cnt=0;
    memset(p,-1,sizeof(p));
}
void add(int u,int v)
{
    E[cnt].v=v;
    E[cnt].next=p[u];
    p[u]=cnt++;
}
int fg[maxn];
int pp[maxn];
bool Find(int x)
{
    for(int i=p[x];i!=-1;i=E[i].next)
    {
        int y=E[i].v;
        if(!fg[y])
        {
            fg[y]=1;
            if(pp[y]==0||Find(pp[y]))
            {
                pp[y]=x;
                return 1;
            }
        }
    }
    return 0;
}
int solve()
{
    int ans=0;
    for(int i=1;i<=m;i++) pp[i]=0;
    for(int i=1;i<=n;i++)///从第一题开始找匹配的锦囊
    {
        for(int i=1;i<=m;i++) fg[i]=0;
        if(Find(i)) ans++;
        else return ans;///没有找到匹配的锦囊，那么淘汰，直接输出答案
    }
    return ans;
}
int main()
{
    scanf("%d%d",&m,&n);
    init();
    for(int i=1;i<=n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        a++,b++;
        add(i,a);
        add(i,b);
    }
    printf("%d\n",solve());
    return 0;
}

E：

这个题给你一个长度不超过10^6的01串，让你求子串中1的个数为k的子串个数。注意k为0的情况！！！还有此题要用int64，用long long是wrong answer，不要问我怎么知道的= =

这个题我们有两种方法可做：

1.二分查找，我们先预处理出sum[i]，表示从1~i中‘1’的个数，扫一次即可，然后求以i结尾的满足条件的子串个数，由于终点确定，我们只需要二分查找一下这个子串的起点可能范围就行。有些细节需要考虑！！

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define LL __int64
char s[1000010];
int sum[1000010];
int main()
{
    int k;
    while(~scanf("%d",&k))
    {
        scanf("%s",s+1);
        int n=strlen(s+1);
        sum[0]=0;
        for(int i=1;i<=n;i++)
        {
            if(s[i]=='1') sum[i]=sum[i-1]+1;
            else sum[i]=sum[i-1];
        }
        LL ans=0;
        for(int i=1;i<=n;i++)
        {
            int val=sum[i]-k;
            if(val>=0)
            {
                int p1=lower_bound(sum,sum+i,val)-sum;
                int p2=lower_bound(sum,sum+i,val+1)-sum;
                ans+=p2-p1;
            }
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

2.two pointer来做

反正我是直接特判了k=0的情况，k=0时就是找连续的0的个数

假如某一段连续的0的个数为num，那么对答案的贡献为C（num）（2）+num，即从num个位置中选两个出来作为起点和终点，还要加上起点终点一样的情况，所以为num*(num-1)/2+num

#include<stdio.h>
#include<string.h>
using namespace std;
#define LL __int64 
char s[1000010];
int main()
{
    int k;
    while(~scanf("%d",&k))
    {
        scanf("%s",s+1);
        int n=strlen(s+1);
        if(k==0)
        {
            LL ans=0;
            LL res=0;
            for(int i=1;i<=n;i++)
            {
                if(s[i]=='1')
                {
                    ans+=res*(res-1)/2+res;
                    res=0;
                }
                else res++;
            }
            ans+=res*(res-1)/2+res;///假如最后一个数是0，那么就会损失一些答案，加上即可
            printf("%I64d\n",ans);
            continue;
        }
        int l=1,r=1,num=0;
        LL ans=0;
        if(s[1]=='1') num++;
        while(1)
        {
            LL x=0,y=0;
            while(num<=k)
            {
                if(num==k) y++;
                if(r+1>n) break;
                if(s[r+1]=='1'&&num+1>k) break;
                r++;
                if(s[r]=='1') num++;
            }
            while(num==k)
            {
                if(num==k) x++;
                if(s[l]=='1') num--;
                l++;
            }
            ans+=x*y;
            if(r==n) break;
        }
        printf("%I64d\n",ans);
    }
    return 0;
}