每日一题

4.29

51nod 2607 摧毁数组

1.0 秒 131,072.0 KB

有一个由n个非负整数组成的数列 a1,a2,a3…an。现在将要一个一个摧毁这个数列中的数。同时，有一个由 1 到 n 组成的序列来告诉你每个数被摧毁的时间顺序。

每当一个元素被摧毁时，你需要找到这个当前数列中的未被摧毁的数组成的和最大的连续子序列，另外，如果当前剩余的序列是空的的话，最大和就是0。

第一个样例：

1.第三个数被删除了，现在的数列是 1 3 O 5 ，答案为5由一个数5组成。

2.第四个数被删除了，现在的数列是 1 3 O O ，答案为4由两个数1和3组成。

3.第一个数被删除了，现在的数列是 O 3 O O ，答案为3由一个数3组成。

4.第二个数被删除了，现在的数列是O O O O，答案为0没有数字组成。

输入
第一行包含一个整数n (1 <= n <= 100000) , 代表数列的长度。
第二行包含n个整数 ,第i个数为a[i].0<=a[i]<=1000000000。
第三行包含一个由1到n的整数组成的序列，代表数被摧毁的顺序。
输出
输出有n行，第i行包含一个整数表示在第i个操作已经执行完之后，数列中连续的最大和。
输入样例
4
1 3 2 5
3 4 1 2
输出样例
5
4
3
0

因为如果正向模拟的话，是一个区间分裂问题，不是很好操作，所以我们可以反向思考一下这个过程，将其变为一个区间合并的问题，这样就可以用并查集来处理这个问题了。

具体操作的话，就是每次向空位插入一个数（最后删除的最先插入），如果这个插入的数的位置的左边一位或者右边一位已经有数了的话，就说明当前插入的数可以和之前已经有的区间进行合并，每次取区间和的最大值。这些区间都使用用并查集来维护。

代码：

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

const int N = 1e5 + 10, M = 5e4 + 10;
const int inf = 0x3f3f3f3f;

typedef long long ll;
int n, m;
ll a[N], wz[N];
int p[N];
ll sum[N];
int b[N];

int find(int x) {
	int son = x, tem;
	while(p[x] != x) x = p[x];
	while(son != x) {
		tem = p[son];
		p[son] = x;
		son = tem;
	}
	return x;
}

void solve() {
	ll mmax = 0;
	vector<ll> ans;
	cin >> n;
	for(int i = 1; i <= n; ++ i) cin >> a[i], p[i] = i, sum[i] = a[i];
	for(int i = 1; i <= n; ++ i) cin >> b[i];
	for(int i = n; i >= 1; -- i) {
		wz[b[i]] = 1;
		int r1 = find(b[i]); 
		if(wz[b[i] + 1]) {
			int r2 = find(b[i] + 1);
			p[r2] = r1;
			sum[r1] += sum[r2];
		}if(wz[b[i] - 1]) {
			int r2 = find(b[i] - 1);
			p[r2] = r1;
			sum[r1] += sum[r2];
		}
		ans.push_back(mmax);
		mmax = max(mmax, sum[r1]);
	}
	reverse(ans.begin(), ans.end());
	for(int i = 0; i < ans.size(); ++ i) cout << ans[i] << endl;
}

int main() {
    solve();
    return 0;
}

5.3

51nod 1204 Parity

你的朋友写下一串包含1和0的串让你猜，你可以从中选择一个连续的子串（例如其中的第3到第5个数字）问他，该子串中包含了奇数个还是偶数个1，他会回答你的问题，然后你可以继续提问…

你怀疑朋友的答案可能有错，或说同他之前的答案相互矛盾，例如：1 - 2 奇数，3 - 4 奇数，那么可以确定1 - 4 一定是偶数，如果你的朋友回答是奇数，就产生了矛盾。给出所有你朋友的答案，请你找出第一个出现矛盾的答案。

Input
第1行：2个数N, Q，N为串的长度，Q为询问的数量。（2 <= N <= 100000, 2 <= Q <= 50000)
第2 - Q + 1行：每行包括两个数以及一个字符串来描述朋友的回答，2个数中间用空格分隔，分别表示区间的起点和终点，后面的字符为"even"或"odd"，表示朋友的答案。

Output
输出1个数，表示朋友的答案中第一个错误答案的位置，如果所有答案均不矛盾，则输出-1。

Input示例
10 5
1 2 even
3 4 odd
5 6 even
1 6 even
7 10 odd

Output示例
4

题解:
第一次遇到这种题目，大概无从下手，实际上这类题目的标准方法是并查集。
我们定义前缀和s[i]表示1~i的和,那么s[b] - sum[a-1]就是a ~ b的和。
如果a ~ b当中有奇数个1的话，s[a - 1]和s[b]的奇偶性就一定是相反的，反之如果a ~ b当中有偶数个1的话，s[a - 1]和s[b]的奇偶性就是相同的，也就是说对于每两个前缀和s[a-1]和s[b]来说，我们都需要使用两个集合（对应两种性质）来维护，以便我们确认这两个前缀和是否是在一个集合当中，如果在一个集合当中，就说明a ~ b之间一定只有偶数个1.

使用种类并查集
一些细节：我们可以将并查集数组的0~n-1个点作为原始部分，n ~ 2*n-1的点作为集合部分，如对于一个区间a ~ b来说，我们需要维护的就是p[a-1],p[b],p[a-1+n],p[b+n]这四个点之间的关系，如果p[a-1]和p[b+n]在同一个集合中且 p[b],p[a-1+n]也在同一个集合中的话，说明s[a-1]和s[b]处于两个不同的集合当中；而如果p[a-1]和p[a - 1+n]在同一个集合中且 p[b],p[b+n]也在同一个集合中的话就说明s[a-1]和s[b]处于两个相同的集合当中。
     上面的思路很像一个类二分图，0~n-1为左边点，n ~ 2*n-1为右边点，如果左边点集里的点与右边点集里的点右边的话，就说明他们在两个不同的集合里。

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

const int N = 3e5 + 100;

const int inf = 0x3f3f3f3f;

int n, m;
int p[N];

void init() {
    for(int i = 0; i <= 2 * (n + 1); ++ i) p[i] = i;
}

int find(int x) {
    int son = x, tem;
    while(p[x] != x) x = p[x];
    while(son != x) {
        tem = p[son];
        p[son] = x;
        son = tem;
    }
    return x;
}

void solve() {
    cin >> n >> m;
    init();
    for(int i = 1; i <= m; ++ i) {
        int a, b;
        string c;
        cin >> a >> b >> c;
        int ra1 = find(a - 1), ra2 = find(a - 1 + n);
        int rb1 = find(b), rb2 = find(b + n);
        if(c == "even") {
            if(ra1 == rb2 && rb1 == ra2) {
                cout << i << endl;
                return ;
            }
            p[ra1] = rb1;
            p[ra2] = rb2;
        }
        else {
            if(ra1 == rb1 && rb2 == ra2) {
                cout << i << endl; 
                return;
            }
            p[ra1] = rb2;
            p[ra2] = rb1;
        }
    }
    cout << -1 << endl;
}

int main() {
    solve();
    return 0;
}