2017国庆 清北学堂 北京综合强化班 Day1

期望得分：60+ +0=60+

实际得分：30+56+0=86

时间规划极端不合理，T2忘了叉积计算，用解析几何算，还有的情况很难处理，浪费太多时间，最后gg

导致T3只剩50分钟，20分钟写完代码，没调出来

设sum[i][j] 表示字母j出现次数的前缀和

那么题目要求我们 最大化sum[r][x]-sum[l-1][x]-(sum[r][y]-sum[l-1][y])

如果枚举r，再枚举y，时间复杂度为O（n*26），是可以承受的

但此时还有l-1未知，能否O（1）找到l-1呢？

我们发现式子可以化为 ：sum[r][x]-sum[r][y]-(sum[l-1][x]-sum[l-1][y]）

这样减号两边形式相同

那就可以用前缀和来维护

所以设mi[i][j] 表示 当前 sum[i]-sum[j] 的最小值

在枚举r之前，l肯定已经计算过，所以sum的第一维可以不再mi中体现

那么ans=max（sum[r][x]-sum[r][y]-mi[x][y]，sum[r][y]-sum[l][x]-mi[y][x]）

小细节：

zhx的std中，

另外记录了当前每个字符的上一个出现的位置last[i]，更新mi[i][j]的位置pos[i][j]

在更新答案的时候，是sum[r][x]-sum[r][y]-mi[x][y]-(pos[x][y]==last[i])

原因是因为 题目中要求 用来计算答案的 字母必须在所选区间出现过

std 每次在用sum更新mi时，不能保证用的这个字符出现过

还不明白的话 ，把std 的那句判等去掉，跑一遍数据：hhfffff

所以 我们仅需要在更新mi的时候，判断sum[]是否为真

便可以把这个特殊判断和last，pos 数组 去掉

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

#define N 1000001

int sum[N],mi[][];
char s[N];

int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    int n;
    scanf("%d",&n); scanf("%s",s+);
    int ans=;
    memset(mi,,sizeof());
    for(int i=;i<=n;i++)
    {
        int now=s[i]-'a';
        sum[now]++;
        for(int j=;j<;j++)
            if(sum[j]) ans=max(ans,max(sum[now]-sum[j]-mi[now][j],sum[j]-sum[now]-mi[j][now]));
        for(int j=;j<;j++)
        {
            if(sum[j] && sum[j]-sum[now]<mi[j][now]) mi[j][now]=sum[j]-sum[now];
            if(sum[j] && sum[now]-sum[j]<mi[now][j]) mi[now][j]=sum[now]-sum[j];
        }
    }
    printf("%d",ans);
}

gg了。。。。。。

反射那块是怎么求的？

最后的交点怎么求的？

#include<cmath>
#include<cstdio>
#include<iostream>
#include<algorithm>

using namespace std;

const double eps=1e-;

struct Point
{
    double x,y;
    Point() { };
    Point(double a,double b)  {     x=a; y=b;  }
    void init()  {     scanf("%lf%lf",&x,&y);     }
}v,p,w1,w2,m1,m2;

Point operator + (Point A,Point B) { return Point(A.x+B.x,A.y+B.y); }
Point operator - (Point A,Point B) { return Point(A.x-B.x,A.y-B.y); }
Point operator * (Point A,double a) { return Point(A.x*a,A.y*a); }

int dcmp(double a) { if(fabs(a)<eps) return ; return a> ?  : -; }

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(dcmp(Cross(P2-P1,P3-P1))*dcmp(Cross(P2-P1,P4-P1))==) return false;
    if(dcmp(Cross(P4-P3,P1-P3))*dcmp(Cross(P4-P3,P2-P3))==) return false;
    if(dcmp(fmax(P1.x,P2.x)-fmin(P3.x,P4.x))==-) return false;
    if(dcmp(fmax(P1.y,P2.y)-fmin(P3.y,P4.y))==-) return false;
    if(dcmp(fmax(P3.x,P4.x)-fmin(P1.x,P2.x))==-) return false;
    if(dcmp(fmax(P3.y,P4.y)-fmin(P1.y,P2.y))==-) return false;
    return true;
}

Point GetLineProjection(Point P,Point A,Point B)
{
    Point v=B-A;
    return A+v*(Dot(v,P-A)/Dot(v,v));
}

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);
}

bool check()
{
    if(!cross(v,p,w1,w2))
    {
        if(!cross(v,p,m1,m2)) return true;
        if(dcmp(Cross(m1-v,m2-v))== && dcmp(Cross(m1-p,m2-p))==) return true;
    }
    if(dcmp(Cross(m2-m1,v-m1))*dcmp(Cross(m2-m1,p-m1))==)
    {
        Point foot=GetLineProjection(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(p,foot,w1,w2)) return true;
        }
        return false;
    }
    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()) puts("YES");
    else printf("NO");
    return ;
}

bfs，结构体内char数组3*3*6表示状态，map判重

#include<map>
#include<queue>
#include<cstring>
#include<cstdio>
#include<iostream>

using namespace std;

struct node
{
    char s[][][];
}cur,nxt;

queue<node>q;
map<string,int>mp;

string t;

int sum[],cnt;

bool v[][][];

bool vis()
{
    t.clear();
    for(int i=;i<;i++)
        for(int j=;j<;j++)
            t+=nxt.s[i][j];
    return mp.count(t);
}

