2015年第六屆藍橋杯C/C++B組省賽題目解析

一、獎券數目

有些人很迷信數字，比如帶“4”的數字，認為和“死”諧音，就覺得不吉利。
雖然這些說法純屬無稽之談，但有時還要迎合大眾的需求。某抽獎活動的獎券號碼是5位數（10000-99999），要求其中不要出現帶“4”的號碼，主辦單位請你計算一下，如果任何兩張獎券不重號，最多可發出獎券多少張。

請提交該數字（一個整數），不要寫任何多余的內容或說明性文字。

 

分析：直接枚舉10000-99999之間的數字，如果帶4，直接排除；不帶4的，記錄一次，直到枚舉完后輸出。

#include <iostream>
using namespace std;
bool jiangjuan(int t)
{
     while(t)
     {
         if(t%10==4)
             return false;
         t/=10;
     }
     return true;
}

int main()
{
     int ans = 0, t = 10000;
     while(t<100000)
         if(jiangjuan(t++))
             ans++;
     
     cout<<ans<<endl;
     return 0;
}

 

答案：52488

 

二、星系炸彈

在X星系的廣袤空間中漂浮着許多X星人造“炸彈”，用來作為宇宙中的路標。
每個炸彈都可以設定多少天之后爆炸。
比如：阿爾法炸彈2015年1月1日放置，定時為15天，則它在2015年1月16日爆炸。
有一個貝塔炸彈，2014年11月9日放置，定時為1000天，請你計算它爆炸的准確日期。

請填寫該日期，格式為 yyyy-mm-dd 即4位年份2位月份2位日期。比如：2015-02-19
請嚴格按照格式書寫。不能出現其它文字或符號。

 

1，代碼解題

#include<stdio.h>  
int mon[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};    
bool isleap(int year)  //判斷閏年    
{    
    if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)    
        return true;    
    return false;    
}    
    
int main()    
{    
    int year = 2014;    
    int month,day;    
    int sum = 1000 - 52;//到這一年年底的時候剩余的時間    
    int sum1;    
    while(true)    
    {    
        if(isleap(year+1))       
            sum1 = 366;      
        else       
            sum1 = 365;     
        if(sum < sum1)    
        {    
            year++;    
            break;    
        }    
        else    
        {    
            year++;    
            sum -= sum1;    
        }    
    }    
    if(isleap(year))       
        mon[2]++;      
    for(int i = 1; i <= 12; i++)    
    {    
        if(sum > mon[i])    
        {    
            sum -= mon[i];    
        }    
        else    
        {    
            month = i;    
            break;    
        }    
    }    
    day = sum;    
    printf("%d-%d-%d\n",year,month,day);    
    
    return 0;    
}  

  

2，手動解題

2014/11/9到2015/11/9一共是365天，2015/11/9到2016/11/9一共是366天，2016/11/9到2017/11/9一共是365天，

365+366+365-1000=96天，再從2017/11/9往回減96天，依次-9=87，-31=56，-30=26，剩下的26天在8月里面，31-26=5，所以是2017/8/5

 

答案：2017-08-05

 

三、三羊獻瑞

觀察下面的加法算式：

祥 瑞 生 輝
+ 三 羊 獻 瑞
-------------------
三 羊 生 瑞 氣

(如果有對齊問題，可以參看【圖1.jpg】)

其中，相同的漢字代表相同的數字，不同的漢字代表不同的數字。

請你填寫“三羊獻瑞”所代表的4位數字（答案唯一），不要填寫任何多余內容。

 

分析：將“祥瑞生輝三羊獻氣”分別編號為01234567，然后用回溯法窮舉就行了。

