A. Erasing Zeroes
Description
You are given a string \(s\). Each character is either 0 or 1.
You want all 1's in the string to form a contiguous subsegment. For example, if the string is 0, 1, 00111 or 01111100, then all 1's form a contiguous subsegment, and if the string is 0101, 100001 or 11111111111101, then this condition is not met.
You may erase some (possibly none) 0's from the string. What is the minimum number of 0's that you have to erase?
Input
The first line contains one integer \(t\) (\(1 \le t \le 100\)) — the number of test cases.
Then \(t\) lines follow, each representing a test case. Each line contains one string \(s\) (\(1 \le |s| \le 100\)); each character of \(s\) is either 0 or 1.
Output
Print \(t\) integers, where the \(i\)-th integer is the answer to the \(i\)-th testcase (the minimum number of 0's that you have to erase from \(s\)).
Sample Input
3
010011
0
1111000
Sample Output
2
0
0
思路
签到，首尾1
AC代码
#include<bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 3e5+7;
char s[150];
int main() {
int _;
cin>>_;
while(_--){
cin>>s+1;
int n=strlen(s+1);
int l=-1,r=-1;
for(int i=1;i<=n;++i){
if(s[i]=='1'){
l=i;
break;
}
}
for(int i=n;i>=1;--i){
if(s[i]=='1'){
r=i;
break;
}
}
if(l==-1){
puts("0");
continue;
}
int ans=0;
for(int i=l;i<=r;++i){
if(s[i]=='0')ans++;
}
printf("%d\n",ans);
}
return 0;
}B. National Project
Description
Your company was appointed to lay new asphalt on the highway of length \(n\). You know that every day you can either repair one unit of the highway (lay new asphalt over one unit of the highway) or skip repairing.
Skipping the repair is necessary because of the climate. The climate in your region is periodical: there are \(g\) days when the weather is good and if you lay new asphalt these days it becomes high-quality pavement; after that, the weather during the next \(b\) days is bad, and if you lay new asphalt these days it becomes low-quality pavement; again \(g\) good days, \(b\) bad days and so on.
You can be sure that you start repairing at the start of a good season, in other words, days \(1, 2, \dots, g\) are good.
You don't really care about the quality of the highway, you just want to make sure that at least half of the highway will have high-quality pavement. For example, if the \(n = 5\) then at least \(3\) units of the highway should have high quality; if \(n = 4\) then at least \(2\) units should have high quality.
What is the minimum number of days is needed to finish the repair of the whole highway?
Input
The first line contains a single integer \(T\) (\(1 \le T \le 10^4\)) — the number of test cases.
Next \(T\) lines contain test cases — one per line. Each line contains three integers \(n\), \(g\) and \(b\) (\(1 \le n, g, b \le 10^9\)) — the length of the highway and the number of good and bad days respectively.
Output
Print \(T\) integers — one per test case. For each test case, print the minimum number of days required to repair the whole highway if at least half of it should have high quality.
Sample Input
3
5 1 1
8 10 10
1000000 1 1000000
Sample Output
5
8
499999500000
思路
要注意一定要修\(n\)天，我的做法是先判断前\(n\)有没有到一半，然后如果不到一半，那就只需要判断剩下需要多少轮好天气的．总之就是一堆判断．
AC代码
#include<bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int _;
cin>>_;
while(_--) {
ll n,a,b;
cin>>n>>a>>b;
ll k=a+b;
ll tmp=n/k*a+min(a,n%k);//前n个有多少好的
if(tmp*2>=n) printf("%lld\n",n);
else{
ll ans=n/k*k;
tmp=(n+1)/2-n/k*a;//差
ll p=tmp/a;
if(tmp%a) ans+=p*k+tmp%a;
else ans+=(p-1)*k+a;
printf("%lld\n",ans);
}
}
return 0;
}其实也有简单做法:
cout << max(n, (n - 1) / 2 / g * (g + b) + (n - 1) / 2 % g + 1) << '\n';
这个其实挺像打怪兽那个题．也是判断最后一块有多少的
可以断言除了等于\(n\)的情况最后一块一定是以g结尾的．
总结一下设总数为\(N\)，每轮为\(k\)，则需要\((N-1)/k+1\)轮，最后一块是$(N-1) mod (k) +1 $．
C. Perfect Keyboard
Description
Polycarp wants to assemble his own keyboard. Layouts with multiple rows are too complicated for him — his keyboard will consist of only one row, where all \(26\) lowercase Latin letters will be arranged in some order.
Polycarp uses the same password \(s\) on all websites where he is registered (it is bad, but he doesn't care). He wants to assemble a keyboard that will allow to type this password very easily. He doesn't like to move his fingers while typing the password, so, for each pair of adjacent characters in \(s\), they should be adjacent on the keyboard. For example, if the password is abacaba, then the layout cabdefghi... is perfect, since characters a and c are adjacent on the keyboard, and a and b are adjacent on the keyboard. It is guaranteed that there are no two adjacent equal characters in \(s\), so, for example, the password cannot be password (two characters s are adjacent).
Can you help Polycarp with choosing the perfect layout of the keyboard, if it is possible?
Input
The first line contains one integer \(T\) (\(1 \le T \le 1000\)) — the number of test cases.
Then \(T\) lines follow, each containing one string \(s\) (\(1 \le |s| \le 200\)) representing the test case. \(s\) consists of lowercase Latin letters only. There are no two adjacent equal characters in \(s\).
Output
For each test case, do the following:
if it is impossible to assemble a perfect keyboard, print NO (in upper case, it matters in this problem); otherwise, print YES (in upper case), and then a string consisting of \(26\) lowercase Latin letters — the perfect layout. Each Latin letter should appear in this string exactly once. If there are multiple answers, print any of them.
Sample Input
5
ababa
codedoca
abcda
zxzytyz
abcdefghijklmnopqrstuvwxyza
Sample Output
YES
bacdefghijklmnopqrstuvwxyz
YES
edocabfghijklmnpqrstuvwxyz
NO
YES
xzytabcdefghijklmnopqrsuvw
NO
思路
一个大模拟，符合的是无环，并且每个点度数最多为2
AC代码
#include<bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 3e5+7;
char s[250];
vector<int>G[30];
bool vis[30][30];
bool us[30],uss[30];
int cnt,ans,sum;
void dfs(int u){
us[u]=cnt;
ans++;
sum+=G[u].size();
for(int v:G[u]){
if(!us[v]){
dfs(v);
}
}
}
void print(int u,int fa){
uss[u]=1;
printf("%c",u+'a');
for(int v:G[u]){
if(v!=fa){
print(v,u);
}
}
}
int main() {
int _;
cin>>_;
while(_--){
cin>>s;
cnt=0;
for(int i=0;i<26;++i) G[i].clear(),us[i]=uss[i]=0;
memset(vis,0,sizeof(vis));
for(int i=1;s[i];++i){
if(!vis[s[i]-'a'][s[i-1]-'a']){
G[s[i]-'a'].push_back(s[i-1]-'a');
G[s[i-1]-'a'].push_back(s[i]-'a');
vis[s[i]-'a'][s[i-1]-'a']=1;
vis[s[i-1]-'a'][s[i]-'a']=1;
}
}
bool flag=0;
for(int i=0;i<26;++i){
if(G[i].size()>2){
flag=1;
break;
}
if(!us[i]){
cnt++;
ans=0;
sum=0;
dfs(i);
if(sum/2!=ans-1){
flag=1;
break;
}
}
}
if(flag==0){
puts("YES");
for(int i=0;i<26;++i){
if(!uss[i]&&G[i].size()==1){
print(i,i);
}
}
for(int i=0;i<26;++i){
if(!uss[i]){
printf("%c",i+'a');
}
}
printf("\n");
}else{
puts("NO");
}
}
return 0;
}D. Fill The Bag
Description
You have a bag of size \(n\). Also you have \(m\) boxes. The size of \(i\)-th box is \(a_i\), where each \(a_i\) is an integer non-negative power of two.
You can divide boxes into two parts of equal size. Your goal is to fill the bag completely.
For example, if \(n = 10\) and \(a = [1, 1, 32]\) then you have to divide the box of size \(32\) into two parts of size \(16\), and then divide the box of size \(16\). So you can fill the bag with boxes of size \(1\), \(1\) and \(8\).
Calculate the minimum number of divisions required to fill the bag of size \(n\).
Input
The first line contains one integer \(t\) (\(1 \le t \le 1000\)) — the number of test cases.
The first line of each test case contains two integers \(n\) and \(m\) (\(1 \le n \le 10^{18}, 1 \le m \le 10^5\)) — the size of bag and the number of boxes, respectively.
The second line of each test case contains \(m\) integers \(a_1, a_2, \dots , a_m\) (\(1 \le a_i \le 10^9\)) — the sizes of boxes. It is guaranteed that each \(a_i\) is a power of two.
It is also guaranteed that sum of all \(m\) over all test cases does not exceed \(10^5\).
Output
For each test case print one integer — the minimum number of divisions required to fill the bag of size \(n\) (or \(-1\), if it is impossible).
Sample Input
3
10 3
1 32 1
23 4
16 1 4 1
20 5
2 1 16 1 8
Sample Output
2
-1
0
思路
我这个是照着代码最短的那个代码写的，如果按照题意模拟二进制可能更容易理解一点．
AC代码
#include<bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int _,n;
ll m;
cin>>_;
while(_--) {
priority_queue<int>q;
cin>>m>>n;
ll ans=0,sum=0;
for(int i=1,s;i<=n;++i){
cin>>s;q.push(s);
ans+=s;
}
if(ans<m){puts("-1");continue;}
while(m&&!q.empty()){
int x=q.top();
q.pop();
if(x<=m) m-=x,ans-=x;
else if(ans-x<m) sum++,q.push(x>>1),q.push(x>>1);
else ans-=x;
}
cout<<sum<<'\n';
}
return 0;
}E. Erase Subsequences
Description
You are given a string \(s\). You can build new string \(p\) from \(s\) using the following operation no more than two times:
choose any subsequence \(s_{i_1}, s_{i_2}, \dots, s_{i_k}\) where \(1 \le i_1 < i_2 < \dots < i_k \le |s|\); erase the chosen subsequence from \(s\) (\(s\) can become empty); concatenate chosen subsequence to the right of the string \(p\) (in other words, \(p = p + s_{i_1}s_{i_2}\dots s_{i_k}\)). Of course, initially the string \(p\) is empty.
For example, let \(s = \text{ababcd}\). At first, let's choose subsequence \(s_1 s_4 s_5 = \text{abc}\) — we will get \(s = \text{bad}\) and \(p = \text{abc}\). At second, let's choose \(s_1 s_2 = \text{ba}\) — we will get \(s = \text{d}\) and \(p = \text{abcba}\). So we can build \(\text{abcba}\) from \(\text{ababcd}\).
Can you build a given string \(t\) using the algorithm above?
Input
The first line contains the single integer \(T\) (\(1 \le T \le 100\)) — the number of test cases.
Next \(2T\) lines contain test cases — two per test case. The first line contains string \(s\) consisting of lowercase Latin letters (\(1 \le |s| \le 400\)) — the initial string.
The second line contains string \(t\) consisting of lowercase Latin letters (\(1 \le |t| \le |s|\)) — the string you'd like to build.
It's guaranteed that the total length of strings \(s\) doesn't exceed \(400\).
Output
Print \(T\) answers — one per test case. Print YES (case insensitive) if it's possible to build \(t\) and NO (case insensitive) otherwise.
Sample Input
4
ababcd
abcba
a
b
defi
fed
xyz
x
Sample Output
YES
NO
NO
YES
思路
AC代码
F. Number of Components
Description
You are given a matrix \(n \times m\), initially filled with zeroes. We define \(a_{i, j}\) as the element in the \(i\)-th row and the \(j\)-th column of the matrix.
Two cells of the matrix are connected if they share a side, and the elements in these cells are equal. Two cells of the matrix belong to the same connected component if there exists a sequence \(s_1\), \(s_2\), ..., \(s_k\) such that \(s_1\) is the first cell, \(s_k\) is the second cell, and for every \(i \in [1, k - 1]\), \(s_i\) and \(s_{i + 1}\) are connected.
You are given \(q\) queries of the form \(x_i\) \(y_i\) \(c_i\) (\(i \in [1, q]\)). For every such query, you have to do the following:
replace the element \(a_{x, y}\) with \(c\); count the number of connected components in the matrix. There is one additional constraint: for every \(i \in [1, q - 1]\), \(c_i \le c_{i + 1}\).
Input
The first line contains three integers \(n\), \(m\) and \(q\) (\(1 \le n, m \le 300\), \(1 \le q \le 2 \cdot 10^6\)) — the number of rows, the number of columns and the number of queries, respectively.
Then \(q\) lines follow, each representing a query. The \(i\)-th line contains three integers \(x_i\), \(y_i\) and \(c_i\) (\(1 \le x_i \le n\), \(1 \le y_i \le m\), \(1 \le c_i \le \max(1000, \lceil \frac{2 \cdot 10^6}{nm} \rceil)\)). For every \(i \in [1, q - 1]\), \(c_i \le c_{i + 1}\).
Output
Print \(q\) integers, the \(i\)-th of them should be equal to the number of components in the matrix after the first \(i\) queries are performed.
Sample Input
3 2 10
2 1 1
1 2 1
2 2 1
1 1 2
3 1 2
1 2 2
2 2 2
2 1 2
3 2 4
2 1 5
Sample Output
2
4
3
3
4
4
4
2
2
4
思路
AC代码
G. Sum of Prefix Sums
Description
We define the sum of prefix sums of an array \([s_1, s_2, \dots, s_k]\) as \(s_1 + (s_1 + s_2) + (s_1 + s_2 + s_3) + \dots + (s_1 + s_2 + \dots + s_k)\).
You are given a tree consisting of \(n\) vertices. Each vertex \(i\) has an integer \(a_i\) written on it. We define the value of the simple path from vertex \(u\) to vertex \(v\) as follows: consider all vertices appearing on the path from \(u\) to \(v\), write down all the numbers written on these vertices in the order they appear on the path, and compute the sum of prefix sums of the resulting sequence.
Your task is to calculate the maximum value over all paths in the tree.
Input
The first line contains one integer \(n\) (\(2 \le n \le 150000\)) — the number of vertices in the tree.
Then \(n - 1\) lines follow, representing the edges of the tree. Each line contains two integers \(u_i\) and \(v_i\) (\(1 \le u_i, v_i \le n\), \(u_i \ne v_i\)), denoting an edge between vertices \(u_i\) and \(v_i\). It is guaranteed that these edges form a tree.
The last line contains \(n\) integers \(a_1\), \(a_2\), ..., \(a_n\) (\(1 \le a_i \le 10^6\)).
Output
Print one integer — the maximum value over all paths in the tree.
Sample Input
4
4 2
3 2
4 1
1 3 3 7
Sample Output
36
思路
AC代码