Asce's Summer Ranking No.5

最新推荐文章于 2022-02-23 15:02:25 发布

YLAsce

最新推荐文章于 2022-02-23 15:02:25 发布

阅读量804

点赞数

分类专栏： acm 算法编程语言文章标签：题解 acm c

本文链接：https://blog.csdn.net/YLAsce/article/details/38149327

版权

acm 同时被 3 个专栏收录

16 篇文章 0 订阅

订阅专栏

算法

15 篇文章 0 订阅

订阅专栏

编程语言

12 篇文章 0 订阅

订阅专栏

A. 平方的平均值 2014新生暑假个人排位赛05

时间限制 1000 ms 内存限制 65536 KB

题目描述

给定集合A，求集合A的子集合B使得：B中元素的平方的平均值尽可能小。

输入格式

每组case两行，第一行一个正整数n，n<1e5,表示集合A的大小，第二行n个整数xi,xi<1e5，表示A中的元素。

输出格式

输出上述比值，如果是整数，直接输出，否则保留两位小数。

输入样例

输出样例

16
4

水题但wa了三次

注意一个问题，如果算两个1e6的int数的乘积，要先强转成longlong，只是把保存结果的变量开成longlong也会爆

#include <iostream>
#include <cstdio>
 
using namespace std;
int n;
long long temp;
long long ans;
int main()
{
    while(~scanf("%d",&n))
    {
        scanf("%lld",&temp);
        ans=temp*temp;
 
        for(int i=2;i<=n;i++)
        {
            scanf("%lld",&temp);
            if(temp*temp<ans) ans=temp*temp;
        }
 
        printf("%lld\n",ans);
    }
    return 0;
}

-----------------------------------------------------------------------------------------------------------------------------------------

时间限制 1000 ms 内存限制 65536 KB

题目描述

已经知道一个正立方体的7个顶点的坐标，求最后顶点的坐标。

输入格式

第一行一个整数t，表示组数，t<1000。接下来每组数据有7行，每行三个整数,分别表示各点的x,y,z坐标,每个坐标的范围为[-1e6,1e6]。

输出格式

每组数据输出一行,所求顶点的坐标。

输入样例

输出样例

1 1 1
3 7 5

不同的人方法不一样啊，我的非常奇葩

去掉一个点后，只有原正方体的棱能构成三组，每组三个相同的向量

我求出这个向量后，用剩下那个点加上这个向量就行了

（代码好冗长）

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
 
using namespace std;
 
struct Node
{
    int x;
    int y;
    int z;
}a[10];
 
struct D
{
    int x;
    int y;
    int z;
    int num1;
    int num2;
}delta[100];
int t,Index,i,j,remain1,remain2;
 
bool cmp(D a,D b)
{
    if(abs(a.x<b.x) ||(abs(a.x==b.x) && abs(a.y<b.y)) || (abs(a.x==b.x) && abs(a.y==b.y) && abs(a.z<b.z))) return true;
 
    return false;
}
 
