2016 CCPC Hefei Onsite [HDU 5961、5963、5965、5969]

                                               传递

 

 吐槽一下题意，硬是卡了2个小时，结束才做出来。

题意：给你两个有向图，判断这两个图是否都是传递图。传递图的定义是，对于任意三个不同点，如果能找到a->b>c,而且a->c的边也存在，那么就为传递图。

这样看题意貌似不是很难理解，原题中并没有说明顺序关系，也就是如果不为传递图，那么必须要找到a->b->c,并且a->c不存在才算不传递，要在这三个点存在这样的a->b->c的基础上才可以判断是否为传递。

先预处理出两幅图，判断方法都是一样的，我们枚举a和b，如果a->b的边存在再判断b的出度是否为0，不为0再看是否同时有一个c，使得a->c&&b->c，这里就可以用bitset来优化了。

char s[2017][2017];
bitset<2017>b[2017],c[2017],tmp;
int w1[2017][2017],w2[2017][2017];
int chu1[2017],chu2[2017];
int main()
{
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
        int n;
        scanf("%d",&n);
        memset(w1,0,sizeof(w2));
        memset(w2,0,sizeof(w2));
        memset(chu1,0,sizeof(chu1));
        memset(chu2,0,sizeof(chu2));
        for(int i=0; i<n; i++)
        {
            scanf("%s",s[i]);
            b[i].reset();
            c[i].reset();
        }
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                if(s[i][j]!='-')
                {
                    if(s[i][j]=='Q') b[i][j]=1,w1[i][j]=1,chu1[i]++;
                    else c[i][j]=1,w2[i][j]=1,chu2[i]++;
                }
        int flag=0;
        for(int i=0; i<n&&!flag; i++)
            for(int j=0; j<n&&!flag; j++)
                if(i!=j&&w1[i][j]&&chu1[j]!=0)
                {
                    tmp.reset();
                    tmp=b[i]&b[j];
                    if(tmp.count()!=chu1[j])
                    {
//                        printf("Q: i=%d j=%d chu=%d\n",i,j,chu1[j]);
                        flag=1;
                    }
                }
        for(int i=0; i<n&&!flag; i++)
            for(int j=0; j<n&&!flag; j++)
                if(i!=j&&w2[i][j]&&chu2[j]!=0)//能找到第三个点
                {
                    tmp.reset();
                    tmp=c[i]&c[j];
                    if(tmp.count()!=chu2[j])
                    {
//                        printf("P: i=%d j=%d chu=%d\n",i,j,chu2[j]);
                        flag=1;
                    }
              }
        if(flag) puts("N");
        else puts("T");
    }
    return 0;
}

                                          扫雷

 

 看似一道dp题，队友给出了大致想法，于是模拟了一波，真坑啊。

题意：3*n个方格上，每个格子可能有一个地雷，现在第二行的格子都不存在地雷，并且告诉你第二行每个格子周围8个方向的地雷总数，要你求方案数%1e8+7

思路：一眼上去好像是dp,但我们如果确定了某一列的状态，我们可以进而确定其他的，队友说枚举第一列两个格子放0，1，2个地雷的方案数，这样就可以推出后面的了，注意每列最多2个地雷，于是三种情况讨论