#include <iostream>
using namespace std;
int a[8];
bool b[10];
void dfs(int cur)
{
     if(cur == 8)
     {
         int x = a[0]*1000 + a[1]*100 + a[2]*10 + a[3],y = a[4]*1000 + a[5]*100 + a[6]*10 + a[1], z = a[4]*10000 + a[5]*1000 + a[2]*100 + a[1]*10 + a[7];
         if(x + y == z)
             cout<<a[4]<<a[5]<<a[6]<<a[1]<<endl;
     }
     else
     {
         for(int i = 0; i < 10; i++)
         {
             if(cur == 0 && i == 0)continue;
             if(cur == 4 && i == 0)continue;
             if(!b[i])
             {
                 b[i]=1;
                 a[cur]=i;
                 dfs(cur+1);
                 b[i]=0;
             }
         }
     }
}

int main()
{
     dfs(0);
     return 0;
}

 

答案：1085

 

四、格子中輸出

StringInGrid函數會在一個指定大小的格子中打印指定的字符串。
要求字符串在水平、垂直兩個方向上都居中。
如果字符串太長，就截斷。
如果不能恰好居中，可以稍稍偏左或者偏上一點。

下面的程序實現這個邏輯，請填寫划線部分缺少的代碼。

#include <stdio.h>
#include <string.h>

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;i<width-2;i++) printf("-");
    printf("+\n");
    
    for(k=1; k<(height-1)/2;k++){
        printf("|");
        for(i=0;i<width-2;i++) printf(" ");
        printf("|\n");
    }
    
    printf("|");
    
    printf("%*s%s%*s",_____________________________________________);  //填空
              
    printf("|\n");
    
    for(k=(height-1)/2+1; k<height-1; k++){
        printf("|");
        for(i=0;i<width-2;i++) printf(" ");
        printf("|\n");
    }    
    
    printf("+");
    for(i=0;i<width-2;i++) printf("-");
    printf("+\n");    
}

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

 

對於題目中數據，應該輸出：

（如果出現對齊問題，參看下圖所示）

注意：只填寫缺少的內容，不要書寫任何題面已有代碼或說明性文字。

 

答案：(width-strlen(s)-2)/2,"",s,(width-strlen(s)-1)/2,""

 

注意：printf("%.*s\n"，int,str) 的含義

  %.*s 其中的.*表示顯示的精度 對字符串輸出(s)類型來說就是寬度

 這個*代表的值由后面的參數列表中的整數型(int)值給出。比如

printf("%.*s\n", 1, "abc");        // 輸出a
printf("%.*s\n", 2, "abc");        // 輸出ab
printf("%.*s\n", 3, "abc");        // 輸出abc >3是一樣的效果 因為輸出類型type = s，遇到'\0'會結束

 

五、九數組分數

1,2,3...9 這九個數字組成一個分數，其值恰好為1/3，如何組法？

下面的程序實現了該功能，請填寫划線部分缺失的代碼。

#include <stdio.h>

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;
}

 

注意：只填寫缺少的內容，不要書寫任何題面已有代碼或說明性文字。

 

答案：{t=x[k]; x[k]=x[i]; x[i]=t;}

注：使用回朔法。

 

六、加法變乘法

我們都知道：1+2+3+ ... + 49 = 1225
現在要求你把其中兩個不相鄰的加號變成乘號，使得結果為2015

比如：
1+2+3+...+10*11+12+...+27*28+29+...+49 = 2015
就是符合要求的答案。

請你尋找另外一個可能的答案，並把位置靠前的那個乘號左邊的數字提交（對於示例，就是提交10）。

注意：需要你提交的是一個整數，不要填寫任何多余的內容。

 

分析：一共有48個位置，C(48,2)后扣掉連在一起的情況，窮舉一遍過即可。

#include <iostream>
using namespace std;
int main()
{
    for(int i = 1; i < 47; i++)
    for(int j = i + 2; j < 49; j++)
    {
         int sum = 0;
         for(int k = 1; k < i; k++)
             sum += k;
         sum += i*(i+1);
         for(int k = i+2; k < j; k++)
             sum += k;
         sum += j*(j+1);
         for(int k = j+2; k < 50; k++)
             sum += k;
        if(sum == 2015)
            cout<<i<<endl;
    }
    return 0;
}

 

答案：10（題目已給）和16

 

七、牌型種數

