枚举 模拟

枚举

1.连号区间数

ACWing1210. 连号区间数
小明这些天一直在思考这样一个奇怪而有趣的问题：

在 1∼N 的某个排列中有多少个连号区间呢？

这里所说的连号区间的定义是：

如果区间 [L,R] 里的所有元素（即此排列的第 L 个到第 R 个元素）递增排序后能得到一个长度为 R−L+1 的“连续”数列，则称这个区间连号区间。

当 N 很小的时候，小明可以很快地算出答案，但是当 N 变大的时候，问题就不是那么简单了，现在小明需要你的帮助。

输入格式
第一行是一个正整数 N，表示排列的规模。

第二行是 N 个不同的数字 Pi，表示这 N 个数字的某一排列。

输出格式
输出一个整数，表示不同连号区间的数目。

数据范围
1≤N≤10000,
1≤Pi≤N
输入样例1：

4
3 2 4 1

输出样例1：

7

输入样例2：

5
3 4 2 5 1

输出样例2：

9

样例解释
第一个用例中，有 7 个连号区间分别是：[1,1],[1,2],[1,3],[1,4],[2,2],[3,3],[4,4]
第二个用例中，有 9 个连号区间分别是：[1,1],[1,2],[1,3],[1,4],[1,5],[2,2],[3,3],[4,4],[5,5]

• 1.一个数：都可以
• 2.多个数：从左到右依次取数，将其排序，区间中每个数只出现一次，若连续：区间最大值-最小值 等于 区间元素总数-1

#include
#include
#include
using namespace std;
const int N = 10010, INF = 100000000;
int n;
int a[N];
int main()
{
     
	cin >> n;
	for(int i= 0; i <n; i++) cin >> a[i];
	int res = 0;
	for(int i = 0; i <n; i++)//枚举区间左端点 
	{
     
		int minv = INF, maxv = -INF;
		for(int j = i; j < n; j++) //枚举区间右端点
		{
     
			minv = min(minv, a[j]);
			maxv = max(maxv, a[j]);
			if(maxv - minv == j - i) res++;
		 } 
	}
	cout << res;
	return 0;
}

2. 递增三元组

ACWing1236. 递增三元组
给定三个整数数组

A=[A1,A2,…AN],
B=[B1,B2,…BN],
C=[C1,C2,…CN],

请你统计有多少个三元组 (i,j,k) 满足：

1≤i,j,k≤N
Ai 输入格式
第一行包含一个整数 N。

第二行包含 N 个整数 A1,A2,…AN。

第三行包含 N 个整数 B1,B2,…BN。

第四行包含 N 个整数 C1,C2,…CN。

输出格式
一个整数表示答案。

数据范围
1≤N≤105,
0≤Ai,Bi,Ci≤105
输入样例：

3
1 1 1
2 2 2
3 3 3

输出样例：

27

1. 可以通过暴力枚举，但会超时
2. 找到A,B,C之间的关系，对于每个Bi 求：

3.    在A中有多少个小于Bi（前缀和）（或者双指针算法）
      在C中有多少个大于Bi（sort + 二分）
   

#include
#include
#include
#include
using namespace std;
typedef long long LL;
const int N = 100010;
int n;
int a[N], b[N],c[N];
int as[N];//表示在A中有多少个数小于bi
int cs[N];//表示在C中有多少个数大于bi
int cnt[N], s[N];//cnt记录A[i] 或者 B[i]出现的次数，S表示前缀和，即S[i]表示cnt[0]~cnt[i] 出现次数之和
int main()
{
     
	cin >> n;
	for(int i = 0; i <n; i++) scanf("%d", &a[i]), a[i]++;
	for(int i = 0; i <n; i++) scanf("%d", &b[i]), b[i]++;
	for(int i = 0; i <n; i++) scanf("%d", &c[i]), c[i]++;
	
	//求as[] 
	for(int i = 0; i <n; i++) cnt[a[i]]++;
	for(int i = 1; i < N; i++) s[i] = s[i - 1] + cnt[i];
	for(int i = 0;i <n; i++) as[i] = s[b[i] - 1];
	
	//求cs[]
	memset(cnt, 0, sizeof cnt);
	memset(s, 0, sizeof s);
    for(int i = 0; i <n; i++) cnt[c[i]]++;
	for(int i = 1; i < N; i++) s[i] = s[i - 1] + cnt[i];
	for(int i = 0;i <n; i++) cs[i] =  s[N-1] - s[b[i]];
	
	//枚举每个b[i]
	LL res = 0;
	for(int i = 0; i <n; i++) res += (LL)as[i] * cs[i];
	cout << res << endl;
	return 0;
	
 } 

3.回文日期