bool flag1[10],flag2[10];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        for( i=1;i<=7;i++) scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
 
        Index=0;
        for( i=1;i<=6;i++)
            for( j=i+1;j<=7;j++)
        {
            Index++;
            delta[Index].x=a[i].x-a[j].x;
            delta[Index].y=a[i].y-a[j].y;
            delta[Index].z=a[i].z-a[j].z;
            delta[Index].num1=i;
            delta[Index].num2=j;
        }
 
        sort(delta+1,delta+1+Index,cmp);
 
        memset(flag1,0,sizeof(flag1));
        memset(flag2,0,sizeof(flag2));
 
        for( i=1;i<=Index-2;i++)
            if(delta[i].x==delta[i+1].x && delta[i].x==delta[i+2].x &&
               delta[i].y==delta[i+1].y && delta[i].y==delta[i+2].y &&
               delta[i].z==delta[i+1].z && delta[i].z==delta[i+2].z)
        {
            flag1[delta[i].num1]=true;
            flag1[delta[i].num2]=true;
            flag1[delta[i+1].num1]=true;
            flag1[delta[i+1].num2]=true;
            flag1[delta[i+2].num1]=true;
            flag1[delta[i+2].num2]=true;
            break;
        }
 
        for(int temp=1;temp<=7;temp++) if(!flag1[temp]) remain1=temp;
 
        for( j=i+1;j<=Index-2;j++)
            if(abs(delta[j].x)==abs(delta[j+1].x) && abs(delta[j].x)==abs(delta[j+2].x) &&
               abs(delta[j].y)==abs(delta[j+1].y) && abs(delta[j].y==delta[j+2].y) &&
               abs(delta[j].z==delta[j+1].z) && abs(delta[j].z==delta[j+2].z) )
        {
            flag2[delta[j].num1]=true;
            flag2[delta[j].num2]=true;
            flag2[delta[j+1].num1]=true;
            flag2[delta[j+1].num2]=true;
            flag2[delta[j+2].num1]=true;
            flag2[delta[j+2].num2]=true;
            break;
        }
 
        for(int temp=1;temp<=7;temp++) if(!flag2[temp]) remain2=temp;
 
        if((a[remain1].x+delta[i].x ==a[remain2].x+delta[j].x&& a[remain1].y+delta[i].y ==a[remain2].y+delta[j].y&& a[remain1].z+delta[i].z==a[remain2].z+delta[j].z)
           ||(a[remain1].x+delta[i].x ==a[remain2].x-delta[j].x&& a[remain1].y+delta[i].y ==a[remain2].y-delta[j].y&& a[remain1].z+delta[i].z==a[remain2].z-delta[j].z))
            printf("%d %d %d\n",a[remain1].x+delta[i].x,a[remain1].y+delta[i].y,a[remain1].z+delta[i].z);
        else printf("%d %d %d\n",a[remain1].x-delta[i].x,a[remain1].y-delta[i].y,a[remain1].z-delta[i].z);
    }
    return 0;
}

这题最简洁的是直接用数学方法

立方体去掉一点后，剩下7点的坐标平均值平分对角线3比4，（证明的话，把和去掉那个点不是最远的那四个点，捏成一个在立方体中心重量为4的大点）

还有，离这个平均点最近的那个点，就是去掉的点对角线上的那个点（这么想，去掉点时，平均值朝对角线上那个点移动，原来距各点距离相等，那一定是朝着哪个点去，和那个点的距离减少得越快啦）

（附hiyot神犇学长代码）

#include<bits/stdc++.h>
using namespace std;
int x[8],y[8],z[8];
int main()
{
    int t,i;
    scanf("%d",&t);
    while(t--) {
        long long sx=0,sy=0,sz=0,ss=0x7fffffffffffffff,ti;
        for(i=1; i<=7; i++) {
            scanf("%d%d%d",&x[i],&y[i],&z[i]);
            sx+=x[i],sy+=y[i],sz+=z[i];
        }
        for(i=1; i<=7; i++) {
            long long tmp=(x[i]*7-sx)*(x[i]*7-sx)+(y[i]*7-sy)*(y[i]*7-sy)+(z[i]*7-sz)*(z[i]*7-sz);
            if(tmp<ss)  ss=tmp,ti=i;
        }
        printf("%lld %lld %lld\n",(sx-4*x[ti])/3,(sy-4*y[ti])/3,(sz-4*z[ti])/3);

    }
    return 0;
}

-----------------------------------------------------------------------------------------------------------------------------------------

时间限制 1000 ms 内存限制 65536 KB

题目描述

给定一个字符串，求它的一个重排，使得没有两个相邻字符相同。

输入格式

第一行一个整数t，表示组数(t<10)。接下来的t行，每行一个字符串s，s中只包含小写字母，s的长度不大于1e5.

输出格式

若符合条件的重排存在，输出字典序最小的一个。
若不存在，输出-1。

输入样例

2
aabbccdd
aaaaabcd

输出样例

ababcdcd
-1

先上一个我 wa了的代码

#include <iostream>
#include <cstring>
#include <cstdio>
 
using namespace std;
 