小明被劫持到X賭城，被迫與其他3人玩牌。
一副撲克牌（去掉大小王牌，共52張），均勻發給4個人，每個人13張。
這時，小明腦子里突然冒出一個問題：
如果不考慮花色，只考慮點數，也不考慮自己得到的牌的先后順序，自己手里能拿到的初始牌型組合一共有多少種呢？

請填寫該整數，不要填寫任何多余的內容或說明文字。

 

分析：一共有A,2,3,4,5,6,7,8,9,10,J,Q,K十三鍾牌，每個牌的情況可能是0,1,2,3,4。這十三種牌的和為13即可。回溯法窮舉后再剪枝。

#include <iostream>
using namespace std;
int ans = 0, sum = 0;
void dfs(int cur)
{
     if (sum>13)
         return;
     if (cur == 13)
     {
         if (sum == 13)
             ans++;
         return;
     }
     else
     {
         for (int i = 0; i < 5; i++)
         {
             sum += i;
             dfs(cur + 1);
             sum -= i;
         }
     }
}

int main()
{
     dfs(0);
     cout << ans << endl;
     return 0;
}

 

答案：3598180

 

八、移動距離

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 <xxx>， 不能通過工程設置而省略常用頭文件。

提交時，注意選擇所期望的編譯器類型。

 

#include <iostream>
#include <cmath>
using namespace std;
int main()
{
    int w,m,n;
    cin>>w>>m>>n;
    m--;n--;
    int m1 = m/w, m2 = m%w;
    if(m1 & 1)
        m2=w-1-m2;
    int n1 = n/w, n2 = n%w;
    if(n1 & 1)
        n2 = w - 1 - n2;
    cout<<abs(m1-n1)+abs(m2-n2)<<endl;
    
    return 0;
}

 

九、壘骰子

賭聖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 <xxx>， 不能通過工程設置而省略常用頭文件。

提交時，注意選擇所期望的編譯器類型。

 

分析1：利用記憶化DP窮舉底面銜接的所有情況，dp[p][q]表示第p層底面是q的情況種數，側面是相互獨立的最后乘以4^n即可比如提給數據就是34再乘上兩個4。

#include <iostream>
#include <cstring>
#define N 1000000007
using namespace std;
int o[7] = { 0, 4, 5, 6, 1, 2, 3 };
bool fuck[7][7];
int n, m;
long long ans = 0;
const int maxn = 20005;
long long dp[maxn][7];
long long dfs(int cur, int p)
 {
     if (cur == n) return 1;
     else
     {
        if (dp[cur][p] >= 0)return dp[cur][p];
        long long t = 0;
        for (int i = 1; i < 7; i++)
        {
             if (fuck[i][o[p]])continue;
             t += dfs(cur + 1, i);
             t %= N;
        }
        return dp[cur][p] = t;
     }
 }

int main()
{
    memset(dp, -1, sizeof(dp));
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
         int t1, t2;
         cin >> t1 >> t2;
         fuck[t1][t2] = 1;
         fuck[t2][t1] = 1;
    }
    for (int i = 1; i < 7; i++)
    {
        ans += dfs(1, i);
        ans %= N;
    }
    for (int i = 0; i < n; i++)
    {
        ans *= 4;
        ans %= N;
    }
    cout << ans << endl;
     
    return 0;
}

 

分析2，矩陣快速冪

同理我們只考慮底面的情況，最后乘上4^n即可。

我們設六階矩陣A_n，其中A_n的第a行第b列表示第一層底面數字為a、第n層數字為b的所有排列的情況

記六階矩陣X中，第a行第b列表示相鄰兩層的是否能成功連接的情況。a和b能連則為1，a和b不能連則為0（注意是相鄰兩層的底面，不是銜接面，所以要轉化，比如題給的1 2要改為1 5）

根據上述定義，易得遞推式：

A_n = A_n-1X，且 A₁ = E（六階單位矩陣）

可得到An的表達式為A_n = X^n-1

那么ans就是矩陣 X^n-1 的36個元素之和

