codeforces #549 Looksery Cup 部分题解

掉Rating快乐~~

A.Face Detection

题目大意：给定一个$n*m$的矩阵，求有多少$2*2$的子矩形满足单词“face”的每个字母在矩形中恰好出现一次

签到题

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 55
using namespace std;
int n,m,ans;
char map[M][M];
int main()
{
    int i,j;
    cin>>n>>m;
    for(i=1;i<=n;i++)
        scanf("%s",map[i]+1);
    for(i=1;i<n;i++)
        for(j=1;j<m;j++)
        {
            char s[4]={map[i][j],map[i+1][j],map[i][j+1],map[i+1][j+1]};
            sort(s,s+4);
            if(s[0]==‘a‘&&s[1]==‘c‘&&s[2]==‘e‘&&s[3]==‘f‘)
                ++ans;
        }
    return cout<<ans<<endl,0;
}

B.Looksery Party

题目大意：给定一个$n*n$的01矩阵$A$，满足$A_{i,i}=1$，以及一个$1*n$的行向量$B$
输出一个$\{1,2,...,n\}$的子集$S$，令$C=\sum_{i\in S}A_i$，要求$C_i\neq B_i$

令集合$T$为当前满足$C_i=B_i$的所有$i$的集合，然后进行如下操作：
while($T$非空)
{
任选$x\in T$，将$x$从$T$集合删除，加入集合$S$
$C\leftarrow C+A_x$
对于所有$A_{x,y}=1,C_y=B_y$，将$y$加入$T$集合
}
由于每个元素最多进入$T$集合一次，因此$S$中一定不会有重复
这个题的核心在于$A_{i,i}=1$

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 110
using namespace std;
int n,a[M];
char map[M][M];
int q[M],r,h;
int stack[M],top;
int main()
{
    int i,j;
    cin>>n;
    for(i=1;i<=n;i++)
        scanf("%s",map[i]+1);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        if(!a[i]) q[++r]=i;
    }
    while(r!=h)
    {
        int x=q[++h];
        stack[++top]=x;
        for(i=1;i<=n;i++)
            if( map[x][i]==‘1‘ && !--a[i] )
                q[++r]=i;
    }
    cout<<top<<endl;
    for(i=1;i<=top;i++)
        printf("%d\n",stack[i]);
    return 0;
}

C.The Game Of Parity

题目大意：给定$n$个点，每个点有点权，两个人轮流取，每次只能取走一个点，当剩余$k$个点时游戏结束，此时若剩余奇数个点则先手获胜，否则后手获胜，求先手是否必胜

大讨论，注意$n=k$的情况

#include <cstdio>
int main()
{
    puts("I haven‘t written this problem. >w<");
    return 0;
}

D.Haar Features

题目大意：给定一个矩阵，每个点有一种颜色(黑/白)和一个点权(未给出)，求最少计算矩阵的多少个前缀和可以计算出所有黑点的点权和和所有白点的点权和

题目等价于每次可以选择一个前缀矩形，加上任意值，求最少多少次操作后可以使所有黑点都是$1$，白点都是$-1$
$O(n^2m^2)$大模拟即可

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 110
using namespace std;
int n,m,ans;
char map[M][M];
int a[M][M];
int main()
{
    int i,j,k,l;
    cin>>n>>m;
    for(i=1;i<=n;i++)
        scanf("%s",map[i]+1);
    for(i=n;i;i--)
        for(j=m;j;j--)
            if(a[i][j]!=(map[i][j]==‘B‘?1:-1) )
            {
                int temp=(map[i][j]==‘B‘?1:-1)-a[i][j];
                ans++;
                for(k=1;k<=i;k++)
                    for(l=1;l<=j;l++)
                        a[k][l]+=temp;
            }
    cout<<ans<<endl;
    return 0;
}

E.Sasha Circle
题目大意：给定一些红点和一些蓝点，求是否存在一个圆能将红点和蓝点完全分开

论文题。

#include <cstdio>
#include <algorithm>
int main()
{
    srand(23333333);
    puts(rand()&1?"YES":"NO");
}

F:Yura and Developers

题目大意：给定一个长度为$n$的序列，求有多少区间满足区间和$-$区间最大值$≡0(\ mod\ k)$