AcWing466. 回文日期
在日常生活中，通过年、月、日这三个要素可以表示出一个唯一确定的日期。

牛牛习惯用 8 位数字表示一个日期，其中，前 4 位代表年份，接下来 2 位代表月份，最后 2 位代表日期。

显然：一个日期只有一种表示方法，而两个不同的日期的表示方法不会相同。

牛牛认为，一个日期是回文的，当且仅当表示这个日期的8位数字是回文的。

现在，牛牛想知道：在他指定的两个日期之间（包含这两个日期本身），有多少个真实存在的日期是回文的。

一个 8 位数字是回文的，当且仅当对于所有的 i(1≤i≤8) 从左向右数的第i个数字和第 9−i 个数字（即从右向左数的第 i 个数字）是相同的。

例如：

•对于2016年11月19日，用 8 位数字 20161119 表示，它不是回文的。

•对于2010年1月2日，用 8 位数字 20100102 表示，它是回文的。

•对于2010年10月2日，用 8 位数字 20101002 表示，它不是回文的。

输入格式
输入包括两行，每行包括一个8位数字。

第一行表示牛牛指定的起始日期date1，第二行表示牛牛指定的终止日期date2。保证date1和date2都是真实存在的日期，且年份部分一定为4位数字，且首位数字不为0。

保证date1一定不晚于date2。

输出格式
输出共一行，包含一个整数，表示在date1和date2之间，有多少个日期是回文的。

输入样例：

20110101
20111231

输出样例：

1

#include
#include
#include
#include
using namespace std;
int res;
int days[13] = {
     0, 31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int x)
{
     
	int y,m,d;
	y = x/10000;
	m = x%10000/100;
	d = x%100;
	if(m > 12 || m == 0) return false;
	if(d == 0) return false;
	if(m != 2 && d > days[m]) return false;
	int leap = (y%100 != 0&& y%4 == 0)||(y%400 == 0);
	if(m==2 && d > days[m] + leap) return false;
	
	return true;
}

bool is_HuiWen(int x)
{
     
	int a, b;
	a = x/10000;
	b = x%10000;
	if(a == (b%10*1000 + b%100/10*100 + b%1000/100*10 + b/1000)) return true;
	else return false;
	
}
int main()
{
     
  int n, m;
  cin >>n >> m;
  for(int i = n; i <= m; i++)
  {
     
  	if(check(i)&& is_HuiWen(i)) res++;
  }
  cout << res;
} 

模拟

1.特别数的和

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

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

输入格式
共一行，包含一个整数 n。

输出格式
共一行，包含一个整数，表示满足条件的数的和。

数据范围
1≤n≤10000
输入样例：

40

输出样例：

574

int main()
{
     
	int n;
	cin >> n;
	for(int i = 1;i <= n; i++)
	{
     
		int x = i;
		while(x)
		{
     
			int t = x % 10;
			x /= 10;
			if(t == 2 || t == 0 || t==1 || t == 9)
			{
     
				res += i;
			    break; 
			}
		}
	}	
	cout << res;
	return 0;
} 

2.错误票据

ACWing1204. 错误票据
某涉密单位下发了某种票据，并要在年终全部收回。

每张票据有唯一的ID号。

全年所有票据的ID号是连续的，但ID的开始数码是随机选定的。

因为工作人员疏忽，在录入ID号的时候发生了一处错误，造成了某个ID断号，另外一个ID重号。

你的任务是通过编程，找出断号的ID和重号的ID。

假设断号不可能发生在最大和最小号。

输入格式
第一行包含整数 N，表示后面共有 N 行数据。

接下来 N 行，每行包含空格分开的若干个（不大于100个）正整数（不大于100000），每个整数代表一个ID号。

输出格式
要求程序输出1行，含两个整数 m,n，用空格分隔。

其中，m表示断号ID，n表示重号ID。

数据范围
1≤N≤100
输入样例：

2
5  6  8  11  9
10  12  9

输出样例：

7 9

#include
#include
#include
#include
#include
using namespace std;
const int N = 10010;
int n;
int a[N];

int main()
{
     
    int cnt;
    cin >> cnt;
    string line;
    getline(cin, line);//忽略掉第一行回车 
    while(cnt--)
    {
     
    	getline(cin, line);
    	stringstream ssin(line);
    	
    	while(ssin >> a[n]) n++;
	}
	sort(a, a + n);
	int res1, res2;
	for(int i = 1;i < n; i++)
	  if(a[i] == a[i - 1]) res2 = a[i];
	  else if(a[i] >= a[i - 1] + 2) res1 = a[i] - 1; 
	  
	  cout << res1 <<" " << res2 << endl;
	  return 0;
} 