LL a[maxn];
char s[maxn];
LL judge(int x)
{
    if(x==1) return 2;
    else if(x==0||x==2)  return 1;
    return 0;
}
int main()
{
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
        scanf("%s",s+1);
        int len=strlen(s+1);
        for(int i=1; i<=len; i++)  a[i]=(s[i]-'0');
        if(len==1)
        {
           printf("%lld\n",judge(a[1]));
            continue;
        }
        LL ans=0,sum1=0,sum2=0,sum3=0;
        LL now=a[1],pre=0;
        //第一列有0个
        sum1=judge(pre)*judge(now);
        for(int i=2; i<len; i++)
        {
            LL tmp=now;
            now=a[i]-pre-now;
            pre=tmp;
            sum1=sum1*judge(now)%MOD;
        }
        if(now+pre!=a[len]) sum1=0;
        //第一列有一个
        if(a[1]>=1)
        {
            pre=1,now=a[1]-pre;
            sum2=judge(pre)*judge(now);
            for(int i=2; i<len; i++)
            {
                LL tmp=now;
                now=a[i]-pre-now;
                pre=tmp;
                sum2=sum2*judge(now)%MOD;
            }
             if(now+pre!=a[len]) sum2=0;
        }
        //第一列有二个
        if(a[1]>=2)
        {
            pre=2,now=a[1]-pre;
//            printf("%lld %lld\n",pre,now);
            sum3=judge(pre)*judge(now);
            for(int i=2; i<len; i++)
            {
                LL tmp=now;
                now=a[i]-pre-now;
                pre=tmp;
                sum3=sum3*judge(now)%MOD;
            }
             if(now+pre!=a[len]) sum3=0;
        }
//        printf("sum1=%lld sum2=%lld sum3=%lld\n",sum1,sum2,sum3);
        printf("%lld\n",(sum1+sum2+sum3)%MOD);
    }
    return 0;
}

                                         最大的位或

 

 队友说是nyoj原题，然而把位或看成异或了，写了半天发现问题。。

题意：给你一个区间[l,r]，让你从里面选两个数使得或值最大。

思路：开始一眼以为找2^x与2^x-1或就行了，习惯性的异或思维，我们最终要得到的结果的二进制位是最多的而且最大，我们高位1肯定越多越好，这就确定了贪心的方向，最大数的最高位1肯定是不变的，而且根据运算性质，我们只需将l个r或上即可，这样就保证了所选的数在这个区间里，然后将结果二进制位从高位往低位贪心，如果某一位为0，则判断这一位贡献值加上l是否为超过r，如果不会，加上即可。否则跳过。

int a[100],b[100],c[100];
int solve(LL l)
{
    int cnt=0;
    while(l)
    {
        a[cnt++]=l%2;
        l>>=1;
    }
    return cnt;
}
int main()
{
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
        for(int i=0; i<100; i++)
            a[i]=b[i]=c[i]=0;
        LL l,r;
        scanf("%lld%lld",&l,&r);
        LL hehe=l|r,ans=0;
        int len=solve(hehe);
        for(int i=len-1; i>=0; i--)
        {
            if(a[i])
               c[i]=a[i];
            else
            {
                if((l^(1ll<<i))<=r) c[i]=1;
                else c[i]=0;
            }
        }
        for(int i=0; i<=len; i++)
            if(c[i])
                ans+=(1ll<<i);
        printf("%lld\n",ans);
    }
}

C题队友一个人写的，不上代码了，A题题意好坑呐~~

                                              朋友

 

 补题。

猜一发就过的大佬真是厉害。

题意：题面中文。

思路：统计每个点直接相连的边权为1的个数判奇偶即可。

证明：女孩先手，与根直接相连的如果为1，那么必然变成0，男孩要么再次将其变为1，要么输了， 这是单链的情况，所以直接统计直接相连的边权和即可，修改这里我用的是map存图。566ms

map<pair<int,int> ,int>q;
int d[N];
int main()
{
    int t,n,m;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        q.clear();
        memset(d,0,sizeof(d));
        for(int i=1;i<n;i++)
        {
            int u,v,k;
            scanf("%d%d%d",&u,&v,&k);
            q[make_pair(u,v)]=q[make_pair(v,u)]=k;
            d[u]+=k,d[v]+=k;
        }
       while(m--)
       {
           int op,u,v,k;
           scanf("%d%d",&op,&u);
           if(op==0)
           {
               if(d[u]&1) puts("Girls win!");
               else puts("Boys win!");
           }
           else
           {
               scanf("%d%d",&v,&k);
               int x=q[make_pair(u,v)];
               d[u]+=k-x,d[v]+=k-x;
               q[make_pair(u,v)]=q[make_pair(v,u)]=k;
           }
       }
    }
    return 0;
}