int t,len;
char s[100005],out[100005];
int num[30];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset(num,0,sizeof(num));
 
        scanf("%s",s);
        len=strlen(s);
        for(int i=0;i<len;i++)
            num[s[i]-'a' ]++;
 
 
        for(int i=0;i<=25;i++)
            if(num[i]>0)
        {
            out[0]=i+'a';
            num[i]--;
            break;
        }
        bool Flag=true;
        for(int i=1;i<len;i++)
        {
 
            bool flag=false;
 
            for(int j=0;j<=25;j++)
                if((char)out[i-1]!=(char)j+'a' && num[j]>0)
            {
                out[i]=j+'a';
                num[j]--;
                flag=true;
                break;
            }
            if(!flag){Flag=false;break;}
        }
        if(Flag){out[len]='\0';printf("%s\n",out);}
        else printf("-1\n");
    }
    return 0;
}

开始以为这么想是对的，可是测了一组数据，aabbcc

照我这个代码，它会排abab，然后剩下两个c，就只能输出-1了

其实abcabc就是方案，说明我的贪心有点儿太贪了0.0（决策的优先级不对）

有一个临界点没考虑到，当剩下的字母为奇数，且有一种字母等于n/2+1时，就必须输出这个字母

为什么只在奇数时出现临界呢，我想了一下，如果在偶数时出现某个字母等于其他字母的个数和（*），如果有一个其他字母被拿去，则就转移到了先前所述的临界点

如果某个字母大于其他的个数和，由于和是偶数，那么一定大于至少两个，肯定这两个排完会挨着，直接输-1即可

再想，把那个临界点处理以后，则变成了（*）所述的情况，仍然合理，所以这个决策序列不至于把一个原本能成立的字母序列搞砸了

加上这个临界点，程序就过了

当时时间不充足，要不然还是应该能想到的

#include <iostream>
#include <cstring>
#include <cstdio>
 
using namespace std;
 
int t,len,maxnum;
char s[100005],out[100005];
int num[30];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset(num,0,sizeof(num));
       maxnum=0;
        scanf("%s",s);
        len=strlen(s);
        for(int i=0;i<len;i++)
            num[s[i]-'a' ]++;
       for(int i=0;i<=25;i++) maxnum=max(maxnum,num[i]);
       if((len%2==0 && maxnum>len/2) || (len%2==1 && maxnum>len/2+1)) {printf("-1\n");continue;}
       bool flag=false;
        for(int i=0;i<=25;i++)
            if(len%2==1 && num[i]*2==len+1)
        {
            out[0]=i+'a';
            num[i]--;
            flag=true;
            break;
        }
        if(!flag)
            for(int i=0;i<=25;i++)
            if(num[i]>0)
        {
            out[0]=i+'a';
            num[i]--;
            break;
        }
 
        for(int i=1;i<len;i++)
        {
 
            flag=false;
 
            for(int j=0;j<=25;j++)
                if((len-i)%2==1 && num[j]*2==len-i+1)
            {
                out[i]=j+'a';
                num[j]--;
                flag=true;
                break;
            }
            if(!flag)
                for(int j=0;j<=25;j++)
                if(out[i-1]!=j+'a' && num[j]>0)
            {
                out[i]=j+'a';
                num[j]--;
                break;
            }
        }
        out[len]='\0';
        printf("%s\n",out);
 
    }
    return 0;
}

-----------------------------------------------------------------------------------------------------------------------

时间限制 1000 ms 内存限制 65536 KB

题目描述

已知函数f,f(0)=f(1)=1,对于所有n>=2，f(n)=f(n-1)+f(n-2)+n。给定n，求f(n)。

输入格式

第一行一个整数t,表示组数,t<1000。之后t行每行一个整数n,0<=n<=1e9。

输出格式

对于每组测试组，输出一行f(n)%1000000007.

输入样例

输出样例

裸的矩阵快速幂，建一个3*3的矩阵描述递推关系

（还是矩阵快速幂我没有模板！！！先是照着数的快速幂写了一个，没写对，后来跟人要的模板。。坑啊。。再遇到这种情况就来915拿那些全的模板了）

#include <iostream>
#include <cstdio>
#define mo 1000000007
 
using namespace std;
 
