Codeforces Round 481 (Div. 3)_petya has an array ai of n integers. his brother v-CSDN博客

本文链接：https://blog.csdn.net/m0_70675786/article/details/132578177

A. Remove Duplicates

time limit per test: 1 second memory limit per test: 256 megabytes input: standard input output: standard output

Petya has an array $a$ consisting of $n$ integers. He wants to remove duplicate (equal) elements.

Petya wants to leave only the rightmost entry (occurrence) for each element of the array. The relative order of the remaining unique elements should not be changed.

Input

The first line contains a single integer $n$ ( $\le n \le 50$ ) — the number of elements in Petya’s array.

The following line contains a sequence $a_1, a_2, \dots, a_n$ ( $\le a_i \le 1\,000$ ) — the Petya’s array.

Output

In the first line print integer $x$ — the number of elements which will be left in Petya’s array after he removed the duplicates.

In the second line print $x$ integers separated with a space — Petya’s array after he removed the duplicates. For each unique element only the rightmost entry should be left.

Example
input1

6
1 5 5 1 6 1

output1

3
5 6 1

input2

5
2 4 2 4 4

output2

2
2 4

Note

In the first example you should remove two integers $1$ , which are in the positions $1$ and $4$ . Also you should remove the integer $5$ , which is in the position $2$ .

In the second example you should remove integer $2$ , which is in the position $1$ , and two integers $4$ , which are in the positions $2$ and $4$ .

In the third example you should remove four integers $6$ , which are in the positions $1$ , $2$ , $3$ and $4$ .

Tutorial
先逆序遍历，在遍历的过程中，一个数第一次出现就将其存起来，然后将答案逆序输出即可

Solution

import sys
input = sys.stdin.readline

n = int(input())
a = list(map(int, input().split()))
ans = []
for x in a[::-1]:
    if x not in ans:
        ans.append(x)
print(len(ans))
print(*ans[::-1])

B. File Name

time limit per test: 1 second memory limit per test: 256 megabytes input: standard input output: standard output

You can not just take the file and send it. When Polycarp trying to send a file in the social network “Codehorses”, he encountered an unexpected problem. If the name of the file contains three or more “x” (lowercase Latin letters “x”) in a row, the system considers that the file content does not correspond to the social network topic. In this case, the file is not sent and an error message is displayed.

Determine the minimum number of characters to remove from the file name so after that the name does not contain “xxx” as a substring. Print 0 if the file name does not initially contain a forbidden substring “xxx”.

You can delete characters in arbitrary positions (not necessarily consecutive). If you delete a character, then the length of a string is reduced by $1$ . For example, if you delete the character in the position $2$ from the string “exxxii”, then the resulting string is “exxii”.

Input

The first line contains integer $n$ $\le n \le 100)$ — the length of the file name.

The second line contains a string of length $n$ consisting of lowercase Latin letters only — the file name.

Output

Print the minimum number of characters to remove from the file name so after that the name does not contain “xxx” as a substring. If initially the file name dost not contain a forbidden substring “xxx”, print 0.

Example
input1

6
xxxiii

output1

input2

10
xxxxxxxxxx

output2

Note

In the first example Polycarp tried to send a file with name contains number $33$ , written in Roman numerals. But he can not just send the file, because it name contains three letters “x” in a row. To send the file he needs to remove any one of this letters.

Tutorial
暴力遍历，遇到不是 x 的字符刷新计数即可

Solution

package main

import (
	"bufio"
	. "fmt"
	"os"
)

