It is winter now, and Max decided it’s about time he watered the garden.
The garden can be represented as n consecutive garden beds, numbered from 1 to n. k beds contain water taps (i-th tap is located in the bed xi), which, if turned on, start delivering water to neighbouring beds. If the tap on the bed xi is turned on, then after one second has passed, the bed xi will be watered; after two seconds have passed, the beds from the segment [xi - 1, xi + 1] will be watered (if they exist); after j seconds have passed (j is an integer number), the beds from the segment [xi - (j - 1), xi + (j - 1)] will be watered (if they exist). Nothing changes during the seconds, so, for example, we can’t say that the segment [xi - 2.5, xi + 2.5] will be watered after 2.5 seconds have passed; only the segment [xi - 2, xi + 2] will be watered at that moment.
The garden from test 1. White colour denotes a garden bed without a tap, red colour — a garden bed with a tap.
The garden from test 1 after 2 seconds have passed after turning on the tap. White colour denotes an unwatered garden bed, blue colour — a watered bed.
Max wants to turn on all the water taps at the same moment, and now he wonders, what is the minimum number of seconds that have to pass after he turns on some taps until the whole garden is watered. Help him to find the answer!
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 200).
Then t test cases follow. The first line of each test case contains two integers n and k (1 ≤ n ≤ 200, 1 ≤ k ≤ n) — the number of garden beds and water taps, respectively.
Next line contains k integers xi (1 ≤ xi ≤ n) — the location of i-th water tap. It is guaranteed that for each condition xi - 1 < xi holds.
It is guaranteed that the sum of n over all test cases doesn’t exceed 200.
Note that in hacks you have to set t = 1.
Output
For each test case print one integer — the minimum number of seconds that have to pass after Max turns on some of the water taps, until the whole garden is watered.
Example
input
3
5 1
3
3 3
1 2 3
4 1
1
output
3
1
4
Note
The first example consists of 3 tests:
There are 5 garden beds, and a water tap in the bed 3. If we turn it on, then after 1 second passes, only bed 3 will be watered; after 2 seconds pass, beds [1, 3] will be watered, and after 3 seconds pass, everything will be watered.
There are 3 garden beds, and there is a water tap in each one. If we turn all of them on, then everything will be watered after 1 second passes.
There are 4 garden beds, and only one tap in the bed 1. It will take 4 seconds to water, for example, bed 4.
题意:
n个点,k个出发点,从各个出发点同时出发,向两侧延伸,求延伸n个点的最少花费时间,一步算一秒(只有整数秒).
分析:
先求出所有出发点之间的最大距离,再除以2就是出发点与出发点之间最大时间,把两端枚举出来比较,最大值就是答案.
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long LL;
const int MAXN = 1e3 + 10;
int a[MAXN];
int main() {
int t;
scanf("%d", &t);
while(t--) {
memset(a, 0, sizeof(a));
int n, k;
int ans = 0;
scanf("%d %d", &n, &k);
for(int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + k + 1);
for(int i = 2; i <= k; i++) {
ans = max(ans, a[i] - a[i - 1] + 2);
}
ans /= 2;
ans = max(ans, max(a[1], n - a[k] + 1));
printf("%d\n", ans);
}
return 0;
}
/*
5 4
1 2 4 5
输出:
2
*/
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every condition li - 1 ≤ li holds.
The sum of n over all test cases doesn’t exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
input
2
2
1 3
1 4
3
1 5
1 1
2 3
output
1 2
1 0 2
Note
The example contains 2 tests:
During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
题意:
n个人排队去喝茶,每个人都有自己的排队时间区间,喝到茶的输出喝茶时的时间,没喝到的输出0.
分析:
直接暴力,注意时间可能会有空的时候(我特码输出的是下标,输出的是时间)。。。
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long LL;
const int MAXN = 1e3 + 10;
int L[MAXN], R[MAXN];
struct node {
int id;
int L;
int R;
int p;
}s[MAXN];
bool camp(node x, node y) {
if(x.L != y.L) return x.L < y.L;
return x.id < y.id;
}
int main() {
int t, n;
scanf("%d", &t);
while(t--) {
memset(s, 0, sizeof(s));
scanf("%d", &n);
for(int i = 0; i < n; i++) {
scanf("%d %d", &s[i].L, &s[i].R);
s[i].id = i;
}
sort(s, s + n, camp);
int k = 1, cnt = s[0].L + 1;
s[0].p = s[0].L;
for(int i = 1; i < n; i++) {
if(s[i].R >= cnt) {
s[i].p = max(cnt, s[i].L);
cnt = max(cnt, s[i].L) + 1;
}
}
for(int i = 0; i < n; i++) {
if(i) printf(" ");
printf("%d", s[i].p);
}
puts("");
}
return 0;
}
You have an array a consisting of n integers. Each integer from 1 to n appears exactly once in this array.
For some indices i (1 ≤ i ≤ n - 1) it is possible to swap i-th element with (i + 1)-th, for other indices it is not possible. You may perform any number of swapping operations any order. There is no limit on the number of times you swap i-th element with (i + 1)-th (if the position is not forbidden).
Can you make this array sorted in ascending order performing some sequence of swapping operations?
Input
The first line contains one integer n (2 ≤ n ≤ 200000) — the number of elements in the array.
The second line contains n integers a1, a2, …, an (1 ≤ ai ≤ 200000) — the elements of the array. Each integer from 1 to n appears exactly once.
The third line contains a string of n - 1 characters, each character is either 0 or 1. If i-th character is 1, then you can swap i-th element with (i + 1)-th any number of times, otherwise it is forbidden to swap i-th element with (i + 1)-th.
Output
If it is possible to sort the array in ascending order using any sequence of swaps you are allowed to make, print YES. Otherwise, print NO.
Examples
input
6
1 2 5 3 4 6
01110
output
YES
input
6
1 2 5 3 4 6
01010
output
NO
Note
In the first example you may swap a3 and a4, and then swap a4 and a5.
题意:
给你n个数,分别是1~n,让你按照1~n排好顺序,第三行输出可交换的位置,第i位为1表示i和i + 1位可以交换.
分析:
既然可以交换,那么交换的区间和一定与需要交换的位置数相等,按照这个暴力一遍就过了.
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long LL;
const int MAXN = 2e5 + 5;
int a[MAXN], sum[MAXN];
char str[MAXN];
int main() {
int t;
scanf("%d", &t);
for(int i = 1; i <= t; i++) {
getchar();
scanf("%d", &a[i]);
}
getchar();
scanf("%s", str);
int ans = 0;
for(int i = 0; i < t - 1; i++) {
if(str[i] == '1') ans++;
sum[i + 1] = ans;
}
bool flag = true;
int cnt;
for(int i = 1; i <= t; i++) {
if(a[i] != i) {
if(a[i] > i) {
cnt = a[i] - i;
if(cnt != sum[a[i] - 1] - sum[i - 1]) { //区间和和交换位置数比较
flag = false;
break;
}
}
else {
cnt = i - a[i];
if(cnt != sum[i - 1] - sum[a[i] - 1]) {
flag = false;
break;
}
}
}
}
if(!flag) printf("NO\n");
else printf("YES\n");
return 0;
}