蓝桥杯2015年第六届省赛C_C++程序设计本科B组

1.奖券数目

有些人很迷信数字,比如带“4”的数字,认为和“死”谐音,就觉得不吉利。
虽然这些说法纯属无稽之谈,但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数(10000-99999)
,要求其中不要出现带“4”的号码,主办单位请你计算一下,如果任何两张奖券不重号,
最多可发出奖券多少张。

请提交该数字(一个整数),不要写任何多余的内容或说明性文字。

解法一

for循环10000-99999,然后通过求余拆分就OK了

#include 
using namespace std;
#include 
#include 
#include 


int main(int argc, char** argv) 
{
    /**拆分数分别成为个位**/
    int total=0;

    for(double a = 1; a<=9 ; a++)
        for(double b = 0; b<=9 ; b++)
        for(int c = 0; c<=9 ;c++)
                for(int d = 0; d<=9 ; d++)
                    for(int e = 0; e<=9 ; e++)

                    if(a/4==1 || b/4==1 && c/4==1 && d/4==1 && e/4==1)
                        continue;
                    else 
                        total++;
                    cout<return 0;
}
//output:79488

2.星系炸弹

在X星系的广袤空间中漂浮着许多X星人造“炸弹”,用来作为宇宙中的路标。
每个炸弹都可以设定多少天之后爆炸。
比如:阿尔法炸弹2015年1月1日放置,定时为15天,则它在2015年1月16日爆炸。
有一个贝塔炸弹,2014年11月9日放置,定时为1000天,请你计算它爆炸的准确日期。

请填写该日期,格式为 yyyy-mm-dd 即4位年份2位月份2位日期。比如:2015-02-19
请严格按照格式书写。不能出现其它文字或符号。

解法一

你可以通过Excel表格或者口算或者写出完整的计算代码。。。

代码:

#include 
using namespace std;
#include 
#include 
#include 
#include  

//阿尔法炸弹2015年1月1日放置,定时为15天,则它在2015年1月16日爆炸。
//有一个贝塔炸弹,2014年11月9日放置,定时为1000天,请你计算它爆炸的准确日期。
bool leap_year(unsigned int year);
int year = 2014;
int month = 11;
int day=9;
int addDay=1000;
int main(int argc, char** argv) 
{
    while(addDay>=365)
    {
        addDay-=leap_year(year+1)==true?366:365;
        year+=1;
    }

    while((addDay+day)>=30)
        switch(month)
        {
            case 1: month++; addDay-=30;break;
            case 2: month++; addDay-=leap_year(year)==true?29:28;break;
            case 3: month++; addDay-=30;break;
            case 4: month++; addDay-=31;break;
            case 5: month++; addDay-=30;break;
            case 6: month++; addDay-=31;break;
            case 7: month++; addDay-=31;break;
            case 8: month++; addDay-=30;break;
            case 9: month++; addDay-=31;break;
            case 10: month++; addDay-=30;break;
            case 11: month++; addDay-=30;break;
            case 12: month=1; year+=1;addDay-=31;break; 
        }

        day+=addDay;
        addDay-=addDay; 


    cout<" "<" "<" "<return 0;
}

bool leap_year(unsigned int year)
{
    return year%4==0&&year%100==0||year%400==0;
}
//output:2017 8 7

3.三羊献瑞

蓝桥杯2015年第六届省赛C_C++程序设计本科B组_第1张图片

观察下面的加法算式:

    祥 瑞 生 辉    a b c d
+   三 羊 献 瑞    e f g b
————————————————————————————
三 羊 生 瑞 气    e f c b h 

(如果有对齐问题,可以参看【图1.jpg】)

其中,相同的汉字代表相同的数字,不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字(答案唯一),不要填写任何多余内容。

解法一

把0~9都存进入数组中,通过next_permutation()全排列函数进行筛选结果,注意e(三)不为零。

#

