【2016蓝桥杯省赛】试题C++ B组试题

一、煤球数目

作答：171700

#include <iostream>

using namespace std;

int main() {

        int sum=,x=;

        for(int i=;i<=;i++){

                 x+=i;

                 sum += x;

        }

        cout<<sum;

}

二、生日蜡烛

作答：26

#include <iostream>

using namespace std;

int main() {

    for(int i=;i<;i++){

        int sum=;

        for(int j=i;sum<;j++){

            sum+=j;

        }

        if(sum==){

            cout<<i;

            break;

        }

    }

}

三、凑算式

纯暴力+剪枝，剪成这样大概30s就跑出来了，觉得剪得差不多了，跑起来试试，反正跑的时候又不耽误继续写。

作答：29

#include <iostream>

#include <math.h>

using namespace std;

int gcd(int x, int y) {

    if (y == )return x;

    return gcd(y, x%y);

}

int lcm(int x, int y) {

    return x * y / gcd(x, y);

}

void simp(int &x, int &y) {

    int t = gcd(x, y);

    x /= t;

    y /= t;

}

void add(int &x1, int &y1, int x2, int y2) {

    int t = lcm(y1, y2);

    x1 = x1 * t / y1 + x2 * t / y2;

    y1 = t;

    simp(x1, y1);

}

int repeat(int A, int B, int C, int DEF, int GHI) {

    int a[] = {  };

    a[A]++; a[B]++; a[C]++;

    while (DEF > ) {

        a[DEF % ]++;

        a[GHI % ]++;

        GHI /= ;

        DEF /= ;

    }

    if (a[] > )return ;

    for (int i = ; i < ; i++) {

        if (a[i] > )return ;

    }

    return ;

}

int main() {

    int count = ;

    for (int A = ; A <= ; A++) {

        for (int B = ; B <= ; B++) {

            if (A == B)continue;

            for (int C = ; C <= ; C++) {

                if (A == C || B == C || (A + B / (float)C > ))continue;

                for (int DEF = ; DEF <= ; DEF++) {

                    for (int GHI = ; GHI <= ; GHI++) {

                        if (repeat(A, B, C, DEF, GHI)) continue;

                        else {

                            int a = A, b = B, c = C, def = DEF, ghi = GHI;

                            add(b, c, def, ghi);

                            if (c ==  && b ==  - a) {

                                cout << A << "+" << B << "/" << C << "+" << DEF << "/" << GHI << "=" <<  << endl;

                                count++;

                            }

                        }

                    }

                }

            }

        }

    }

    cout << count << endl;

    return ;

}

四、快速排序

快速排序的partition过程，基本算法是很重要的。

swap(a,p,j);

五、抽签

看到题目，第一反应，这肯定是个递归，蒙蒙看，看终止条件K==N，输出条件m==0，

第一次试，f(a,k+1,m-1,b); 不对。

第二次试，f(a,k+1,m-j,b); 半分钟解决。。。。

其实仔细看下，也很简单，k表示第几个国家，m表示当前还剩多少空位。当然实际循环里，添加进去b数组的不止5个，多出来的，b[M] = 0; 都给砍掉了。

f(a,k+,m-j,b);

六、方格填数

