【2023蓝桥杯】枚举专项题

@[TOC] (目录)

【枚举】卡片

小蓝有很多数字卡片，每张卡片上都是数字 0 到 9。

小蓝准备用这些卡片来拼一些数，他想从 1开始拼出正整数，每拼一个，就保存起来，卡片就不能用来拼其它数了。

小蓝想知道自己能从 1拼到多少。

例如，当小蓝有 30 张卡片，其中 0 到 9 各 3 张，则小蓝可以拼出 1 到 10，

但是拼 11 时卡片 1 已经只有一张了，不够拼出 11。

现在小蓝手里有 0 到 9的卡片各 2021 张，共 20210张，请问小蓝可以从 1拼到多少？ 3181

#include <bits/stdc++.h>
using namespace std;
int num[10];

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
bool check(int x){
    //语法：while(循环条件){ 循环语句 }  解释：只要循环条件的结果为真，就执行循环语
    while(x){                       // x为真，即不为0 
        int now = x % 10;             // % 除余 eg 980%10=0 
        if(num[now]>0) num[now]--;
        else return false;
        x /= 10;                      //  / 除 
    }
    return true;
} 


int main(int argc, char** argv) {
    for(int i=0; i<10; i++) num[i]=2021; // 0~9各2021张
    for(int i=1;;i++){
        if(!check(i)){                    // 检查数字i是否存在 
            cout<<i-1<<endl;            // 不存在，则输出上一个数 
            break;
        }
    }
    return 0;
}

【枚举】数的分解

把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包含数字 2 和 4，一共有多少种不同的分解方法？40785

注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18被视为同一种。

#include <bits/stdc++.h>
using namespace std;         
//检查是否含有2或者4 
int check(int x){    
    //语法：while(循环条件){ 循环语句 }  解释：只要循环条件的结果为真，就执行循环语
    if(x<=0) return false;
    while(x){                       // x为真，即不为0 
        int now = x % 10;             // % 除余 eg 980%10=0 
        if(now ==2||now==4) return false;     // ||或 
        x /= 10;                      //  / 除 
    }
    return true;
} 


int main() {
    int ans = 0;                     //方案数    
    for(int i=1; i<=2019; i++){
        for(int j=i+1; j<=2019; j++){
            int k = 2019 - i -j;
            if(check(i) && check(j) && check(k) && i<j && j<k) ans++;
        }
    } 
    cout <<ans<<endl;
    return 0;
}

【枚举】特别数的和

小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。

请问，在 1 到 n 中，所有这样的数的和是多少？

#include<bits/stdc++.h>
using namespace std;
//根据题目，由2，0，1，9构成的数字
bool check(int x){
    if(x==0) return false;
    while(x){
        int now = x%10;
        if(now==2 || now==0 || now==1|| now==9) return true;        
        x /=10;                
    }
    return false;    
}


int main(){
    int n=0;
    cin >> n;
    int sum=0;
    for(int i=1; i<=n; i++){
        int k=i;
        if(check(i)) sum = sum +k;
    }
    cout << sum << endl;
    return 0;
} 

【枚举】日期问题

小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在 1960 年 1 月 1 日至 2059 年 12 月 31 日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。

更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。

比如 02/03/04，可能是 2002 年 03 月 04 日、2004 年 02 月 03 日或 2004 年 03 月 02 日。

给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？

#include<bits/stdc++.h>
using namespace std;
int max_days[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int year,int month,int day){
    //月不匹配？ 
    if(month == 0 || month > 12) return false;
    //日不匹配？ 
    if(day==0) return 0;
    //月日不匹配？ 
    if(month!=2){
        if(day > max_days[month]) return false;
    }
    else
    {
        //判断闰年  四年一润，百年不润，四百年再润 
        int leap=(year%4==0 && year%100!=0)||(year%400==0);
        if(day>28+leap) return false; 
     } 
     return true;
}
//遍历19600101~20591231，是否能够得到与输入相同的数字
//如果可以，则为一种可能性 
int main(){
    int a, b, c;
    scanf("%d/%d/%d",&a,&b,&c);
    for(int data=19600101;data<=20591231;data++){
        int year = data/10000;
        int month = data%10000/100;
        int day = data%100;
        if(check(year,month,day)){            
            if(year%100 == a && month == b && day ==c||
               month == a && year%100 == b && day ==c||
               day == a && month == b && year%100 ==c)
               printf("%d-%02d-%02d\n", year,month,day); // %02d：若不足两位，则补上前导0
        }
    }
    return 0;
}