#define a 0
#define b 1
#define c 2
#define d 3
#define e 4
#define f 5
#define g 6
#define h 7
int main(int argc, char** argv) 
{
    int num[10]={0,1,2,3,4,5,6,7,8,9};
    int sum[3];
    int total=0;
    do{

        sum[0] = num[a]*1000 + num[b]*100 + num[c]*10 +num[d];
        sum[1] = num[e]*1000 + num[f]*100 + num[g]*10 +num[b];
        sum[2] = num[e]*10000 + num[f]*1000 + num[c]*100 +num[b]*10 +num[h];
        if( sum[0] + sum[1] == sum[2] &&num[e]!=0 &&num[a]!=0)
        {
            cout<<" "<" "<while(next_permutation(num,num+10));


    return 0;
}

//output: 
/* 9567
 1085
10652*/

解法二

for循环暴力破解,注意e(三)不为零

int main(int argc, char** argv) 
{

    for(int a=0;a<=9;a++)
        for(int b=0;b<=9;b++)
            for(int c=0;c<=9;c++)
                for(int d=0;d<=9;d++)
                    for(int e=1;e<=9;e++)   //e不为零 
                        for(int f=0;f<=9;f++)
                            for(int g=0;g<=9;g++)
                                for(int h=0;h<=9;h++)
                                {
                                    if(
                                    a!=b&&a!=c&&a!=d&&a!=e&&a!=f&&a!=g&&a!=h&&
                                        b!=c&&b!=d&&b!=e&&b!=f&&b!=g&&b!=h&&
                                            c!=d&&c!=e&&c!=f&&c!=g&&c!=h&&
                                                d!=e&&d!=f&&d!=g&&d!=h&&
                                                    e!=f&&e!=g&&e!=h&&
                                                        f!=g&&f!=h&&
                                                            g!=h
                                    )
                                    if((a*1000+b*100+c*10+d  +  e*1000+f*100+g*10+b)==e*10000+f*1000+c*100+b*10+h)
                                    {
                                        cout <<" "<" "<return 0;
}

4.格子中输出

StringInGrid函数会在一个指定大小的格子中打印指定的字符串。
要求字符串在水平、垂直两个方向上都居中。
如果字符串太长,就截断。
如果不能恰好居中,可以稍稍偏左或者偏上一点。

下面的程序实现这个逻辑,请填写划线部分缺少的代码。

#include 
#include 

void StringInGrid(int width, int height, const char* s)
{
    int i,k;
    char buf[1000];
    strcpy(buf, s);
    if(strlen(s)>width-2) buf[width-2]=0;

    printf("+");
    for(i=0;i2;i++) printf("-");
    printf("+\n");

    for(k=1; k<(height-1)/2;k++){
        printf("|");
        for(i=0;i2;i++) printf(" ");
        printf("|\n");
    }

    printf("|");

    printf("%*s%s%*s",_____________________________________________);  //填空

    printf("|\n");

    for(k=(height-1)/2+1; k1; k++){
        printf("|");
        for(i=0;i2;i++) printf(" ");
        printf("|\n");
    }   

    printf("+");
    for(i=0;i2;i++) printf("-");
    printf("+\n");  
}

int main()
{
    StringInGrid(20,6,"abcda1234");
    return 0;
}

对于题目中数据,应该输出:
+——————+
| |
| abcd1234 |
| |
| |
+——————+

(如果出现对齐问题,参看【图1.jpg】)

注意:只填写缺少的内容,不要书写任何题面已有代码或说明性文字。

注意:通过浏览器提交答案。只填写缺少的内容,不要填写任何多余的内容(例如:说明性文字)

解法一

数组的长度和空符号相加等于最后符合要求的长度,主要考察理解逻辑,没什么好讲的。。。。。,

answer:printf(“%*s%s%*s”,(width-strlen(buf)-2)/2,”“,buf,(width-strlen(buf)-2)/2,”“); //填空

5.九数组分数

1,2,3…9 这九个数字组成一个分数,其值恰好为1/3,如何组法?

下面的程序实现了该功能,请填写划线部分缺失的代码。

#include 

void test(int x[])
{
    int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
    int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]*10 + x[8];

    if(a*3==b) printf("%d / %d\n", a, b);
}

void f(int x[], int k)
{
    int i,t;
    if(k>=9){
        test(x);
        return;
    }

    for(i=k; i<9; i++){
        {t=x[k]; x[k]=x[i]; x[i]=t;}
        f(x,k+1);
        _____________________________________________ // 填空处
    }
}

int main()
{
    int x[] = {1,2,3,4,5,6,7,8,9};
    f(x,0); 
    return 0;
}

注意:只填写缺少的内容,不要书写任何题面已有代码或说明性文字。

解法一

主要考察递归调用和回溯。填空处就是实现复原,即回溯。

answer: {t=x[k]; x[k]=x[i]; x[i]=t;}// 填空处 -回溯

6.奇怪的分式

蓝桥杯2015年第六届省赛C_C++程序设计本科B组_第2张图片

上小学的时候,小明经常自己发明新算法。一次,老师出的题目是:

1/4 乘以 8/5 

小明居然把分子拼接在一起,分母拼接在一起,答案是:18/45 (参见图1.png)

老师刚想批评他,转念一想,这个答案凑巧也对啊,真是见鬼!

对于分子、分母都是 1~9 中的一位数的情况,还有哪些算式可以这样计算呢?

请写出所有不同算式的个数(包括题中举例的)。

显然,交换分子分母后,例如:4/1 乘以 5/8 是满足要求的,这算做不同的算式。

但对于分子分母相同的情况,2/2 乘以 3/3 这样的类型太多了,不在计数之列!

注意:答案是个整数(考虑对称性,肯定是偶数)。请通过浏览器提交。不要书写多余的内容。

解法一

用贪心就好了,两个for循环搞定

int main(int argc, char** argv) 
{
    int originalTotal = 0;
    int total;
    int a[50];
    for(int i=0;i<49;i++)
    {
        a[i] = i+1;
        originalTotal += a[i];
    }

    for(int i=0;i<49-1;i++)
        for(int j=i;j<49;j++)
        {
            total = (originalTotal - a[i] -a[i+1]) + (a[i]*a[i+1]);
            total = (total - a[j] - a[j+1]) + (a[j]*a[j+1]);
            if(total==2015)
            {
                cout<<a[i]<<" "<<a[i+1]<;
                cout<<a[j]<<" "<<a[j+1]<;
            }

        }


    return 0;
}

7.牌型种数

小明与其他3人玩牌。
一副扑克牌(去掉大小王牌,共52张),均匀发给4个人,每个人13张。
这时,小明脑子里突然冒出一个问题:
如果不考虑花色,只考虑点数,也不考虑自己得到的牌的先后顺序,
自己手里能拿到的初始牌型组合一共有多少种呢?

请填写该整数,不要填写任何多余的内容或说明文字。

解法一

先提取关键条件:

1.不考虑花色,只考虑点数

2.不考虑自己得到的牌的先后顺序

3.均匀发给4个人,每个人13张

暴力for循环破解:52张牌没必要分完,我只需要看一个人就行了。每个人分到13张牌,概率一样。自己手里能拿到的初始牌型组合无非就是从13种类型牌(52张)里面抽出13张,因此,编号1~13的牌每种类型的取值范围是0~4,所以每种牌取法从0~4遍历一次,答案就出来了。

int main()
{
    int sum =0;
    int total=0;
    int a[14];
    for( a[1]=0;a[1]<=4;a[1]++)     //1 
        for( a[2]=0;a[2]<=4;a[2]++) //2 
            for( a[3]=0;a[3]<=4;a[3]++) //3 
                for( a[4]=0;a[4]<=4;a[4]++) //4 
                    for( a[5]=0;a[5]<=4;a[5]++) //5 
                        for( a[6]=0;a[6]<=4;a[6]++) //6 
                            for( a[7]=0;a[7]<=4;a[7]++) //7 
                                for( a[8]=0;a[8]<=4;a[8]++) //8 
                                    for( a[9]=0;a[9]<=4;a[9]++) //9 
                                        for( a[10]=0;a[10]<=4;a[10]++)  //10 
                                            for( a[11]=0;a[11]<=4;a[11]++)  //11 
                                                for( a[12]=0;a[12]<=4;a[12]++)  //12 
                                                    for( a[13]=0;a[13]<=4;a[13]++)      //13
            {
                for(int i=1;i<=13;i++)
                {
                    sum += a[i];
                }
                if(sum == 13)
                {
                    total++;
                }
                sum=0;
            }   

    cout<return 0;
}
//answer:3598180

解法二

用DFS,dfs相当于替换了13层for循环。

int sum=0;

/**
parameter: n:步移 ; cartNum:手上的牌数量 ;  前者,后者
*/ 
void dfs(int n,int cartNum)  
{

    if(n>14)        //出口1:抽牌的次数(13次)越界 相当于for循环阶数:13阶 
    {
        return;
    }

    if(cartNum>=13)     //出口2:牌数量越界 
    {
        if(cartNum==13) //截取条件成立的结果 
            sum++;
        return;
    } 
    else            //相当于for循环中的条件int a=0~a<=4; 
    {
        dfs(n+1,cartNum);       //没有该类的牌 
        dfs(n+1,cartNum+1);     //有一张该类的牌  
        dfs(n+1,cartNum+2);     //有两张该类的牌 
        dfs(n+1,cartNum+3);     //有三张该类的牌 
        dfs(n+1,cartNum+4);     //有四张该类的牌 
    }

} 

int main(void)
{
    dfs(1,0);       
    cout<return 0;
}

解法三

此题也可以用动态规划

typedef long long LL;  

LL dp[14][14]; // dp[i][j]: 当前到第i张牌,总共有j张牌时的解的个数  

int main() 
{  

    dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = dp[1][4] = 1;  //初始化数值 

    for (int i = 2; i <= 13; i++)   //第i张牌
    {  
        for (int k = 0; k <= 13; k++)   
        {  
            if (k - 1 >= 0) 
                dp[i][k] += dp[i-1][k-1]; 

            if (k - 2 >= 0) 
                dp[i][k] += dp[i-1][k-2]; 

            if (k - 3 >= 0) 
                dp[i][k] += dp[i-1][k-3]; 

            if (k - 4 >= 0) 
                dp[i][k] += dp[i-1][k-4];  

            dp[i][k] += dp[i-1][k];  
        }  
    }  

    cout << dp[13][13] << endl;  

    return 0;  
} 

8.移动距离

X星球居民小区的楼房全是一样的,并且按矩阵样式排列。其楼房的编号为1,2,3…
当排满一行时,从下一行相邻的楼往反方向排号。
比如:当小区排号宽度为6时,开始情形如下:

1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …..

我们的问题是:已知了两个楼号m和n,需要求出它们之间的最短移动距离(不能斜线方向移动)

输入为3个整数w m n,空格分开,都在1到10000范围内
w为排号宽度,m,n为待计算的楼号。
要求输出一个整数,表示m n 两楼间最短移动距离。

例如:
用户输入:
6 8 2
则,程序应该输出:
4

再例如:
用户输入:
4 7 20
则,程序应该输出:
5

资源约定:
峰值内存消耗 < 256M
CPU消耗 < 1000ms

请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。

注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准,不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include , 不能通过工程设置而省略常用头文件。

提交时,注意选择所期望的编译器类型。

解法一

观察可知关键求两点分别的坐标值,便可以求出结果。所以先把数据存入二位数组a[row][col],然后优化for语句在该数组对应row中找到数组并存储坐标值,然后计算出结果。

int abs(int x)
{
    if(x<0)
        return -x;
    else 
        return x;
}

static int a[10000][10000];
int main(int argc, char** argv) 
{
    int w,m,n;
    int width,height;
    int before_width=0,before_height=0;
    int after_width=0,after_height=0;
    int num = 1;
    cin>>w>>m>>n;

    int max_height = (m>n ? m : n) /w +1;

    for( height = 0;height < max_height;height++)
        for( width = (height%2==0?0:w-1);;)
        {
            a[height][width]=num++;

            if(height%2==0)
            {
                width++;    
            }
            else
            {
                width--;                
            }

            if(height%2==0&&width>=w)
            {
                break;
            }
            else if(height%2!=0&&width<0)
            {
                break;
            }   

        }

        for( height = m/w-1;height < max_height;height++)   //find height & width
            for(width = 0;width < w;width++)
            {
                if(m==a[height][width])
                {
                    before_width = width;
                    before_height = height;
                    break;  
                }
            }

        for( height = n/w-1;height < max_height;height++)   //find height & width
            for(width = 0;width < w;width++)
            {
                if(n==a[height][width])
                {
                    after_width = width;
                    after_height = height;
                    break;  
                }
            }

        cout<<abs(before_width-after_width)+abs(before_height-after_height);

        //this method for output data checked.
        /*  for( height = 0;height < max_height;height++)
            {
                for( width = 0;width < w;width++ )
                {
                    cout<

    return 0;
}

解法二

仔细观察,可以发现就是求两点坐标的差值。关键是如何求坐标,如果用数组存储,要开很大的数组,内存时间都是问题。因此需要其他的方法,可以仔细观察,用数排列的规律来求 。

  // 输入宽度w和房子编号n,返回房子所在行x,列y  
    void GetPos(int w, int n, int& x, int& y) {  
        x = (n-1) / w + 1;  
        y = n % w;  

        if (y == 0) y = w;  
        if (x%2 == 0) { // 偶数行要倒着数  
            y = w - y + 1;  
        }  
    }  

    int main() {  
        int w, m, n;  
        int x1, y1, x2, y2;  

        cin >> w >> m >> n;  
        GetPos(w, m, x1, y1);  
        GetPos(w, n, x2, y2);  

        cout << abs(x1-x2) + abs(y1-y2) << endl;  

        return 0;  
    }  

9.垒骰子

赌圣atm晚年迷恋上了垒骰子,就是把骰子一个垒在另一个上边,不能歪歪扭扭,要垒成方柱体。
经过长期观察,atm 发现了稳定骰子的奥秘:有些数字的面贴着会互相排斥!
我们先来规范一下骰子:1 的对面是 4,2 的对面是 5,3 的对面是 6。
假设有 m 组互斥现象,每组中的那两个数字的面紧贴在一起,骰子就不能稳定的垒起来。
atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同,当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多,请输出模 10^9 + 7 的结果。

不要小看了 atm 的骰子数量哦~

「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行,每行两个整数 a b ,表示 a 和 b 数字不能紧贴在一起。

「输出格式」
一行一个数,表示答案模 10^9 + 7 的结果。

「样例输入」
2 1
1 2

「样例输出」
544

「数据范围」
对于 30% 的数据:n <= 5
对于 60% 的数据:n <= 100
对于 100% 的数据:0 < n <= 10^9, m <= 36

资源约定:
峰值内存消耗 < 256M
CPU消耗 < 2000ms

请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。

注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准,不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include , 不能通过工程设置而省略常用头文件。

提交时,注意选择所期望的编译器类型。

解法一

#

10.生命之树

在X森林里,上帝创建了生命之树。

他给每棵树的每个节点(叶子也称为一个节点)上,都标了一个整数,代表这个点的和谐值。
上帝要在这棵树内选出一个非空节点集S,使得对于S中的任意两个点a,b,都存在一个点列 {a, v1, v2, …, vk, b} 使得这个点列中的每个点都是S里面的元素,且序列中相邻两个点间有一条边相连。

在这个前提下,上帝要使得S中的点所对应的整数的和尽量大。
这个最大的和就是上帝给生命之树的评分。

经过atm的努力,他已经知道了上帝给每棵树上每个节点上的整数。但是由于 atm 不擅长计算,他不知道怎样有效的求评分。他需要你为他写一个程序来计算一棵树的分数。

「输入格式」
第一行一个整数 n 表示这棵树有 n 个节点。
第二行 n 个整数,依次表示每个节点的评分。
接下来 n-1 行,每行 2 个整数 u, v,表示存在一条 u 到 v 的边。由于这是一棵树,所以是不存在环的。

「输出格式」
输出一行一个数,表示上帝给这棵树的分数。

「样例输入」
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5

「样例输出」
8

「数据范围」
对于 30% 的数据,n <= 10
对于 100% 的数据,0 < n <= 10^5, 每个节点的评分的绝对值不超过 10^6 。

资源约定:
峰值内存消耗 < 256M
CPU消耗 < 3000ms

请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。

注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准,不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include , 不能通过工程设置而省略常用头文件。

提交时,注意选择所期望的编译器类型。

你可能感兴趣的:(LQB,Contest)