1580

    #include <iostream>

    #include <stdio.h>

    #include <algorithm>

    using namespace std;

    int f1(int a[][], int x, int y) {

        for (int i = x - ; i <= x + ; i++)

            for (int j = y - ; j <= y + ; j++) {

                if (i == x && y == j)continue;

                if (a[x][y] +  == a[i][j] || a[x][y] -  == a[i][j])return ;

            }

        return ;

    }

    int f2(int x, int y) {

        if (x == y +  || x == y -  || x == y)return ;

        return ;

    }

    int main() {

        int a[][] = { - };

            int count = ;

        for (int a0 = ; a0 <= ; a0++) {

            for (int a1 = ; a1 <= ; a1++) {

                if (f2(a0, a1))continue;

                         for (int a2 = ; a2 <= ; a2++) {

                        if (a2 == a0 || f2(a2, a1))continue;

                                            for (int a3 = ; a3 <= ; a3++) {

                        if (a3 == a2 || a3 == a1 || f2(a3, a0))continue;

                        for (int a4 = ; a4 <= ; a4++) {

                            if (f2(a4, a3) || a4 == a2 || f2(a4, a1) || f2(a4, a0))continue;

                            for (int a5 = ; a5 <= ; a5++) {

                                if (f2(a5, a4) || a5 == a3 || f2(a5, a2) || f2(a5, a1) || f2(a5, a0))continue;

                                for (int a6 = ; a6 <= ; a6++) {

                                    if (f2(a6, a5) || a6 == a4 || a6 == a3 || f2(a6, a2) || f2(a6, a1) || a6 == a0)continue;

                                    for (int a7 = ; a7 <= ; a7++) {

                                        if (a7 == a6 || a7 == a5 || f2(a7, a4) || f2(a7, a3) || a7 == a2 || a7 == a1 || a7 == a0)continue;

                                        for (int a8 = ; a8 <= ; a8++) {

                                            if (f2(a8, a7) || a8 == a6 || f2(a8, a5) || f2(a8, a4) || f2(a8, a3) || a8 == a2 || a8 == a1 || a8 == a0)continue;

                                            for (int a9 = ; a9 <= ; a9++) {

                                                if (f2(a9, a8) || a9 == a7 || f2(a9, a6) || f2(a9, a5) || f2(a9, a4) || a9 == a3 || a9 == a2 || a9 == a1 || a9 == a0)continue;

                                                count++;

                                            }

                                        }

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

        cout << count << endl;

    }

七、剪邮票

如, 有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，，中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

这5个点一定是个连通图，BFS更好写。

核心思想：1. BFS判定给定的5个位置是否符合。

　　　　　2. 每层循环取不同值，避免重复

#include <iostream>

#include <queue>

using namespace std;

bool BFS(int a, int b, int c, int d, int e) {

    bool m[] = {};

    queue<int>q;

    m[b] = ; m[c] = ; m[d] = ; m[e] = ;

    q.push(a);

    while (!q.empty()) {

        int i = q.front(); q.pop();

        //向上走

         if ((i - ) >  && m[i - ] == ) {

             m[i - ] = ;

             q.push(i - );

         }

         //向下走

         if ((i + ) <  && m[i + ] == ) {

             m[i + ] = ;

             q.push(i + );

         }

         //向右走

         if (i !=  && i !=  && i +  <  && m[i + ] == ) {

             m[i + ] = ;

             q.push(i + );

         }

         //向左走

         if (i !=  && i !=  && i -  >  && m[i - ] == ) {

             m[i - ] = ;

             q.push(i - );

         }

    }

    for (int i = ; i < ; i++) if (m[i])return false;

    return true;

}

int main() {

    int a, b, c, d, e, res = ;

    for (a = ; a <= ; a++) {

        for (b = a + ; b <= ; b++) {

                for (c = b + ; c <= ; c++) {

                        for (d = c + ; d <= ; d++) {

                                for (e = d + ; e <= ; e++) {

                                        if (BFS(a, b, c, d, e)) {

                                            printf("%d %d %d %d %d\n", a, b, c, d, e);

                                            res++;

                                        }

                                }

                        }

                }

        }

    }

    cout << res << endl;

    return ;

}

八、四平方和定理

（1）NC做法，四重循环，死求，能出来，但是时间上，完全不达标。

（2）三重循环：因为第四个数可以由 前三个数和输入的数相剪 得出，省去最后一个循环。效率提升就很显著了。

#include <iostream>

#include <math.h>

using namespace std;

int main() {

    int x, i, j, k;

    int sign = ;

    cin >> x;

    double X = sqrt(x);

    for (i = ; sign&&i <= X; i++) {

        for (j = i; sign&&j <= X; j++) {

            for (k = j; sign&&k <= X; k++) {

                double L = sqrt(x - i * i - j * j - k * k);

                if (L == (int)L) {

                    cout << i << " " << j << " " << k << " " << L << endl;

                    sign = ;

                }

            }

        }

    }

    return ;

}

（3）三重循环，将算过的数据存起来 + 剪枝：

#include <iostream>

#include <math.h>

using namespace std;

int main() {

    int x, i, j, k;

    int sign = ;

    cin >> x;

    int *arr = new int[x];

    memset(arr, , x * sizeof(int));

    double X = sqrt(x);

    for (i = ; sign&&i <= X; i++) {

        if (!arr[i]) arr[i] = i * i;//i^2没算过，就算好存起来

        for (j = i; sign&&j <= X; j++) {

            if (!arr[j]) arr[j] = j * j;//j^2没算过，就算好存起来

            int J = arr[i] + arr[j];

            if (J > x) break;//剪枝

            for (k = j; sign&&k <= X; k++) {

                if (!arr[k]) arr[k] = k * k;//k^2没算过，就算好存起来

                int K = J + arr[k];

                if (K > x) break;

                double L = sqrt(x - K);

                if (L == (int)L) {

                    cout << i << " " << j << " " << k << " " << L << endl;

                    sign = ;

                }

            }

        }

    }

    return ;

}

九、交换瓶子

一开始，觉得最快的应该是快速排序的交换过程，后来仔细想下，数据很特殊，最后有序情况下，就是a[i]=i；快速排序还是会进行很多次无用的交换。

就从前面往后直接找，所以下标是1的位置就应该放1号瓶子，以此类推。

正常是一次交换排好一个元素，想要一次排好两个元素，就得数据支持，比如 a [ i ] = j ; a [ j ] = i ；这个交换代码也是可以做到的，所以这就是最少的步数。

#include <iostream>

using namespace std;

int main()

{

    int n,a[];

    cin>>n;

    for(int i = ; i <= n; i++)

        cin>>a[i];

    int ans = ;

    for(int i = ; i <= n; i++)

    {

        while(a[i] != i)  //如果数值和下标不相等，直接交换

        {

            swap(a[i],a[a[i]]);

            ans++;

        }

    }

    cout<<ans<<endl;

    return ;

}

十、最大比例

首先这个比例一定是 大于 1 ，小于 max/min 的，那我们就可以用这个 max/min 不断除以自身的最小素因子，来寻找答案。

思想：

1. 用最大的数除以最小的数，得到一个可能的最大比例（A/B）。

2. 从小到大进行遍历。

如果第 i 个数乘以A/B小于第 i+1个数，继续乘A/B。
如果大于第i+1个数，说明这个比例是不对的（大了），A和B分别除去自己的最小素因子。

3. 遍历一遍之后，会得到一个A/B。但这并不一定是答案，回到第二步，如果整个遍历都没有出现第二部的蓝色字段，出来的就是答案了。

上面的这些过程，时间主要在找素因子上，我们可以分析得到，这个最大的素因子会出现的情况是：X=x^2，X除1以外只有x一个因子，X数值上接近10^12，简单说就是素数表准备到一百万就够用了。

#include <iostream>

#include <algorithm>

#include <set>

#include <vector>

using namespace std;

typedef long long ll;

#define N 1000000

int prime[];

int M[N+];

//打素数表

void EulerSieve() {

    int count = ;

    for (int i = ; i <= N; i++) {

        if (M[i] == ) {

            prime[count++] = i;

        }

        for (int j = ; j < count && prime[j] * i <= N; j++) {

            M[i*prime[j]] = ;

            if (i%prime[j] == )

                break;

        }

    }

}

ll getMinPrimefactor(ll x) {

    if (x < N&&M[x] == )return x;

    //不知道具体数字，循环终止写大点无所谓，不会做到后面的。

    for (int i = ; i < ; i++) {

        if (prime[i] == )return x;

        if (x%prime[i] == )return prime[i];

    }

}

ll gcd(ll a, ll b) {

    return b ? gcd(b, a%b) : a;

}

void reduce(ll &x, ll &y) {

    ll g = gcd(x, y);

    x /= g; y /= g;

}

//分数除

void div(ll &x1,ll &y1,ll x2,ll y2) {

    y1 *= x2; x1 *= y2;

    reduce(x1, y1);

}

//分数乘

void mul(ll &x1, ll &y1, ll x2, ll y2) {

    y1 *= y2; x1 *= x2;

    reduce(x1, y1);

}

void check(ll &A,ll &B,set<ll>s,int &flag) {

    set<ll>::iterator it = s.begin();

    while (true) {

        ll a = *it++, b = ;

        if (it == s.end()) return;

        while (a < *it) {

            mul(a, b, A, B);

        }

        if (a > *it) {

            B /= getMinPrimefactor(B);

            A /= getMinPrimefactor(A);

            flag = true;

            it--;

        }

        //if (a == *it) {

        //    cout << A << "/" << B << endl;

        //}

    }

}

int main() {

    ll n, t;

    int flag = true;

    EulerSieve();

    cin >> n;

    set<ll>s;

    for (ll i = ; i < n;i++)  {

        cin >> t;

        s.insert(t);

    }

    ll B = *s.begin(), A = *s.rbegin();

    reduce(A, B);

    while (flag) {

        flag = false;

        check(A,B,s, flag);

    }

    cout << A << "/" << B << endl;

    return ;

}