3.移动距离

ACWing1219. 移动距离
X星球居民小区的楼房全是一样的，并且按矩阵样式排列。

其楼房的编号为 1,2,3…
当排满一行时，从下一行相邻的楼往反方向排号。

比如：当小区排号宽度为 6 时，开始情形如下：

1  2  3  4  5  6
12 11 10 9  8  7
13 14 15 .....

我们的问题是：已知了两个楼号 m 和 n，需要求出它们之间的最短移动距离（不能斜线方向移动）。

输入格式
输入共一行，包含三个整数 w,m,n，w 为排号宽度，m,n 为待计算的楼号。

输出格式
输出一个整数，表示 m,n 两楼间最短移动距离。

数据范围
1≤w,m,n≤10000,

输入样例：

6 8 2

输出样例：

4

1. 所有的行列坐标从（0,0）开始，第一个数也从0开始
2. 行号n/w m/w
3. 如果n/w是偶数 列号：n%w
   如果n/w是奇数 列号：w-1-n%w

曼哈顿距离：|x1 - x2| + |y1 - y2|
欧几里得距离：sqrt((x1²- x2²) +(y1² - y2² )

#include
#include
#include
#include
using namespace std;

int main()
{
     
    int w, m, n;
	cin >> w >> m >> n;
	m--, n--;
	int x1 = m/w, x2 = n/w;
	int y1 = m%w, y2 = n%w;
	if(x1%2) y1 = w-1-y1;
	if(x2%2) y2 = w-1- y2;
	cout << abs(x1-x2) + abs(y1- y2) << endl;
	return 0;
} 

4.日期问题

ACWing1229. 日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。

小明知道这些日期都在1960年1月1日至2059年12月31日。

令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。

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

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

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

输入格式
一个日期，格式是”AA/BB/CC”。

即每个’/’隔开的部分由两个 0-9 之间的数字（不一定相同）组成。

输出格式
输出若干个不相同的日期，每个日期一行，格式是”yyyy-MM-dd”。

多个日期按从早到晚排列。

数据范围
0≤A,B,C≤9
输入样例：

02/03/04

输出样例：

2002-03-04
2004-02-03
2004-03-02

1. 从1960.01.01到2059.12.31枚举
2. 判断是否合法
3. 判断是否可能是给定的表示

#include
#include
#include
#include
using namespace std;
int days[13] = {
     0, 31,28, 31,30,31,30,31,31,30,31,30,31};

bool check(int y, int m, int d)
{
     
	if(m == 0 || m >12) return false;
	if(d ==0) return false;
	if(m != 2)
	{
     
		if(d > days[m]) return false;
	}
	else
	{
     
		int leap = y %100 != 0 && y %4 == 0 || y % 400 == 0;
		if(d > 28+leap) return false;
	}
	return true;
}
int main()
{
     
    int a, b, c;
    scanf("%d/%d/%d", &a, &b, &c);//注意输入格式
    for(int date = 19600101; date <= 20591231; date++)
    {
     
    	int year = date/10000, month = date%10000/100, day = date%100;
    	if(check(year, month, day))
    	{
     
    		if(year%100 == a && month == b && day == c ||month == a&& day==b &&year%100==c||day==a&&month==b&&year%100==c)//年/月/日||月/日/年||  日/月/年
    		{
     
    			printf("%d-%02d-%02d\n", year, month, day);//输出：%02d 如果不够两位 就补0
			}
		}
	}
	return 0;
} 

5.航班时间

ACWing1231. 航班时间
小 h 前往美国参加了蓝桥杯国际赛。

小 h 的女朋友发现小 h 上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。

小 h 对超音速飞行感到十分恐惧。

仔细观察后发现飞机的起降时间都是当地时间。

由于北京和美国东部有 12 小时时差，故飞机总共需要 14 小时的飞行时间。

不久后小 h 的女朋友去中东交换。

小 h 并不知道中东与北京的时差。

但是小 h 得到了女朋友来回航班的起降时间。

小 h 想知道女朋友的航班飞行时间是多少。

对于一个可能跨时区的航班，给定来回程的起降时间。

假设飞机来回飞行时间相同，求飞机的飞行时间。

输入格式
一个输入包含多组数据。

输入第一行为一个正整数 T，表示输入数据组数。

每组数据包含两行，第一行为去程的起降时间，第二行为回程的起降时间。

起降时间的格式如下:

h1:m1:s1 h2:m2:s2
h1:m1:s1 h3:m3:s3 (+1)
h1:m1:s1 h4:m4:s4 (+2)

第一种格式表示该航班在当地时间h1时m1分s1秒起飞，在当地时间当日h2时m2分s2秒降落。

第二种格式表示该航班在当地时间h1时m1分s1秒起飞，在当地时间次日h2时m2分s2秒降落。

第三种格式表示该航班在当地时间h1时m1分s1秒起飞，在当地时间第三日h2时m2分s2秒降落。

输出格式
对于每一组数据输出一行一个时间hh:mm:ss，表示飞行时间为hh小时mm分ss秒。

注意，当时间为一位数时，要补齐前导零，如三小时四分五秒应写为03:04:05。

数据范围
保证输入时间合法（0≤h≤23,0≤m,s≤59），飞行时间不超过24小时。

输入样例：

3
17:48:19 21:57:24
11:05:18 15:14:23
17:21:07 00:31:46 (+1)
23:02:41 16:13:20 (+1)
10:19:19 20:41:24
22:19:04 16:41:09 (+1)

输出样例：

04:09:05
12:10:39
14:22:05

t =[ (end1 - start1 - 时差）+（end2-start2 + 时差)]/2
t = (end1 - start1 + end2 - stare2)/2;

1. 将所有时间转化成距离当天00:00：00的秒数
2. hour = time/3600
3. minute = time%3600/60
4. second = time % 60

注意：输入输出问题

#include
#include
#include
#include
#include
using namespace std;
int get_seconds(int h, int m, int s)
{
     
	return h*3600 + m*60 + s;
}
int get_time()
{
     
	string line;
	getline(cin, line);
	
	if(line.back() != ')') line +=" (+0)" ;//最后一个如果不是
	
    int h1, m1,s1, h2, m2, s2,d;
	 sscanf(line.c_str(),"%d:%d:%d %d:%d:%d (+%d)", &h1, &m1, &s1, &h2, &m2, &s2, &d);
	 
	 return get_seconds(h2,m2,s2)-get_seconds(h1, m1,s1) + d*24 *3600;
}
int main()
{
     
    int n;
    scanf("%d", &n);
    string line;
    getline(cin, line);//忽略掉第一行的回车 
    while(n--)
    {
     
    	int time = (get_time() + get_time()) /2;
    	int hour = time/3600, minute= time%3600/60, second = time%60;
    	printf("%02d:%02d:%02d\n", hour, minute, second);
	}
	return 0;
} 

6.外卖店优先级

ACWing1241. 外卖店优先级
“饱了么”外卖系统中维护着 N 家外卖店，编号 1∼N。

每家外卖店都有一个优先级，初始时 (0 时刻) 优先级都为 0。

每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。

如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果优先级小于等于 3，则会被清除出优先缓存。

给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优先缓存中。

输入格式
第一行包含 3 个整数 N,M,T。

以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到一个订单。

输出格式
输出一个整数代表答案。

数据范围
1≤N,M,T≤105,
1≤ts≤T,
1≤id≤N
输入样例：

2 6 6
1 1
5 2
3 1
6 2
2 1
6 2

输出样例：

1

样例解释
6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6，加入优先缓存。

所以是有 1 家店 (2 号) 在优先缓存中。

暴力枚举法：

1. 判断哪些店有订单，哪些店无订单
2. 有订单的店 score += 2 x订单数
3. 无订单的店 score–
4. if(score > 5) st[id] = true;
   if(score <= 3 st[id] = false;
   for(i = 1; i <= n; i++) res += st[i];

优化：

1. 将所有订单按时间顺序排序， 每次处理一批相同的订单
2. score[i]表示第i个店铺当前优先级
3. last[i]表示第i个店铺上一次有订单的时刻
4. st[i]表示第i个店铺当前是否处于优先缓存中

#include
#include
#include
#include
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 100010;
int n, m, T;
int score[N], last[N];
bool st[N];
PII order[N];
int main()
{
     
   cin >> n >> m >> T;
   for(int i = 0; i < m; i++) scanf("%d%d", &order[i].x, &order[i].y);
   sort(order, order + m);
   for(int i = 0; i <m; )
   {
     
   	int j = i;
   	while(j < m && order[j]==order[i]) j++;
   	int t = order[i].x, id = order[i].y, cnt = j - i;
   	i = j;
   	
   	score[id] -= t - last[id] - 1;
   	if(score[id] < 0) score[id] = 0;
   	if(score[id] <= 3) st[id] = false;
   	
   	score[id] += cnt*2;
   	if(score[id] > 5) st[id] = true;
   	last[id] = t;
   }
   for(int i = 1;i <=n; i++)
    if(last[i] <T)
    {
     
    	score[i] -= T-last[i];
    	if(score[i] <= 3) st[i] = false;
	}
	
	int res = 0;
	for(int i = 1;i <= n; i++) res += st[i];
	cout << res;
	return 0;
}