蓝桥杯备赛-模拟专题

TT1：连号区间数(第四届蓝桥杯省赛）

解题思路:思路转化 + 枚举区间

先考虑直接暴力枚举,O(n^3)明显过不去,我们尝试优化，可以看出连号区间的一个性质区间的长度 = 区间最大值 - 区间最小值，于是我们只要枚举区间的起点和终点，不断更新区间内的最大值和最小值满足是否等于区间长度即可,时间复杂度为o(n^2)足以通过该题。

代码实现：

// 问题转化为区间长度 = max - min的区间数
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
    int n; cin >> n;
    int a[n + 1];
    for (int i = 1;i <= n; i++) cin >> a[i];
    ll ans = 0;
    for (int l = 1;l <= n ;l++) {
        int mx = -1,mn = 1e9;
        for (int r = l;r <= n ; r++) {
            mx = max(mx,a[r]);
            mn = min(mn,a[r]);
            if (mx - mn == r - l) {
                // cout << l << " " << r << " " << mx << " " << mn << '\n';
                ans++;
            }
        }
    }
    cout << ans;
}

T2:递增三元组(第九届蓝桥杯省赛)

解题思路：二分 + 枚举

考虑暴力,o(n^3)行不通，我们先对a,b,c排序，然后枚举bj,二分a中小于bj位置，二分c中大于c(k)的位置，min(sa,sc)即为可以与当前b组成满足条件的三元组数,时间复杂度O(nlog(n))

代码：

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 1e5 + 50;
int a[N],b[N],c[N];
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n; cin >> n;
	int ans = 0;
    for (int i = 1;i <= n; i++) cin >> a[i];
    for (int i = 1;i <= n; i++) cin >> b[i];
    for (int i = 1;i <= n; i++) cin >> c[i];
    sort(a + 1,a + n + 1);
    sort(b + 1,b + n + 1);
    sort(c + 1,c + n + 1);
    for (int i = 1;i <= n; i++) { // 枚举b[i]
    	// 大于b[i]的第一个位置 - 1,就是小于b[i]的位置,l就是个数
    	int l = lower_bound(a + 1,a + n + 1,b[i]) - a;
        // 大于b[i]的第一个位置,n - r为个数
    	int r = upper_bound(c + 1,c + n + 1,b[i]) - c;
        // b[i]于a,c有很多种组合方式,(l - 1) * (n - r)
        ans += (l - 1) * (n - r + 1);
    }
    cout << ans;
	return 0;
}

T3:错误票据

解题思路：枚举

注意一下数据的读入即可，简单的枚举

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int M=100010;

int cnt[M];

int main(){
    int line,Min=100001,Max=0,a;
    int n,m; //m表示断号ID，n表示重号ID
    cin>>line;
    while(line--){
        while(cin>>a){
            cnt[a]++;
            Max=max(Max,a);
            Min=min(Min,a);
        }
    }

    for(int j=Min;j<=Max;j++){
        if(cnt[j]==0) m=j;
        else if(cnt[j]==2) n=j;
    }

    cout<<m<<" "<<n<<endl;    return 0;
}

 T4:移动距离(第六届蓝桥杯省赛)

解题思路：模拟

首先题目中的最短距离为abs(x1-x2) + abs(y1-y2),这不就是曼哈顿距离吗,所以我们只要求的两个点的坐标就可以解决该题，暴力用二维数组肯定会超时，但是蓝桥杯没有思路时暴力未长不是一种思路，可以拿到一些分，总比不写好，嘻嘻嘻。

我们尝试将所有的值减1,坐标从0开始，这样的曼哈顿距离是不会变的，但是我们可以很轻松求出坐标

0	1	2	3	4	5
11	10	9	8	7	6
12	13	14	15	16	17

1.横坐标：我设列数为w,那么x = num / w

2.纵坐标：如果x为偶数(递增排列),y = num % w,为奇数的话相当于改行的轴对称点y = w - num % w - 1

代码：

// 两个点之间的最短距离就是曼哈顿距离
// 所以求出两个点之间的坐标即可
// 我们将m,n都减1,那么他们之间的曼哈顿距离是不会变的
// 于是x坐标 = num / w
// y坐标:1.如果x坐标为偶数,正序,那么就为num % w
//       2.如果x坐标为奇数,逆序,那么就为w - num % w -  1,当前行的轴对称点
#include <bits/stdc++.h>
using namespace std;
int main() {
    int w,n,m; cin >> w >> n >> m;
    n--,m--;
    int x1 = n / w;
    int x2 = m / w;
    int y1,y2;
    if (x1 & 1) y1 = w - n % w - 1;
    else y1 = n % w;
    if (x2 & 1) y2 = w - m % w - 1;
    else y2 = m % w;
    int ans = abs(x1 - x2) + abs(y1 - y2);
    cout << ans;
}

