Codeforces Round #624 (Div. 3)

---

Catalogue

• 1311A-Add Odd or Subtract Even[简单思维]
• 1311B-WeirdSort[简单思维]
• 1311C-Perform the Combo[简单思维]
• 1311D-Three Integers[暴力]
• 1311E-Construct the Binary Tree[模拟]
• 1311F-Moving Points[树状数组+离散化]

---

1311A-Add Odd or Subtract Even[简单思维]

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

You are given two positive integers $a$ and $b$.
In one move, you can change a in the following way:
Choose any positive odd integer $x(x>0)$and replace $a$ with $a+x$;
choose any positive even integer $y(y>0)$ and replace $a$ with $a-y$.
You can perform as many such operations as you want. You can choose the same numbers $x$ and $y$ in different moves.
Your task is to find the minimum number of moves required to obtain $b$ from $a$. It is guaranteed that you can always obtain $b$ from $a$.
You have to answer $t$ independent test cases.

Input

The first line of the input contains one integer $t$ $(1\le t\le 10^4)$ — the number of test cases.
Then $t$ test cases follow. Each test case is given as two space-separated integers $a$ and $b$ $(1\le a,b\le 10^9)$.

Output

For each test case, print the answer — the minimum number of moves required to obtain $b$ from $a$ if you can perform any number of moves described in the problem statement. It is guaranteed that you can always obtain $b$ from $a$.

Example input

5
2 3
10 10
2 4
7 4
9 3

Example output

1
0
2
2
1

Note

In the first test case, you can just add 1.
In the second test case, you don’t need to do anything.
In the third test case, you can add 1 two times.
In the fourth test case, you can subtract 4 and add 1.
In the fifth test case, you can just subtract 6.

分析：
题意：
从$a$移动到$b$，每次$a$可以移动$a+x,x\in (x$, 或者$a-y,y\in (y$,且$a,b,x,y>0$, 问所需的最少移动次数
做法：
很容易可以想到次数必然$\in 0,1,2$，当$a\le b$时，若$(b-a)$，直接选择奇数$x$即可；若为偶数，选择奇数$x$，在选择偶数$y$
$a>b$同理，若$(a-b)$，直接选择偶数$y$即可；若为奇数，选择偶数$y$，在选择奇数$x$

Code:

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <bitset>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
const int inf  = 1e18;
const int maxn = 1e3 + 5;

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        int a, b;
        scanf("%d%d", &a, &b);
        if(a == b)	puts("0");
        else if((b - a) > 0 && (b - a) % 2 != 0)    puts("1");
        else if((a - b) > 0 && (a - b) % 2 == 0)    puts("1");
        else    	puts("2");
    }
    return 0;
}

---

1311B-WeirdSor[简单思维]

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

You are given an array $a$ of length $n$.
You are also given $a$ set of distinct positions $p_1,p_2,\dots ,p_m$, where $1\le pi<n$. The position $p_i$ means that you can swap elements $a[p_i]$ and $a[p_{i+1}]$. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order $(a_1\le a_2\le \cdots \le a_n)$ using only allowed swaps.
For example, if $a=[3,2,1]$ and $p=[1,2]$, then we can first swap elements $a[2]$ and $a[3]$ (because position $2$ is contained in the given set $p$). We get the array $a=[3,1,2]$. Then we swap $a[1]$ and $a[2]$ (position $1$ is also contained in $p$). We get the array $a=[1,3,2]$. Finally, we swap $a[2]$ and $a[3]$ again and get the array $a=[1,2,3]$, sorted in non-decreasing order.
You can see that if $a=[4,1,2,3]$ and $p=[3,2]$ then you cannot sort the array.
You have to answer $t$ independent test cases.

Input

The first line of the input contains one integer $t(1\le t\le 100)$ — the number of test cases.
Then $t$ test cases follow. The first line of each test case contains two integers $n$ and $m$ $(1\le m<n\le 100)$ — the number of elements in $a$ and the number of elements in $p$. The second line of the test case contains $n$ integers $a_1,a_2,\dots ,a_n(1\le ai\le 100)$. The third line of the test case contains $m$ integers $p_1,p_2,\dots ,p_m$ $(1\le pi<n$, all $p_i$ are distinct) — the set of positions described in the problem statement.

Output

For each test case, print the answer — “YES” (without quotes) if you can sort the initial array in non-decreasing order $(a_1\le a_2\le \cdots \le a_n)$ using only allowed swaps. Otherwise, print “NO”.

Example input

6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4

Example output

YES
NO
YES
YES
NO
YES

