【枚举】卡片
小蓝有很多数字卡片，每张卡片上都是数字 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;
}