【枚举】图像模糊

小蓝有一张黑白图像，由 n×m 个像素组成，其中从上到下共 n 行，每行从左到右m 列。每个像素由一个 0到 255 之间的灰度值表示。

现在，小蓝准备对图像进行模糊操作，操作的方法为：

对于每个像素，将以它为中心 3×3 区域内的所有像素（可能是 9个像素或少于 9 个像素）求和后除以这个范围内的像素个数（取下整），得到的值就是模糊后的结果。

请注意每个像素都要用原图中的灰度值计算求和。

#include<bits/stdc++.h>
using namespace std;
int n,m;
int s[105][105]; //source
int r[105][105]; //result
int dir[8][2]={{-1,0},{-1,1},{-1,-1},{0,1},{0,-1},{1,1},{1,0},{1,-1}}; //8个方向
int main(){
    cin>>n>>m; //n*m图像
    //获取各像素值 
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            cin>>s[i][j];
        }
    }
    
    for(int i=1; i<=n; i++){
        for(int j=1;j<=m; j++){
            //当前点
            int sum = s[i][j];
            int num =1; //初始像素个数为1 
            for(int k=0; k<8; k++){
                //周边的像素点 
                int x=i+dir[k][0];
                int y=j+dir[k][1];
                //判断(x,y)是否存在 
                if(x>=1 && x<=n && y>=1 &&y<=m){
                    sum += s[x][y]; 
                    num++; 
                }    
            } 
            r[i][j]=sum/num; 
        }
    } 
    //输出
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            cout<<r[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
} 

【枚举】赢球票

某机构举办球票大奖赛。获奖选手有机会赢得若干张球票。

主持人拿出 N 张卡片（上面写着 1⋯1⋯N 的数字），打乱顺序，排成一个圆圈。

你可以从任意一张卡片开始顺时针数数: 1,2,3 ⋯⋯

如果数到的数字刚好和卡片上的数字相同，则把该卡片收入囊中，从下一个卡片重新数数。

直到再无法收获任何卡片，游戏结束。囊中卡片数字的和就是赢得球票的张数。

比如：

卡片排列是：1 2 3

我们从 1 号卡开始数，就把 1 号卡拿走。再从 2 号卡开始，但数的数字无法与卡片对上，很快数字越来越大，不可能再拿走卡片了。因此这次我们只赢得了 1 张球票。

还不算太坏！如果我们开始就傻傻地从 2 或 3 号卡片数起，那就一张卡片都拿不到了。

如果运气好，卡片排列是 2 1 3，那我们可以顺利拿到所有的卡片！

本题的目标：已知顺时针卡片序列，随便你从哪里开始数，求最多能赢多少张球票（就是收入囊中的卡片数字之和）

#include<bits/stdc++.h>
using namespace std;
int a[100]; //卡片数目存储
int vis[100]; //卡片是否获取

int main(){
    int n; //卡片的数目
    //何时停止？数数大于卡片最大值，数数终止  
    int maxx=0; //最大的卡片数值
    int out=0;//种数 
    int res, ans, p, t; //ans获取的卡片总面值，t为当前数数的数字 
    cin >> n;
    //存储数字
    for(int i=0; i<n; i++){
        cin >> a[i];
        out=max(out,a[i]);  //由于打乱顺序，需要比较，获取最大的卡片数值 
    }
    //for循环开始 
    for(int i; i<n; i++){
        res=0; 
        ans=0;
        p=i;
        t=1;
        //注意每一次获得卡片都要重新将vis数组清零
        memset(vis,0,sizeof(vis)); 
        //当前数数从1开始，t为所数数 
        while(t<=out){
            //当前卡片已经获取
            if(vis[p]==1){
                //假设n=18,p为7，更新p=8%18，从8开始 
                //假设n=18,p为21，更新p=21%18，从3开始 
                p=(p+1)%n; //随便你从哪里开始数，将p的值加1，然后取余，使p的值保持在0到n-1之间。
                continue; 
            } 
            //数数==卡片，收获 
            if(t==a[p]){
                res++; //获取的卡片数+1
                vis[p]=1;//当前卡片已被获取，不再参与数数
                ans+=a[p];//获取的卡片总面值，即彩票张数 
                t=1; //数数重新开始
                if(res==n)//获取的卡片等于总卡数 
                break; 
            }
            else
            {
                t++; //如果数数！=卡片，继续往下数数 
             } 
             p=(p+1)%n;    //随便你从哪里开始数，将p的值加1，然后取余，使p的值保持在0到n-1之间。        
        } //while循环结束 
        maxx=max(maxx,ans);//每种情况所对应的球票张数 
    } //for循环结束 
    cout<<maxx<<endl;
    return 0;
} 