void dfs(int i,int j,int k,char c)
{
    cnt++;
    v[i][j][k]=true;
    if(!k)
    {
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(i && nxt.s[i-][j][]==c && !v[i-][j][]) dfs(i-,j,,c);
    }
    else if(k==)
    {
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(i!= && nxt.s[i+][j][]==c && !v[i+][j][]) dfs(i+,j,,c);
    }
    else if(k==)
    {
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(j!= && nxt.s[i][j-][]==c && !v[i][j-][]) dfs(i,j-,,c);
    }
    else
    {
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(nxt.s[i][j][]==c && !v[i][j][]) dfs(i,j,,c);
        if(j!= && nxt.s[i][j+][]==c && !v[i][j+][]) dfs(i,j+,,c);
    }
} 

bool judge()
{
    memset(v,false,sizeof(v));
    bool ok=false;
    for(int i=;i< && !ok;i++)
        for(int j=;j< && !ok;j++)
            for(int k=;k< && !ok;k++)
                if(nxt.s[i][j][k]=='R')
                {
                    cnt=;
                    dfs(i,j,k,'R');
                    if(cnt!=sum[]) return false;
                    ok=true;
                }
    ok=false;
    for(int i=;i< && !ok;i++)
        for(int j=;j< && !ok;j++)
            for(int k=;k< && !ok;k++)
                if(nxt.s[i][j][k]=='G')
                {
                    cnt=;
                    dfs(i,j,k,'G');
                    if(cnt!=sum[]) return false;
                    ok=true;
                }
    ok=false;
    for(int i=;i< && !ok;i++)
        for(int j=;j< && !ok;j++)
            for(int k=;k< && !ok;k++)
                if(nxt.s[i][j][k]=='B')
                {
                    cnt=;
                    dfs(i,j,k,'B');
                    if(cnt!=sum[]) return false;
                    ok=true;
                }
    ok=false;
    for(int i=;i< && !ok;i++)
        for(int j=;j< && !ok;j++)
            for(int k=;k< && !ok;k++)
                if(nxt.s[i][j][k]=='O')
                {
                    cnt=;
                    dfs(i,j,k,'O');
                    if(cnt!=sum[]) return false;
                    ok=true;
                }
    return true;
}

int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);
    for(int i=;i<;i++)
        for(int j=;j<;j++)
        {
            scanf("%s",cur.s[i][j]);
            for(int k=;k<;k++) t+=cur.s[i][j][k];
            for(int k=;k<;k++)
            switch(cur.s[i][j][k])
            {
                case 'R':sum[]++; break;
                case 'G':sum[]++; break;
                case 'B':sum[]++; break;
                case 'O':sum[]++; break;
            }
        }
    q.push(cur);
    mp[t]=;
    bool ok;

    string a,b;

    while(!q.empty())
    {
        cur=q.front(); q.pop();
        a.clear();

        for(int i=;i<;i++)
            for(int j=;j<;j++)
                a+=cur.s[i][j];
        // left
        for(int i=;i<;i++)
        {
            ok=true;
            for(int j=;j< && ok;j++) if(cur.s[i][j][]=='') ok=false;
            if(!ok) continue;
            nxt=cur;
            swap(nxt.s[i][],nxt.s[i][]);
            swap(nxt.s[i][],nxt.s[i][]);
            if(vis()) continue;
            if(judge()) { printf("%d",mp[a]); return ; }
             b.clear();
             for(int i=;i<;i++)
                 for(int j=;j<;j++)
                     b+=nxt.s[i][j];
            mp[b]=mp[a]+;
            q.push(nxt);
        }
        // right
        for(int i=;i<;i++)
        {
            ok=true;
            for(int j=;j< && ok;j++) if(cur.s[i][j][]=='') ok=false;
            if(!ok) continue;
            nxt=cur;
            swap(nxt.s[i][],nxt.s[i][]);
            swap(nxt.s[i][],nxt.s[i][]);
            if(vis()) continue;
             if(judge()) {  printf("%d",mp[a]); return ; }
             b.clear();
             for(int i=;i<;i++)
                 for(int j=;j<;j++)
                     b+=nxt.s[i][j];
            mp[b]=mp[a]+;
            q.push(nxt);
         }
         // up
         for(int j=;j<;j++)
         {
             ok=true;
             for(int i=;i< && ok;i++) if(cur.s[i][j][]=='') ok=false;
             if(!ok) continue;
             nxt=cur;
             swap(nxt.s[][j],nxt.s[][j]);
             swap(nxt.s[][j],nxt.s[][j]);
             if(vis()) continue;
             if(judge()) { printf("%d",mp[a]); return ; }
             b.clear();
             for(int i=;i<;i++)
                 for(int j=;j<;j++)
                     b+=nxt.s[i][j];
            mp[b]=mp[a]+;
            q.push(nxt);
         }
         // down
         for(int j=;j<;j++)
         {
             ok=true;
             for(int i=;i< && ok;i++)
              if(cur.s[i][j][]=='') ok=false;
             if(!ok) continue;
             nxt=cur;
             swap(nxt.s[][j],nxt.s[][j]);
             swap(nxt.s[][j],nxt.s[][j]);
             if(vis()) continue;
             if(judge()) { printf("%d",mp[a]); return ; }
             b.clear();
             for(int i=;i<;i++)
                 for(int j=;j<;j++)
                     b+=nxt.s[i][j];
            mp[b]=mp[a]+;
            q.push(nxt);
         }
    }
}