A - Vasya And Password
题意:
给你一个字符串(S)，可能包含小写字母或大写字母或数字。让你改变其中的一些字符，使得改变后的字符串包含小写字母、大写字母和数字。输出改变后的字符串。保证有解。
题解:
扫描一遍，找出小写字母、大写字母和数字出现的第一个位置。然后再重新扫一遍，如果说(i)不是小写字母、大写字母或数字出现的第一个位置，就可以把(S_i)改变成没有出现过的一种字符。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
#define is_lower(a) (a >= 'a' && a <= 'z')
#define is_upper(a) (a >= 'A' && a <= 'Z')
#define is_digit(a) (a >= '0' && a <= '9')
void solve() {
string s;
cin >> s;
int n = s.length();
int pos_lower = -1, pos_upper = -1, pos_dig = -1;
for (int i = 0; i < n; ++i) {
if (is_lower(s[i])) {
pos_lower = i;
break;
}
}
for (int i = 0; i < n; ++i) {
if (is_upper(s[i])) {
pos_upper = i;
break;
}
}
for (int i = 0; i < n; ++i) {
if (is_digit(s[i])) {
pos_dig = i;
break;
}
}
for (int i = 0; i < n; ++i) {
if (i == pos_lower) continue;
if (i == pos_upper) continue;
if (i == pos_dig) continue;
if (pos_lower == -1) s[i] = 'a', pos_lower = 0;
else if (pos_upper == -1) s[i] = 'A', pos_upper = 0;
else if (pos_dig == -1) s[i] = '0', pos_dig = 0;
}
cout << s << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int tests; cin >> tests;
while (tests--) solve();
return 0;
}
B - Relatively Prime Pairs
题意:
给你一个范围([l,r],r-lmod 2=1,lle r)，要你把范围里面的所有的整数分成(dfrac{r-l+1}{2})个部分，每一个部分有两个数，且这两个数互质。如果能办到，就输出YES，然后输出方案；否则输出NO。(1le l<rle 10^{18})
题解:
很容易发现每两个相邻的数是互质的，所以就可以把两个相邻的数分到一组，即((l,l+1),(l+2,l+3),ldots,(r-1,r))。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
signed main() {
ll l, r;
cin >> l >> r;
puts("YES");
for (ll i = l; i <= r; i += 2)
printf("%lld %lld
", i, i + 1);
return 0;
}
C - Vasya and Multisets
题意:
给你一个多重集合(S)，如果(xin S)且(x)在(S)中只出现(1)次，则称(x)为好数。现在要你把(S)分成两个多重集合(A,B)，使得(A,B)里面的好数的个数相等。如果办不到，输出NO。(1le|S|le 100)
题解:
统计(S)中的好数的个数(c)，如果(cmod2=0)，则直接把(dfrac{c}{2})个好数分给(A)，其他的所有数都分给(B)。如果(cmod 2=1)，先把(dfrac{c-1}{2})个好数分给(A)，其余的好数分给(B)。在剩下来的那些不是好数的数中，若存在(d)在(S)中出现的次数(>2)，则可以把一个(d)分给(A)，其他的(d)分给(B)，这样(A,B)集合的好数就相等了。如果找不到这样的(d)，那么答案就是NO。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
int n;
int a[105];
int mp[105];
bool vis[105];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i], mp[a[i]]++;
int cnt = 0, cnt1 = 0;
for (int i = 1; i <= 100; ++i)
cnt += (mp[i] >= 3), cnt1 += (mp[i] == 1);
if (cnt == 0 && cnt1 % 2) return puts("NO") & 0;
puts("YES");
int cnt2 = 0, flag = 0;
for (int i = 1; i <= n; ++i)
if (mp[a[i]] == 1) {
++cnt2;
if (cnt2 * 2 <= cnt1) vis[i] = 0;
else vis[i] = 1;
}
else if (mp[a[i]] > 2) {
if (cnt1 % 2 && !flag)
vis[i] = 0;
else vis[i] = 1;
flag = 1;
}
else vis[i] = 'B';
for (int i = 1; i <= n; ++i)
putchar("AB"[vis[i]]);
return 0;
}
D - Bicolorings
题意:
给定一个(2 imes n)的棋盘，可以对上面的格子黑白染色，求染色后棋盘上的颜色相同联通块的个数正好为(k)的染色方案数。(1le nle 2000)
题解:
设(dp_{i,j,c_1,c_2})表示当前染色到第(i)列，前面一共有(j)个联通块，第(i-1)列的颜色分别为(c_1,c_2)。
转移的话直接枚举(c_1,c_2)，是(O(1))的。总时间复杂度就是(O(nk))。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
constexpr int Maxn = 2005;
constexpr int mod = 998244353;
inline int add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
inline void inc(int &x, int y) { (x += y) >= mod && (x -= mod); }
inline int mul(int x, int y) { return 1LL * x * y - 1LL * x * y / mod * mod; }
int n, k;
int dp[Maxn][Maxn][2][2];
int more(int a1, int a2, int b1, int b2) {
if (a1 == b1 && a2 == b2) return 0;
if (a1 == a2) {
if (b1 == a1 && b2 == a1) return 0;
return 1;
}
if (b1 == b2) return 0;
if (b1 == a1) return 0;
return 2;
}
signed main() {
cin >> n >> k;
dp[1][1][0][0] = 1, dp[1][1][1][1] = 1;
dp[1][2][0][1] = 1, dp[1][2][1][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
for (int a1 = 0; a1 < 2; ++a1) {
for (int a2 = 0; a2 < 2; ++a2) {
for (int b1 = 0; b1 < 2; ++b1) {
for (int b2 = 0; b2 < 2; ++b2) {
inc(dp[i + 1][j + more(a1, a2, b1, b2)][b1][b2], dp[i][j][a1][a2]);
}
}
}
}
}
}
cout << add(add(dp[n][k][0][0], dp[n][k][0][1]), add(dp[n][k][1][0], dp[n][k][1][1])) << endl;
return 0;
}
E - Vasya and Big Integers
题意:
给你一个由数字构成的字符串(S)，问你有多少种划分方式，使得划分的每段不含前导0，并且每段的数字大小在([l,r])之间。(0le lle rle 10^{10^{6}},0le Sle10^{10^{6}})
题解:
先考虑一个DP:(dp_i)表示(S_{i..|S|})这一段数字字符串有(dp_i)种划分方式满足要求。
很显然，若(S_i=0)，则当(l=0)时，(dp_i=dp_{i+1})，否则(dp_i=0)。
若(S_i eq 0)，则要找到最小的(L)，最大的(R)，使得(S_{i..(L-1)}ge l,S_{i..(R-1)}le r)，那么这样(dp_i=dp_L+dp_{L+1}+dp_{L+2}+dots+dp_{R})。
但这样时间复杂度为(O(|S|^2))，显然是不行的。
首先那个求和部分可以用后缀和进行优化，现在要做的就是要快速找到(L,R)。
进一步观察可以发现，若(S_{i,i+|l|-1}ge l)，则(L=i+|l|)，否则(L=i+|l|+1)，对于(R)也是同理。所以现在问题就转化成了判断(S_{i+|l|-1},l)和(S_{i+|r|-1},r)的大小关系。
常规的判断方法是枚举(j=0
ightarrow|l|-1)，若(S_{i+j}
eq l_j)，则(S_{i+|l|-1})和(l)的大小就是(S_{i+j})和(l_j)的大小。设(lcp(S_{i+|l|-1},l)=lcp)，则(S_{i+|l|-1})和(l)的大小就是(S_{i+lcp})和(l_{lcp})的大小。现在问题就转化成了快速求(lcp(S_{i+|l|-1},l))。这可以通过哈希或对(l+S)建立z function求得。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
constexpr int mod = 998244353;
inline int add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
inline void inc(int &x, int y) { (x += y) >= mod && (x -= mod); }
constexpr int Maxn = 2000005;
int n, ln, rn;
char a[Maxn], l[Maxn], r[Maxn];
int zl[Maxn], zr[Maxn];
inline void buildZ(int n, const char *s, int *z) {
for (register int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = (z[i - l] < r - i + 1 ? z[i - l] : r - i + 1);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
inline int cmp(int len, int *z, const char *s, int pos) {
if (n - pos + 1 < len) return -1;
int x = z[pos + len + 1];
if (x == len) return 0;
return a[pos + x] < s[1 + x] ? -1 : 1;
}
int dp[Maxn], suf[Maxn];
signed main() {
scanf("%s%s%s", a + 1, l + 1, r + 1);
n = strlen(a + 1);
ln = strlen(l + 1);
rn = strlen(r + 1);
l[ln + 1] = r[rn + 1] = '$';
strcat(l + 1, a + 1);
strcat(r + 1, a + 1);
buildZ(ln + 1 + n, l + 1, zl + 1);
buildZ(rn + 1 + n, r + 1, zr + 1);
//for (int i = 1; i <= n + ln + 1; ++i) fprintf(stderr, "zl[%d] = %d
", i, zl[i]);
//for (int i = 1; i <= n + rn + 1; ++i) fprintf(stderr, "zr[%d] = %d
", i, zr[i]);
dp[n + 1] = suf[n + 1] = 1;
for (int i = n; i >= 1; --i) {
if (a[i] == '0') {
if (l[1] == '0') dp[i] = dp[i + 1];
else dp[i] = 0;
suf[i] = add(suf[i + 1], dp[i]);
continue;
}
int cmpl = cmp(ln, zl, l, i);
int cmpr = cmp(rn, zr, r, i);
int L = min(ln + i + (cmpl == -1), n + 2);
int R = min(rn + i - (cmpr == 1), n + 2);
//fprintf(stderr, "i = %d, cmpl = %d, cmpr = %d, L = %d, R = %d
", i, cmpl, cmpr, L, R);
dp[i] = (L <= R) ? add(suf[L], mod - suf[R + 1]) : 0;
//fprintf(stderr, "dp[%d] = %d
", i, dp[i]);
suf[i] = add(suf[i + 1], dp[i]);
}
printf("%d
", dp[1]);
return 0;
}
F - The Shortest Statement
题意:
给你一个图，有(n)个点，(m)条边，保证(m-nle 20)。有(q)次询问，每次询问求两个点(x,y)之间的最短路。
题解:
我们把这个图的其中一个生成树给拿出来，那么还有最多(21)条边不在这个生成树上。
这个最短路可能有两种：经过不在生成树上的边，和不经过的。
不经过生成树上的边的路径就只有(1)条，直接在生成树上找lca，然后(d=根到x的距离+根到y的距离-2 imes 根到lca的距离)
然后考虑经过不在生成树上的边。
如果一个路径经过一个边，那么它必定经过这条边的两个端点。所以我们对所有这些不在生成树上的边的端点跑一遍dijkstra，这些点最多只有(42)个。设(dist_{i,j})表示编号为(i)的这种点到原图上(j)号点的距离。那么经过不在生成树上的边的最短路(ans=minlimits_{i=0}^{41}{dist_{i,x}+dist_{i,y}})
最后把这两种最短路取(min)即可。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
#define fi first
#define se second
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
constexpr int Maxn = 100005;
#define int ll
vector<pair<int, int>> g[Maxn];
int n, m, q;
int par[Maxn][20], dep[Maxn];
ll dist[Maxn][50], deep[Maxn];
vector<int> vec;
bool vis[Maxn], low[Maxn];
void dfs(int u, int fa) {
vis[u] = true;
for (auto pr: g[u]) {
int v = pr.fi;
if (v != fa) {
if (!vis[v]) {
par[v][0] = u;
dep[v] = dep[u] + 1;
deep[v] = deep[u] + pr.se;
dfs(v, u);
}
else low[u] = low[v] = true;
}
}
}
inline int get_lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int i = 0; i < 20; ++i)
if ((dep[v] - dep[u]) >> i & 1)
v = par[v][i];
if (u == v) return v;
for (int i = 19; i >= 0; --i)
if (par[u][i] != par[v][i])
u = par[u][i], v = par[v][i];
return par[u][0];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v; ll w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
par[1][0] = 0;
dfs(1, 1);
for (int j = 1; j < 20; ++j)
for (int i = 1; i <= n; ++i)
par[i][j] = par[par[i][j - 1]][j - 1];
for (int i = 1; i <= n; ++i)
if (low[i]) vec.push_back(i);
for (int num = 0; num < (int)vec.size(); ++num) {
for (int i = 1; i <= n; ++i) dist[i][num] = lnf;
priority_queue<pair<ll, int>> pq;
dist[vec[num]][num] = 0;
pq.push({0, vec[num]});
while (!pq.empty()) {
ll d = -pq.top().fi;
int u = pq.top().se;
pq.pop();
if (d != dist[u][num]) continue;
for (auto pr: g[u]) {
int v = pr.fi;
ll w = pr.se;
if (dist[v][num] > dist[u][num] + w) {
dist[v][num] = dist[u][num] + w;
pq.push({-dist[v][num], v});
}
}
}
}
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
int lca = get_lca(u, v);
ll ans = deep[u] + deep[v] - deep[lca] * 2;
for (int i = 0; i < (int)vec.size(); ++i)
ans = min(ans, dist[u][i] + dist[v][i]);
cout << ans << endl;
}
return 0;
}
G - Distinctification
题意:
若多重集合(S={(a_i,b_i)|1le ile k})，定义一个操作为：
- 若存在(j)，使得(a_i=a_j)，则可以花(b_i)的代价使(a_i=a_i+1)
- 若存在(j)，使得(a_i=a_j+1)，则可以花(-b_i)的代价使(a_i=a_i-1)
你可以进行任何次数的操作。
定义(f(S))为最小的代价，使得你可以花(f(S))的代价使(S)里面的所有(a_i)不同。(f(S))可以为负数。
你现在有(n)次询问，每次询问是在当前的(S)里面插入((a_i,b_i))后询问(f(S))。开始时(S=varnothing)。保证(1le a_ile 2 imes 10^5,1le b_ile n)，且所有的(b_i)不同。
题解:
很容易地可以观察到当且仅当(|a_i-a_j|le1)，则可以交换(a_i,a_j)
首先先考虑若(S)里的(a_i)是一段连续值域，且互不相同怎么求。我们可以想到，(b_i)越大，就要尽可能的减少(a_i)。又因为(S)里的(a_i)是一段连续的值域且互不相同，所以(S)里的(a_i)可以随便排，所以最后的(S)应该是：对于任意(a_i<a_j)，(b_i>b_j)。此时的代价应为((a'_1-a_1) imes b_1+(a'_2-a_2) imes b_2+dots+(a'_{|S|}-a_{|S|}) imes b_{|S|})，即((a'_1 imes b_1+a'_2 imes b_2+dots+a'_{|S|} imes b_{|S|})-(a_1 imes b_1+a_2 imes b_2+dots+a_{|S|} imes b_{|S|}))。
又因为当且仅当(|a_i-a_j|le1)，则可以交换(a_i,a_j)，所以(S)的每一个极长(a_i)连续值域段是互相独立的，所以对于任意一个(S)，(f(S)=(a'_1 imes b_1+a'_2 imes b_2+dots+a'_{|S|} imes b_{|S|})-(a_1 imes b_1+a_2 imes b_2+dots+a_{|S|} imes b_{|S|}))。
显然(a_1 imes b_1+a_2 imes b_2+dots+a_{|S|} imes b_{|S|})是很好求的，所以问题就转化为了求(a'_1 imes b_1+a'_2 imes b_2+dots+a'_{|S|} imes b_{|S|})。记这个式子为after。
我们先考虑在一个极长(a_i)连续值域段里面插入((a_i,b_i))怎么做。我们维护这个极长(a_i)连续值域的最左端(beg)，这样将(b)从小到大排序后可得(after=b_1 imes (beg+k-1)+b_2 imes (beg+k-2)+dots+b_k imes beg)，即(after=beg imes(b_1+b_2+dots+b_k)+(b_1 imes(k-1)+b_2 imes(k-2)+dots+b_k imes0))。现在问题就是动态地在一个排好序的数组(b)中插入(x)，插入完后求上面那个式子。(beg imes(b_1+b_2+dots+b_k))特别好求，每一次插入(x)，答案就(+x imes beg)。对于(b_1 imes(k-1)+b_2 imes(k-2)+dots+b_k imes0)我们可以用treap维护数组(b)，每一次插入(x)时把(b)分成(b_{1..pos})和(b_{pos+1..k})。那么这个时候(b_{1..pos})里的每一个(b)对答案的贡献(+1)，(x)对答案的贡献(+(k-pos) imes x)。这个可以在treap上维护size和sum来快速实现。于是动态插入((a_i,b_i))的单次时间复杂度是(O(log k))的。
接着我们考虑如何合并两个极长(a_i)连续值域段(S,T)。不妨设(|S|le|T|)。一个很直接的想法就是直接将(S)里面的(b_i)依次插入到(T)里面。这样的时间复杂度是(O(|S|log|T|))。
然后我们考虑在一个普通的集合(S)里面插入((a_i,b_i))。
我们用并查集维护那些极长(a_i)连续值域段已经合并。
如果((a_i,b_i))属于之前的一个极长(a_i)连续值域段，那么直接在那个极长(a_i)连续值域段里插入((a_i,b_i))，同时还要占据这个连续值域段的右端点的右边一位。否则就新开创一个极长(a_i)连续值域段，长度为(1)。
在这之后还要看((a_i,b_i))所属的极长(a_i)连续值域段是否能和它旁边的两个极长(a_i)连续值域段合并。两个极长(a_i)连续值域段(S,T)能合并的条件是(r(S)+1=l(T))或(r(T)+1=l(S))，其中(r(S))代表(S)的右端点，(l(S))代表(S)的左端点。
每一次合并的时间复杂度是(O(min(|S|,|T|)log N))的。由于是把小集合的元素的往大集合里面插入进去，每一个元素最多只会被插入(log N)次，所以总时间复杂度最坏情况下是(O((N imes log N) imes log N)=O(Nlog^2N))。
Code:
// Code by H~$~C
#include <bits/stdc++.h>
using namespace std;
#define epoch_time chrono::steady_clock::now().time_since_epoch().count()
static mt19937 __gen(epoch_time);
#define random_shuffle(begin, end) shuffle(begin, end, __gen)
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr int inf = 0x3f3f3f3f;
constexpr ll lnf = 0x3f3f3f3f3f3f3f3f;
inline int randint() {
return uniform_int_distribution<int>()(__gen);
}
constexpr int Maxn = 400005;
int n;
ll before, after;
struct node {
int size, fix;
node *l, *r;
int x;
ll sum;
node() { }
node(int x, node *l = NULL, node *r = NULL)
: x(x), l(l), r(r), size(1), fix(randint()) {
sum = x;
}
inline int lsize() const { return l ? l->size : 0; }
inline int rsize() const { return r ? r->size : 0; }
inline ll lsum() const { return l ? l->sum : 0; }
inline ll rsum() const { return r ? r->sum : 0; }
inline void pushup() {
size = lsize() + rsize() + 1;
sum = lsum() + rsum() + x;
}
} pool[Maxn * 20], *cur_ptr = pool;
inline node *newnode(int x, node *l = NULL, node *r = NULL) {
return &(*cur_ptr++ = node(x, l, r));
}
node *merge(node *l, node *r) {
if (!l || !r) return l ? l : r;
if (l->fix < r->fix) {
l->r = merge(l->r, r);
l->pushup();
return l;
}
else {
r->l = merge(l, r->l);
r->pushup();
return r;
}
}
void split(node *p, int k, node *&l, node *&r) {
if (!p) l = r = NULL;
else {
if (p->x <= k) {
l = p;
split(p->r, k, l->r, r);
l->pushup();
}
else {
r = p;
split(p->l, k, l, r->l);
r->pushup();
}
}
}
struct adjacent {
node *root;
int beg;
ll all_sum, inner_sum;
adjacent() = default;
inline void update_all() {
all_sum = inner_sum;
if (root) all_sum += root->sum * beg;
}
void insert(int b) {
node *A, *B;
split(root, b, A, B);
if (A) inner_sum += A->sum;
if (B) inner_sum += 1LL * B->size * b;
root = merge(merge(A, newnode(b)), B);
update_all();
}
void insert_treap(node *p) {
if (!p) return ;
insert(p->x);
insert_treap(p->l);
insert_treap(p->r);
}
friend adjacent operator + (adjacent x, adjacent y) {
int xsize = x.root ? x.root->size : 0;
int ysize = y.root ? y.root->size : 0;
if (xsize < ysize) swap(x, y);
x.beg = min(x.beg, y.beg);
x.insert_treap(y.root);
x.update_all();
return x;
}
};
adjacent adj[Maxn];
int fa[Maxn], sz[Maxn];
inline int fnd(int x) {
return fa[x] == x ? x : fa[x] = fnd(fa[x]);
}
void unite(int x, int y) {
x = fnd(x), y = fnd(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
fa[y] = x, sz[x] += sz[y];
after -= adj[x].all_sum;
after -= adj[y].all_sum;
adj[x] = adj[x] + adj[y];
after += adj[x].all_sum;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> n;
before = 0;
set<int> rest;
for (int i = 0; i < Maxn; ++i) {
rest.insert(i);
fa[i] = i, sz[i] = 1;
}
for (int i = 1; i <= n; ++i) {
int a, b;
cin >> a >> b;
before += 1LL * a * b;
int pos = *rest.lower_bound(a);
rest.erase(pos);
adj[pos].beg = pos;
adj[pos].insert(b);
after += adj[pos].all_sum;
if (rest.find(pos - 1) == rest.end()) unite(pos - 1, pos);
if (rest.find(pos + 1) == rest.end()) unite(pos + 1, pos);
cout << after - before << endl;
}
return 0;
}