【NOIP】最长序列

Problem

问题描述

有一种序列按照如下定义：
1．1在这个序列中；
2．这个序列是按照从小到大的顺序排列的；
3．如果一个数i出现在这个序列中，那么2i+1和4i+5也一定存在在这个序列中。
现在要求你写一个程序，将这个序列前n个数连接成一个长串，并且在这个基础上，从得到的长串中删除m个数字，使得这个长串的字典序最大。

输入

输入文件一行两个整数n，m。

输入样例：
4 2

输出

输出文件2行，第一行是未删除数字之前的原串。第二行是删除数字之后的数字串。

输出样例：
1379
79

数据范围

对于30%的数据，n，m ≤ 10000；
对于100%的数据，n ≤ 30000；0 ≤ m ≤ 50000。

Solution

用一个堆构造整个数列
然用一个链表和两个指针l和r完成删除
其中l和r删除后的数列中相邻的两个数
若a[l]

#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
#define red(i, a, b) for(int i = (a); i >= (b); i--)
#define ll long long

const int inf = 1000000;
const int N = 400000;
map<int, int> hash;
priority_queue <int, vector<int>, greater<int> > q;
struct node{
    int last, num, nxt;
}lstn[N];
int n, m, tail;
int del[N], lst[N];

int main() {
    freopen("number.in", "r", stdin);
    freopen("number.out", "w", stdout);

    scanf("%d%d", &n, &m);
    memset(lst, 0, sizeof(lst));
    memset(lstn, 0, sizeof(lstn));
    q.push(1);
    tail = 0;
    while(tail < n) {
        int x = q.top(); q.pop();
        lst[++tail] = x;
        int x_1 = x * 2 + 1, x_2 = x * 4 + 5;
        if (!hash[x_1]) {
            q.push(x_1);
            hash[x_1] = 1;
        }
        if (!hash[x_2]) {
            q.push(x_2);
            hash[x_2] = 1;
        }
    }
    tail = 0;
    rep(i, 1, n) {
        int x = lst[i];
        int number[20], nn = 0;
        while(x) {
            number[++nn] = x % 10;
            x /= 10;
        }
        red(j, nn, 1) lstn[++tail].num = number[j]; 
    }
    rep(i, 1, tail) printf("%d", lstn[i].num);
    printf("\n");
    lstn[1].last = -1;
    lstn[1].nxt = 2;
    rep(i, 2, tail) {
        lstn[i].last = i - 1;
        lstn[i].nxt = i + 1;
    }
    lstn[tail + 1].num = inf;
    lstn[tail + 1].last = tail;
    lstn[tail + 1].nxt = -1;
    int xm = 0, l = 1, r = 2;
    memset(del, 0, sizeof(del));
    while(xm < m) {
        if (lstn[l].num < lstn[r].num) {
            del[l] = 1;
            if (lstn[l].last == -1) {
                lstn[r].last = -1;
                l = r;
                r = lstn[r].nxt;
            }else{
                lstn[lstn[l].last].nxt = r;
                lstn[r].last = lstn[l].last;
                l = lstn[l].last;
            }
            xm++;
        }else {
            r = lstn[r].nxt;
            l = lstn[l].nxt;
        }
    }
    rep(i, 1, tail) if (!del[i]) printf("%d", lstn[i].num);
    printf("\n");
    return 0;
}

End.