Codeforces Round #854 by cybercats (Div. 1 + Div. 2)

A. Recent Actions

给出n个格子，从上到下是1~n，其他的n+1~。。。不在格子内。给出m个操作，若该操作的数字不在格子内，那就将它拿到格子的第一个位置，同时格子第n个位置的数被挤下去；若操作的数字在格子内，仅将它拿到格子第一个位置，问原来数组的每个数什么时候被挤下去，若不会被挤下去，则输出-1。

思路：模拟，记录一下时间即可。

AC Code：

#include 

typedef long long ll;
const int N = 1e5 + 5;
int t, n, m;
int ans[N], a[N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> m;
        memset(ans, -1, sizeof(ans));
        for(int i = 1; i <= m; i ++) {
            std::cin >> a[i];
        }
        int cnt = n, pos = 0;
        std::map mp;
        for(int i = 1; i <= m; i ++) {
            if(!mp[a[i]])
                ans[cnt] = ++ pos, cnt --, mp[a[i]] ++;
            else
                pos ++;
        }
        for(int i = 1; i <= cnt; i ++) {
            if(!ans[i])
                ans[i] = -1;
        }
        for(int i = 1; i <= n; i ++) {
            std::cout << ans[i] << " \n"[i == n];
        }
    }
    return 0;
}

os：a题就搞这么难搞的题面，离大谱

B. Equalize by Divide

给出一个数组a，每次可以选择两个位置的数，按照上述方式赋值，问是否可以使得数组中所有的数都变为相同的，输出操作方式，且操作数不能大于30n。

思路：每次选择最小的数，用其他数除以这个最小的数，每次更新最小的数；若数组中存在1且不全为1，则一定不可以。

代码看看就好啦，写的一堆什么东西我也不知道。

AC Code：

#include 

typedef long long ll;
typedef std::pair PII;
const int N = 105;
int t, n;
int a[N];

struct node {
    int num, pos;
} e[N];

bool cmp(node a, node b) {
    if(a.num < b.num) return true;
    else return false;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n;
        int cnt = 0, min = 1e9 + 5, tot = 0;
        for(int i = 1; i <= n; i ++) {
            std::cin >> a[i];
            e[++tot] = {a[i], i};
            min = std::min(min, a[i]);
            if(a[i] == 1) cnt ++;
        }
        if(cnt && cnt != n) {
            std::cout << -1 << '\n';
            continue;
        }
        std::sort(e + 1, e + 1 + n, cmp);
        int cc = e[1].pos;
        std::vector vec;
        while(e[1].num != e[n].num && e[1].num != 1) {
            for(int i = 1; i <= n; i ++) {
                if(e[i].num == min) continue;
                while(e[i].num > min) {
                    int res = e[i].num % min;
                    e[i].num /= min;
                    if(res) e[i].num ++;
                    vec.push_back({e[i].pos, cc});
                }
                if(e[i].num < min) {
                    min = e[i].num;
                    cc = e[i].pos;
                } 
                if(min == 1) break;
            }
            std::sort(e + 1, e + 1 + n, cmp);
        }
        std::sort(e + 1, e + 1 + n, cmp);
        if(e[1].num != e[n].num) {
            std::cout << -1 << '\n';
            continue;
        }
        std::cout << vec.size() << '\n';
        for(auto [x, y] : vec)
            std::cout << x << ' ' << y << '\n';
    }
    return 0;
}

C. Double Lexicographically Minimum

给出一个字符串，重新排列这个字符串，使得排列后的字符串和它的逆序的字典序最大值最小。

思路：容易想到，对于成对的同一字母来说，最好的是前面一个，后面一个，而且是字典序比较小的在外围更优；如果遇到奇数个的字母呢？可以分以下情况讨论：只剩下一个字母，那一定是放在最中间；剩下两种字母，其中一个只剩一个，且这一个是字典序较小的，那就尽可能将这个最小的尽可能放在中间位置；若剩下的大于两种字母，若要保证这个最大值最下，那应该把现存的最下的放在后面，让它成为某个字符串和它的逆序字典序中较大的那个，然后剩下的按照顺序加到前面就可以了。

AC Code：

#include 

typedef long long ll;
const int N = 105;
int t, n;
int cnt[30];
std::string s;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> s;
        memset(cnt, 0, sizeof(cnt));
        for(int i = 0; i < s.length(); i ++) {
            cnt[s[i] - 'a'] ++;
        }
        std::string l = "", r = "";
        for(int i = 0; i < 26; i ++) {
            while(cnt[i] > 1) {
                l += (char)('a' + i);
                r += (char)('a' + i);
                cnt[i] -= 2;
            }
            if(cnt[i]) break;
        }
        int cc = 0;
        for(int i = 0; i < 26; i ++) {
            if(cnt[i]) cc ++;
        }
        if(cc <= 2) {
            for(int i = 25; i >= 0; i --) {
                while(cnt[i] > 1) {
                    l += (char)('a' + i);
                    r += (char)('a' + i);
                    cnt[i] -= 2;
                }
                if(cnt[i])
                    l += (char)('a' + i);
            }
        }
        else {
            int flag = true;
            for(int i = 0; i < 26; i ++) {
                while(cnt[i]) {
                    if(flag)
                        r += (char)('a' + i), cnt[i] --, flag = 0;
                    else
                        l += (char)('a' + i), cnt[i] --;
                }

            }
        }
        reverse(r.begin(), r.end());
        std::cout << l << r << '\n';
    }
    return 0;
}

D1. Hot Start Up (easy version)

有两个cpu，可以处理程序，只有前一个程序处理完才可以处理下一个，如果上一个和当前处理的程序相同，则耗时是hot[i]否则就是cold[i]，问所需最少的时间。

思路：设f[i][j]是处理到第i个，以j为结尾所用的最少时间，具体看代码：

AC Code：

#include 

typedef long long ll;
#define INF 0x3f3f3f3f3f3f3f3f
const int N = 5e3 + 5;
int t, n, k;
ll a[N], b[N], c[N], e[N];
ll f[N][N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> k;
        // memset(f, INF, sizeof(f));
        for(int i = 0; i <= n; i ++) {
            a[i] = 0, b[i] = 0, c[i] = 0;
            for(int j = 0; j <= k; j ++)
                f[i][j] = INF;
        }
        for(int i = 1; i <= n; i ++) {
            std::cin >> a[i];
        }
        for(int i = 1; i <= k; i ++) {
            std::cin >> b[i];
        }
        for(int i = 1; i <= k; i ++) {
            std::cin >> c[i];
        }
        //f[i][j]进行到第i个，以j结尾的最小答案
        f[0][0] = 0;
        for(int i = 1; i <= n; i ++) {
            if(a[i] == a[i - 1]) {
                for(int j = 0; j <= k; j ++) {
                    f[i][j] = std::min(f[i][j], f[i - 1][j] + c[a[i]]);
                }
            }
            else {
                for(int j = 0; j <= k; j ++) {
                    f[i][j] = std::min(f[i][j], f[i - 1][j] + b[a[i]]);
                }
            }
            f[i][a[i]] = std::min(f[i][a[i]], f[i - 1][a[i]] + c[a[i]]);
            for(int j = 0; j <= k; j ++) {
                f[i][a[i - 1]] = std::min(f[i][a[i - 1]], f[i][j]);
            }
        }
        ll ans = INF;
        for(int i = 0; i <= k; i ++)
            ans = std::min(ans, f[n][i]);
        std::cout << ans << '\n';
    }
    return 0;
}