蓝桥杯省赛PREV-348试题1：算术填符号

Posted 2023-04-08 Blossom i

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

　　匪警请拨110,即使手机欠费也可拨通！

　　为了保障社会秩序，保护人民群众生命财产安全，警察叔叔需要与罪犯斗智斗勇，因而需要经常性地进行体力训练和智力训练！

　　某批警察叔叔正在进行智力训练：

　　1 2 3 4 5 6 7 8 9 = 110;

　　请看上边的算式，为了使等式成立，需要在数字间填入加号或者减号（可以不填，但不能填入其它符号）。之间没有填入符号的数字组合成一个数，例如：12+34+56+7-8+9 就是一种合格的填法；123+4+5+67-89 是另一个可能的答案。

　　请你利用计算机的优势，帮助警察叔叔快速找到所有答案。

　　每个答案占一行。形如：

　　12+34+56+7-8+9
　　123+4+5+67-89
　　......

　　已知的两个答案可以输出，但不计分。

　　各个答案的前后顺序不重要。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
//a:原先的数组  k:当前的数组的下标  s:由递归所得的字符串 goal:目标数字 
 
void fk(int* a,int k,char* s,int goal)

     if(k == 0)
     
         if(a[0] == goal)
         
             printf("%d%s\\n",a[0],s);
         //若当前下标为零，则检查是否满足goal，否则直接返回 
        return;
     
     char* p=malloc(2*k + 1);
     memset(p,0,2*k + 1);//定义字符数组p来储存字符串 
     
     p[0] = '+';
     _itoa(a[k],p + 1,10); //将a[k]转换为字符储存在串中 
     int x = strlen(p);
     strcat(p + x,s);
     fk(a,k - 1,p,goal - a[k]);
     
     p[0] = '-';
     fk(a,k - 1,p,goal + a[k]);
     //分别假设a[k]之前的符号为“+”、“-” 
     int old=a[k - 1];//若a[k]之前无符号，则要合并，合并之前将旧值储存，方便回溯 
     char ak[1024] = 0;
     char ak2[1024]=0;
     _itoa(a[k - 1],ak,10);
     _itoa(a[k],ak2,10);
     strcat(ak,ak2);
     a[k - 1] = atoi(ak);
     memset(p,0,k*2 + 1);
     strcat(p,s);
     fk(a,k - 1,p,goal);
     a[k - 1] = old;

 
void main()

     int  a[]=1,2,3,4,5,6,7,8,9;
     fk(a,8,"",110);
 

第六届蓝桥杯省赛试题 垒骰子

赌圣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

注意

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

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

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

 

一开始想用动态规划，结果最后一个测试点总是超时，后来经人指点，用矩阵快速幂做，然后自己研究了一下应该就是矩阵的n次方，用快速幂来完成。

超时代码：

#include <iostream>
#include <algorithm>
#include <map>
#include <cstring>
#include <cstdio>
#define mod 1000000007
using namespace std;
int mp[7][7],n,m,x,y;
long long d[2][7],ans = 0;
struct adm
{
    int num;
    int nu[7];
}s[7];
int pow_(int a,int b)
{
    long long d = a,e = 1;
    while(b)
    {
        if(b % 2)e = (e * d) % mod;
        b /= 2;
        d = (d * d) % mod;
    }
    return e;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i = 0;i < m;i ++)
    {
        scanf("%d%d",&x,&y);
        mp[x][y] = mp[y][x] = 1;
    }
    for(int i = 1;i <= 6;i ++)
    {
        d[0][i] = 1;
        for(int j = 1;j <= 6;j ++)
        {
            if(!mp[(i + 2) % 6 + 1][j])s[i].nu[s[i].num ++] = j;
        }
    }
    for(int i = 1;i < n;i ++)
    {
        x = i % 2,y = (i + 1) % 2;
        for(int j = 1;j <= 6;j ++)
        {
            d[x][j] = 0;
            for(int k = 0;k < s[j].num;k ++)
            {
                d[x][j] = (d[x][j] + d[y][s[j].nu[k]]) % mod;
            }
        }
    }
    for(int i = 1;i <= 6;i ++)
    {
        ans = (ans + d[x][i]) % mod;
    }
    ans = (ans * pow_(4,n)) % mod;
    printf("%lld",ans);
}

 

ac代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#define mod 1000000007
using namespace std;
long long **mp = new long long *[6],**d = new long long *[6];
int n,m,x,y,r[6] = {3,4,5,0,1,2};
long long quick_c(int t)
{
    long long e = 4,ans = 1;
    while(t)
    {
        if(t % 2)ans = (ans * e) % mod;
        t /= 2;
        e = (e * e) % mod;
    }
    return ans;
}
void mul_m(long long **a,long long **b)
{
    long long s[6][6] = {0};
    for(int i = 0;i < 6;i ++)
    {
        for(int j = 0;j < 6;j ++)
        {
            for(int k = 0;k < 6;k ++)
            {
                s[i][j] = (s[i][j] + a[i][k] * b[k][j]) % mod;
            }
        }
    }
    for(int i = 0;i < 6;i ++)
    {
        for(int j = 0;j < 6;j ++)
            a[i][j] = s[i][j];
    }
}
long long quick_m(int t)
{
    while(t)
    {
        if(t % 2)mul_m(mp,d);
        t /= 2;
        mul_m(d,d);
    }
    long long ans = 0;
    for(int i = 0;i < 6;i ++)
    {
        for(int j = 0;j < 6;j ++)
            ans = (ans + mp[i][j]) % mod;
    }
    return ans;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 0;i < 6;i ++)
    {
        mp[i] = new long long[6];
        d[i] = new long long[6];
    }
    for(int i = 0;i < 6;i ++)
    {
        for(int j = 0;j < 6;j ++)
            mp[i][j] = 0,d[i][j] = 1;
    }
    for(int i = 0;i < 6;i ++)
        mp[i][i] = 1;
    for(int i = 1;i <= m;i ++)
    {
        scanf("%d%d",&x,&y);
        d[x - 1][r[y - 1]] = d[y - 1][r[x - 1]] = 0;
    }
    long long ans = (quick_c(n) * quick_m(n - 1)) % mod;
    cout<<ans;
}