2017-10-17 NOIP模拟赛2

a

【问题描述】
你是能看到第一题的 friends 呢。
——hja
何大爷对字符串十分有研究，于是天天出字符串题虐杀 zhx。何大爷今天为
字符串定义了新的权值计算方法。一个字符串由小写字母组成，字符串的权值
被定义为其中出现次数最多的字符的次数减去出现次数最少的字符的次数。 （注
意，在讨论出现最少的字符的时候，该字符必须至少出现一次）现在何大爷给
你一个字符串，何大爷想知道这个字符串的所有子串中权值最大的权值是多
少？
【输入格式】
第一行一个整数?，代表字符串的长度。
接下来一行?个小写字母，代表该字符串。
【输出格式】
一行一个整数代表答案。
【样例输入】
10
aabbaaabab
【样例输出】
3
【数据范围与规定】
3。
60%的数据，1 ≤ ? ≤ 1000。
对于100%的数据，1 ≤ ? ≤ 10 6 .

#include<iostream>
#include<cstdio>
using namespace std;
#define maxn 1000010
int len,sum[maxn][];
char s[maxn];
int main(){
    freopen("a.in","r",stdin);freopen("a.out","w",stdout);
    scanf("%d%s",&len,s+);
    for(int i=;i<=len;i++){
        for(int j=;j<;j++){
            if(s[i]==(char)(j+'a'))sum[i][j]=sum[i-][j]+;
            else sum[i][j]=sum[i-][j];
        }
    }
    int ans=;
    for(int i=;i<=len;i++){
        for(int j=i;j<=len;j++){
            int mn=0x7fffffff,mx=;
            for(int k=;k<;k++){
                int cha=sum[j][k]-sum[i-][k];
                if(cha==)continue;
                mn=min(mn,cha);
                mx=max(mx,cha);
            }
            ans=max(ans,mx-mn);
        }
    }
    printf("%d",ans);
}

60分 暴力