var in = bufio.NewReader(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func solve() {
	var n int
	var s string
	Fscan(in, &n, &s)
	cnt, ans := 0, 0
	for _, c := range s {
		if c == 'x' {
			cnt++
		} else {
			cnt = 0
		}
		if cnt > 2 {
			ans++
		}
	}
	Println(ans)
}

func main() {
	defer out.Flush()
		solve()
}

C. Letters

time limit per test: 4 second memory limit per test: 256 megabytes input: standard input output: standard output

There are $n$ dormitories in Berland State University, they are numbered with integers from $1$ to $n$ . Each dormitory consists of rooms, there are $a_i$ rooms in $i$ -th dormitory. The rooms in $i$ -th dormitory are numbered from $1$ to $a_i$ .

A postman delivers letters. Sometimes there is no specific dormitory and room number in it on an envelope. Instead of it only a room number among all rooms of all $n$ dormitories is written on an envelope. In this case, assume that all the rooms are numbered from $1$ to $a_1 + a_2 + \dots + a_n$ and the rooms of the first dormitory go first, the rooms of the second dormitory go after them and so on.

For example, in case $n = 2$ , $a_1=3$ and $a_2=5$ an envelope can have any integer from $1$ to $8$ written on it. If the number $7$ is written on an envelope, it means that the letter should be delivered to the room number $4$ of the second dormitory.

For each of $m$ letters by the room number among all $n$ dormitories, determine the particular dormitory and the room number in a dormitory where this letter should be delivered.

Input

The first line contains two integers $n$ and $m$ $\le n, m \le 2 \cdot 10^{5})$ — the number of dormitories and the number of letters.

The second line contains a sequence $a_1, a_2, \dots, a_n$ $\le a_i \le 10^{10})$ , where $a_i$ equals to the number of rooms in the $i$ -th dormitory. The third line contains a sequence $b_1, b_2, \dots, b_m$ $\le b_j \le a_1 + a_2 + \dots + a_n)$ , where $b_j$ equals to the room number (among all rooms of all dormitories) for the $j$ -th letter. All $b_j$ are given in increasing order.

Output

Print $m$ lines. For each letter print two integers $f$ and $k$ — the dormitory number $f$ $\le f \le n)$ and the room number $k$ in this dormitory $\le k \le a_f)$ to deliver the letter.

Example
input1

3 6
10 15 12
1 9 12 23 26 37

output1

input2

2 3
5 10000000000
5 6 9999999999

output2

1 5
2 1
2 9999999994

Note

In the first example letters should be delivered in the following order:

the first letter in room $1$ of the first dormitory
the second letter in room $9$ of the first dormitory
the third letter in room $2$ of the second dormitory
the fourth letter in room $13$ of the second dormitory
the fifth letter in room $1$ of the third dormitory
the sixth letter in room $12$ of the third dormitory

Tutorial
前缀和记录到当前宿舍位置，一共有多少个房间，然后直接对要找的房间进行二分查找即可

Solution

import sys
input = sys.stdin.readline
from bisect import *

n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(n):
    if i:
        a[i] += a[i - 1]
for bi in b:
    ans = bisect_left(a, bi)
    print(ans + 1, bi - (a[ans - 1] if ans else 0))

D. Almost Arithmetic Progression

time limit per test: 1 second memory limit per test: 256 megabytes input: standard input output: standard output

Polycarp likes arithmetic progressions. A sequence $[a_1, a_2, \dots, a_n]$ is called an arithmetic progression if for each $i$ ( $\le i < n$ ) the value $a_{i+1} - a_i$ is the same. For example, the sequences $[42]$ , $[5, 5, 5]$ , $[2, 11, 20, 29]$ and $[3, 2, 1, 0]$ are arithmetic progressions, but $[1, 0, 1]$ , $[1, 3, 9]$ and $[2, 3, 1]$ are not.

It follows from the definition that any sequence of length one or two is an arithmetic progression.

Polycarp found some sequence of positive integers $[b_1, b_2, \dots, b_n]$ . He agrees to change each element by at most one. In the other words, for each element there are exactly three options: an element can be decreased by $1$ , an element can be increased by $1$ , an element can be left unchanged.

Determine a minimum possible number of elements in $b$ which can be changed (by exactly one), so that the sequence $b$ becomes an arithmetic progression, or report that it is impossible.

It is possible that the resulting sequence contains element equals $0$ .

Input

The first line contains a single integer $n$ $\le n \le 100\,000)$ — the number of elements in $b$ .

The second line contains a sequence $b_1, b_2, \dots, b_n$ $\le b_i \le 10^{9})$ .

Output