分析：
题意：
有一个数组$a$长度为$n$, 一个数组$p$长度为$n$, $p[i]$表示数组$a[p[i]]$的值可以与$a[p[i]+1]$的值互换，问最后能否是一个非递减数组
做法：
要求得非递减数组，可以直接排序，然后将原本下标比较小的排前面
容易可以知道这就是最后数组每个数应该在的位置。可以发现若要使$a[i+2]$的数可以换到$a[i]$的位置，则必须有$p[j]=i,p[k]=i+1$

Code:

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <bitset>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
const int inf  = 0x3f3f3f3f;
const int maxn = 100 + 5;
 
struct node {
    int x, id;
    bool operator<(const node &ope) const {
        if(x == ope.x)  return id < ope.id;
        return x < ope.x;
    }
}b[maxn];
bool vis[maxn];
 
int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        int n, m, x;
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; ++i) {
            scanf("%d", &b[i].x);
            b[i].id = i, vis[i] = false;
        }
        for(int i = 1; i <= m; ++i) {
            scanf("%d", &x);
            vis[x] = true;
        }
        bool flag = true;
        sort(b + 1, b + 1 + n);
        for(int i = 1; i <= n; ++i) {
            if(b[i].id == i)    continue;
            int id1 = b[i].id, id2 = i;
            if(id1 > id2)   swap(id1, id2);
            for(int j= id1; j < id2; ++j) {
                if(vis[j])    continue;
                flag = false;
            }
            if(!flag)   break;
        }
        if(flag)    puts("YES");
        else        puts("NO");
    }
    return 0;
}

---

1311C-Perform the Combo[简单思维]

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

You want to perform the combo on your opponent in one popular fighting game. The combo is the string $s$ consisting of $n$ lowercase Latin letters. To perform the combo, you have to press all buttons in the order they appear in $s$. I.e. if $s="abca"$ then you have to press ${}^{\prime }{a}^{\prime }$, then ${}^{\prime }b$', ${}^{\prime }{c}^{\prime }$ and ${}^{\prime }{a}^{\prime }$ again.
You know that you will spend $m$ wrong tries to perform the combo and during the $i-th$ try you will make a mistake right after $p_i-th$ button (1≤pi<n) (i.e. you will press first pi buttons right and start performing the combo from the beginning). It is guaranteed that during the $(m+1)-th$ try you press all buttons right and finally perform the combo.
I.e. if $s="abca"$, $m=2$ and $p=[1,3]$ then the sequence of pressed buttons will be ‘a’ (here you’re making a mistake and start performing the combo from the beginning), ‘a’, ‘b’, ‘c’, (here you’re making a mistake and start performing the combo from the beginning), ‘a’ (note that at this point you will not perform the combo because of the mistake), ‘b’, ‘c’, ‘a’.
Your task is to calculate for each button (letter) the number of times you’ll press it.
You have to answer $t$ independent test cases.

Input

The first line of the input contains one integer $t(1\le t\le 10^4)$ — the number of test cases.
Then $t$ test cases follow.
The first line of each test case contains two integers $n$ and $m$ $(2\le n\le 2\cdot 10^5,1\le m\le 2\cdot 10^5)$ — the length of $s$ and the number of tries correspondingly.
The second line of each test case contains the string $s$ consisting of $n$ lowercase Latin letters.
The third line of each test case contains m integers $p_1,p_2,\dots ,p_m(1\le p_i<n)$ — the number of characters pressed right during the i-th try.
It is guaranteed that the sum of $n$ and the sum of m both does not exceed $2\cdot 10^5$ $(\sum n\le 2\cdot 10^5,\sum m\le 2\cdot 10^5)$.
It is guaranteed that the answer for each letter does not exceed $2\cdot 10^9$.

Output

For each test case, print the answer — 26 integers: the number of times you press the button ‘a’, the number of times you press the button ‘b’, …, the number of times you press the button ‘z’.

Example input

3
4 2
abca
1 3
10 5
codeforces
2 8 3 2 9
26 10
qwertyuioplkjhgfdsazxcvbnm
20 10 1 2 3 5 10 5 9 4

Example output

4 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 9 4 5 3 0 0 0 0 0 0 0 0 9 0 0 3 1 0 0 0 0 0 0 0
2 1 1 2 9 2 2 2 5 2 2 2 1 1 5 4 11 8 2 7 5 1 10 1 5 2

分析：
题意：
统计每次字符串从$0\to p[i]$每个字母出现的次数的总和，最后还要将原串再算一次
没什么技巧，就是看有没有看懂题目而已

Code:

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <bitset>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
const int inf  = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
 
char s[maxn];
int a[maxn][30];
int sum[30];
 