int n,nn,t;
long long ans;
 
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&nn);
        if(nn==0) {printf("1\n");continue;}
        if(nn==1) {printf("1\n");continue;}
        n=nn-1;
        long long a[3][3]={{1,1,3},{1,0,0},{0,0,1}};
        long long res[3][3]={{1,0,0},{0,1,0},{0,0,1} };
        while(n)
       {
             if(n&1)
             {
                 long long temp1[3][3]={{0,0,0},{0,0,0},{0,0,0} };
                 for(int i=0;i<=2;i++)
                    for(int k=0;k<=2;k++)
                      for(int j=0;j<=2;j++)
                       temp1[i][k]=(temp1[i][k]+res[i][j]*a[j][k]+mo)%mo;
 
                for(int i=0;i<=2;i++)
                    for(int k=0;k<=2;k++)
                        res[i][k]=temp1[i][k];
             }
             //res=res*a;-
             n>>=1;
             long long temp2[3][3]={{0,0,0},{0,0,0},{0,0,0} };
                 for(int i=0;i<=2;i++)
                    for(int k=0;k<=2;k++)
                      for(int j=0;j<=2;j++)
                       temp2[i][k]=(temp2[i][k]+a[i][j]*a[j][k]+mo)%mo;
 
                for(int i=0;i<=2;i++)
                    for(int k=0;k<=2;k++)
                        a[i][k]=temp2[i][k];
             //a=a*a;
       }
       ans=(2*res[0][0]+res[0][1]+res[0][2]-nn+mo)%mo;
 
       printf("%lld\n",ans);
    }
 
    return 0;
}

-------------------------------------------------------------------------------------------------------------------------

时间限制 1000 ms 内存限制 65536 KB

题目描述

斗地主玩法简单，娱乐性强，老少皆宜。据传在万恶的旧社会，地主横行乡里，无恶不做，人们为了发泄对地主的痛恨，常常在一天的劳作之后，一家人关起门来“斗地主”。该游戏由三人玩一副牌，地主为一方，其余两家为另一方，双方对战，先出完手中牌的一方胜。
机智的学姐已经通过某些不和谐的手段，得到了下家手上的牌型，可是学姐的机智值全都用来得到下家牌型了。她非常想知道自己是不是有一种出牌的方法，使得下家没有办法能大过自己，这个艰难的任务就交给你了。（不用判断输赢，只需判断这一轮牌有没有好的策略使下家没法大过自己）
关于牌型比较
火箭：即双王（大王和小王），最大的牌。
炸弹：四张同数值牌（如四个7）。
单牌：单个牌（如一张5）。
对牌：数值相同的两张牌（如一对4）。
三张牌：数值相同的三张牌（如三个J）。
三带一：数值相同的三张牌 + 一张单牌或一对牌。例如：333+6 或 444+99。
单顺：五张或更多的连续单牌（如：45678 或 78910JQK）。不包括 2 点和双王。
双顺：三对或更多的连续对牌（如：334455 、77 88 99 1010 JJ）。不包括 2 点和双王。
三顺：二个或更多的连续三张牌（如：333444 、 555 666 777 888）。不包括 2 点和双王。
飞机带翅膀：三顺+同数量的单牌（或同数量的对牌）。
如： 444555+79 或 333444555+7799JJ。
四带二：四张牌+两手牌（注意：四带二不是炸弹）。
如： 5555+3+8 或 4444+55+77。

关于牌型大小
火箭最大，可以打任意其他的牌。
炸弹比火箭小，比其他牌大。都是炸弹时按牌的分值比大小。
除火箭和炸弹外，其他牌必须要牌型相同且总张数相同才能比大小。相同牌型按牌的分值比大小。
依次是大王 > 小王 >2>A>K>Q>J>10>9>8>7>6>5>4>3 ，不分花色。

输入格式

为了处理方便，我们用Y表示大王，X表示小王，T表示10。
所有牌都用A23456789TJQKXY表示，两家牌的数量小于20。
每组数据两行，有多组数据，EOF结束。

输出格式

每个测试数据一行Yes或者No

输入样例

输出样例