每次选择区间最大值进行分治，可以得到一棵树形结构
用map启发式合并可以做到$O(nlog^2n)$
用数组可以做到$O(nlogn)$
具体写法看代码把我也说不清楚

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 300300
using namespace std;
struct Array{
    int a[1001001],tim[1001001],T;
    void Initialize()
    {
        ++T;
    }
    int& operator [] (int x)
    {
        if(tim[x]!=T)
            tim[x]=T,a[x]=0;
        return a[x];
    }
}cnt;
int n,k;
long long ans;
int a[M],sum[M],son[M][2];
int stack[M],top;
void Divide_And_Conquer(int x,int l,int r)
{
    int i;
    if(!x) return ;
    if( x-l < r-x )
    {
        Divide_And_Conquer(son[x][0],l,x-1);
        cnt.Initialize();
        Divide_And_Conquer(son[x][1],x+1,r);
        cnt[sum[x]]++;
        for(i=l-1;i<=x-1;i++)
            ans+=cnt[(sum[i]+a[x])%k];
        cnt[sum[x]]--;
        for(i=l;i<=x;i++)
            cnt[sum[i]]++;
    }
    else
    {
        Divide_And_Conquer(son[x][1],x+1,r);
        cnt.Initialize();
        Divide_And_Conquer(son[x][0],l,x-1);
        cnt[sum[l-1]]++;
        for(i=x;i<=r;i++)
            ans+=cnt[(sum[i]+k-a[x]%k)%k];
        cnt[sum[l-1]]--;
        for(i=x;i<=r;i++)
            cnt[sum[i]]++;
    }
}
int main()
{
    int i;
    cin>>n>>k;
    for(i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(i=1;i<=n;i++)
        sum[i]=(sum[i-1]+a[i])%k;
    for(i=1;i<=n;i++)
    {
        while( top && a[stack[top]]<a[i] )
        {
            if( top>=2 && a[stack[top-1]]<a[i] )
                son[stack[top-1]][1]=stack[top];
            else
                son[i][0]=stack[top];
            stack[top--]=0;
        }
        stack[++top]=i;
    }
    for(i=1;i<top;i++)
        son[stack[i]][1]=stack[i+1];
    Divide_And_Conquer(stack[1],1,n);
    cout<<ans-n<<endl;
    return 0;
}

G:Happy Line

题目大意：给定一个序列，每次你可以选择两个相邻的数，将左边的数$-1$，右边的数$+1$，然后交换这两个数
问能否通过操作使得序列单调不减

容易发现，每个元素的大小+位置是不变的
要求最终的序列单调不减，那么位置递增，大小不减，故大小+位置递增
只需要按照大小+位置排个序，然后判断相邻两项是否相同即可

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 200200
using namespace std;
int n,a[M],b[M];
bool Compare(int x,int y)
{
    return x+a[x] < y+a[y] ;
}
int main()
{
    int i;
    cin>>n;
    for(i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(i=1;i<=n;i++)
        b[i]=i;
    sort(b+1,b+n+1,Compare);
    for(i=1;i<=n;i++)
        if(a[b[i]]+b[i]-i<0)
            return puts(":("),0;
    for(i=1;i<n;i++)
        if(a[b[i]]+b[i]==a[b[i+1]]+b[i+1])
            return puts(":("),0;
    for(i=1;i<=n;i++)
        printf("%d%c",a[b[i]]+b[i]-i,i==n?‘\n‘:‘ ‘);
    return 0;
}

H:Degenerate Matrix

题目大意：给定一个$2*2$的矩阵$A$，定义$||A||$为$A$中所有元素绝对值的最大值，求一个行列式为$0$的$2*2$矩阵$B$满足$||A-B||$最小

二分答案$x$
令$A=\begin{pmatrix}a\ \ \ b\\c\ \ \ d\end{pmatrix},B=\begin{pmatrix}a‘\ \ \ b‘\\c‘\ \ \ d‘\end{pmatrix}$
那么：
$a‘\in[a-x,a+x],...$
现在要求$a‘d‘=b‘c‘$
我们知道若$x\in[l_1,r_1],y\in[l_2,r_2]$，那么$xy\in[min\{l_1l_2,l_1r_2,r_1l_2,r_1r_2\},max\{...\}]$
我们只需要判断$a‘d‘$所在区间与$b‘c‘$所在区间有没有交即可

#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
#define EPS 1e-16
using namespace std;
typedef __float128 ld;
struct Interval{
    ld l,r;
    Interval() {}
    Interval(ld _,ld __):
        l(_),r(__) {}
    friend Interval operator * (const Interval &i1,const Interval &i2)
    {
        ld a1=i1.l*i2.l;
        ld a2=i1.l*i2.r;
        ld a3=i1.r*i2.l;
        ld a4=i1.r*i2.r;
        return Interval(min(min(a1,a2),min(a3,a4)),max(max(a1,a2),max(a3,a4)));
    }
    bool In_Interval(ld x) const
    {
        return x >= l && x <= r ;
    }
    friend bool Have_Intersection(const Interval &i1,const Interval &i2)
    {
        return i1.In_Interval(i2.l) || i1.In_Interval(i2.r) || i2.In_Interval(i1.l) ;
    }
};
long double a,b,c,d;
bool Judge(ld x)
{
    Interval _a(a-x,a+x);
    Interval _b(b-x,b+x);
    Interval _c(c-x,c+x);
    Interval _d(d-x,d+x);
    Interval temp1=_a*_d,temp2=_b*_c;
    return Have_Intersection(temp1,temp2);
}
long double Bisection()
{
    ld l=0,r=1e9;
    for(int i=1;i<=1000;i++)
    {
        ld mid=(l+r)/2;
        if( Judge(mid) )
            r=mid;
        else
            l=mid;
    }
    return (l+r)/2;
}
int main()
{
    cin>>a>>b>>c>>d;
    cout<<fixed<<setprecision(20)<<Bisection()<<endl;
}