Wannafly挑战赛3 部分题解

Wannafly挑战赛3

  前天晚上的比赛，今天阴差阳错把 2015 四川省赛B题读成了本场C题题意，结果全场在补题，结束才发现读题出了偏差，索性把C也补了吧。

A.珂朵莉  期望不会，不想看。

B

遇见

 全场签到，也是全场最坑，卡在精度问题和特判问题-13发才过，智商-250。

题意：A有n个档位，速度为负表示朝反方向走，AB相聚 K m，B的速度为b，求两个人最快和最慢什么时候相遇，时间向上取整。

注意n和k可能为0，能用乘法就不要用除法，所以单位换算把m转化为km比转化速度更优。

int n;
    double b,k;
    while(~scanf("%d%lf%lf",&n,&b,&k))
    {
//        b/=3.6;
        for(int i=1;i<=n;i++)
        {scanf("%lf",&a[i]);
//         a[i]/=3.6;
        }
        if(n==0)
        {
            double t=k*3.6/b;
            printf("%.0f %.0f\n",ceil(t),ceil(t));
        }
        else
        {
            sort(a+1,a+n+1);
            double t1=k*3.6/(b+a[1]);
            double t2=k*3.6/(b+a[n]);
            printf("%.0f %.0f\n",ceil(t2),ceil(t1));
        }

C

位数差

 今天做2015年四川省赛时发现B题和此题题意极像，然后成功将题意读成这个题了，这个题是求a+b与a的位数差，而那个题是求a+b进了几位，方法自然不一样，不过倒是想到了这个题的做法。

题意：对于任意对(i,j，i<j) ,求a[i]+a[j]与a[i]的位数差。

进位无非就是一个小的数加上另外一个数位数增加，所以可以枚举10，100，1000....然后用权值线段树查找另一个差值以上出现多少个数，统计即可。

这种思路边界要求较高，细节处理比较麻烦，具体看代码：

const int N=1e5+10;
int tc[15]= {0,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000,2000000000};
struct node
{
    int l,r,x;
} a[N<<2];
int n,nn,A[N],ha[N],b[N];
int cnt[N];
void build(int l,int r,int k)
{
    a[k].l=l,a[k].r=r,a[k].x=0;
    if(l==r) return ;
    int mid=(l+r)/2;
    build(l,mid,2*k);
    build(mid+1,r,2*k+1);
}
void update(int pos,int k)
{
    if(a[k].l==pos&&pos==a[k].r)
    {
        a[k].x++;
        return ;
    }
    int mid=(a[k].l+a[k].r)>>1;
    if(pos<=mid) update(pos,2*k);
    else update(pos,2*k+1);
    a[k].x=a[k*2].x+a[k*2+1].x;
}
int query(int l,int r,int k)
{
    if(l>r) return 0;
    if(l<=a[k].l&&a[k].r<=r) return a[k].x;
    int mid=(a[k].l+a[k].r)>>1;
    if(r<=mid) return query(l,r,2*k);
    else if(l>mid) return query(l,r,2*k+1);
    return query(l,mid,2*k)+query(mid+1,r,2*k+1);
}
void init_hash()
{
    sort(ha+1,ha+n+1);
    nn=unique(ha+1,ha+n+1)-ha-1;
    for(int i=1; i<=n; i++)
    {
        A[i]=lower_bound(ha+1,ha+nn+1,A[i])-ha;
        int num=b[i],x=0;
        if(num==0) x=1;
        while(num) x++,num/=10;
        cnt[i]=x;
    }
    build(1,nn+1,1);
}
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&A[i]);
            b[i]=ha[i]=A[i];
        }
        init_hash();
        ll ans=0;
        for(int i=n; i>=1; i--)
        {
            for(int j=1; j<=9; j++)
                if(tc[j]>b[i])
                {
                    int l=lower_bound(ha+1,ha+nn+1,tc[j]-b[i])-ha;
                    int r=lower_bound(ha+1,ha+nn+1,tc[j+1]-b[i])-ha-1;//注意边界
                    ans+=query(l,r,1)*(j-cnt[i]+1);
                }
            update(A[i],1);
        }
        printf("%lld\n",ans);
    }
    return 0;
}

