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