BOJ 2014新生暑假个人排位赛05 整合

最新推荐文章于 2019-10-18 20:56:05 发布
最新推荐文章于 2019-10-18 20:56:05 发布
阅读量677 收藏
点赞数
分类专栏： acm BUPT OJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/birdstorm_s/article/details/38147571
版权
acm 同时被 2 个专栏收录
77 篇文章 0 订阅
订阅专栏
BUPT OJ
44 篇文章 3 订阅
订阅专栏

A. 平方的平均值


仔细读题= =


#include <cstdio>
#define MAXN 100005
#define For(i,m,n) for(int i=(m);i<(n);i++)
#define LL long long
/*author birdstorm*/
using namespace std;
 
int main()
{
    int a, n;
    while(~scanf("%d",&n)){
        LL ans=0;
        int minans=MAXN;
        For(i,0,n){
            scanf("%d",&a); if(a<0) a=-a;
            if(a<minans) minans=a;
        }
        printf("%lld\n",(long long)minans*(long long)minans);
    }
    return 0;
}


B. 立方体


数学, 可以暴力判出所有点的对角位置, 如果发现有一个点的对角缺失, 即可输出结果.


比赛的姿势比较难看就不献丑了...



C. 字符串重排


贪心构造, 贪心正确性比赛时没有证出来, 所以使用了dfs搜索, 还是过了

对于一个字典序最小的字符串, 如果在构造时出现剩余长度为奇数且有一个字母剩余数量超过为(剩余长度+1)的一半时, 显然只能填这个字符

当所有字母的剩余数量都小于剩余长度的一半时都填写字典序最小且不和前一个字符重复的字符, 这样一定可以构造完毕

实际测试只要第一步能构造, 后面的都能构造


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <climits>
  
#define MAXN 100005
#define eps 1e-5
#define MOD 1000000009
  
#define test
  
#define For(i,m,n) for(int i=(m);i<(n);i++)
#define vecfor(iter,a) for(vector<int>::iterator iter=a.begin();iter!=a.end();iter++)
#define rep(i,m,n) for(int i=(m);i<=(n);i++)
#define LL long long
  
/*author birdstorm*/
using namespace std;
const double pi=acos(-1.0);

int vis[30];
int sta[MAXN];
char s[MAXN];
int len, top;
bool judge(int b, int len)
{
    if(len==0){
        sta[top++]=b;
        return true;
    }
    int tmp, cnt=0;
    for(int i=25; i>=0; i--){
        if(vis[i]&&i!=b){
            if(vis[i]==(len+1)/2&&len%2==1){
                tmp=i;
                cnt++;
            }
            else if(vis[i]>(len+1)/2&&len%2==1) return false;
        }
    }
    if(cnt==1){
        vis[tmp]--;
        if(judge(tmp,len-1)){
            sta[top++]=tmp;
            return true;
        }
        else{
            vis[tmp]++;
            return false;
        }
    }
    else if(cnt==0){
        int i;
        for(i=0;i<26;i++){
            if(vis[i]&&i!=b){
                vis[i]--;
                if(judge(i,len-1)){
                    sta[top++]=i;
                    return true;
                }
                else vis[i]++;
            }
        }
    }
    return false;
}
int main()
{
    int n, t;
    scanf("%d",&t);
    while(t--){
        scanf("%s",s);
        top=0;
        memset(vis,0,sizeof vis);
        len=strlen(s);
        For(i,0,len){
            vis[s[i]-'a']++;
        }
        bool out=false;
        For(i,0,26){
            if(len%2==0&&vis[i]*2>len||len%2==1&&vis[i]*2>len+1){
                printf("-1\n");
                out=true;
                break;
            }
        }
        if(out) continue;
        if(!judge(-1,len)) printf("-1");
        else for(int i=top-1; i>=1; i--){
            printf("%c",sta[i]+'a');
        }
        putchar('\n');
    }
    return 0;
}


D. Fibnacci

直接应用矩阵快速幂 

dp[n]=dp[n-1]+dp[n-2]+n;

