Wi Know（线段树）

Wi Know（线段树）

【传送门】

题意:
在字符串中找形如ABAB的子序列，要求AB字典序最小。

思路：
这道题最重要的性质：如果存在形如ABAB的子序列，那么一定可以找到一个A1B1A2B2，满足A1A2之间没有其它A，B1B2之间没有其它B。

先预处理每个字符右边相同大小的位置。扫一遍数组，每次扫的时候查询这次和下次之间的最小值（因为能在线段树中出现一定是成对的），然后更新答案，再将下一个右边相同大小的放入线段树中（保证了线段树中是成对出现的）。

比如：
跑1的时候把3放进线段树里。
然后跑2的时候就查询2~4里面的最小值3，所以1(a)2(b)3(a)4(b).

刚开始想用面向对象写个线段树类，结果run time了，还是老老实实用函数吧QAQ。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 5e5 + 5;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
int a[maxn], nexts[maxn], r[maxn], n;

int tree[maxn * 4];
int lz[maxn * 4];  // 延迟标记
void init();
// 区间更新，lr为更新范围，LR为线段树范围，add为更新值
void push_down(int root, int l,
               int r);  //懒标记下传，若需取模，懒标记均可取模
void update_range(int root, int l, int r, int L, int R, int add);
int query_range(int root, int L, int R, int l, int r);

void push_down(int root, int l, int r) {
    if (lz[root]) {
        int mid = (l + r) >> 1;
        lz[root << 1] += lz[root];
        lz[root << 1 | 1] += lz[root];
        tree[root << 1] += lz[root];
        tree[root << 1 | 1] += lz[root];
        lz[root] = 0;
    }
}

void init() {  //初始化
    memset(tree, INF, sizeof(tree));
    memset(lz, 0, sizeof(lz));
}

// 区间更新，lr为更新范围，LR为线段树范围，add为更新值
void update_range(int root, int l, int r, int L, int R, int add) {
    push_down(root, L, R);  //应放在最开始，否则会出错
    if (l <= L && r >= R) {
        lz[root] += 1LL * add;
        tree[root] = add;  //更新方式
        return;
    }
    int mid = (L + R) >> 1;
    if (mid >= l) update_range(root << 1, l, r, L, mid, add);
    if (mid < r) update_range(root << 1 | 1, l, r, mid + 1, R, add);
    tree[root] = min(tree[root << 1], tree[root << 1 | 1]);  //可取模
}

// 区间查找
int query_range(int root, int L, int R, int l, int r) {
    push_down(root, L, R);  //应放在最开始，否则会出错
    if (l <= L && r >= R) return tree[root];
    int mid = (L + R) >> 1;
    int val = 0x3f3f3f3f;
    if (mid >= l)
        val = min(val, query_range(root << 1, L, mid, l, r));  //可取模
    if (mid < r)
        val = min(val, query_range(root << 1 | 1, mid + 1, R, l, r));  //可取模
    return val;
}

int main() {
    init();
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", a + i);
    for (int i = n; i >= 1; --i)  //处理每个字符右边一个的位置
    {
        nexts[i] = r[a[i]];
        r[a[i]] = i;
    }
    P ans(INF, INF);
    for (int i = 1; i <= n; ++i) {
        if (!nexts[i]) continue;
        int v = query_range(1, 1, n + 1, i + 1,
                            nexts[i]);  //在当前位置与下一个位置之间查询最小值
        ans = min(ans, make_pair(v, a[i]));
        update_range(1, nexts[i], nexts[i], 1, n + 1,
                     a[i]);  //把当前字符下一个更新进线段树
    }
    if (ans.first == INF || ans.second == INF)
        puts("-1");
    else
        printf("%d %d\n", ans.first, ans.second);
    return 0;
}

面向对象，线段树类（只过了17个点），挂个代码，以后熟练后再修改。

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 5e5 + 5;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
int a[maxn], nexts[maxn], r[maxn], n;

class Tree {
   public:
    int tree[maxn * 4];
    int lz[maxn * 4];  // 延迟标记
    void init();
    // 区间更新，lr为更新范围，LR为线段树范围，add为更新值
    void push_down(int root, int l,
                   int r);  //懒标记下传，若需取模，懒标记均可取模
    void update_range(int root, int l, int r, int L, int R, int add);
    int query_range(int root, int L, int R, int l, int r);
};

void Tree::push_down(int root, int l, int r) {
    if (lz[root]) {
        int mid = (l + r) >> 1;
        lz[root << 1] += lz[root];
        lz[root << 1 | 1] += lz[root];
        tree[root << 1] += lz[root];
        tree[root << 1 | 1] += lz[root];
        lz[root] = 0;
    }
}

void Tree::init() {  //初始化
    memset(tree, INF, sizeof(tree));
    memset(lz, 0, sizeof(lz));
}

// 区间更新，lr为更新范围，LR为线段树范围，add为更新值
void Tree::update_range(int root, int l, int r, int L, int R, int add) {
    push_down(root, L, R);  //应放在最开始，否则会出错
    if (l <= L && r >= R) {
        lz[root] += 1LL * add;
        tree[root] = add;  //更新方式
        return;
    }
    int mid = (L + R) >> 1;
    if (mid >= l) update_range(root << 1, l, r, L, mid, add);
    if (mid < r) update_range(root << 1 | 1, l, r, mid + 1, R, add);
    tree[root] = min(tree[root << 1], tree[root << 1 | 1]);  //可取模
}

// 区间查找
int Tree::query_range(int root, int L, int R, int l, int r) {
    push_down(root, L, R);  //应放在最开始，否则会出错
    if (l <= L && r >= R) return tree[root];
    int mid = (L + R) >> 1;
    int val = 0x3f3f3f3f;
    if (mid >= l)
        val = min(val, query_range(root << 1, L, mid, l, r));  //可取模
    if (mid < r)
        val = min(val, query_range(root << 1 | 1, mid + 1, R, l, r));  //可取模
    return val;
}

int main() {
    Tree* tree1 = new Tree();
    tree1->init();
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", a + i);
    for (int i = n; i >= 1; --i)  //处理每个字符右边一个的位置
    {
        nexts[i] = r[a[i]];
        r[a[i]] = i;
    }
    P ans(INF, INF);
    for (int i = 1; i <= n; ++i) {
        if (!nexts[i]) continue;
        int v = tree1->query_range(
            1, 1, n + 1, i + 1,
            nexts[i]);  //在当前位置与下一个位置之间查询最小值
        ans = min(ans, make_pair(v, a[i]));
        tree1->update_range(1, nexts[i], nexts[i], 1, n + 1,
                            a[i]);  //把当前字符下一个更新进线段树
    }
    if (ans.first == INF || ans.second == INF)
        puts("-1");
    else
        printf("%d %d\n", ans.first, ans.second);
    delete tree1;
    return 0;
}