注意最后側面的4^n也要二分冪不然會爆炸

#include <iostream>
#include <cstring>
#define N 1000000007
using namespace std;
struct Matrix
{
     long long a[6][6];
     Matrix(int x)
     {
         memset(a, 0, sizeof(a));
         for (int i = 0; i < 6; i++) a[i][i] = x;
     }
};
 
Matrix operator*(const Matrix& p, const Matrix& q) 
{
     Matrix ret(0);
     for (int i = 0; i < 6; i++)
         for (int j = 0; j < 6; j++)
             for (int k = 0; k < 6; k++)
             {
                 ret.a[i][j] += p.a[i][k] * q.a[k][j];
                 ret.a[i][j] %= N;
             }
     return ret;
}

Matrix fast_mod(Matrix x, int t)
{
     Matrix ret(1);
     while (t)
     {
         if (t & 1)ret = x*ret;
         x = x*x;
         t >>= 1;
     }
     return ret;
 }

int main()
{
     Matrix z(0);
     for (int  i = 0; i < 6; i++) 
        for (int  j = 0; j < 6; j++)
         {
             z.a[i][j] = 1;
         }
     int m, n;
     cin >> n >> m; 
     for (int i = 0; i < m; i++)
     {
         int t1, t2;
         cin >> t1 >> t2;
         z.a[t1 - 1][(t2 + 2) % 6] = 0;
         z.a[t2 - 1][(t1 + 2) % 6] = 0;
     }
     Matrix ret(0);
     ret = fast_mod(z, n - 1);
     long long ans = 0;
     for (int i = 0; i < 6; i++)
     {
         for (int j = 0; j < 6; j++)
         {
             ans += ret.a[i][j];
             ans %= N;
         }
     }
     long long p = 4;
     while (n)
     {
         if (n & 1)
         {
             ans *= p;
             ans %= N;
         }
         p *= p;
         p %= N;
         n >>= 1;
     }
     cout << ans << endl;
     return 0;
}

 

 

十、生命之樹

在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 <xxx>， 不能通過工程設置而省略常用頭文件。

提交時，注意選擇所期望的編譯器類型。

 

分析：考查樹形DP。具體思路可參考 第六屆藍橋杯【省賽試題10】生命之樹 ( 樹形DP )

#include<cstdio>  
#include<cstring>  
#include<vector>  
#define N 100005  
using namespace std;  
vector<int> node[N];  
// dp[i][0],dp[i][1];  
// 分別表示選i結點和不選能得到的最大分數   
int dp[N][2];  
int v[N],vis[N];  
int n,a,b;  
void dfs(int u){  
    dp[u][1] = v[u];  
    dp[u][0] = 0;  
    vis[u]=1;  
    for(int i=0 ;i<node[u].size();i++){  
        if(!vis[node[u][i]]){  
            dfs(node[u][i]);  
      
            dp[u][1] += max(dp[node[u][i]][1],dp[node[u][i]][0]);  
          
        }else{  
            dp[u][1] = max(dp[u][1],v[u]);  
            dp[u][0] = max(dp[u][0],0);  
        }  
    }  
}   
  
void init(){  
    memset(v,0,sizeof(v));  
    memset(dp,0,sizeof(dp));  
    scanf("%d",&n);  
    for(int i=1 ;i<=n ;i++){  
        scanf("%d",&v[i]);  
    }  
    for(int i=1 ;i<n ;i++){  
        scanf("%d%d",&a,&b);  
        node[a].push_back(b);  
        node[b].push_back(a);  
    }  
}  
  
int main(){  
    init();  
      
    dfs(1);  
    int ans = -1;  
    for(int i=1 ;i<=n ;i++){  
//      printf("dp[%d][1]:%d\n",i,dp[i][1]);  
//      printf("dp[%d][0]:%d\n",i,dp[i][0]);  
        ans = max(ans,dp[i][1]);  
        ans = max(ans,dp[i][0]);  
    }  
    printf("%d\n",ans);  
    return 0;  
}