使用4*4矩阵

{0,0,0,1,0,1,0,0,0,1,1,0,1,0,1,1}
作为base即可, 能保证每一个矩阵的[0][0]项都是dp[n] 


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <climits>
 
#define MAXN 100005
#define eps 1e-5
#define MOD 1000000007
 
#define test
 
#define For(i,m,n) for(int i=(m);i<(n);i++)
#define vecfor(iter,a) for(vector<int>::iterator iter=a.begin();iter!=a.end();iter++)
#define rep(i,m,n) for(int i=(m);i<=(n);i++)
#define LL long long
 
/*author birdstorm*/
using namespace std;
const double pi=acos(-1.0);

LL s[4][4]={0,0,0,1,0,1,0,0,0,1,1,0,1,0,1,1};
class mat {
    public:
    LL m[4][4];
    mat(){}
    void init(LL s1[4][4]){
        for(int i = 0 ; i < 4 ; i++){
            for(int j = 0 ; j < 4 ; j++){
                m[i][j] = s1[i][j];
           }
       }
    }
    friend mat operator*(mat &m1 ,mat &m2) {
        int i, j, k;
        mat temp;
        for (i = 0; i < 4; i++) {
            for (j = 0; j < 4; j++) {
                temp.m[i][j] = 0;
                for(k = 0 ; k < 4 ; k++)
                   temp.m[i][j] += (m1.m[i][k] * m2.m[k][j])%MOD;
                temp.m[i][j] %= MOD;
           }
        }
        return temp;
    }
    friend mat power(mat &M , LL n){
        mat ans;
        for(int i = 0 ; i < 4 ; i++){
            for(int j = 0 ; j < 4 ; j++){
                if(i == j) ans.m[i][j] = 1;
                else ans.m[i][j] = 0;
            }
        }
        while(n){
            if(n & 1) ans = ans * M;
            n = n >> 1;
            M = M * M;
        }
       return ans;
    }
};
LL s2[4][4]={1,0,0,0,1,0,0,0,2,0,0,0,1,0,0,0};
int main()
{
    int t;
    LL a;
    mat a1;
    scanf("%d",&t);
    while(t--){
        scanf("%lld",&a);
        if(a==0){
            printf("1\n");
            continue;
        }
        if(a==1){
            printf("1\n");
            continue;
        }
        a1.init(s);
        mat a2;
        a2.init(s2);
        mat a3=power(a1,a);
        a3=a3*a2;
        printf("%lld\n",a3.m[0][0]);
    }
    return 0;
}


E. 机智的学姐


飞机带翅膀, 学姐实在是太机智了= =

巨大模拟题 依次判断


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <climits>
#define For(i,m,n) for(int i=(m);i<(n);i++)
#define YES printf("Yes\n")
#define NO printf("No\n")
#define mem(s) memset(s,0,sizeof s)