/*
    枚举右端点,前缀和优化。对于当前点x，答案为
    sum[x][r]-sum[x][l-1]-(sum[z][r]-sum[z][l-1])
    整理为
    sum[x][r]-sum[z][r]-(sum[x][l-1]-sum[z][l-1])
    我们已知x和sum[x][r],对于z我们枚举，对于sum[x][l-1]-sum[z][l-1]我们需要一个最小的
    用minv[x][y]表示sum[x]-sum[y]的最小值。
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>

using namespace std;

const int maxn=;

int n,ans,p[][],minv[][],sum[],last[];

char s[maxn];

int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);

    scanf("%d",&n);
    scanf("%s",s+);
    for (int a=;a<=n;a++)
    {
        int c=s[a]-'a';
        sum[c]++;
        last[c]=a;
        for (int b=;b<;b++)
            if (b!=a && sum[b]) ans=max(ans,max(sum[c]-sum[b]-minv[c][b]-(last[b]==p[c][b]),sum[b]-sum[c]-minv[b][c]-(last[b]==p[b][c])));
        for (int b=;b<;b++)
        {
            if (sum[c]-sum[b]<minv[c][b]) minv[c][b]=sum[c]-sum[b],p[c][b]=a;
            if (sum[b]-sum[c]<minv[b][c]) minv[b][c]=sum[b]-sum[c],p[b][c]=a;
        }
    }
    printf("%d\n",ans);

    return ;
}

100分

b

【问题描述】
你是能看到第二题的 friends 呢。
——laekov
Hja 和 Yjq 在玩捉迷藏。Yjq 躲了起来，Hja 要找他。在他们玩游戏的房间
里，只有一堵不透明的墙和一个双面的镜子。Hja 和 Yjq 可以看作平面上坐标分
别为(? ? ,? ? )和(? ? ,? ? )的点。墙是一条连接(? ? 1 ,? ? 1 )和(? ? 2 ,? ? 2 )的线段，镜子是
一条连接(? ? 1 ,? ? 1 )和(? ? 2 ,? ? 2 )的线段。
如果视线和障碍物有公共点，那么我们认为视线会被阻挡，无法看见。如果
视线和镜子有公共点，那么我们认为发生了反射。反射的过程遵循物理规律——
入射角等于反射角，且反射光线与入射光线在镜子同侧。也就是说，想要看见对
方，Hja 和 Yjq 必须在镜子的同一侧，包括镜子所在直线上（参见样例 1） 。如果
视线与镜子重合， 那么不会发生反射， 并且镜子不被当作障碍物 （参见样例 4） 。
Hja 很想知道他站在原地能否看见 Yjq，帮助他解决这个问题。
【输入格式】
第一行两个数? ? ,? ? ，表示 Hja 的坐标。
第二行两个数? ? ,? ? 表示 Yjq 的坐标。
第三行四个数? ? 1 ,? ? 1 ,? ? 2 ,? ? 2 ，分别表示墙的两个端点的坐标。
第四行四个数? ? 1 ,? ? 1 ,? ? 2 ,? ? 2 ，分别表示镜子的两个端点的坐标。
【输出格式】
如果 Hja 站在原地能看到 Yjq，则输出"YES"，否则输出"NO"。
【样例输入 1】
-1 3
1 3
0 2 0 4
0 0 0 1
【样例输出 1】
NO
P97 zhxb
第 4 页 共 5 页
【样例输入 2】
0 0
1 1
0 1 1 0
-100 -100 -101 -101
【样例输出 2】
NO
【样例输入 3】
0 0
1 1
0 1 1 0
-1 1 1 3
【样例输出 3】
YES
【样例输入 4】
0 0
10 0
100 100 101 101
1 0 3 0
【样例输出 4】
YES
【数据规模与约定】
对于100%的数据，所有坐标均为绝对值不超过10 4 的整数。输入的线段不会
退化成点，且两条线段没有交点。Hja 和 Yjq 的位置不同，且不在任何一条线段
上。

#include<iostream>
#include<cstdio>
using namespace std;
struct node{
    double x,y;
}p[];
double A1,A2,B1,B2,C1,C2;
node check(int n1,int n2,int A,int B,int C){
    node res;
    if(B==){
        if(p[n1].x-p[n2].x==){
            res.x=p[n1].x,res.y=p[n1].y;
            return res;
        }
    }
    else if(-A/B==(p[n1].y-p[n2].y)/(p[n1].x-p[n2].x)){
        res.x=p[n1].x,res.y=p[n1].y;
        return res;
    }
    double xx1=p[n1].x,yy1=p[n1].y;
    double xx2=p[n2].x,yy2=p[n2].y;
    double AA=yy1-yy2,BB=xx2-xx1,CC=xx1*yy2-xx2*yy1;
    res.y=(AA*C-CC*A)/(-AA*B+BB*A);
    //res.x=((-B*AA*C+C*AA*B)/A)+CC*B-C*BB;
    res.x=(-B*C*AA+A*CC*B+C*B*AA-C*A*BB)/(-A*B*AA+A*A*BB);
    return res;
}
int main(){
    //freopen("Cola.txt","r",stdin);
    freopen("b.in","r",stdin);freopen("b.out","w",stdout);
    for(int i=;i<=;i++)scanf("%lf%lf",&p[i].x,&p[i].y);
    if(p[].x<p[].x)swap(p[],p[]);
    if(p[].x<p[].x)swap(p[],p[]);

    double m1=p[].x,m2=p[].x,n1=p[].y,n2=p[].y;
    A1=n1-n2;
    B1=m2-m1;
    C1=m1*n2-m2*n1;

    m1=p[].x,m2=p[].x,n1=p[].y,n2=p[].y;
    A2=n1-n2;
    B2=m2-m1;
    C2=m1*n2-m2*n1;

    node a1=check(,,A1,B1,C1);
    if(a1.x>max(p[].x,p[].x)||a1.x<min(p[].x,p[].x)||a1.y>max(p[].y,p[].y)||a1.y<min(p[].y,p[].y)){
        puts("YES");
        return ;
    }

    double x=p[].x,y=p[].y;
    p[].x=x-*A2*(A2*x+B2*y+C2)/(A2*A2+B2*B2);
    p[].y=y-*B2*(A2*x+B2*y+C2)/(A2*A2+B2*B2);//求关于镜子对称点的坐标 

    a1=check(,,A2,B2,C2);
    if(a1.x>max(p[].x,p[].x)||a1.x<min(p[].x,p[].x)||a1.y>max(p[].y,p[].y)||a1.y<min(p[].y,p[].y)){
        puts("NO");
        return ;
    }

    a1=check(,,A1,B1,C1);
    if(a1.x>max(p[].x,p[].x)||a1.x<min(p[].x,p[].x)||a1.y>max(p[].y,p[].y)||a1.y<min(p[].y,p[].y)){
        puts("YES");
        return ;
    }
    else puts("NO");
    return ;
}

58.75分 各种判断

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const double eps=1e-;
int sgn(double a)
{
    if (fabs(a)<eps) return ;
    else
    {
        if (a>0.0) return ;
        else return -;
    }
}
struct point
{
    double x,y;
    point(){}
    point(double a,double b)
    {
        x=a;y=b;
    }
    void init()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator+(const point &a)const
    {
        point ans;
        ans.x=x+a.x;
        ans.y=y+a.y;
        return ans;
    }
    point operator-(const point &a)const
    {
        point ans;
        ans.x=x-a.x;
        ans.y=y-a.y;
        return ans;
    }
    point operator*(const double &a)const
    {
        point ans;
        ans.x=x*a;
        ans.y=y*a;
        return ans;
    }
    void print()
    {
        printf("%lf %lf\n",x,y);
    }
}v,p,w1,w2,m1,m2;
double cross(point a,point b)
{
    return a.x*b.y-a.y*b.x;
}
double dot(point a,point b)
{
    return a.x*b.x+a.y*b.y;
}
bool cross(point p1,point p2,point p3,point p4)
{
    if (sgn(cross(p2-p1,p3-p1))*sgn(cross(p2-p1,p4-p1))==) return false;
    if (sgn(cross(p4-p3,p1-p3))*sgn(cross(p4-p3,p2-p3))==) return false;
    if (sgn(max(p1.x,p2.x)-min(p3.x,p4.x))==-) return false;
    if (sgn(max(p1.y,p2.y)-min(p3.y,p4.y))==-) return false;
    if (sgn(max(p3.x,p4.x)-min(p1.x,p2.x))==-) return false;
    if (sgn(max(p3.y,p4.y)-min(p1.y,p2.y))==-) return false;
    return true;
}
point getcross(point p1,point p2,point p3,point p4)
{
    double a=p2.y-p1.y;
    double b=p1.x-p2.x;
    double c=-p1.x*p2.y+p1.y*p2.x;
    double d=p4.y-p3.y;
    double e=p3.x-p4.x;
    double f=-p3.x*p4.y+p3.y*p4.x;
    double x=(b*f-c*e)/(a*e-b*d);
    double y=(a*f-c*d)/(b*d-a*e);
    return point(x,y);
}
point calcfoot(point p1,point p2,point p3)
{
    double ratio=dot(p1-p2,p3-p2)/dot(p3-p2,p3-p2);
    return p2+(p3-p2)*ratio;
}
bool check()
{
    if (!cross(v,p,w1,w2))
    {
        if (!cross(v,p,m1,m2)) return true;
        if (sgn(cross(m1-v,m2-v))== && sgn(cross(m1-p,m2-p)==)) return true;
    }
    if (sgn(cross(m2-m1,v-m1))*sgn(cross(m2-m1,p-m1))==)
    {
        point foot=calcfoot(p,m1,m2);
        foot=foot*2.0-p;
        if (cross(v,foot,m1,m2))
        {
            foot=getcross(v,foot,m1,m2);
            if (!cross(v,foot,w1,w2) && !cross(foot,p,w1,w2)) return true;
        }
    }
    return false;
}
int main()
{
    freopen("b.in","r",stdin);
    freopen("b.out","w",stdout);
    v.init();
    p.init();
    w1.init();
    w2.init();
    m1.init();
    m2.init();
    if (check()) printf("YES\n");
    else printf("NO\n");
    return ;
}

100分

c

【问题描述】
你是能看到第三题的 friends 呢。
——aoao
众所周知，八数码问题是一个非常难的问题，但是 Yjq 非常有面子，他把这
道题简化了一番。 现在给了你一个3 × 3的方格图， 你的目标是通过不断移动使得
相邻颜色的块形成联通块。 你每次的移动方式是选择一列或者一行进行置换滑动
（这个解释起来比较麻烦，看下面的图就懂了） 。所谓置换滑动，就是所有格子
沿着给定的方向顺次移动， 最后一个格子会被置换到最前面的过程。 现在给定整
个方格图，以及每个格子是否能够移动，求使得相同颜色联通的最小步数。
【输入格式】
输入为3 × 3的方格图，每个位置由五个字符组成，前四个字符分别表示上下
左右四个部分的颜色， 第五个字符表示该格子是否能够移动， 其中0是能移动1是
不能移动。
【输出格式】
一行一个整数代表答案。
【样例输入】
GGGG0 GGGG0 GGGG0
OGOO0 GGGG0 OGOO0
OOOO0 OGGG1 OOOO0
【样例输出】
5
【样例解释】
【数据规模与约定】
对于100%的数据，所有颜色只可能是 RGBO 中的一种，且一定有解。