技術標籤：藍橋杯藍橋杯

文章目錄

• 引言
• 填空題
• 程式設計題

引言

本蒟蒻實力有限，可能有些程式碼是錯誤，希望多多包涵，歡迎指出。

填空題

請問在 1 到 2020 中，有多少個數既是 4 的整數倍，又是 6 的整數倍

#include <iostream>
using namespace std;
int main()
{
    int ans = 0;
    for(int i = 1; i <= 2020; ++i)
        if(i%4 == 0 && i %6 == 0) ans++;
    cout<<ans<<
 
endl;
    return 0;
}

My Answer:

168

小明要用二進位制來表示 1 到 10000 的所有整數，要求不同的整數用不同的
二進位制數表示，請問，為了表示 1 到 10000 的所有整數，至少需要多少個
二進位制位？

#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
    int temp = 0;
    string s;
    int ans = 0;
 

    for(int i = 1; i <= 10000; i++)
    {
        s.clear();
        int t = i;
        while(t>0)
        {
            int yu = t%2;
            t /= 2;
            s = s + (char)(yu + '0');
        }
        //cout<<s.size()<<endl;
        ans += s.size();
        int x = s.size();
        temp =
 
 max(temp,x);
    }
    cout<<temp<<endl;
    cout<<ans<<endl;
    return 0;
}

My Answer:

14

請問有多少個序列滿足下面的條件：
1. 序列的長度為 5。
2. 2. 序列中的每個數都是 1 到 10 之間的整數。
3. 3. 序列中後面的數大於等於前面的數。

#include <iostream>
#include <cstring>
using namespace std;
int a[6];
int main()
{
    int ans = 0;
    for(int i = 10000; i <= 99999; ++i)
    {
        memset(a, 0, sizeof a);
        int t = i, idx = 0;
        while(t>0)
        {
            a[idx++] = t%10;
            t /= 10;
        }
        int ok = 1;
        for(int j = 0; j < idx-1; j++)
            if(a[j] < a[j+1]) ok = 0;
        if(ok) ans++;
    }
    cout<<ans<<endl;
    return 0;
}

My Answer:

1287

一個無向圖包含 2020 條邊，如果圖中沒有自環和重邊，請問最少包含多
少個結點？

My Answer:

2021

兩個字母之間的距離定義為它們在字母表中位置的距離。例如 A 和 C 的
距離為2，L 和 Q 的距離為 5。對於一個字串，我們稱字串中兩兩字
符之間的距離之和為字串的內部距離。例如：ZOO 的內部距離為 22，其
中 Z 和 O 的距離為 11。請問，LANQIAO 的內部距離是多少？

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int ans = 0;
    string s = "LANQIAO";
    for(int i = 0; i < s.size(); i++)
        for(int j = i + 1; j < s.size(); j++)
        {
         //   if(s[j] > s[i]) cout<<s[j]<<" - " <<s[i]<< " = "<<s[j]-s[i]<<endl;
          //  else cout<<s[i]<<" - " <<s[j]<< " = "<<s[i]-s[j ]<<endl;
            if(s[j] < s[i]) ans = ans + (int)(s[i] - s[j]);
            else  ans = ans + (int)(s[j] - s[i]);
        }
    cout<<ans<<endl;
    return 0;
}

My Answer:

162

程式設計題

題目描述
給定一個平行四邊形的底邊長度 l l l 和高度 h h h，求平行四邊形的面積。
輸入格式
輸入的第一行包含一個整數 l l l，表示平行四邊形的底邊長度。
第二行包含一個整數 h h h，表示平行四邊形的高。
輸出格式
輸出一個整數，表示平行四邊形的面積。（提示：底邊長度和高都是整數的平行四邊形面積為整數）
樣例輸入

2
7

樣例輸出

14

資料規模和約定
對於所有評測用例： 1 ≤ l , h ≤ 100 1 \leq l, h \leq 100 1≤l,h≤100

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int l,h;
    cin>>l>>h;
    int ans = l*h;
    cout<<ans<<endl;
    return 0;
}

題目描述
現在時間是 a a a 點 b b b 分，請問 t t t 分鐘後，是幾點幾分？
輸入格式
輸入的第一行包含一個整數 a a a。
第二行包含一個整數 b b b。
第三行包含一個整數 t t t。
輸出格式
輸出第一行包含一個整數，表示結果是幾點。
第二行包含一個整數，表示結果是幾分。
樣例輸入

3
20
165

樣例說明

6
5

資料規模和約定
對於所有評測用例： 0 ≤ a ≤ 23 , 0 ≤ b ≤ 59 , 0 ≤ t , t 0 \leq a \leq 23, 0 \leq b \leq 59, 0 \leq t, t 0≤a≤23,0≤b≤59,0≤t,t 分鐘後還是在當天。

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int a,b,t;
    cin>>a>>b>>t;
    int yu = (b+t)%60;
    int s = (b+t)/60;
    cout<<(a+s)<<endl;
    cout<<yu<<endl;
    return 0;
}

