Codeforces Round 879 (Div. 2) A-E

最新推荐文章于 2024-06-16 22:47:03 发布

a1214034447

最新推荐文章于 2024-06-16 22:47:03 发布

阅读量206

点赞数

文章标签：算法数据结构思维题

本文链接：https://blog.csdn.net/a1214034447/article/details/131590314

版权

题目链接：Dashboard - Codeforces Round 879 (Div. 2) - Codeforces

A - Unit Array

解题思路：保证-1个数是偶数，1的个数不小于-1的个数即可。

#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6 + 10;
const int mod = 1e9 + 7;
using ll = long long;

int a[mx];

int main() {
	int t;
	int n;
	scanf("%d", &t);
	while (t--) {
		scanf("%d", &n);
		int pos = 0, neg = 0;
		for (int i=1;i<=n;i++) {
			scanf("%d", a+i);
			if (a[i] == 1)
				pos++;
			else
				neg++;
		}
		int ans = 0;
		if (neg & 1)
			ans++, neg--, pos++;
		int temp = max(0, (n+1)/2 - pos);
		printf("%d\n", ans + temp + (temp&1));
	}
    return 0;
}

B - Maximum Strength

解题思路：对第一个数补充前导0，然后找到他们第一个不相同的数的位置，就可以把两个数设置成abcd..x00000,abcd..y99999,x > y，abcd..x00000>abcd..y99999。这样得到的答案就是最大的。

#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6 + 10;
const int mod = 1e9 + 7;
using ll = long long;

int a[mx];

int main() {
	int t;
	int n;
	scanf("%d", &t);
	while (t--) {
		string s1;
		string s2;
		cin >> s1 >> s2;
		int len0 = s1.length();
		int len = s2.length();
		if (len > len0)
			s1 = string(len-len0, '0') + s1;

		int i = 0;
		while (i < len && s1[i] == s2[i]) {
			i++;
		}
		printf("%d\n", max((len-i-1) * 9, 0) + (i==len?0:s2[i]-s1[i]));
	}
    return 0;
}

C - Game with Reversing

解题思路：我们只要考虑两种情况，一种是bob翻了奇数次，一种是偶数次。两个取最小就行了。bob翻了奇数次就是要一个字符串反转后在比较。

#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
const int mod = 1e9 + 7;
using ll = long long;


int main() {
	auto get_ans = [](string &s1, string &s2) {
		int ans = 0;
		for (int i=0; i<s1.length(); i++) {
			if (s1[i] != s2[i])
				ans++;
		}
		return ans;
	};
	
	int t;
	int n;
	scanf("%d", &t);
	while (t--) {
		int n;
		scanf("%d", &n);
		string s1;
		string s2;
		cin >> s1 >> s2;
		int ans = 1e9;
		int temp = get_ans(s1, s2);
		ans = min(ans, temp + temp / 2 * 2);
		reverse(s1.begin(), s1.end());
		temp = get_ans(s1, s2);
		ans = min(ans, max(2, 2 * temp - (temp % 2 == 0)));
		printf("%d\n", ans);
	}
    return 0;
}

D - Survey in Class

解题思路：答案肯定是某一个区间的一段长度*2，那么枚举每一个区间他的最大值是多少。那么就是要去看这个区间和最左边的区间的交集和最右边区间的交集以及区间被包含的情况。以下提供一个比较复杂的解决思路，先考虑区间包含最大的情况，那么一个区间被另一个区间包含，肯定是找最大的能够包含他的那个区间。然后剩下的左边和右边的情况值需要看最右边的区间和最左边的区间即可。

#include <bits/stdc++.h>
using namespace std;
#define k_m (k / 2 + 1)
#define inf 0x3f3f3f3f
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid + 1, r

const int mx = 1e5 + 10;
const int mod = 1e9 + 7;

struct node {
    int l;
    int r;
    node (int ll, int rr): l(ll), r(rr) {} 
    node () {}
    bool operator < (const node &A) const {
        if (l == A.l)
            return r > A.r;
        return l < A.l;
    }
}a[mx];

int b[mx];

int maxx[mx<<3];