Yes
Yes
No

斗地主，最烦的题之一（哦没有之一）

这题交了个wa，就一点没心情改了

贴个wa的代码（提醒过了）

如果有无聊的犇可以来改下0.0

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

char shang[25],xia[25];
int numshang[20],numxia[20];


int main()
{
    while(~scanf("%s",shang))
    {
        scanf("%s",xia);
        int lenshang=strlen(shang);
        int lenxia=strlen(xia);

        memset(numshang,0,sizeof(numshang));
        for(int i=0;i<lenshang;i++)
        {
            if(shang[i]=='T'){numshang[10]++;continue;}
            if(shang[i]=='J'){numshang[11]++;continue;}
            if(shang[i]=='Q'){numshang[12]++;continue;}
            if(shang[i]=='K'){numshang[13]++;continue;}
            if(shang[i]=='A'){numshang[14]++;continue;}
            if(shang[i]=='2'){numshang[15]++;continue;}
            if(shang[i]=='X'){numshang[16]++;continue;}
            if(shang[i]=='Y'){numshang[17]++;continue;}
            numshang[shang[i]-'1'+1 ]++;
        }

        memset(numxia,0,sizeof(numxia));
        for(int i=0;i<lenxia;i++)
        {
            if(xia[i]=='T'){numxia[10]++;continue;}
            if(xia[i]=='J'){numxia[11]++;continue;}
            if(xia[i]=='Q'){numxia[12]++;continue;}
            if(xia[i]=='K'){numxia[13]++;continue;}
            if(xia[i]=='A'){numxia[14]++;continue;}
            if(xia[i]=='2'){numxia[15]++;continue;}
            if(xia[i]=='X'){numxia[16]++;continue;}
            if(xia[i]=='Y'){numxia[17]++;continue;}
            numxia[xia[i]-'1'+1 ]++;
        }

       if(numshang[17]==1 && numshang[16]==1){printf("Yes\n");continue;}//wang
       if(numxia[17]==1 && numxia[16]==1){printf("No\n");continue;}


       int shangmax=0,xiamax=0;//zhadan
       for(int i=3;i<=17;i++) if(numshang[i]==4) shangmax=i;
       for(int i=3;i<=17;i++) if(numxia[i]==4) xiamax=i;
       if(shangmax!=0 && xiamax!=0 && xiamax>shangmax){printf("No\n");continue;}
       if(shangmax!=0 && xiamax!=0 && xiamax<=shangmax){printf("Yes\n");continue;}
       if(shangmax==0 && xiamax!=0){printf("No\n");continue;}
       if(shangmax!=0 && xiamax==0){printf("Yes\n");continue;}


       shangmax=0;xiamax=0;//danpai
       for(int i=3;i<=17;i++) if(numshang[i]>=1) shangmax=i;
       for(int i=3;i<=17;i++) if(numxia[i]>=1) xiamax=i;
       if(shangmax>0 && xiamax<=shangmax){printf("Yes\n");continue;}

       shangmax=0;xiamax=0;//shuangpai
       for(int i=3;i<=17;i++) if(numshang[i]>=2) shangmax=i;
       for(int i=3;i<=17;i++) if(numxia[i]>=2) xiamax=i;
       if(shangmax>0 && xiamax<=shangmax){printf("Yes\n");continue;}

       shangmax=0;xiamax=0;//sanpai
       bool shanghaselse=false,xiahaselse=false,shanghastwo=false,xiahastwo=false;

       for(int i=3;i<=17;i++) if(numshang[i]>=3) shangmax=i;
       for(int i=3;i<=17;i++) if(numxia[i]>=3) xiamax=i;
       for(int i=3;i<=17;i++) {if(numshang[i]>0 && i!=shangmax) shanghaselse=true;if(numshang[i]>=2 && i!=shangmax) shanghastwo=true;}
       for(int i=3;i<=17;i++) {if(numxia[i]>0 && i!=xiamax) xiahaselse=true;if(numxia[i]>=2 && i!=xiamax) xiahastwo=true;}

       if(shangmax>0 && xiamax<=shangmax){printf("Yes\n");continue;}
       if(xiamax>shangmax && shanghaselse &&(!xiahaselse)){printf("Yes\n");continue;}//san dai yi(1)
       if(xiamax>shangmax && shanghastwo &&(!xiahastwo)){printf("Yes\n");continue;}//san dai yi(2)

       int shangliannum,xialiannum,maxshanglian=0,maxxialian=0;
       for(int i=3;i<=13;i++)
       {
           if(numshang[i] && (!numshang[i-1]))shangliannum=1;
           if(numshang[i] &&   numshang[i-1] )shangliannum++;
           if(numshang[i] && (!numshang[i+1]))maxshanglian=max(maxshanglian,shangliannum);
       }
       for(int i=3;i<=13;i++)
       {
           if(numxia[i] && (!numxia[i-1]))xialiannum=1;
           if(numxia[i] &&   numxia[i-1] )xialiannum++;
           if(numxia[i] && (!numxia[i+1]))maxxialian=max(maxxialian,xialiannum);
       }
       if(maxshanglian>=5 && maxshanglian>=maxxialian){printf("Yes\n");continue;}// dan shun

       maxshanglian=0;maxxialian=0;
       for(int i=3;i<=13;i++)
       {
           if(numshang[i]>=2 && (numshang[i-1]<2))shangliannum=1;
           if(numshang[i]>=2 &&   numshang[i-1]>=2 )shangliannum++;
           if(numshang[i]>=2 && (numshang[i+1]<2))
           if(shangliannum>maxshanglian){maxshanglian=shangliannum;}
       }
       for(int i=3;i<=13;i++)
       {
           if(numxia[i]>=2 && (numxia[i-1]<2))xialiannum=1;
           if(numxia[i]>=2 &&  numxia[i-1]>=2 )xialiannum++;
           if(numxia[i]>=2 && (numxia[i+1]<2))
            if(xialiannum>maxxialian){maxxialian=xialiannum;}
       }
       if(maxshanglian>=3 && maxshanglian>=maxxialian){printf("Yes\n");continue;}// shuang shun

       maxshanglian=0;maxxialian=0;
       int maxshangpos,maxxiapos;
       for(int i=3;i<=13;i++)
       {
           if(numshang[i]>=3 && (numshang[i-1]<3))shangliannum=1;
           if(numshang[i]>=3 &&   numshang[i-1]>=3 )shangliannum++;
           if(numshang[i]>=3 && (numshang[i+1]<3))
           if(shangliannum>maxshanglian){maxshanglian=shangliannum;maxshangpos=i;}
       }
       for(int i=3;i<=13;i++)
       {
           if(numxia[i]>=3 && (numxia[i-1]<3))xialiannum=1;
           if(numxia[i]>=3 &&  numxia[i-1]>=3 )xialiannum++;
           if(numxia[i]>=3 && (numxia[i+1]<3))
            if(xialiannum>maxxialian){maxxialian=xialiannum;maxxiapos=i;}
       }
       if(maxshanglian>=2 && maxshanglian>=maxxialian){printf("Yes\n");continue;}// san shun

       int xiann=0,shangnn=0;
       for(int i=3;i<=17;i++)
        if((i<=maxshangpos-maxshanglian || i>maxshangpos) &&numshang[i]) shangnn++;

       for(int i=3;i<=17;i++)
        if((i<=maxxiapos-maxxialian || i>maxxiapos) &&numxia[i]) xiann++;
        
        if(shangnn<=maxshanglian && shangnn>=2 && shangnn>=xiann){printf("Yes\n");continue;}//chi bang1

          xiann=0;shangnn=0;
       for(int i=3;i<=17;i++)
        if((i<=maxshangpos-maxshanglian || i>maxshangpos) &&numshang[i]>=2) shangnn++;

       for(int i=3;i<=17;i++)
        if((i<=maxxiapos-maxxialian || i>maxxiapos) &&numxia[i]>=2) xiann++;
        
        if(shangnn<=maxshanglian && shangnn>=2 && shangnn>=xiann){printf("Yes\n");continue;}//chi bang1

       printf("No\n");
    }
    return 0;
}