If it is impossible to make an arithmetic progression with described operations, print -1. In the other case, print non-negative integer — the minimum number of elements to change to make the given sequence becomes an arithmetic progression. The only allowed operation is to add/to subtract one from an element (can’t use operation twice to the same position).

Example
input1

4
24 21 14 10

output1

input2

3
14 5 1

output2

-1

Note

In the first example Polycarp should increase the first number on $1$ , decrease the second number on $1$ , increase the third number on $1$ , and the fourth number should left unchanged. So, after Polycarp changed three elements by one, his sequence became equals to $[25, 20, 15, 10]$ , which is an arithmetic progression.

In the second example it is impossible to make an arithmetic progression.

Tutorial
由于每个数都可以进行三种操作： $+ 1 、 - 1$ 和不变，所以我们可以对前两个元素分别进行这样的操作，然后根据前两个元素计算出公差，逐一判断后面的元素即可

Solution

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

#define endl '\n'
#define int long long

void solve() {
    int n;
    cin >> n;
    vector<int> b(n);
    for (int &bi : b) {
        cin >> bi;
    }
    if (n < 3) {
        cout << 0 << endl;
        return;
    }
    int ans = n + 1;
    for (int i = -1; i < 2; ++i) {
        for (int j = -1; j < 2; ++j) {
            int start = b[0] + i;
            int diff = b[1] + j - start;
            int cnt = 0;
            for (int k = 0; k < n; ++k) {
                int target = start + diff * k;
                if (abs(target - b[k]) == 1) {
                    cnt++;
                } else if (abs(target - b[k]) >= 2) {
                    goto flag;
                }
            }
            ans = min(ans, cnt);
            flag:;
        }
    }
    cout << (ans == n + 1 ? -1 : ans);
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
    solve();
    return 0;
}

E. Bus Video System

time limit per test: 1 second memory limit per test: 256 megabytes input: standard input output: standard output

The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.

If $x$ is the number of passengers in a bus just before the current bus stop and $y$ is the number of passengers in the bus just after current bus stop, the system records the number $y - x$ . So the system records show how number of passengers changed.

The test run was made for single bus and $n$ bus stops. Thus, the system recorded the sequence of integers $a_1, a_2, \dots, a_n$ (exactly one number for each bus stop), where $a_i$ is the record for the bus stop $i$ . The bus stops are numbered from $1$ to $n$ in chronological order.

Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to $w$ (that is, at any time in the bus there should be from $0$ to $w$ passengers inclusive).

Input

The first line contains two integers $n$ and $w$ $\le n \le 1\,000, 1 \le w \le 10^{9})$ — the number of bus stops and the capacity of the bus.

The second line contains a sequence $a_1, a_2, \dots, a_n$ $(-10^{6} \le a_i \le 10^{6})$ , where $a_i$ equals to the number, which has been recorded by the video system after the $i$ -th bus stop.

Output

Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to $w$ . If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.

Example
input1

3 5
2 1 -3

output1

input2

2 4
-1 1

output2

Note

In the first example initially in the bus could be $0$ , $1$ or $2$ passengers.

In the second example initially in the bus could be $1$ , $2$ , $3$ or $4$ passengers.

Tutorial
首先我们应该找到汽车内最大乘客数 $m x$ 和最小乘客数 $mn$ ，我们可以先假设汽车内最初是空的，然后一次遍历每一个公交车站，并将最大乘客数 $m x$ 和最小乘客数 $mn$ 更新

如果 $m x > w$ ，那么此时是一个无效情况
如果 $mn < 0$ ，那么巴士上最开始至少有 $ab s (mn)$ 个乘客，否则巴士上最开始就可以没有乘客
如果 $m x < 0$ ，那么巴士上最开始可以有 $w$ 个乘客，否则巴士上最开始可以有 $w - m x$ 个乘客

最后比较巴士上最初可能有的最大乘客数和最小乘客数，答案输出为 $ma x (0,$ 最大乘客数 - 最小乘客数 + $1)$

Solution

package main

import (
	"bufio"
	. "fmt"
	"os"
)