題目描述
小藍負責花園的灌溉工作。
花園可以看成一個 n n n 行 m m m 列的方格圖形。中間有一部分位置上安裝有出水管。
小藍可以控制一個按鈕同時開啟所有的出水管，開啟時，有出水管的位置可以被認為已經灌溉好。
每經過一分鐘，水就會向四面擴充套件一個方格，被擴充套件到的方格可以被認為已經灌溉好。即如果前一分鐘某一個方格被灌溉好，則下一分鐘它上下左右的四個方格也被灌溉好。
給定花園水管的位置，請問 k k k 分鐘後，有多少個方格被灌溉好？
輸入格式
輸入的第一行包含兩個整數 n n n, m m m。
第二行包含一個整數 t t t，表示出水管的數量。
接下來 t t t 行描述出水管的位置，其中第 i i i 行包含兩個數 r , c r, c r,c 表示第 r r r 行第 c c c 列有一個排水管。
接下來一行包含一個整數 k k k。
輸出格式
輸出一個整數，表示答案。
樣例輸入

3 6
2
2 2
3 4
1

樣例輸出

9

樣例說明
用1表示灌溉到，0表示未灌溉到。
開啟水管時：
　　000000
　　010000
　　000100
1分鐘後：
　　010000
　　111100
　　011110
　　共有9個方格被灌溉好。
資料規模和約定 　
對於所有評測用例： 1 ≤ n , m ≤ 100 , 1 ≤ t ≤ 10 , 1 ≤ k ≤ 100 1 \leq n, m \leq 100, 1 \leq t \leq 10, 1 \leq k \leq 100 1≤n,m≤100,1≤t≤10,1≤k≤100。
將最初水龍頭的位置標記，存入佇列，再用一個佇列儲存下一分鐘蔓延的位置，每分鐘結束，更新佇列中的元素，最後輸出在規定時間內灌溉的位置有多少個即可。

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
using namespace std;
char mp[110][110];
int vis[110][110];
int dir[4][2] = {0,1,-1,0,0,-1,1,0};
struct node{
    int x,y;
    char ch;
};
node a[110];
bool inbound(int x, int l, int r)
{
    if(x < l || x > r) return false;
    return true;
}

int main()
{
    int n,m,t;
    cin>>n>>m>>t;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) vis[i][j] = 0, mp[i][j] = '0';
    queue<node> q;
    for(int i = 0; i < t; i++)
    {
        int x,y;
        cin>>x>>y;
        mp[x][y] = '1';
        vis[x][y] = 1;
        a[i] = {x,y,'1'};
        q.push(a[i]);
    }
    int ans = t, k = 0;
    cin>>k;
    int time = 0;
    queue<node> p;
    while(!q.empty())
    {
        node now = q.front();
        q.pop();
        int x = now.x, y = now.y;
        char ch = now.ch;
        for(int i = 0; i < 4; i++)
        {
            int tx = x + dir[i][0];
            int ty = y + dir[i][1];
            if(!inbound(tx,1,n) || !inbound(ty,1,m)) continue;
            if(!vis[tx][ty] && mp[tx][ty] == '0')
            {
                ans++;
                node temp = {tx,ty,'1'};
                mp[tx][ty] = '1';
                p.push(temp);
            }
        }
        if(q.empty())
        {
            time++;
            while(!p.empty())
            {
                node s = p.front();
                p.pop();
                q.push(s);
            }
        }
        if(time >= k) break;
    }
    cout<<ans<<endl;
    /***
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cout<<mp[i][j]<<" ";
        }
        cout<<'\n';
    }
    ***/
    return 0;
}

題目描述
小藍有一張黑白影象，由 n ∗ m n * m n∗m 個畫素組成，其中從上到下共 n n n 行，每行從左到右 m m m 列。每個畫素由一個 0 到 255 之間的灰度值表示。
現在，小藍準備對影象進行模糊操作，操作的方法為：
對於每個畫素，將以它為中心 3 * 3 區域內的所有畫素（可能是 9 個畫素或少於 9 個畫素）求和後除以這個範圍內的畫素個數（取下整），得到的值就是模糊後的結果。
請注意每個畫素都要用原圖中的灰度值計算求和。
輸入格式
輸入的第一行包含兩個整數 n , m n, m n,m。
第 2 行到第 n + 1 n + 1 n+1 行每行包含 m m m 個整數，表示每個畫素的灰度值，相鄰整數之間用一個空格分隔。
輸出格式
輸出 n n n 行，每行 m m m 個整數，相鄰整數之間用空格分隔，表示模糊後的影象。
樣例輸入

3 4
0 0 0 255
0 0 255 0
0 30 255 255

樣例輸出

0 42 85 127
5 60 116 170
7 90 132 191