/*author birdstorm*/
using namespace std;
bool fd;
int maxa[5], maxb[5], comba[5][20], combb[5][20], twocnt, a, b, g;
char s[30], xj[30], idx[100];
inline void solve(int lena, int *cnta, int lenb, int *cntb)
{
    For(i,1,16) For(j,1,5){
        if(cnta[i]>=j) maxa[j]=i;
        if(cntb[i]>=j) maxb[j]=i;
    }
    if(cnta[15]&&cnta[14]) maxa[4]=20;
    if(cntb[15]&&cntb[14]) maxb[4]=20;
    if(maxa[4]>maxb[4]){ YES ; return;}
    if(maxa[4]<maxb[4]){ NO ; return;}
    if(maxa[1]>=maxb[1]){ YES ; return;}
    if(maxa[3]>=maxb[3]&&maxa[3]){ YES ; return;}
    if(maxa[2]>=maxb[2]&&maxa[2]){ YES ; return;}
    For(k,5,13){
        g=k; fd=true;
        while(k<=12&&cnta[k]&&cnta[k-1]&&cnta[k-2]&&cnta[k-3]&&cnta[k-4]) k++, fd=false;
        if(fd) continue;
        k--;
        for(int len=k-g+5;len>=5;len--) comba[1][len]=k;
    }
    For(k,5,13){
        g=k; fd=true;
        while(k<=12&&cntb[k]&&cntb[k-1]&&cntb[k-2]&&cntb[k-3]&&cntb[k-4]) k++, fd=false;
        if(fd) continue;
        k--;
        for(int len=k-g+5;len>=5;len--) combb[1][len]=k;
    }
    For(len,5,13) if(comba[1][len]&&comba[1][len]>=combb[1][len]){ YES ; return;}
    For(k,3,13){
        g=k; fd=true;
        while(k<=12&&cnta[k]>=2&&cnta[k-1]>=2&&cnta[k-2]>=2) k++, fd=false;
        if(fd) continue;
        k--;
        for(int len=k-g+3;len>=3;len--) comba[2][len]=k;
    }
    For(k,3,13){
        g=k; fd=true;
        while(k<=12&&cntb[k]>=2&&cntb[k-1]>=2&&cntb[k-2]>=2) k++, fd=false;
        if(fd) continue;
        k--;
        for(int len=k-g+3;len>=3;len--) combb[2][len]=k;
    }
    For(len,3,13) if(comba[2][len]&&comba[2][len]>=combb[2][len]){ YES ; return;}
    For(k,2,13){
        g=k; fd=true;
        while(k<=12&&cnta[k]>=3&&cnta[k-1]>=3) k++, fd=false;
        if(fd) continue;
        k--;
        for(int len=k-g+2;len>=2;len--) comba[3][len]=k;
    }
    For(k,2,13){
        g=k; fd=true;
        while(k<=12&&cntb[k]>=3&&cntb[k-1]>=3) k++, fd=false;
        if(fd) continue;
        k--;
        for(int len=k-g+2;len>=2;len--) combb[3][len]=k;
    }
    For(len,2,13) if(comba[3][len]&&comba[3][len]>=combb[3][len]){ YES ; return;}
    For(len,2,13){
        if(!comba[3][len]) continue;
        a=0, b=0;
        if(comba[3][len]&&lena>=4*len) a=comba[3][len];
        if(combb[3][len]&&lenb>=4*len) b=combb[3][len];
        if(a&&a>=b){ YES ; return;}
    }
    For(len,2,13){
        if(!comba[3][len]) continue;
        a=0, b=0; twocnt=0;
        For(j,1,13) if(j!=comba[3][len]&&j!=comba[3][len]-1&&cnta[j]>=2)
            twocnt++;
        if(twocnt>=len) a=comba[3][len];
        if(!a) continue;
        twocnt=0;
        For(j,1,13) if(j!=combb[3][len]&&j!=combb[3][len]-1&&cntb[j]>=2)
            twocnt++;
        if(twocnt>=len) b=combb[3][len];
        if(a>=b){ YES ; return;}
    }
    NO ;
}
int cntx[30], cnts[30];
int main()
{
    freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    idx['Y']=15; idx['X']=14; idx['2']=13; idx['A']=12;
    idx['K']=11; idx['Q']=10; idx['J']=9; idx['T']=8;
    For(i,0,7) idx[i+'3']=i+1;
    while(~scanf("%s%s",xj,s)){
        mem(cntx); mem(cnts); mem(maxa); mem(maxb); mem(comba); mem(combb);
        int lenxj=strlen(xj), lens=strlen(s);
        For(i,0,lenxj) cntx[idx[xj[i]]]++;
        For(i,0,lens) cnts[idx[s[i]]]++;
        solve(lenxj,cntx,lens,cnts);
    }
    return 0;
}



题目数据比较弱, 有些东西不判可能可以水过去

欢迎来hack~