int main() {
    int T, x;
    const char str[10] = "abca";
    scanf("%d", &T);
    while(T--) {
        int n, m;
        memset(sum, 0, sizeof(sum));
        scanf("%d%d%s", &n, &m, s + 1);
        for(int i = 1; i <= n; ++i) {
            for(int j = 0; j < 26; ++j) {
                if(i == 1)  a[i][j] = 0;
                else        a[i][j] = a[i - 1][j];
                if(j == s[i] - 'a') a[i][j]++;
            }
        }
        for(int i = 1; i <= m; ++i) {
            scanf("%d", &x);
            for(int j = 0; j < 26; ++j)
                sum[j] += a[x][j];
        }
        for(int i = 0; i < 26; ++i)
            printf("%d%c", sum[i] + a[n][i], i == 25 ? '\n' : ' ');
    }
    return 0;
}

---

1311D-Three Integers[暴力]

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

You are given three integers $a\le b\le c$.
In one move, you can add $+1$ or $-1$ to any of these integers (i.e. increase or decrease any number by one). You can perform such operation any (possibly, zero) number of times, you can even perform this operation several times with one number. Note that you cannot make non-positive numbers using such operations.
You have to perform the minimum number of such operations in order to obtain three integers $A\le B\le C$ such that $B$ is divisible by $A$ and $C$ is divisible by $B$.
You have to answer $t$ independent test cases.

Input

The first line of the input contains one integer $t(1\le t\le 100)$ — the number of test cases.
The next $t$ lines describe test cases. Each test case is given on a separate line as three space-separated integers $a,b$ and $c$ $(1\le a\le b\le c\le 10^4)$.

Output

For each test case, print the answer. In the first line print res — the minimum number of operations you have to perform to obtain three integers $A\le B\le C$ such that $B$ is divisible by $A$ and $C$ is divisible by $B$. On the second line print any suitable triple $A,B$ and $C$.

Example input

8
1 2 3
123 321 456
5 10 15
15 18 21
100 100 101
1 22 29
3 19 38
6 30 46

Example output

1
1 1 3
102
114 228 456
4
4 8 16
6
18 18 18
1
100 100 100
7
1 22 22
2
1 19 38
8
6 24 48

分析：
题意：
$A,B,C$每次可以改变自身$+1$ or $-1$， 问至少要改变几次才能使$B\%A==0$ $\&\&$ $C\%B==0$
分析：
$1\le A,B,C\le 1e4$, 其实只要暴力就可以了，只是范围要扩大到$2e4$
忘记改了睡了一觉被$hack$，枯了

Code:

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <bitset>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
const int inf  = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
 
 
int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        int a, b, c, ans = inf;
        int ea, eb, ec, k;
        scanf("%d%d%d", &a, &b, &c);
        for(int i = 1; i <= 20000; ++i) {
            for(int j = i; j <= 20000; j += i) {
                if(c - c / j * j < (c / j + 1) * j - c)
                    k = c / j * j;
                else
                    k = (c / j + 1) * j;
                if(k < j)   continue;
                if(ans > abs(a - i) + abs(b - j) + abs(c - k)) {
                    ea = i, eb = j, ec = k;
                    ans = abs(a - i) + abs(b - j) + abs(c - k);
                }
            }
        }
        printf("%d\n%d %d %d\n", ans, ea, eb, ec);
    }
    return 0;
}

---

1311E-Construct the Binary Tree

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

You are given two integers $n$ and $d$. You need to construct a rooted binary tree consisting of $n$ vertices with a root at the vertex $1$ and the sum of depths of all vertices equals to $d$.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a vertex $v$ is the last different from $v$ vertex on the path from the root to the vertex $v$. The depth of the vertex $v$ is the length of the path from the root to the vertex $v$. Children of vertex $v$ are all vertices for which $v$ is the parent. The binary tree is such a tree that no vertex has more than $2$ children.
You have to answer $t$ independent test cases.

Input

The first line of the input contains one integer $t(1\le t\le 1000)$ — the number of test cases.
The only line of each test case contains two integers $n$ and $d(2\le n,d\le 5000)$ — the number of vertices in the tree and the required sum of depths of all vertices.
It is guaranteed that the sum of $n$ and the sum of d both does not exceed $5000$ $(\sum n\le 5000,\sum d\le 5000)$.

Output

For each test case, print the answer.
If it is impossible to construct such a tree, print “NO” (without quotes) in the first line. Otherwise, print “{YES}” in the first line. Then print $n-1$ integers $p_2,p_3,\dots ,p_n$ in the second line, where $p_i$ is the parent of the vertex $i$. Note that the sequence of parents you print should describe some binary tree.