資料規模和約定
對於所有評測用例， 1 ≤ n , m ≤ 100 1 \leq n, m \leq 100 1≤n,m≤100。
擴充套件有8個方向擴充套件，然後以當前這個點為中心向 8 個方向擴充套件即可，最後按照題意求模糊值。

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
using namespace std;
int vis[110][110];
int dir[8][2] = {0,1,-1,1,-1,0,-1,-1,0,-1,1,-1,1,0,1,1};
int mp[110][110];
int ans[110][110];
bool inbound(int x, int l, int r)
{
    if(x < l || x > r) return false;
    return true;
}

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) cin>>mp[i][j];

    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            int t = mp[i][j], cnt = 1;
            for(int k = 0; k < 8; k++)
            {
                int tx = i + dir[k][0];
                int ty = j + dir[k][1];
                if(!inbound(tx,1,n) || !inbound(ty,1,m)) continue;
                t += mp[tx][ty];
                cnt++;
            }
            ans[i][j] = (int)(t/cnt);
        }
    }
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
            if(j == 1) cout<<ans[i][j];
            else cout<<" "<<ans[i][j];
        cout<<'\n';
    }

    return 0;
}

題目描述
小藍在一個 n n n 行 m m m 列的方格圖中玩一個遊戲。
開始時，小藍站在方格圖的左上角，即第 1 行第 1 列。
小藍可以在方格圖上走動，走動時，如果當前在第 r r r 行第 c c c 列，他不能走到行號比 r r r 小的行，也不能走到列號比 c c c 小的列。同時，他一步走的直線距離不超過3。
例如，如果當前小藍在第 3 行第 5 列，他下一步可以走到第 3 行第 6 列、第 3 行第 7 列、第 3 行第 8 列、第 4 行第 5 列、第 4 行第 6 列、第 4 行第 7 列、第 5 行第 5 列、第 5 行第 6 列、第 6 行第 5 列之一。
小藍最終要走到第 n n n 行第 m m m 列。
在圖中，有的位置有獎勵，走上去即可獲得，有的位置有懲罰，走上去就要接受懲罰。獎勵和懲罰最終抽象成一個權值，獎勵為正，懲罰為負。
小藍希望，從第 1 行第 1 列走到第 n n n 行第 m m m 列後，總的權值和最大。請問最大是多少？
輸入格式
輸入的第一行包含兩個整數 n , m n, m n,m，表示圖的大小。
接下來 n n n 行，每行 m m m 個整數，表示方格圖中每個點的權值。
輸出格式
輸出一個整數，表示最大權值和。
樣例輸入

3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

樣例輸出

15

資料規模和約定
對於30%的評測用例， 1 ≤ n , m ≤ 10 1 \leq n, m \leq 10 1≤n,m≤10；
對於50%的評測用例， 1 ≤ n , m ≤ 20 1 \leq n, m \leq 20 1≤n,m≤20；
對於所有評測用例， 1 ≤ n ≤ 100 ， − 10000 ≤ 權 值 ≤ 10000 1 \leq n \leq 100，-10000 \leq 權值 \leq 10000 1≤n≤100，−10000≤權值≤10000

動態規劃， d p [ i ] [ j ] dp[i][j] dp[i][j] 表示在第 i i i 第 j j j 列，屬性表示權值，處理特殊的行和列以及特殊的點，然後其餘點的狀態轉移方程就是在可以擴充套件來的點選取最大值加。答案就是 d p [ n ] [ m ] dp[n][m] dp[n][m]

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
using namespace std;
int vis[110][110];
int mp[110][110];
int ans[110][110];

int main()
{
    int n,m;
    memset(mp, 0, sizeof mp);
    memset(ans,0,sizeof ans);
    cin>>n>>m;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) cin>>mp[i][j],ans[i][j] = mp[i][j];

    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(i == 1)
            {
                if(j == 1) continue;
                else if(j == 2) ans[i][j] += mp[i][j-1];
                else if(j == 3) ans[i][j] += max(mp[i][j-2],ans[i][j-1]);
                else ans[i][j] +=  max(ans[i][j-1],max(ans[i][j-2],mp[i][j-3]));
            }
            else if(j == 1)
            {
                if(i == 2) ans[i][j] += mp[i-1][j];
                else if(i == 3) ans[i][j] += max(ans[i-1][j],mp[i-2][j]);
                else ans[i][j] += max(ans[i-1][j],max(ans[i-2][j],mp[i-3][j]));
            }
            else if(i == 2 && j == 2)
            {
                ans[i][j] += max(mp[1][1],max(mp[1][2],mp[2][1]));
            }
            else if(i == 2 && j == 3)
            {
                int x = max(mp[1][1],mp[1][2]);
                int y = max(mp[2][1],mp[2][2]);
                ans[i][j] += max(mp[1][3],max(x,y));
            }
            else if(i == 3 && j == 2)
            {
                int x = max(mp[1][1],mp[1][2]);
                int y = max(mp[2][1],mp[2][2]);
                ans[i][j] += max(mp[3][1],max(x,y));
            }
            else
            {
                int x = max(ans[i][j-1],max(ans[i][j-2],ans[i][j-3]));
                int y = max(ans[i-1][j],max(ans[i-2][j],ans[i-3][j]));
                int z = max(ans[i-1][j-1],max(ans[i-2][j-1],ans[i-1][j-2]));
                ans[i][j] += max(x,max(y,z));
            }
        }
    }

    /***
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cout<<ans[i][j]<<" ";
        }
        cout<<'\n';
    }
    ***/
    cout<<ans[n][m]<<endl;
    return 0;
}