【枚举】灌溉

小蓝负责花园的灌溉工作。

花园可以看成一个 n 行 m 列的方格图形。中间有一部分位置上安装有出水管。

小蓝可以控制一个按钮同时打开所有的出水管，打开时，有出水管的位置可以被认为已经灌溉好。

每经过一分钟，水就会向四面扩展一个方格，被扩展到的方格可以被认为已经灌溉好。即如果前一分钟某一个方格被灌溉好，则下一分钟它上下左右的四个方格也被灌溉好。

给定花园水管的位置，请问 k 分钟后，有多少个方格被灌溉好？

#include<bits/stdc++.h>
using namespace std;
int n,m,r,c;             //花园为n行m列的方格图形 
int t;                    //水管的数量 
int s[100][100];          //水管的位置 
int vis[100][100];        //花园的浇灌情况，最大为100 
int k;                    //时间情况 
int ax,by;

char dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};//浇灌扩散的4个方向
//k时间浇灌土地情况 
void dfs(int a, int b, int time){
    if(time==k) return ;
    for(int c=0; c<4; c++){
        ax=a+dir[c][0];
        by=b+dir[c][1];
        if(ax>0 && ax<=n && by>0 && by<=m){
        vis[ax][by]=1;}
        dfs(ax,by,time+1);
    }        
}

int main(){
    cin>>n>>m;                 //方格 
    cin>>t;                    //水管数 
    //读取水管位置 
    for(int i=1; i<=t; i++){
        cin>>r>>c;
        s[r][c]=1; 
        vis[r][c]=1;        
    }
    cin>>k; 
    //开始浇灌土地
    //每个水管情况，遍历 
    int time=1;
    for(int i=1; i<=t; i++){
        for(int a=1; a<=n; a++){
            for(int b=1; b<=m; b++){
                //这是一个水管！ 
                if(s[a][b]==1){
                    //k时间浇灌土地情况 
                    dfs(a,b,0);
                }
            }
        }
    }
    //遍历浇灌的方格计数 
    int count=0;
    for(int i=1; i<=n; i++){
        for(int j=1;j<=m; j++){
            if(vis[i][j]==0) count++;
        }
    }
    cout<<count<<endl; 
} 

【枚举】带分数

100 可以表示为带分数的形式：100 = 3 + 69258 / 714

还可以表示为：100 = 82 + 3546 / 197

注意特征：带分数中，数字 1~9 分别出现且只出现一次（不包含 0 ）。

类似这样的带分数，100 有 11 种表示法。

#include<bits/stdc++.h>
using namespace std;
int num[10]={1,2,3,4,5,6,7,8,9}; // 0不用
int n; //输入的整数 
//dfs搜索所有满足的带分数  枚举出来返回
//全排列不会超时。首先将9个数字全排列，然后将加号+和乘号*插入到 9个数中间
int dfs(int a,int b){ 
    int temp=0;
    for(int i=a;i<=b;i++){
      temp=temp*10+num[i];    
    }
    return temp;
}

int main(){
    cin>>n; //读取整数
    int count=0;//计数
    //next_permutation(num,num+9)全排列函数 
    //next_permutation()会取得[first,last)所标示之序列的下一个排列组合，如果没有下一个排列组合，便返回false;否则返回true。 
    while(next_permutation(num, num+9)){
        for(int i=0; i<7;i++){
            for(int j=i+1;j<=8;j++){
                int x=dfs(0,i);
                int y=dfs(i+1,j);
                int z=dfs(j+1,8);
                if(x*z+y==z*n)
                count ++;
            }
        }
    }
    cout<<count<<endl;
    return 0;         
}

