构造数组

构造数组

给定一个长度为 $n$ 的整数数组 $a_{1},a_{2}, \dots ,a_{n}$。

请你构造长度为 $n$ 的整数数组 $b_{1},b_{2}, \dots ,b_{n}$，要求数组 $b$ 满足：

1. $b_{1}=0$ 。
2. 对于任意一对索引 $i$ 和 $j$ $\left( {1 \leq i,j \leq n} \right)$，如果 $a_{i}=a_{j}$ 则 $b_{i}=b_{j}$（注意，如果 $a_{i} \ne a_{j}$，则 $b_{i}$ 和 $b_{j}$ 相等与否随意）。
3. 对于任意索引 $i$ $\left( {i \in \left[ {1,n−1} \right]} \right)$，要么满足 $b_{i}=b_{i}+1$，要么满足 $b_{i}+1=b_{i}+1$。

请计算，一共可以构造出多少个不同的满足条件的数组 $b$。

由于答案可能很大，你只需要输出对 $998244353$ 取模后的结果。

例如，如果 $a= \left[ {1,2,1,2,3} \right]$，则一共有 $2$ 个满足条件的数组 $b$，分别是 $b= \left[ {0,0,0,0,0} \right]$ 和 $b= \left[ {0,0,0,0,1} \right]$。

输入格式

第一行包含一个整数 $n$。

第二行包含 $n$ 个整数 $a_{1},a_{2}, \dots, a_{n}$。

输出格式

一个整数，表示对 $998244353$ 取模后的结果。

数据范围

前 $3$ 个测试点满足 $2 \leq n \leq 5$。
所有测试点满足 $2 \leq n \leq 2 \times {10}^{5}$，$1 \leq a_{i} \leq {10}^{9}$。

输入样例1：

5
1 2 1 2 3

输出样例1：

2

输入样例2：

2
100 1

输出样例2：

2

输入样例3：

4
1 3 3 7

输出样例3：

4

 

解题思路

　　如果有$a_{i} = a_{j}$，那么就有$b_{i} = b_{j}$，又因为$b_{i}$到$b_{j}$是单调递增的，即$b_{i} \leq b_{i + 1} \leq \dots \leq b_{j}$，因此必然有$b_{i} = b_{i + 1} = \dots = b_{j}$。因此如果有$b_{i} = b_{j}$，那么数组$b$中区间$\left[ {i,j} \right]$中的数都相等。

　　因此最终数组$b$会被分成若干段，每一段中的数都相等。

　　因此如果有$m$段，那么一共就有$2^{m-1}$种方案。

　　因此需要把每一段区间都找出来，同时还需要把相交的区间进行合并得到一个区间，因为如果两个区间有交集，又因为每个区间中的数是一样的，因此这两个区间中的数都是一样的，因此需要把这两个区间进行合并。把剩余的区间找出来进行合并后，就会得到上图的结果。

　　因此我们需要开一个哈希表来记录每一个数的出现的最左边的位置和最右边的位置，如果中这个数再次出现过，就更新最右边的位置。这题的数据故意卡了std::unordered_map，因此需要对哈希表初始化大小。

　　当时写这题的时候推方案数那里推错了，导致没做出来，不过即使做出来的估计也被std::unordered_map卡了。

　　AC代码如下：

#include <cstdio>
#include <unordered_map>
#include <algorithm>
using namespace std;

typedef pair<int, int> PII;

const int N = 2e5 + 10, mod = 998244353;

unordered_map<int, PII> mp(N);  // 初始化大小
PII a[N];
int sz;

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        int val;
        scanf("%d", &val);
        if (mp[val] == PII(0, 0)) mp[val] = {i, i}; // 这个数第一次出现
        else mp[val].second = i;    // 更新右端点
    }
    
    for (auto &it : mp) {
        a[sz++] = it.second;    // 把区间都存到数组中，下面进行区间合并
    }
    sort(a, a + sz);
    
    // 区间合并过程
    int cnt = 0;
    for (int i = 0, l = -1, r = -1; i < sz; i++) {
        if (a[i].first > r) {
            cnt++;
            l = a[i].first, r = a[i].second;
        }
        else {
            r = max(r, a[i].second);
        }
    }
    
    // 方案数为2^(cnt-1)
    int ret = 1;
    for (int i = 0; i < cnt - 1; i++) {
        ret = ret * 2ll % mod;
    }
    printf("%d", ret);
    
    return 0;
}

　　后面自己写的时候就不用std::unordered_map了，直接手写离散化，也是可以过的，AC代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

typedef pair<int, int> PII;

const int N = 2e5 + 10, mod = 998244353;

int a[N], xs[N], sz;
PII h[N];

int find(int x) {
    int l = 0, r = sz - 1;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    
    return l;
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
        xs[sz++] = a[i];
    }
    
    sort(xs, xs + sz);
    sz = unique(xs, xs + sz) - xs;
    
    for (int i = 1; i <= n; i++) {
        int idx = find(a[i]);
        if (h[idx] == PII(0, 0)) h[idx] = {i, i};
        else h[idx].second = i;
    }
    
    sort(h, h + sz);
    
    int cnt = 0;
    for (int i = 0, l = -1, r = -1; i < sz; i++) {
        if (h[i].first > r) {
            cnt++;
            l = h[i].first, r = h[i].second;
        }
        else {
            r = max(r, h[i].second);
        }
    }
    
    int ret = 1;
    for (int i = 0; i < cnt - 1; i++) {
        ret = (ret << 1) % mod;
    }
    printf("%d", ret);
    
    return 0;
} 

　　更新：后面发现当时没想到手写哈希表，其实手写哈希表会比离散化快很多（其实本质也是哈希映射的思想），而离散化的时间复杂度会多一个$O \left( log~n \right)$。

　　手写哈希表的AC代码如下：

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

typedef pair<int, int> PII;

const int N = 2e5 + 10, M = 1e6 + 3, mod = 998244353;

int a[N];
int h[M];
PII p[M], seg[N];
int sz;

int find(int val) {
    int t = val % M;
    while (h[t] != -1 && h[t] != val) {
        if (++t == M) t = 0;
    }
    
    return t;
}

int main() {
    int n;
    scanf("%d", &n);
    
    memset(h, -1, sizeof(h));
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
        int t = find(a[i]);
        if (h[t] == -1) {
            h[t] = a[i];
            p[t] = {i, i};
        }
        else {
            p[t].second = i;
        }
    }
    
    for (int i = 1; i <= n; i++) {
        int t = find(a[i]);
        seg[sz++] = p[t];
    }
    
    sort(seg, seg + sz);
    
    int cnt = 0;
    for (int i = 0, l = -1, r = -1; i < sz; i++) {
        if (seg[i].first > r) {
            cnt++;
            l = seg[i].first, r = seg[i].second;
        }
        else {
            r = max(r, seg[i].second);
        }
    }
    
    int ret = 1;
    for (int i = 0; i < cnt - 1; i++) {
        ret = ret * 2ll % mod;
    }
    printf("%d", ret);
    
    return 0;
}

 

参考资料

　　AcWing 4412. 构造数组（AcWing杯 - 周赛）：https://www.acwing.com/video/3836/