void build(int rt, int l, int r)
{
    if (l == r) {
        maxx[rt] = 0;
        return ;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    maxx[rt] = max(maxx[rt<<1], maxx[rt<<1|1]);
}

void update(int rt, int l, int r, int p, int v)
{
    if (l == r) {
        maxx[rt] = max(maxx[rt], v);
        return ;
    }
    int mid = (l + r) >> 1;
    if (p <= mid)
        update(lson, p, v);
    else    
        update(rson, p, v);
    maxx[rt] = max(maxx[rt<<1], maxx[rt<<1|1]);
}

int query(int rt, int l, int r, int L, int R)
{
    if (L <= l && r <= R) {
        return maxx[rt];
    }
    int mid = (l + r) >> 1;
    if (L <= mid && R > mid)
        return max(query(lson, L, R), query(rson, L, R));
    if (L <= mid)
        return query(lson, L, R);
    return query(rson, L, R);
}

int get_rk(int v, int n)
{
    return lower_bound(b+1, b+1+n, v) - b;
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--) {
        int n, m;
        scanf("%d%d", &n, &m);
        for (int i=1;i<=n;i++) {
            scanf("%d%d", &a[i].l, &a[i].r);
            b[i] = a[i].r;
        }
        sort(b + 1, b + 1 + n);
        build(1, 1, n);
        sort(a + 1, a + 1 + n);
        update(1, 1, n, get_rk(a[1].r, n), a[1].r-a[1].l+1);
        set <int> st;
        st.insert(a[1].r);
        int ans = 0;
        for (int i=2;i<=n;i++) {
            int temp = 2 * (query(1, 1, n, get_rk(a[i].r, n), n) - (a[i].r - a[i].l + 1));
            ans = max(ans, temp);
            update(1, 1, n, get_rk(a[i].r, n), a[i].r - a[i].l + 1);

            int r = *st.begin();
            ans = max(ans, 2 * (a[i].r - a[i].l + 1 - max(0, r - a[i].l + 1)));
            st.insert(a[i].r);
        }

        st.clear();
        for (int i=n; i; i--) {
            if (st.size()) {
                int l = *st.rbegin();
                ans = max(ans, 2 * (a[i].r - a[i].l + 1 - max(0, a[i].r - l + 1)));
            }
            st.insert(a[i].l);
        }
        printf("%d\n", ans);
    }
    return 0;
}

下面提供精简版答案，这个需要去证明为什么包含的一定是最大值减去最小值是最优答案即可。

#include <bits/stdc++.h>
using namespace std;
#define k_m (k / 2 + 1)
#define inf 0x3f3f3f3f
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid + 1, r

const int mx = 1e5 + 10;
const int mod = 1e9 + 7;

struct node {
    int l;
    int r;
    node (int ll, int rr): l(ll), r(rr) {} 
    node () {}
    bool operator < (const node &A) const {
        if (l == A.l)
            return r > A.r;
        return l < A.l;
    }
}a[mx];


int main()
{
    int t;
    scanf("%d", &t);
    while (t--) {
        int n, m;
        scanf("%d%d", &n, &m);
        int len1 = 1e9, len2 = -1e9;
        int maxl = -1e9, minr = 1e9;
        for (int i=1;i<=n;i++) {
            scanf("%d%d", &a[i].l, &a[i].r);
            len1 = min(len1, a[i].r - a[i].l + 1);
            len2 = max(len2, a[i].r - a[i].l + 1);
            maxl = max(maxl, a[i].l);
            minr = min(minr, a[i].r);
        }

        int ans = (len2 - len1);
        for (int i=1;i<=n;i++) {
        	ans = max(ans, min(a[i].r - a[i].l+1, max(a[i].r-minr, maxl-a[i].l)));
		}
        printf("%d\n", ans*2);
    }
    return 0;
}

E - MEX of LCM

解题思路：可以简单得到证明，答案肯定是比较小的（相对于1e9来说）。因为答案肯定不会超过第3e5+1个质数，那么质数一般出现频率是大于1/10的，所以答案大概可以评估出来是3e6左右（可能更小）。所以我们暴力去看所有区间的lcm，并且超过3e6不要，重复的也不要。这样就可以了。

#include <bits/stdc++.h>
using namespace std;
#define k_m (k / 2 + 1)
#define inf 0x3f3f3f3f
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid + 1, r
const int mx = 3e5 + 10;
const int mod = 1e9 + 7;
using ll = long long;

int a[mx];

int main()
{
    int t;
    scanf("%d", &t);
    while (t--) {
        int n;
        int maxv = 6e5;
        scanf("%d", &n);
        for (int i=1;i<=n;i++) {
            scanf("%d", a+i);
        }
        set <int> st, now;
        for (int i=1;i<=n;i++) {
            set <int> temp_st;
            for (int val: now) {
                ll temp = 1ll * val * a[i] / __gcd(val, a[i]);
                if (temp > maxv)
                    continue;
                temp_st.insert(temp);
                st.insert(temp);
            }
            temp_st.insert(a[i]);
            st.insert(a[i]);
            now.swap(temp_st);
        }
        int ans = 1;
        while (st.count(ans)) ans++;
        printf("%d\n", ans);
    }
    return 0;
}

a1214034447

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round 879 (Div. 2) A-E

解题思路：答案肯定是某一个区间的一段长度*2，那么枚举每一个区间他的最大值是多少。那么就是要去看这个区间和最左边的区间的交集和最右边区间的交集以及区间被包含的情况。以下提供一个比较复杂的解决思路，先考虑区间包含最大的情况，那么一个区间被另一个区间包含，肯定是找最大的能够包含他的那个区间。解题思路：对第一个数补充前导0，然后找到他们第一个不相同的数的位置，就可以把两个数设置成abcd..x00000,abcd..y99999,x > y，abcd..x00000>abcd..y99999。
复制链接

扫一扫