T5：外卖店优先级(第十届蓝桥杯省赛)

解题思路：模拟 + 枚举 + 优化

1.暴力解法：直接枚举店铺的每个时刻,到t时刻时是否满足条件，时间复杂度o(n^2)，可以通过大概一半的测试用例，也是一种解法

代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
struct node {
    int ts,id;
    bool operator< (const node x) const {
        return ts < x.ts;
    }
}a[N];
int st[N]; // 判断是否加入了优先缓存
using ll = long long;
map<pair<int,int>,int> mp; // 统计一个店铺某个时刻的订单数
int main() {
    int ans = 0;
    int n,m,t; cin >> n >> m >> t;
    for (int i = 1;i <= m; i++) {
        cin >> a[i].ts >> a[i].id;
        mp[{a[i].id,a[i].ts}]++;
    }
    sort(a + 1,a + m + 1);
    // 暴力枚举每个时刻每个店铺的情况
    for (int i = 1;i <= n; i++) {
        int sum = 0; // 统计优先级
        int flag = 0; // 判断是否加入了优先缓存
        for (int j = 1;j <= t; j++) {
            if (mp[{i,j}]) sum += 2 * mp[{i,j}]; // 有订单
            else sum = max(sum - 1,0); // 没有订单
            if (sum > 5) flag = 1; // 加入优先缓存
            if (flag && sum <= 3) flag = 0; // 退出优先缓存
        }
        if (flag) ans++;
    }
    cout << ans;
}

2.正解:我们发现一家店从1~5时刻如果没有订单，优先级就直接减5，我们可以放到下一个有订单的点去计算，优先级 += 2*当前时刻订单数 - 之前没有订单的时间段，如果之后都没有订单，就放到T时刻去计算，就相当于把中间的状态压缩掉了。

我们就可以定义一个last数组，用来记录上一次有订单的时刻，当前时刻 - last[i]就是中间没有订单优先度的减小量，判断一下不为负数，然后最后的一段时刻用T时刻单独处理就好了

代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
pair<int,int> a[N];
int st[N]; // 判断是否加入了优先缓存
int sum[N]; // 记录优先度
int last[N]; // 上一次有订单的时刻
map<pair<int,int>,int> mp; // 记录相同订单个数
int main() {
    int n,m,t; cin >> n >> m >> t;
    for (int i = 1;i <= m; i++) {
        cin >> a[i].first >> a[i].second;
        mp[{a[i].first,a[i].second}]++;
    }
    sort(a + 1,a + m + 1);
    int i = 1;
    while (i <= m) {
        int t = a[i].first,id = a[i].second;
        int cnt = mp[{t,id}]; // 当前时刻当前店订单的个数
        i += cnt;
        sum[id] = max(sum[id] - (t - last[id] - 1),0);
        if (sum[id] <= 3) st[id] = false;

        sum[id] += cnt * 2;
        if (sum[id] > 5) st[id] = true;
        last[id] = t;
    }
    int ans = 0; // 记录答案
    // 处理最后一段区间
    for (int i = 1;i <= n; i++) {
        if (last[i] < t) {
            sum[i] = max(sum[i] - (t - last[i]),0);
            if (sum[i] <= 3) st[i] = false;
        }
        if (st[i]) ans++;
    }
    cout << ans;
}

我遇到的坑：开始我循环部分的代码是这样写的，一直错，本来是想着增加和减少写到一起

    while (i <= m) {
        int t = a[i].first,id = a[i].second;
        int cnt = mp[{t,id}]; // 当前时刻当前店订单的个数
        sum[id] = max(sum[id] - (t - last[id] - 1) + 2*cnt,0); // 不能为负数
        if (sum[id] > 5) st[id] = true;
        if (sum[id] <= 3) st[id] = false;
        last[id] = t; 
        
        i += cnt;
    }

但是这样我们会忽略一种情况，当sum[id] - (t - last[id] - 1) < 0时我们应该将其置为0，而这样写的话，就会以负数计算，最终的优先度就会小于原来的值