birdstorm
关注
专栏目录
boj452. 解码锦标赛-dp
lvy的专栏
08-01 580
08D. 解码锦标赛 时间限制 1000 ms 内存限制 65536 KB 题目描述 明光村迎来了一年一度的盛世——解码锦标赛，有 2^N 次个队伍从世界各村赶来参与比赛，编号为 1 - 2^N。赛制为每一轮晋级一半队伍，按序号大小两两比赛，淘汰弱者。一轮结束后，所有的胜者进入下一轮，依旧是按顺序两两比赛。比如第一轮就是 1 vs 2, 3 vs 4 ... 2^N
BOJ 2014新生暑假个人排位赛08 整合
birdstorm
08-08 654
A. 游戏
boj contest, C++
chentingpc的专栏
03-16 1157
竞价抢车位<br />算法分为两个模块，第一个模块是典型的计算几何问题，给定一个简单多边形，计算包含其中（不包括边上的点）的整点个数。第二个模块是给定车位数（等于第一个模块计算结果的整点数），求出价。第一个模块的算法没有错误，虽然用到了double的比较，但是，没有出问题（这并不是什么好运，因为我也花了大量时间测试这个模块）。第二个模块虽然没有用标识的方法把两个独立数组整合到一起，但正常情况下也不会有问题，但是有一个极端的输入下会出现问题，当已经出价的当中出现同一价位的分开输入且准备出价的当中也有相同价位时
boj 452 解码锦标赛【动态规划】（排位赛08_D）
...
07-31 870
题目链接：http://code.bupt.edu.cn/problem/p/452/ 452. 解码锦标赛 时间限制 1000 ms 内存限制 65536 KB 题目描述 明光村迎来了一年一度的盛世——解码锦标赛，有 2^N 次个队伍从世界各村赶来参与比赛，编号为 1 - 2^N。赛制为每一轮晋级一半队伍，按序号大小两两比赛，淘汰弱者。一轮结束后，所有
BOJ 433. Fibnacci
leodestiny
07-25 658
思路：f(0) = f(1) = 1, f(n) = f(n-1) + f(n-2) + n,.对于给定的n，求出f(n)
BOJ 19秋练习3 D
游客的博客
10-13 723
题目描述 已知一个整数n，打印1—n所有除以m后所得商正好是它的各个数字平方和的数。 输入与输出要求： 输入两个整数n、m，它们用空格分开且n与m都不会超过10000。输出满足条件的整数，每5个数占一行，用tab分隔，最后一个整数后为换行符。测试用例保证有满足条件的数。 程序运行效果： Sample 1： 1000 11↙ 131 241 324 550 624 803 900 910 Sampl...
BOJ
03-09
【标题】"BOJ"指的是“BZOJ”（Best Of Joy）的缩写，它是一个在线编程竞赛平台，尤其在中国编程爱好者和学生中非常流行。BOJ提供了大量的算法题目，用户可以提交C++等语言的代码来解决这些问题，以此锻炼和提升自己...
BOJ 2019 1st机考题开放练习 D
游客的博客
10-18 356
题目描述 乒乓球比赛规则规定在一局比赛中，先得11分的一方为胜方，10平后，先多得2分的一方为胜方。也就是说十分后一定要领先2分，才算胜方，比如11:10不行，要继续比赛直到一方获胜。现请你写一段程序来判断一局比赛的胜负。 输入：只有一行，为用空格分隔的两个整数m,n(0<=m,n<=200)，依次代表A选手和B选手的得分。 输出： 只有一行，如果A获胜则输出A win，如果B获胜则输...
BOJ 121.最值问题
游客的博客
10-14 166
#include<stdio.h> int main( ) { int t; scanf("%d",&t); for (;t>0;t--){ int max=0,maxs=0; int a,n; scanf("%d",&n); for(;n>0;n--){ scanf("%d",&a); if (a>ma...
BOJ 2019 1st机考题开放练习 E
游客的博客
10-18 213
题目描述 斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368………这个数列从第3项开始，每一项都等于前两项之和。现请你写一个程序计算这个数列的第n项值除以3的余数。 输入： 第一行为一个整数t(0<t，且可以...
好题 BUPT OJ84 SINGLE NUMBER
birdstorm
02-26 3084
题目描述 Given an array with N integers where all elements appear three times except for one. Find out the one which appears only once. 输入格式 Several test cases are given, terminated by EOF. Ea
BUPT OJ85 Three Points On A Line
birdstorm
03-11 2548
题目描述 Given points on a 2D plane, judge whether there're three points that locate on the same line. 输入格式 The number of test cases T(1≤T≤10) appears in the first line of input. Each test cas
BUPT OJ101 IP地址
birdstorm
03-11 2513
题目描述 我们都学过计算机网络，了解IPV4地址的点分十进制表示法。 你的任务很简单：判断一个字符串是否是一个合法的点分十进制表示的IPV4地址。 最低的IP地址是0.0.0.0，最高的IP地址是255.255.255.255。 PS ：方便起见，认为形似00.00.00.00的IP地址也是合法的。   输入格式 第一行是一个整数T，代表输入还剩下T行 以下的T行，每行
BUPT OJ90 字符串转换
birdstorm
03-02 2411
题目描述 我们将仅由若干个同一小写字母构成的字符串称之为简单串，例如"aaaa"是一个简单串，而"abcd"则不是简单串。现在给你一个仅由小写字母组成的字符串，你需要用最小的花费，将其转换成一个简单串。 花费的计算规则如下：将a到z这26个小写字母从左到右排成一排，则每个字母都有左右两个邻居，我们认为a的左邻居是z，z的右邻居是a。一个字母只能转换成其相邻的字母，转换的花费为1。一个字母可以进行
BUPT OJ100 二叉树的层数
birdstorm
03-02 2052
题目描述 老师有一个问题想考考mabo，但是mabo不会，所以想请你来帮帮忙。 问题如下： 给一个二叉树 请把这个棵二叉树按层来打印。如果为相同层，需要从左到右打印。一个节点是先添加左节点后添加右节点，即添加顺序与输入顺序一致。 输入格式 首先输入一个整数T，表示一共有T组数据 0 再输入两个整数N,M(0 表示下面有N行，这个树有M个节点(1号节点是这棵树的根节点)
BUPT OJ92 统计节点个数
birdstorm
03-02 1926
题目描述 给出一棵有向树，一共有N(1N≤1000)个节点，如果一个节点的度（入度+出度）不小于它所有儿子以及它父亲的度(如果存在父亲或儿子)，那么我们称这个节点为p节点，现在你的任务是统计p节点的个数。 如样例，第一组的p节点为1,2,3；第二组的p节点为0。 输入格式 第一行为数据组数T(1≤T≤100)。 每组数据第一行为N表示树的节点数。后面为N−1行，每行两个数x,
BUPT OJ102 最远距离
birdstorm
03-05 1919
题目描述 正义的伙伴褋祈和葬仪社的机器人Fuyuneru正在被邪恶的GHQ部队追杀。眼看着快要逃不掉了，祈就把重要的东西塞到了机器人体内，让它先跑，自己吸引火力。 假设Fuyuneru带上东西开始逃跑时所处的点为原点，朝向为正北。操纵FuyuNeru的指令有如下四种： right X: X是1-359之间的整数，Fuyuneru的前进方向顺时针转X度。 left X: X是1-359之间的
BUPT OJ180 大牛们的午饭
birdstorm
03-11 1895
题目描述 大家都知道ACM比赛有提供午饭的传统,正好最近学校要举办程序设计竞赛，可是ACM大牛们都去打比赛去了.只剩下弱菜Saerdna一个人负责大牛们的午饭.因为负责送那么多大牛的午饭是一件很累的活，所以Saerdna当然希望每位大牛都吃得少一点，最好都不吃。。。。但是不送午饭又说不过去，所以对于每个大牛，Saerdna都会送去一份午饭。 因为每个大牛都有一个大牛值，所以大牛之间都会暗自较劲
boj dll反编译工具
最新发布
10-07
对于你的问题，目前市场上有很多反编译工具可以用于处理.obj和.dll文件。一些常用的反编译工具包括IDA Pro、Ghidra、Hopper等。这些工具都可以将目标文件逆向回汇编代码，帮助用户分析和理解程序的内部结构和功能。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值