var in = bufio.NewReader(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func min(a, b int) int {if a < b {return a}; return b}
func max(a, b int) int {if a > b {return a}; return b}

func solve() {
	var n, w int
	Fscan(in, &n, &w)
	a := make([]int, n)
	mx, mn, cnt := 0, int(1e9), 0
	for i := 0; i < n; i++ {
		Fscan(in, &a[i])
		cnt += a[i]
		mx, mn = max(mx, cnt), min(mn, cnt)
	}
	Println(max(0, w - (mx - 1) + min(0, mn)))
}

func main() {
	defer out.Flush()
		solve()
}

F. Mentors

time limit per test: 3 second memory limit per test: 256 megabytes input: standard input output: standard output

In BerSoft $n$ programmers work, the programmer $i$ is characterized by a skill $r_i$ .

A programmer $a$ can be a mentor of a programmer $b$ if and only if the skill of the programmer $a$ is strictly greater than the skill of the programmer $b$ $r_a > r_b)$ and programmers $a$ and $b$ are not in a quarrel.

You are given the skills of each programmers and a list of $k$ pairs of the programmers, which are in a quarrel (pairs are unordered). For each programmer $i$ , find the number of programmers, for which the programmer $i$ can be a mentor.

Input

The first line contains two integers $n$ and $k$ $\le n \le 2 \cdot 10^5$ , $\le k \le \min(2 \cdot 10^5, \frac{n \cdot (n - 1)}{2}))$ — total number of programmers and number of pairs of programmers which are in a quarrel.

The second line contains a sequence of integers $r_1, r_2, \dots, r_n$ $\le r_i \le 10^{9})$ , where $r_i$ equals to the skill of the $i$ -th programmer.

Each of the following $k$ lines contains two distinct integers $x$ , $y$ $\le x, y \le n$ , $\ne y)$ — pair of programmers in a quarrel. The pairs are unordered, it means that if $x$ is in a quarrel with $y$ then $y$ is in a quarrel with $x$ . Guaranteed, that for each pair $(x, y)$ there are no other pairs $(x, y)$ and $(y, x)$ in the input.

Output

Print $n$ integers, the $i$ -th number should be equal to the number of programmers, for which the $i$ -th programmer can be a mentor. Programmers are numbered in the same order that their skills are given in the input.

Example
input1

output1

0 0 1 2

input2

10 4
5 4 1 5 4 3 7 1 2 5
4 6
2 1
10 8
3 5

output2

5 4 0 5 3 3 9 0 2 5

Note

In the first example, the first programmer can not be mentor of any other (because only the second programmer has a skill, lower than first programmer skill, but they are in a quarrel). The second programmer can not be mentor of any other programmer, because his skill is minimal among others. The third programmer can be a mentor of the second programmer. The fourth programmer can be a mentor of the first and of the second programmers. He can not be a mentor of the third programmer, because they are in a quarrel.

Tutorial
先将正在争吵的人标记出来，对技能值大的那一个进行计数操作，最后通过二分查找快速找到有多少个技能值低于当前技能值，再减去正在争吵的数量，即可得出答案

Solution

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

#define endl '\n'
#define int long long