Example input

3
5 7
10 19
10 18

Example output

YES
1 2 1 3
YES
1 2 3 3 9 9 2 1 6
NO

分析：
题意：
$\_(:з」\angle )\_$模拟题，懒得写

Code:

---

1311F-Moving Points

time limit per test	memory limit per test	input	output
2 seconds	256 megabytes	standard input	standard output

Description:

There are $n$ points on a coordinate axis OX. The i-th point is located at the integer point $x_i$ and has a speed $v_i$. It is guaranteed that no two points occupy the same coordinate. All $n$ points move with the constant speed, the coordinate of the i-th point at the moment $t$ ($t$ can be non-integer) is calculated as $x_i+t\cdot v_i$.
Consider two points $i$ and $j$. Let $d(i,j)$ be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points $i$ and $j$ coincide at some moment, the value $d(i,j)$ will be $0$.
Your task is to calculate the value ${\sum }_{1\le i<j\le n}d(i,j)$ (the sum of minimum distances over all pairs of points).

Input

The first line of the input contains one integer $n(2\le n\le 2\cdot 10^5)$ — the number of points.
The second line of the input contains $n$ integers $x_1,x_2,\dots ,x_n(1\le x_i\le 10^8)$, where $x_i$ is the initial coordinate of the i-th point. It is guaranteed that all $x_i$ are distinct.
The third line of the input contains $n$ integers $v_1,v_2,\dots ,v_n(-10^8\le v_i\le 10^8)$, where $v_i$ is the speed of the i-th point.

Output

Print one integer — the value ${\sum }_{1\le i<j\le n}d(i,j)$ (the sum of minimum distances over all pairs of points).

One Example input

3
1 3 2
-100 2 3

One Example output

3

Two Example input

5
2 1 4 3 5
2 2 2 3 4

Two Example output

19

Three Example input

2
2 1
-3 0

Three Example output

0

分析：
题意： 给$n$个点，给出每个点的坐标和速度，点可以在$x$轴上移动，时间不限，要求${\sum }_{1\le i<j\le n}dis(i,j)$的最小值
做法： 根据题意，意思就是可以在$i,j$两个点分别运动到任意时刻的距离为$dis(i,j)$，要使得$dis(i,j)$最小，则有三种可能性

1. $i,j$无法相遇，要满足$x_i<x_j\&\&v_i\le v_j$，则$min(dis(i,j))=x_j-x_i$，即$t=0$时
2. 否则他们必然会在某一时刻相遇，相遇则$min(dis(i,j))=0$

因此只要计算第一点所有的$dis$的和即可
那么对于每一个$x_i$，我所要求的贡献即为$x_i\times cnt-sum$，$cnt$为$x<x_i$且$v>v_i$的个数，$sum$就是这些点的和
由于$v$较大，可以进行离散化
将$x$进行排序，小的在前大的在后，循环一次计算每次$v<v_i$的$cnt,sum$
利用树状数组维护$cnt,sum$

Code:

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cstdio>
#include <vector>
#include <bitset>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
const int inf  = 0x3f3f3f3f;
const int maxn = 2e5 + 5;

#define lowbit(x)   x&(-x)

struct node {
    ll x, v;
    bool operator<(const node &ope) const {
        return x < ope.x;
    }
}a[maxn];
ll cnt[2][maxn]; // 0 个数, 1 和
ll vv[maxn];
int k;

void update(int id, int val) {
    for(int i = id; i <= k; i += lowbit(i))
        cnt[0][i]++, cnt[1][i] += val; 
}

ll query(int id, int k) {
    ll ans = 0;
    for(int i = id; i > 0; i -= lowbit(i))
        ans += cnt[k][i];
    return ans;
}

int main() {
    int n; ll res = 0;
    scanf("%d", &n);
    memset(cnt, 0, sizeof(cnt));
    for(int i = 1; i <= n; ++i) {
        scanf("%lld", &a[i].x);
    }
    for(int i = 1; i <= n; ++i) {
        scanf("%lld", &a[i].v); vv[i] = a[i].v;
    }
    // v[i]离散化, 比v[i]小的有几个
    sort(a + 1, a + 1 + n);
    sort(vv + 1, vv + 1 + n);
    k = unique(vv + 1, vv + 1 + n) - vv - 1;
    for(int i = 1; i <= n; ++i) {
        int pos = lower_bound(vv + 1, vv + 1 + k, a[i].v) - vv;
        res += a[i].x * query(pos, 0) - query(pos, 1);
        update(pos, a[i].x);
    }
    printf("%lld\n", res);
    return 0;
}

---