【枚举】幸运数

幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的"筛法"生成。

首先从1 开始写出自然数 1,2,3,4,5,6,⋯

1 就是第一个幸运数。我们从 2 这个数开始。把所有序号能被 2整除的项删除，变为：1 3 5 7 9⋯

把它们缩紧，重新记序，为：1 3 5 7 9⋯

这时，3为第 2个幸运数，然后把所有能被 3 整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被 3 整除!!删除的应该是 5，11,17,⋯

此时 7 为第 3 个幸运数，然后再删去序号位置能被 7 整除的( 19,39,⋯)

最后剩下的序列类似：1,3,7,9,13,15,21,25,31,33,37,43,49,51,63,67,69,73,75,79,⋯

#include <bits/stdc++.h>
using namespace std;
int m,n,p; //介于m和n之间
const int N=1e6+10;
int a[N]; 

void dfs(int luck){
    if(luck>n) return;                //如果幸运数超出范围 
    int k=luck;                        //幸运数 
    //缩紧重新计数 
    for(int i=luck; i<=n; i++){
        //如果序号位置能够幸运数整除，则删除
        //第一个被2整除，随后这个特性变为被幸运数整除 
        if(i%a[luck]) a[k++]=a[i];
    }
    dfs(luck+1);    
}

int main() {
    cin>>m>>n;
    //检查 1~n 之间的幸运数
    for(int i=1; i<=n; i++)
        a[i]=2*i-1;
    dfs(2);    //从2开始，删除序号被2整除的项 
    //检查 m~n 之间的幸运数 
    int res=0;
    for(int i=1; a[i]<n; i++)
        if(a[i]>m) res++;        
    cout<<res<<endl;
    return 0;
}

【枚举】连号区间数

小明这些天一直在思考这样一个奇怪而有趣的问题：在 1 ~ N 的某个全排列中有多少个连号区间呢？

这里所说的连号区间的定义是：如果区间 [L,R] 里的所有元素（即此排列的第 L 个到第 R 个元素）递增排序后能得到一个长度为 R−L+1 的"连续"数列，则称这个区间连号区间。当 N 很小的时候，小明可以很快地算出答案，但是当 N 变大的时候，问题就不是那么简单了，现在小明需要你的帮助

#include <bits/stdc++.h>
using namespace std;
const int N=10010;
int n, a[N], ans;


int main() {
    cin>>n;   //全排列规模 
    //N个数字的全排列 
    for(int i=0; i<n; i++){
        cin>>a[i];
    } 
    //判断全排列
    for(int i=0; i<n; i++){
        int maxx=-N, minn=N;
        //第 i个数到第 j 个数 
        for(int j=i; j<n; j++){
            // i~j的两端最值 
            maxx=max(maxx,a[j]);
            minn=min(minn,a[j]);
            // i~j的长度是否符合区间练好区间 
            if(maxx-minn == j-i) ans++;
        }
    } 
    cout<<ans<<endl;
    return 0;
}

【枚举】区间移位

仅作了解-国赛题-中等难度

#include<bits/stdc++.h>
using namespace std;
int n;
int vis[10010];
struct node{
    int a,b;
} ab[10010];//区间 

bool cmp(node x,node y){
    return x.b<y.b;
}
bool check(int c){
    int posb=0;
    memset(vis,0,sizeof(vis));
    while(1){
        int flag=0;
        for(int i=1;i<=n;i++){
            int a=ab[i].a,b=ab[i].b;
            if(vis[i]==0&&posb>=a-c&&posb<=b+c){
                flag=1;
                if(a+c>=posb) posb+=b-a;
                else posb=b+c;    
                vis[i]=1;
                if(posb>=20000) return 1;
                else break;
            } 
        }
        if(!flag&&posb<20000) return 0; 
    }
}

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        int pp,qq;
        cin>>qq>>pp;
        ab[i].a=2*qq;
        ab[i].b=2*pp;
    }
    sort(ab+1,ab+1+n,cmp);
    int l=0,r=20000,mid;
    while(r-l>1e-4){
        mid=(l+r)/2;
        if(check(mid)) r=mid;
        else l=mid+1;
    }
    cout<<1.0*l/2;
    return 0;
}