void solve() {
    int n, k, x, y;
    cin >> n >> k;
    vector<int> r(n);
    for (int &ri : r) {
        cin >> ri;
    }
    vector<int> a(r), cnt(n + 1);
    ranges::sort(a);
    while (k--) {
        cin >> x >> y;
        x--, y--;
        if (r[x] < r[y]) {
            cnt[y]++;
        } else if (r[x] > r[y]) {
            cnt[x]++;
        }
    }
    for (int i = 0 ; i < n; ++i)  {
        cout << ranges::lower_bound(a, r[i]) - a.begin() - cnt[i] << " \n"[i == n - 1];
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
    solve();
    return 0;
}

G. Petya’s Exams

time limit per test: 1 second memory limit per test: 256 megabytes input: standard input output: standard output

Petya studies at university. The current academic year finishes with $n$ special days. Petya needs to pass $m$ exams in those special days. The special days in this problem are numbered from $1$ to $n$ .

There are three values about each exam:

$s_i$ — the day, when questions for the $i$ -th exam will be published,
$d_i$ — the day of the $i$ -th exam ( $s_i < d_i$ ),
$c_i$ — number of days Petya needs to prepare for the $i$ -th exam. For the $i$ -th exam Petya should prepare in days between $s_i$ and $d_i-1$ , inclusive.

There are three types of activities for Petya in each day: to spend a day doing nothing (taking a rest), to spend a day passing exactly one exam or to spend a day preparing for exactly one exam. So he can’t pass/prepare for multiple exams in a day. He can’t mix his activities in a day. If he is preparing for the $i$ -th exam in day $j$ , then $s_i \le j < d_i$ .

It is allowed to have breaks in a preparation to an exam and to alternate preparations for different exams in consecutive days. So preparation for an exam is not required to be done in consecutive days.

Find the schedule for Petya to prepare for all exams and pass them, or report that it is impossible.

Input

The first line contains two integers $n$ and $m$ $\le n \le 100, 1 \le m \le n)$ — the number of days and the number of exams.

Each of the following $m$ lines contains three integers $s_i$ , $d_i$ , $c_i$ $\le s_i < d_i \le n, 1 \le c_i \le n)$ — the day, when questions for the $i$ -th exam will be given, the day of the $i$ -th exam, number of days Petya needs to prepare for the $i$ -th exam.

Guaranteed, that all the exams will be in different days. Questions for different exams can be given in the same day. It is possible that, in the day of some exam, the questions for other exams are given.

Output

If Petya can not prepare and pass all the exams, print -1. In case of positive answer, print $n$ integers, where the $j$ -th number is:

$(m + 1)$ , if the $j$ -th day is a day of some exam (recall that in each day no more than one exam is conducted),
zero, if in the $j$ -th day Petya will have a rest,
$i$ ( $\le i \le m$ ), if Petya will prepare for the $i$ -th exam in the day $j$ (the total number of days Petya prepares for each exam should be strictly equal to the number of days needed to prepare for it).

Assume that the exams are numbered in order of appearing in the input, starting from $1$ .

If there are multiple schedules, print any of them.

Example
input1

5 2
1 3 1
1 5 1

output1

1 2 3 0 3

input2

3 2
1 3 1
1 2 1

output2

-1

input3

output2

2 2 2 1 1 0 4 3 4 4

Note

Tutorial
先根据题目存入数据，并将考试序号一并存入，然后根据考试开始的时间进行排序（先进行的考试先准备嘛）

然后从每场考试题发布的日子开始判断能否准备这次考试，尽可能将每场考试的准备时间提前（尽可能提前准备考试准没错！避免拖延症！算是有点贪心的意味？），如果碰到准备不完的考试，则无法准备并通过所有考试（挂科啦！😭），否则就可以轻松准备所有考试😊

Solution

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

#define ff first
#define ss second
#define endl '\n'
#define int long long
#define PIIII pair<pair<int, int>, pair<int, int>>

void solve() {
    int n, m;
    cin >> n >> m;
    vector<PIIII> a(m + 1);
    vector<int> ans(n + 1);
    for (int i = 1; i <= m; ++i) {
        cin >> a[i].ff.ff >> a[i].ff.ss >> a[i].ss.ff;
        a[i].ss.ss = i;
        ans[a[i].ff.ss] = m + 1;
    }
    ranges::sort(a, [](PIIII a, PIIII b) {
        return a.ff.ss < b.ff.ss;
    });
    
    for (int j = 1; j <= m; ++j) {
        PIIII ai = a[j];
        for (int i = ai.ff.ff; i < ai.ff.ss; ++i) {
            if (not ans[i]) {
                ans[i] = ai.ss.ss;
                if (not --ai.ss.ff) {
                    break;
                }
            }
        }
        if (ai.ss.ff) {
            cout << -1;
            return;
        }
    }
    for (int i = 1; i <= n; ++i) {
        cout << ans[i] << " \n"[i == n];
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
    solve();
    return 0;
}