//2
//5 5
//10
//0 1 2 3 4 5 6 7 8 9
//13
//0 1 2 3 4 5 6 7 8 9 10 11 12
//2
//0 10
//2
//0 100
//2
//3 99
//2
//1 999

  

D	Butterfly2

 这个题也是很坑的，扣字眼。

题意：中文题不再赘述，注意题目描述中的一句话：  且左上顶点与左下顶点之间全由X填充，右上顶点与右下顶点之间全由O填充

左边和右边这两列分别为X和O。

思路：可以n^2预处理每个点的左上方和左下方连续X的个数，右上方和右下方连续O的个数，然后取最小值再判断两边这两列是否满足情况，这样是不对的，样例下面会给出，我们还需要一层循环枚举这个长度再判断是否符合情况。这个复杂度是n^3的，其实根本不用预处理四个方向，直接预处理每一列连续X和O的个数，暴力枚举点，枚举长度判断即可。

当然也有n^2的解法，预处理和上面类似，预处理出每个点左下方和右上方连续X的个数，左上方和右下方连续O的个数，枚举第一个角，一个角确定了，其余四个角都可以确定，直接判断即可。

const int N=502+10;
char s[N][N];
int w1[N][N],w2[N][N];
int w3[N][N],w4[N][N];
int a[N][N],b[N][N];
int n,m;
void init()
{
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(w1,0,sizeof(w1));
    memset(w2,0,sizeof(w2));
    memset(w3,0,sizeof(w3));
    memset(w4,0,sizeof(w4));
    for(int j=1; j<=m; j++)
        for(int i=1; i<=n; i++)
        {
            a[i][j]=a[i-1][j];
            b[i][j]=b[i-1][j];
            if(s[i][j]=='X')
            {
                b[i][j]=0;
                a[i][j]++;
            }
            else
            {
                a[i][j]=0;
                b[i][j]++;
            }
        }
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
        {
            if(s[i][j]=='O')
            {
                w1[i][j]=0;
                w2[i][j]=w2[i-1][j+1]+1;
            }
            else
            {
                w2[i][j]=0;
                w1[i][j]=w1[i-1][j-1]+1;
            }
        }
    for(int i=n; i>=1; i--)
        for(int j=1; j<=m; j++)
        {
            if(s[i][j]=='O')
            {
                w3[i][j]=0;
                w4[i][j]=w4[i+1][j+1]+1;
            }
            else
            {
                w4[i][j]=0;
                w3[i][j]=w3[i+1][j-1]+1;
            }
        }
}
void sovle()
{
    init();
    int ans=-1,flag=0;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            if(s[i][j]=='X')
                flag=1;
    for(int i=2; i<n; i++)
        for(int j=2; j<m; j++)
            if(s[i][j]=='X')
            {
                flag=1;
                int x=min(w2[i-1][j+1],w4[i+1][j+1]);
                x=min(x,min(w1[i][j],w3[i][j])-1);
                for(int k=1; k<=x; k++)//这里倒着枚举会更优一点
                    if(a[i+k][j-k]-a[i-k-1][j-k]>=2*k+1&&b[i+k][j+k]-b[i-k-1][j+k]>=2*k+1)
                    {
                        ans=max(ans,k);
//                        break;
                    }
            }
    if(ans>=1) pd(ans*2+1);
    else if(flag) puts("1");
    else puts("0");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1; i<=n; i++) scanf("%s",s[i]+1);
        sovle();
    }
    return 0;
}
 
 
//Input:
//5 5
//XOOOO
//XXOOO
//XOXOO
//XXOOO
//XOOOO
//2 2
//OO
//OO
//2 2
//XX
//XX
//3 3
//XXO
//OXO
//XXO
//5 5
//XXXOO
//XXXOO
//XXXOO
//XXXOO
//XXXOX
//
//
//output:
//5
//0
//1
//1
//3

 

遇见