├── 800
    ├── 04.cpp
    ├── 09.cpp
    ├── 05.cpp
    ├── 14.cpp
    ├── 01.cpp
    ├── 15.cpp
    ├── 31.cpp
    ├── 08.cpp
    ├── 18.cpp
    ├── 30.cpp
    ├── 07.cpp
    ├── 11.cpp
    ├── 22.cpp
    ├── 20.cpp
    ├── 02.cpp
    ├── 24.cpp
    ├── 19.cpp
    ├── 12.cpp
    ├── 25.cpp
    ├── 23.cpp
    ├── 21.cpp
    ├── 03.cpp
    ├── 16.cpp
    ├── 28.cpp
    ├── 10.cpp
    ├── 06.cpp
    ├── 27.cpp
    ├── 29.cpp
    ├── 13.cpp
    ├── 26.cpp
    └── 17.cpp
├── 900
    ├── 20.cpp
    ├── 25.cpp
    ├── 06.cpp
    ├── 26.cpp
    ├── 04.cpp
    ├── 23.cpp
    ├── 03.cpp
    ├── 24.cpp
    ├── 31.cpp
    ├── 13.cpp
    ├── 08.cpp
    ├── 30.cpp
    ├── 19.cpp
    ├── 09.cpp
    ├── 22.cpp
    ├── 02.cpp
    ├── 28.cpp
    ├── 11.cpp
    ├── 27.cpp
    ├── 14.cpp
    ├── 05.cpp
    ├── 07.cpp
    ├── 29.cpp
    ├── 01.cpp
    ├── 17.cpp
    ├── 15.cpp
    ├── 10.cpp
    ├── 16.cpp
    ├── 18.cpp
    ├── 12.cpp
    └── 21.cpp
├── 1000
    ├── 30.cpp
    ├── 09.cpp
    ├── 28.cpp
    ├── 31.cpp
    ├── 26.cpp
    ├── 27.cpp
    ├── 01.cpp
    ├── 17.cpp
    ├── 18.cpp
    ├── 25.cp
    ├── 16.cpp
    ├── 29.cpp
    ├── 15.cpp
    ├── 22.cpp
    ├── 23.cpp
    ├── 13.cpp
    ├── 14.cpp
    ├── 05.cpp
    ├── 10.cpp
    ├── 08.cpp
    ├── 20.cpp
    ├── 02.cpp
    ├── 24.cpp
    ├── 03.cpp
    ├── 11.cpp
    ├── 12.cpp
    ├── 06.cpp
    ├── 21.cpp
    ├── 04.cpp
    ├── 19.cpp
    └── 07.cpp
├── 1100
    ├── 01.cpp
    ├── 10.cpp
    ├── 07.cpp
    ├── 02.cpp
    ├── 22.cpp
    ├── 09.cpp
    ├── 04.cpp
    ├── 06.cpp
    ├── 08.cpp
    ├── 03.cpp
    ├── 13.cpp
    ├── 11.cpp
    ├── 12.cpp
    ├── 24.cpp
    ├── 28.cpp
    ├── 26.cpp
    ├── 05.cpp
    ├── 18.cpp
    ├── 20.cpp
    ├── 31.cpp
    ├── 14.cpp
    ├── 29.cpp
    ├── 27.cpp
    ├── 21.cpp
    ├── 30.cpp
    ├── 23.cpp
    ├── 15.cpp
    ├── 16.cpp
    ├── 25.cpp
    ├── 17.cpp
    └── 19.cpp
├── 1200
    └── 01.cpp
└── README.md


/800/04.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1899/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main() {
 5 |     int tc;
 6 |     cin>>tc;
 7 |     while(tc--){
 8 |         int n ; cin>>n;
 9 |         if(n%3==0) cout<<"Second"<<endl;
10 |         else cout<<"First"<<endl;
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/800/09.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1877/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main() {
 5 |     int tc;
 6 |     cin>>tc;
 7 |     while(tc--){
 8 |         int n,sum=0; 
 9 |         cin>>n;
10 |         for(int i=0;i<n-1;i++){
11 |             int x; cin>>x;
12 |             sum+=x;
13 |         }
14 |         cout<<(0-sum)<<endl;
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/800/05.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1896/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 |  
 5 | int main() {
 6 |     int tc;
 7 |     cin>>tc;
 8 |     while(tc--){
 9 |         int n;
10 |         cin>>n;
11 |         int arr[n];
12 |         for(int i=0;i<n;i++){
13 |             cin>>arr[i];
14 |         }
15 |         if(arr[0]==1) cout<<"YES"<<endl;
16 |         else cout<<"NO"<<endl;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/900/20.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1606/A
 2 | //AB Balance
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         string s;
16 |         cin>>s;
17 |         s[0] = s.back();
18 |         cout<<s<<endl;
19 | 	}
20 | }
21 | 


--------------------------------------------------------------------------------
/900/25.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1537/problem/B
 2 | //Bad Boy
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int m,n,x,y;
16 |         cin>>m>>n>>x>>y;
17 |         cout<<1<<" "<<1<<" "<<m<<" "<<n<<endl;
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/800/14.cpp:
--------------------------------------------------------------------------------
 1 | //Buttons
 2 | //https://codeforces.com/problemset/problem/1858/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int a,b,c;
10 |         cin>>a>>b>>c;
11 |         if(c%2!=0) a+=c/2+1,b+=c/2;
12 |         else a+=c/2,b+=c/2;
13 |         if(a>b) cout<<"First"<<endl;
14 |         else cout<<"Second"<<endl;
15 |     }
16 |         
17 |     }
18 | 


--------------------------------------------------------------------------------
/800/01.cpp:
--------------------------------------------------------------------------------
 1 | https://codeforces.com/contest/1903/problem/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main(){
 5 |     int tc;
 6 |     cin>>tc; 
 7 |     while(tc--){
 8 |         int n , k;
 9 |         cin>>n>>k;
10 |         int arr[n];
11 |         for(int i=0;i<n;i++){
12 |             cin>>arr[i];
13 |         }
14 |         if(k==1 && !is_sorted(arr,arr+n)) cout<<"NO"<<endl;
15 |         else cout<<"YES"<<endl;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/800/15.cpp:
--------------------------------------------------------------------------------
 1 | //Array Coloring
 2 | //https://codeforces.com/problemset/problem/1857/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int n,odd=0; cin>>n;
10 |         for(int i=0;i<n;i++){
11 |             int x; cin>>x;
12 |             if(x%2!=0) odd++;
13 |         }
14 |         if(odd%2==0) cout<<"Yes"<<endl;
15 |         else cout<<"No"<<endl;
16 |     }
17 |         
18 | }
19 | 


--------------------------------------------------------------------------------
/800/31.cpp:
--------------------------------------------------------------------------------
 1 | //Two Permutations
 2 | //https://codeforces.com/problemset/problem/1761/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         int a,b,n; cin>>n>>a>>b;
11 |         if(n==a and n==b) cout<<"Yes"<<endl;
12 |         else{
13 |             if(n-a-b>1) cout<<"Yes"<<endl;
14 |             else cout<<"No"<<endl;
15 |         }
16 |     }    
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/800/08.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1878/problem/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std; 
 4 | int main(){
 5 |     int tc;
 6 |     cin>>tc;
 7 |     while(tc--){
 8 |         int n , k;
 9 |         cin>>n>>k; bool flag = false;
10 |         for(int i=0;i<n;i++){
11 |             int x;
12 |             cin>>x; 
13 |             if(x==k){flag = true;}
14 |         }
15 |         if(flag) cout<<"YES"<<endl;
16 |         else cout<<"NO"<<endl;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/900/06.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1855/B
 2 | //Longest Divisors Interval
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define ull unsigned long long
 7 | int solve(){
 8 | }
 9 | int main() {
10 | 	int tc;
11 | 	cin>>tc;
12 | 	while(tc--){
13 |         ull n;
14 |         cin>>n;
15 |         ll i = 1;
16 |         for(i;i<=n;i++){
17 |             if(n%i!=0) break;
18 |         } 
19 |         cout << i-1 << endl;
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/800/18.cpp:
--------------------------------------------------------------------------------
 1 | //Grasshopper on a Line
 2 | //https://codeforces.com/contest/1837/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int x,k;
10 |         cin>>x>>k;
11 |         if(x%k){
12 |             cout<<1<<endl<<x;
13 |         }
14 |         else{
15 |             cout<<2<<endl;
16 |             cout<<x-(k+1)<<" "<<k+1;
17 |         }
18 |         cout<<endl;
19 |     }
20 |         
21 | }
22 | 


--------------------------------------------------------------------------------
/900/26.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1475/A
 2 | //Odd Divisor
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | #define yes "YES"
10 | #define no "NO"
11 | int solve(){
12 | }
13 | int main() {
14 | 	int tc;
15 | 	cin>>tc;
16 | 	while(tc--){
17 |         ll n ; cin>>n;
18 |         if((n&(n-1))==0) cout<<no<<endl;
19 |         else cout<<yes<<endl;
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/800/30.cpp:
--------------------------------------------------------------------------------
 1 | //Extremely Round
 2 | //https://codeforces.com/problemset/problem/1776/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         int n; cin>>n;
11 |         int digits = 0, ld;
12 |         while(n>0){
13 |             ld = n%10;
14 |             n/=10;
15 |             digits++;
16 |         }
17 |         cout<<(ld+(digits-1)*9);
18 |         cout<<endl;
19 |     }    
20 | }
21 | 
22 | 


--------------------------------------------------------------------------------
/900/04.cpp:
--------------------------------------------------------------------------------
 1 | https://codeforces.com/contest/1875/problem/A
 2 | //Jellyfish and Undertale
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | int solve(){
 7 | }
 8 | int main() {
 9 | 	int tc;
10 | 	cin>>tc;
11 | 	while(tc--){
12 | 		unsigned ll a,b,n;
13 | 		cin>>a>>b>>n;
14 | 		unsigned ll count = 0,sum = 0;
15 | 		for(int i =0;i<n;i++){
16 | 			int x; cin>>x;
17 | 			if(x>=a) count++;
18 | 			else sum+=x;
19 | 		}
20 | 		cout<<sum+b+(count*(a-1))<<endl;
21 | 
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/800/07.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1881/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main() {
 5 |     int tc;
 6 |     cin>>tc;
 7 |     while(tc--){
 8 |         int n,m,k; string x,s;
 9 |         cin>>n>>m;
10 |         cin>>x>>s;
11 |         for(k = 0;k<6;k++) {
12 |             if(x.find(s) != -1){
13 |                 cout<<k<<endl; 
14 |                 break;
15 |             }
16 |             x+=x;
17 |         }
18 |         if(k==6) cout<<-1<<endl;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/800/11.cpp:
--------------------------------------------------------------------------------
 1 | https://codeforces.com/problemset/problem/1866/A//
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main() {
 5 |     // int tc; 
 6 |     // cin>>tc;
 7 |     // while(tc--){
 8 |         int n;
 9 |         cin>>n;
10 |         int mini = INT_MAX , maxi=INT_MIN+1;
11 |         for(int i=0;i<n;i++){
12 |             int x; cin>>x;
13 |             if(x<0) maxi = max(maxi,x);
14 |             else mini = min(mini,x);
15 |         }
16 |         cout<<min(abs(maxi),mini)<<endl;
17 |    // }
18 | }
19 | 


--------------------------------------------------------------------------------
/800/22.cpp:
--------------------------------------------------------------------------------
 1 | //Coins
 2 | //https://codeforces.com/contest/1814/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | bool solve(ll n,ll k){
 7 |         if(n%2==0 or n%k==0) return true;
 8 |         else if(n%2 and k%2) return true;
 9 |         else return false;
10 | }
11 | int main() {
12 |      int tc;
13 |      cin>>tc;
14 |      while(tc--){
15 |         ll n,k;
16 |         cin>>n>>k;
17 |         cout<<(solve(n,k)?"YES":"NO");
18 |         cout<<endl;
19 |     }    
20 | }
21 | 


--------------------------------------------------------------------------------
/900/23.cpp:
--------------------------------------------------------------------------------
 1 | //Mocha and Math
 2 | //https://codeforces.com/problemset/problem/1559/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;
16 |         cin>>n;int arr[n];
17 |         for(int i=0;i<n;i++) cin>>arr[i];
18 |         int x = arr[0];
19 |         for(auto a : arr) x&=a;
20 |         cout<<x<<endl;
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/900/03.cpp:
--------------------------------------------------------------------------------
 1 | //Vasilije in Cacak
 2 | //https://codeforces.com/problemset/problem/1878/C
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         ll n,k,x;
11 |         cin>>n>>k>>x;
12 |         ll sum = 0;
13 |         ll mini = (k*(k+1))/2; //first k sum 
14 |         ll maxi = (k*(2*n+1-k))/2; // last k sum
15 |         if(x>=mini and x<=maxi) cout<<"YES";
16 |         else cout<<"NO";
17 |         cout<<endl;
18 |     }    
19 | }
20 | 


--------------------------------------------------------------------------------
/800/20.cpp:
--------------------------------------------------------------------------------
 1 | //Twin Permutations
 2 | //https://codeforces.com/contest/1831/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | void solve(){
 6 |         int n;
 7 |         cin>>n;
 8 |         int arr[n]; int maxi = INT_MIN;
 9 |         for(int i=0;i<n;i++) cin>>arr[i],maxi = max(maxi,arr[i]);
10 |         for(int i=0;i<n;i++){
11 |             cout<<maxi-arr[i]<<" ";
12 |         }
13 |         cout<<endl;
14 | }
15 | int main() {
16 |      int tc;
17 |      cin>>tc;
18 |      while(tc--){
19 |         solve();
20 |     }    
21 | }
22 | 


--------------------------------------------------------------------------------
/800/02.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1901/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |     int tc;
 7 |     cin>>tc;
 8 |     while(tc--){
 9 |         int n , x;
10 |         cin>>n>>x;
11 |         int arr[n];
12 |         for(int i=0;i<n;i++) cin>>arr[i];
13 |         int maxdis = arr[0]; int dis = arr[0];
14 |         for(int i=1;i<n;i++){
15 |             dis = arr[i-1];
16 |             maxdis = max(maxdis,arr[i]-dis);
17 |         }
18 |         cout<<max(maxdis,2*(x-arr[n-1]))<<endl;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/1000/30.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1312/B
 2 | //Bogosort
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n;
17 |         cin>>n;
18 |         vector<int> arr(n);
19 |         for(auto &X : arr) cin>>X;
20 |         sort(arr.rbegin(),arr.rend());
21 |         for(auto c: arr) cout<<c<<" ";
22 |         cout<<endl;
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/800/24.cpp:
--------------------------------------------------------------------------------
 1 | //We Need the Zero
 2 | //https://codeforces.com/contest/1805/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int solve(int n){
 7 |     int ans = 0;
 8 |     for(int i=0;i<n;i++){
 9 |         int x; cin>>x;
10 |         ans = ans^x;
11 |     }
12 |     if(n%2) return ans;
13 |     else if(ans==0) return 0;
14 |     else return -1;
15 | }
16 | int main() {
17 |      int tc;
18 |      cin>>tc;
19 |      while(tc--){
20 |         int n; cin>>n;
21 |         cout<<solve(n);
22 |         cout<<endl;
23 |     }    
24 | }
25 | 
26 | 


--------------------------------------------------------------------------------
/1100/01.cpp:
--------------------------------------------------------------------------------
 1 | //Erase First or Second Letter
 2 | //https://codeforces.com/contest/1917/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int main() {
10 | 	int tc;
11 | 	cin>>tc;
12 | 	while(tc--){
13 |         set<char> x;
14 |         int n; cin>>n; 
15 |         string s; cin>>s;
16 |         ll ans = 0;
17 |         for(int i=0;i<n;i++){
18 |             x.insert(s[i]);
19 |             ans+=(ll)x.size();
20 |         }
21 |         cout<<ans<<endl;
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/800/19.cpp:
--------------------------------------------------------------------------------
 1 | //Unit Array
 2 | //https://codeforces.com/contest/1834/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int n;
10 |         cin>>n;
11 |         int neg = 0, pos = 0;
12 |         for(int i=0;i<n;i++){
13 |             int x; cin>>x;
14 |             if(x==1) pos++;
15 |             else neg++;
16 |         }
17 |         int sum = pos-neg, need = 0;
18 |         if(sum<0) need = (abs(sum)+1)/2;
19 |         neg-=need;
20 |         cout<<need+(neg%2)<<endl;
21 |     }    
22 | }
23 | 


--------------------------------------------------------------------------------
/900/24.cpp:
--------------------------------------------------------------------------------
 1 | //Exciting Bets
 2 | //https://codeforces.com/contest/1543/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll a,b;
16 |         cin>>a>>b;
17 |         ll c = abs(a-b);
18 |         if(c==0) {cout<<0<<" "<<0<<endl;continue;}
19 |         ll x = a/c;
20 |         ll x1 = abs(x*c-a),x2 = abs((x+1)*c-a);
21 |         cout<<c<<" "<<min(x1,x2)<<endl;
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/800/12.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1862/B
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main() {
 5 |      int tc;
 6 |      cin>>tc;
 7 |      while(tc--){
 8 |         int n;
 9 |         cin>>n; int arr[n];
10 |         for(int i=0;i<n;i++) cin>>arr[i];
11 |         vector<int> a; a.push_back(arr[0]);
12 |         for(int i=1;i<n;i++){
13 |             if(arr[i]<arr[i-1]) a.push_back(arr[i]);
14 |             a.push_back(arr[i]);
15 |         }
16 |         cout<<a.size()<<endl;
17 |         for(auto x: a) cout<<x<<" ";
18 |         cout<<endl;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/800/25.cpp:
--------------------------------------------------------------------------------
 1 | //Prepend and Append
 2 | //https://codeforces.com/problemset/problem/1791/C
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int solve(string s){
 7 |     if(s.size()==1) return 1;
 8 |     int i=0, j=s.size()-1;
 9 |     while(i<=j){
10 |         if(s[i]==s[j]) return j-i+1;
11 |         else i++,j--;
12 |     }
13 |     return 0;
14 | }
15 | int main() {
16 |      int tc;
17 |      cin>>tc;
18 |      while(tc--){
19 |         int n; cin>>n;
20 |         string s; cin>>s;
21 |         cout<<solve(s);
22 |         cout<<endl;
23 |     }    
24 | }
25 | 
26 | 


--------------------------------------------------------------------------------
/900/31.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1374/B
 2 | //Multiply by 2, divide by 6
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll n;cin>>n;
16 |         int cnt = 0,a=0;
17 |         while(n%6==0) n/=6,cnt++;
18 |         while(n%3==0) n/=3,a++;
19 |         if(n==1){
20 |             cout<<cnt+(a*2)<<endl;
21 |         }
22 |         else cout<<-1<<endl;
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/800/23.cpp:
--------------------------------------------------------------------------------
 1 | //Walking Master
 2 | //https://codeforces.com/contest/1806/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int solve(int a,int b, int c, int d){
 7 |        if(b>d) return -1;
 8 |        int up = d-b;
 9 |        int new_a = a+up;
10 |        if(new_a<c) return -1;
11 |        int left = new_a-c;
12 |        return up+left;
13 | }
14 | int main() {
15 |      int tc;
16 |      cin>>tc;
17 |      while(tc--){
18 |         int a,b,c,d;
19 |         cin>>a>>b>>c>>d;
20 |         cout<<solve(a,b,c,d);
21 |         cout<<endl;
22 |     }    
23 | }
24 | 
25 | 


--------------------------------------------------------------------------------
/800/21.cpp:
--------------------------------------------------------------------------------
 1 | //Blank Space
 2 | //https://codeforces.com/contest/1829/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | void solve(){
 6 |         int n;
 7 |         cin>>n;
 8 |         int arr[n]; int maxi =0;
 9 |         for(int i=0;i<n;i++){ cin>>arr[i];}
10 |         int streak = 0;
11 |         for(int i=0;i<n;i++){
12 |             if(arr[i]==0) streak++,maxi = max(streak,maxi);
13 |             else streak = 0;
14 |         }
15 |         cout<<maxi<<endl;
16 | }
17 | int main() {
18 |      int tc;
19 |      cin>>tc;
20 |      while(tc--){
21 |         solve();
22 |     }    
23 | }
24 | 


--------------------------------------------------------------------------------
/1000/09.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1765/problem/M
 2 | //Minimum LCM
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n;
17 |         cin>>n;
18 |         int a = 1;
19 |         for(int i=2;i*i<=n;i++){
20 |             if(n%i==0){
21 |                 a = n/i;
22 |                 break;
23 |             }
24 |         }
25 |         cout<<a<<" "<<n-a<<endl;
26 | 	}
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/800/03.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1900/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |     int tc;
 7 |     cin>>tc;
 8 |     while(tc--){
 9 |         int n ; string s;
10 |         cin>>n>>s;
11 |         int count = 0; bool flag = false;
12 |         for(int i=0;i<n;i++){
13 |             if(s[i]=='.') count++;
14 |             if(i>0 and i<n-1){
15 |                 if(s[i-1]=='.' and s[i]=='.' and s[i+1]=='.') flag = true;
16 |             }
17 |         }
18 |         if(flag) cout<<2<<endl;
19 |         else cout<<count<<endl;
20 |     }
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/800/16.cpp:
--------------------------------------------------------------------------------
 1 | //Desorting
 2 | //https://codeforces.com/contest/1853/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int n,gap = INT_MAX; bool flag = false;
10 |         cin>>n;
11 |         int prev ; cin>>prev;
12 |         for(int i=1;i<n;i++){
13 |             int x; cin>>x;
14 |             if(x<prev) flag = true;
15 |             else gap = min(gap,x-prev);
16 |             prev = x;
17 |         }
18 |         if(!flag) cout<<(gap/2)+1<<endl;
19 |         else cout<<0<<endl;
20 |     }
21 |         
22 | }
23 | 


--------------------------------------------------------------------------------
/900/13.cpp:
--------------------------------------------------------------------------------
 1 | //NIT Destroys the Universe
 2 | //https://codeforces.com/contest/1696/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;
16 |         cin>>n;int count = 0;
17 |         vector<int> arr(n+1,0);
18 |         for(int i=1;i<=n;i++){
19 |             cin>>arr[i];
20 |             if(arr[i]>0 and arr[i-1]==0) count++;
21 |         }
22 |         cout<<min(count,2)<<endl;
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/800/28.cpp:
--------------------------------------------------------------------------------
 1 | // Make it Beautiful
 2 | //https://codeforces.com/problemset/problem/1783/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         int n; cin>>n;
11 |         int arr[n];
12 |         for(int i=0;i<n;i++){
13 |             cin>>arr[i];
14 |         }
15 |         if(arr[0]==arr[n-1]) cout<<"No";
16 |         else{
17 |             cout<<"Yes"<<endl;
18 |             cout<<arr[n-1]<<" ";
19 |             for(int i=0;i<n-1;i++) cout<<arr[i]<<" ";
20 |         }
21 |  
22 |         cout<<endl;
23 |     }    
24 | }
25 | 


--------------------------------------------------------------------------------
/900/08.cpp:
--------------------------------------------------------------------------------
 1 | //Comparison String
 2 | //https://codeforces.com/problemset/problem/1837/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | int solve(){
 7 | }
 8 | int main() {
 9 | 	int tc;
10 | 	cin>>tc;
11 | 	while(tc--){
12 |         int n;string s;
13 |         cin>>n>>s;
14 |         int cnt=1, maxi = 1;
15 |         for(int i=0;i<s.size()-1;i++){
16 |             if(s[i]==s[i+1]) cnt++;
17 |             else{
18 |                 maxi = max(maxi,cnt);
19 |                 cnt = 1;
20 |             }
21 |         }
22 |         maxi = max(maxi,cnt);
23 |         cout<<maxi+1<<endl;
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/1000/28.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1374/C
 2 | //Move Brackets
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n; cin>>n;
17 |         string s;cin>>s;
18 |         stack<char> st;
19 |         for(int i=0;i<s.size();i++){
20 |             if(s[i]==')' and st.size()>0) st.pop();
21 |             else if(s[i]=='(') st.push(s[i]);
22 |         }
23 |         cout<<st.size()<<endl;
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/900/30.cpp:
--------------------------------------------------------------------------------
 1 | //01 Game
 2 | //https://codeforces.com/contest/1373/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         string s;
16 |         cin>>s;
17 |         int zero=0,one=0;
18 |         for(auto x: s){
19 |             if(x=='0') zero++;
20 |             else one++;
21 |         }
22 |         int moves = min(zero,one);
23 |         if(moves%2) cout<<"DA"<<endl;
24 |         else cout<<"NET"<<endl;
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/900/19.cpp:
--------------------------------------------------------------------------------
 1 | //Odd Grasshopper
 2 | //https://codeforces.com/contest/1607/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll x,n;
16 |         cin>>x>>n;
17 |         ll ans = 0;
18 |         if(n%4==0) ans+=0;
19 |         else if(n%4==1) ans-=n;
20 |         else if(n%4==2) ans+=1;
21 |         else ans+=n+1;
22 |         if(x%2==0) cout<<x+ans<<endl;
23 |         else cout<<x-ans<<endl;
24 | 	}
25 |     
26 |     
27 | }
28 | 


--------------------------------------------------------------------------------
/1000/31.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1155/A
 2 | //Reverse a Substring
 3 | 
 4 | #include <bits/stdc++.h>
 5 | using namespace std;
 6 | #define ll long long 
 7 | #define gcd __gcd
 8 | #define ull unsigned long long
 9 | #define endl "\n"
10 | 
11 | int solve(){
12 | }
13 | int main() {
14 | 	int n;cin>>n;
15 |     string s;
16 |     cin>>s;
17 |     bool flag = true;
18 |     for(int i=0;i<n-1;i++){
19 |         if(s[i]>s[i+1]){
20 |             cout<<"YES"<<endl;
21 |             cout<<i+1<<" "<<i+2<<endl;
22 |             flag = false;
23 |             break;
24 |         }
25 |     }
26 |     if(flag) cout<<"NO"<<endl;
27 | }
28 | 


--------------------------------------------------------------------------------
/900/09.cpp:
--------------------------------------------------------------------------------
 1 | //Permutation Swap
 2 | //https://codeforces.com/contest/1828/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | int solve(){
 8 | }
 9 | 
10 | int main() {
11 | 	int tc;
12 | 	cin>>tc;
13 | 	while(tc--){
14 |         int n;
15 |         cin>>n; int arr[n];
16 |         for(int i=0;i<n;i++){
17 |             cin>>arr[i];
18 |         }
19 |         int x;int ans = 0;
20 |         for(int i=0;i<n;i++){
21 |             if(arr[i]==i+1) continue;
22 |             x = abs(arr[i]-(i+1));
23 |             ans = gcd(x,ans);
24 |         }
25 |         cout<<ans<<endl;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/800/10.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1873/problem/C
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | int main() { 
 5 |     int tc;
 6 |     cin>>tc;
 7 |     while(tc--){
 8 |         int score = 0;
 9 |         for(int i=0;i<10;i++){
10 |             for(int j=0;j<10;j++){
11 |                 char x;
12 |                 cin>>x;
13 |                 if(x=='X'){
14 |                     int k = i,l = j;
15 |                     if(k>=5) k = 10-i-1;
16 |                     if(l>=5) l = 10-j-1;
17 |                     score+=min(k+1,l+1);
18 |                 }
19 |             }
20 |         }
21 |         cout<<score<<endl;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/1000/26.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1418/A
 2 | //Buying Torches
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll cost, coal, k;
17 |         cin>>cost>>coal>>k;
18 |         ll need = (coal*k)+k-1;
19 |         ll ans = k;
20 |         ll stick = 1;
21 |         if(need%(cost-1)==0) ans+=need/(cost-1);
22 |         else{
23 |             ans+=(need/(cost-1))+1;
24 |         }
25 |         cout<<ans<<endl;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/1000/27.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1411/B
 2 | //Fair Numbers
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | bool solve(ll n){
11 |     ll x = n;
12 |     while(n>0){
13 |         int ld = n%10;
14 |         if(ld!=0 and x%ld!=0) return false;
15 |         n/=10;
16 |     }
17 |     return true;
18 | }
19 | int main() {
20 | 	int tc;
21 | 	cin>>tc;
22 | 	while(tc--){
23 |         ll n;cin>>n;ll i;
24 |         for( i=n;;i++){
25 |             if(solve(i)) break;
26 |         }
27 |         cout<<i<<endl;
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/900/22.cpp:
--------------------------------------------------------------------------------
 1 | //Luntik and Subsequences
 2 | //https://codeforces.com/problemset/problem/1582/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll n;cin>>n;
16 |         ll zeroes = 0 ,ones =0;
17 |         for(int i=0;i<n;i++){
18 |             ll x;cin>>x;
19 |             if(x==0) zeroes++;
20 |             else if(x==1) ones++;
21 |         }
22 |         ll each = pow(2,zeroes);
23 |         ll total = ones*(each?each:1);
24 |         cout<<total<<endl;
25 | 	}
26 | }
27 | 


--------------------------------------------------------------------------------
/900/02.cpp:
--------------------------------------------------------------------------------
 1 | //Chemistry
 2 | //https://codeforces.com/problemset/problem/1883/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         int n,k;
11 |         cin>>n>>k;
12 |         string s;
13 |         cin>>s;
14 |         unordered_map<char,int> mp;
15 |         for(auto x: s){
16 |             mp[x]++;
17 |         }
18 |         int odd = 0;
19 |         for(auto x: mp){
20 |             int a = x.second;
21 |             if(a%2) odd++;
22 |         }
23 |         if(odd>k+1) cout<<"NO";
24 |         else cout<<"YES";
25 |         cout<<endl;
26 |     }    
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/1000/01.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1913/B
 2 | //Swap and Delete
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 | 		string s;
17 | 		cin>>s;
18 | 		int z=0, o=0;
19 | 		for(auto x: s){
20 | 			if(x=='0')z++;
21 | 			else o++;
22 | 		}
23 | 		int n = s.size();
24 | 		for(int i=0;i<s.size();i++){
25 | 			if(s[i]=='0'){
26 | 				if(o>0)o--,n--;
27 | 				else break;
28 | 			}
29 | 			else{
30 | 				if(z>0) z--,n--;
31 | 				else break;
32 | 			}
33 | 		}
34 | 		cout<<n<<endl;
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/900/28.cpp:
--------------------------------------------------------------------------------
 1 | //Sum of Medians
 2 | //https://codeforces.com/contest/1440/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n , k;
16 |         cin>>n>>k;int arr[n*k];
17 |         for(int i=0;i<n*k;i++){
18 |             cin>>arr[i];
19 |         }
20 |         ll sum = 0;
21 |         int i=n*k;
22 |         int mid = n/2+n%2;
23 |         int left = n-mid+1;
24 |         while(k--){
25 |             i-=left;
26 |             sum+=arr[i];
27 |         }
28 |         cout<<sum<<endl;
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/1000/17.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1632/B
 2 | //Roof Construction
 3 | #include <bits/stdc++.h>
 4 | #ifndef ONLINE_JUDGE
 5 | #include <D:\CP\debug_Template.cpp>
 6 | #else
 7 | #define debug(...)
 8 | #define debugArr(...)
 9 | #endif
10 | using namespace std;
11 | #define ll long long 
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | 
16 | int solve(){
17 | }
18 | int main(){
19 |     int t;
20 |     cin >> t;
21 |     while(t--) {
22 |         int n;
23 |         cin >> n;
24 |         int k = log2(n-1), s= pow(2,k);
25 |         for(int i = s-1; i>=0; i--) {cout<<i<<' ';}
26 |         for(int i=s;i<n;i++){cout<<i<<' ';}
27 |         cout<<'\n';
28 |     }
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/800/06.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1890/A
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |     int tc;
 7 |     cin>>tc;
 8 |     while(tc--){
 9 |         int n;
10 |         cin>>n;
11 |         int arr[n];
12 |         for(int i=0;i<n;i++) cin>>arr[i];
13 |         unordered_map<int,int> m;
14 |         for(auto x: arr) m[x]++;
15 |         if(m.size()>2) cout<<"No"<<endl;
16 |         else if(m.size()==1) cout<<"Yes"<<endl;
17 |         else if(m.size()==2){
18 |             vector<int> p;
19 |             for(auto x: m) p.push_back(x.second);
20 |             if(abs(p[0]-p[1])<=1) cout<<"Yes"<<endl;
21 |             else cout<<"No"<<endl;
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/800/27.cpp:
--------------------------------------------------------------------------------
 1 | //One and Two
 2 | //https://codeforces.com/problemset/problem/1788/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | 
 7 | int solve(int arr[],int n,int twos){
 8 |     int x = 0;
 9 |     for(int i=0;i<n;i++){
10 |         if(arr[i]==2) x++, twos--;
11 |         if(twos==x) return i+1;
12 |     }
13 |     return -1;
14 | }
15 | int main() {
16 |      int tc;
17 |      cin>>tc;
18 |      while(tc--){
19 |         int n; cin>>n;
20 |         int arr[n];
21 |         int twos =0;
22 |         for(int i=0;i<n;i++){
23 |             cin>>arr[i];
24 |             if(arr[i]==2) twos++;
25 |         }
26 |         cout<<solve(arr,n,twos);
27 |         cout<<endl;
28 |     }    
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/900/11.cpp:
--------------------------------------------------------------------------------
 1 | //Not Dividing
 2 | //https://codeforces.com/problemset/problem/1794/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 | 		int n;
16 | 		cin>>n; int arr[n];
17 | 		for(int i=0;i<n;i++){
18 | 			cin>>arr[i];
19 | 		}
20 | 		if(arr[0]==1) arr[0]++;
21 | 		for(int i=1;i<n;i++){
22 | 			if(arr[i]==1){
23 | 				arr[i]++;
24 | 				while(arr[i]%arr[i-1]==0) arr[i]++;
25 | 			}
26 | 			if(arr[i]%arr[i-1]==0){
27 | 				arr[i]++;
28 | 			}
29 | 		}
30 | 		for(int i=0;i<n;i++) cout<<arr[i]<<" ";
31 | 		cout<<endl;
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/900/27.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1471/A
 2 | // Strange Partition
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll n , x;
16 |         cin>>n>>x; 
17 |         ll sum = 0;ll mini = 0;
18 |         for(int i=0;i<n;i++){
19 |             ll a; cin>>a;
20 |             sum+=a;
21 |             if(a%x==0) mini+=(a/x);
22 |             else mini+=(a/x)+1;
23 |         }
24 |         if(sum%x==0) cout<<sum/x<<" ";
25 |         else cout<<(sum/x)+1<<" ";
26 |         cout<<mini<<endl;
27 | 	}
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/1000/18.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1620/B
 2 | //Triangles on a Rectangle
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int main() {
10 | 	ll tc;
11 | 	cin>>tc;
12 | 	while(tc--){
13 |         ll w,h;cin>>w>>h;
14 |         ll n,area = 0;
15 |         for(int j=0;j<4;j++){
16 |             cin>>n;
17 |             ll s,e;
18 |             for(int i=0;i<n;i++){
19 |                 ll t; cin>>t;
20 |                 if(i==0) s = t;
21 |                 else if(i==n-1) e = t;
22 |             }
23 |             area = max(area, (j<2?h:w)*(e-s));
24 |         }
25 |         cout<<area<<endl;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/900/14.cpp:
--------------------------------------------------------------------------------
 1 | //AvtoBus
 2 | //https://codeforces.com/problemset/problem/1679/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll n,max,min;cin>>n;
16 |         if(n%2 or n<4){
17 |             cout<<-1<<endl;
18 |             continue;
19 |         }
20 |         ll fours = n/4;
21 |         ll six = n/6;
22 |         max = fours;
23 |         if(n%6==0) min = six;
24 |         else{
25 |             if(n%6==4) min = six+1;
26 |             else if(n%6==2) min = ((n-4)/6)+2;
27 |         }
28 |         cout<<min<<" "<<max<<endl;
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/1100/10.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1842/B
 2 | //Tenzing and Books
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         debug(tc);
17 |         int n,x;
18 |         cin>>n>>x;
19 |         vector<int> a(n);
20 |         int i=0,j=0,k=0,curr = 0;
21 |         for(int i=0;i<3;i++){
22 |             for(auto &e: a) cin>>e;
23 |             for(int j=0;j<n;j++){
24 |                 if((a[j]|x)!=x) break;
25 |                 curr |= a[j];
26 |             }
27 |         }
28 |         cout<<(curr==x?"YES":"NO")<<endl;
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/900/05.cpp:
--------------------------------------------------------------------------------
 1 | //Make It Zero
 2 | //https://codeforces.com/problemset/problem/1869/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | int solve(){
 7 | }
 8 | int main() {
 9 | 	int tc;
10 | 	cin>>tc;
11 | 	while(tc--){
12 |         int n; cin>>n;
13 |         for(int i=0;i<n;i++){
14 |             int x;
15 |             cin>>x;
16 |         }
17 |         if(n%2==0){
18 |             cout<<2<<endl;
19 |             cout<<1<<" "<<n<<endl;
20 |             cout<<1<<" "<<n<<endl;
21 |         }
22 |         else{
23 |             cout<<4<<endl;
24 |             cout<<1<<" "<<n<<endl;
25 |             cout<<1<<" "<<n-1<<endl;
26 |             cout<<n-1<<" "<<n<<endl;
27 |             cout<<n-1<<" "<<n<<endl;
28 |         }
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/1000/25.cp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1438/B
 2 | //Valerii Against Everyone
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n;
17 |         cin>>n;
18 |         vector<int>x(n);
19 |         for(int i=0;i<n;i++){
20 |             cin>>x[i];
21 |         }
22 |         sort(x.rbegin(),x.rend());
23 |         bool f = false;
24 |         for(int i=0;i<n-1;i++){
25 |             if(x[i]==x[i+1]) {
26 |                 f = true;
27 |                 break;
28 |             }
29 |         }
30 |         cout<<(f?"YES":"NO")<<endl;
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/900/07.cpp:
--------------------------------------------------------------------------------
 1 | //Balanced Round
 2 | //https://codeforces.com/problemset/problem/1850/D
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | int solve(){
 7 | }
 8 | int main() {
 9 | 	int tc;
10 | 	cin>>tc;
11 | 	while(tc--){
12 |         int n,k;
13 |         cin>>n>>k;
14 |         int arr[n];
15 |         for(int i=0;i<n;i++){
16 |             cin>>arr[i];
17 |         }
18 |         sort(arr,arr+n);
19 |         int streak = 1; int maxstreak = 1;
20 |         for(int i=0;i<n-1;i++){
21 |             if(arr[i+1]-arr[i]<=k) streak++;
22 |             else{
23 |                 maxstreak = max(maxstreak,streak);
24 |                 streak = 1;
25 |             } 
26 |         }
27 |         maxstreak = max(maxstreak,streak);
28 |         cout<<n-maxstreak<<endl;
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/900/29.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1380/problem/A
 2 | //Three Indices
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;cin>>n;int arr[n];
16 |         for(int i=0;i<n;i++) cin>>arr[i];
17 |         int idx = -1;
18 |         for(int i=1;i+1<n;i++){
19 |             if(arr[i]>arr[i+1] and arr[i]>arr[i-1]){
20 |                 idx = i;
21 |                 break;
22 |             }
23 |         }
24 |         if(idx==-1) cout<<"NO"<<endl;
25 |         else{
26 |             cout<<"YES"<<endl;
27 |             cout<<idx<<" "<<idx+1<<" "<<idx+2<<endl;
28 |         }
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/1000/16.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1659/A
 2 | //Red Versus Blue
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n,a,b; cin>>n>>a>>b;
17 |         int groups = a/(b+1);
18 |         int odd = a%(b+1);
19 |         string s;
20 |         while(n>0){
21 |             for(int i=0;i<groups;i++){ s.push_back('R');n--;}
22 |             if(odd){
23 |                  s.push_back('R');
24 |                  odd--;
25 |                  n--;
26 |             }
27 |             if(b) s+="B",b--;
28 |             n--;
29 |         }
30 |         cout<<s<<endl;
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/800/29.cpp:
--------------------------------------------------------------------------------
 1 | //Everybody Likes Good Arrays!
 2 | //https://codeforces.com/problemset/problem/1777/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         int n; cin>>n;
11 |         int arr[n];
12 |         for(int i=0;i<n;i++){
13 |             cin>>arr[i];
14 |             arr[i]%=2;
15 |         }
16 |         int op = 0;
17 |         int streak = 1;
18 |         for(int i=0;i<n-1;i++){
19 |             if(arr[i]==arr[i+1]){
20 |                 streak++;
21 |             }
22 |             else{
23 |                 op+=streak-1;
24 |                 streak = 1;
25 |             }
26 |         }
27 |         op+=streak-1;
28 |         cout<<op<<endl;
29 |         cout<<endl;
30 |     }    
31 | }
32 | 


--------------------------------------------------------------------------------
/800/13.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //https://codeforces.com/problemset/problem/1859/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int n;
10 |         cin>>n; int arr[n];
11 |         for(int i=0;i<n;i++) cin>>arr[i];
12 |         int mx = INT_MIN, count = 0;
13 |         for(auto x: arr){
14 |             if(x>mx) mx = x, count=1;
15 |             else if(x==mx) count++;
16 |         }
17 |         if(count == n) cout<<-1<<endl;
18 |         else{
19 |             int m = n-count;
20 |             cout<<m<<" "<<count<<endl;
21 |             for(auto x: arr) if(x!=mx) cout<<x<<" ";
22 |             cout<<endl;
23 |             while(count--) cout<<mx<<" ";
24 |             cout<<endl;
25 |         }
26 |     }
27 |         
28 |     }
29 | 


--------------------------------------------------------------------------------
/900/01.cpp:
--------------------------------------------------------------------------------
 1 | //Forked
 2 | //https://codeforces.com/problemset/problem/1904/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int main() {
 7 |      int tc;
 8 |      cin>>tc;
 9 |      while(tc--){
10 |         int a,b;
11 |         cin>>a>>b;
12 |         int xk ,yk ,xq,yq;
13 |         cin>>xk>>yk>>xq>>yq;
14 |         int ans = 0;
15 |         set<pair<int,int>> s,t;
16 |         for(auto x: {a,-a}){
17 |             for(auto y:{b,-b}){
18 |                 s.insert({xk+x,yk+y});
19 |                 s.insert({xk+y,yk+x});
20 |                 t.insert({xq+x,yq+y});
21 |                 t.insert({xq+y,yq+x});
22 |             }
23 |         }
24 |         for(auto x:s){
25 |             if(t.find(x)!=t.end()) ans++;
26 |         }
27 |         cout<<ans<<endl;
28 |     }    
29 | }
30 | 
31 | 


--------------------------------------------------------------------------------
/1000/29.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1362/A
 2 | //Johnny and Ancient Computer
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll a,b,ans=0;
17 |         cin>>a>>b;
18 |         if(a==b) ans = 0;
19 |         else{
20 |             if(a>b) swap(a,b);
21 |             ll c = b/a;
22 |             if(b%a!=0 or c%2!=0){ ans = -1;cout<<ans<<endl;continue;}
23 |             while(c>=8 and c%8==0) c/=8,ans++;
24 |             while(c>=4 and c%4==0) c/=4,ans++;
25 |             while(c>=2 and c%2==0) c/=2,ans++;
26 |             if(c!=1) ans = -1;
27 |         }
28 |         cout<<ans<<endl;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/1000/15.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1690/D
 2 | //Black and White Stripe
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n,k; cin>>n>>k;
17 |         string s;
18 |         cin>>s;
19 |         int b = 0 ,ans = INT_MAX;
20 |         int i=0,j=0;
21 |         for(j=0;j<k;j++){
22 |             if(s[j]=='B') b++;
23 |         }
24 |         ans = min({max(0,k-b),ans});
25 |         for(i=0;i<n-k;i++){
26 |             if(s[j]=='B') b++;
27 |             if(s[i]=='B') b--;
28 |             ans = min({max(0,k-b),ans});
29 |             j++;
30 |         }
31 |         cout<<ans<<endl;
32 | 	}
33 | }
34 | 
35 | 


--------------------------------------------------------------------------------
/900/17.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1665/problem/B
 2 | //Array Cloning Technique
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | int solve(int s, int e){
 7 |     int count = 0;
 8 |     while(s<e and s!=e){
 9 |         s*=2;
10 |         count++;
11 |     }
12 |     return count;
13 | }
14 | int main() {
15 |     int tc;
16 |     cin>>tc;
17 |     while(tc--){
18 |         int n;cin>>n;int arr[n];
19 |         unordered_map<int,int> mp;
20 |         for(int i=0;i<n;i++){
21 |             cin>>arr[i];
22 |             mp[arr[i]]++;
23 |         }int maxfreq = 0 ;
24 |         for(auto x: mp){
25 |             if(x.second>maxfreq) maxfreq = x.second;
26 |         }
27 |         int swaps = n-maxfreq;
28 |         int copies = solve(maxfreq,n);
29 |         cout<<swaps+copies<<endl;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/1000/22.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1485/A
 2 | //Add and Divide
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(int n , int i){
11 |     int count = 0;
12 |     if(i==1) return n+1;
13 |     while(n>0){
14 |         n/=i;
15 |         count++;
16 |     }
17 |     return count;
18 | }
19 | int main() {
20 | 	int tc;
21 | 	cin>>tc;
22 | 	while(tc--){
23 |         int a,b;cin>>a>>b;
24 |         if(b>a){cout<<1<<endl;continue;};
25 |         int ans = INT_MAX,prev = INT_MAX;
26 |         for(int i=b;i<=a;i++){
27 |             int curr = solve(a,i)+i-b;
28 |             ans = min(curr,ans);
29 |             if(curr>prev) break;
30 |             prev = curr;
31 |         }
32 |         cout<<ans<<endl;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/1000/23.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1474/B
 2 | //Different Divisors
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | ll prime(ll n) {//SIEVE 
11 |     if(n==2 or n==3) return n;
12 |     if (n % 2 == 0) ++n;
13 |     while (true) {
14 |         bool isPrime = true;
15 |         for (ll i=3; i*i<=n; i+=2) {
16 |             if (n%i == 0) {
17 |                 isPrime = false;
18 |                 break;
19 |             }
20 |         }
21 |         if(isPrime) return n;
22 |         n += 2;
23 |     }
24 | }
25 | 
26 | int main() {
27 | 	int tc;
28 | 	cin>>tc;
29 | 	while(tc--){
30 |         ll d;
31 |         cin>>d;
32 |         ll x = prime(1+d);
33 |         ll y = prime(x+d);
34 |         cout<<x*y<<endl;
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/800/26.cpp:
--------------------------------------------------------------------------------
 1 | //Serval and Mocha's Array
 2 | //https://codeforces.com/problemset/problem/1789/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long
 6 | int gcd(int a, int b) {
 7 |     while (b != 0) {
 8 |         int temp = b;
 9 |         b = a % b;
10 |         a = temp;
11 |     }
12 |     return a;
13 | }
14 | bool solve(int arr[],int n){
15 |     for(int i=0;i<n;i++){
16 |         for(int j=i+1;j<n;j++){
17 |             if(gcd(arr[i],arr[j])<=2) return true;
18 |         }
19 |     }
20 |     return false;
21 | }
22 | int main() {
23 |      int tc;
24 |      cin>>tc;
25 |      while(tc--){
26 |         int n; cin>>n;
27 |         int arr[n];
28 |         for(int i=0;i<n;i++){
29 |             cin>>arr[i];
30 |         }
31 |         if(solve(arr,n)) cout<<"Yes";
32 |         else cout<<"No";
33 |         cout<<endl;
34 |     }    
35 | }
36 | 
37 | 


--------------------------------------------------------------------------------
/1000/13.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1704/B
 2 | //Luke is a Foodie
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n,x;
17 |         cin>>n>>x;
18 |         vector<int> arr(n);
19 |         for(int i=0;i<n;i++) cin>>arr[i];
20 |         int s = INT_MIN,e = INT_MAX,ans = 0;
21 |         for(int i=0;i<n;i++){
22 |             int start = arr[i]-x;
23 |             int end   = arr[i]+x;
24 |             s = max(start,s);
25 |             e = min(end ,e);
26 |             if(s>e){
27 |                 ans++;
28 |                 s = start;
29 |                 e = end;
30 |             }
31 |         }
32 |         cout<<ans<<endl;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/900/15.cpp:
--------------------------------------------------------------------------------
 1 | //Make It Increasing
 2 | //https://codeforces.com/problemset/problem/1675/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;cin>>n;
16 |         int arr[n];
17 |         for(int i=0;i<n;i++){
18 |             cin>>arr[i];
19 |         }
20 |         int count = 0;
21 |         for(int i=n-1;i>0;i--){
22 |             if(arr[i]<=arr[i-1]){
23 |                 if(arr[i]==0){
24 |                     count = -1;
25 |                     break;
26 |                 }
27 |                 while(arr[i-1]>=arr[i]){
28 |                     arr[i-1]/=2; count++;
29 |                 }
30 |             }
31 |         }
32 |         cout<<count<<endl;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/1000/14.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1691/B
 2 | //Shoe Shuffling
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n; cin>>n;
17 |         vector<int> arr(n),res(n,-1);
18 |         for(auto &x: arr) cin>>x;
19 |         int ans = 1;
20 |         int i=0,j=1;
21 |         while(i<n){
22 |             while(j<n and arr[j]==arr[j-1]){
23 |                 res[j] = j;//j-1+1
24 |                 res[i] = j+1;
25 |                 j++;
26 |             }
27 |             if(res[i]==-1){ ans = -1;break;}
28 |             i=j++;
29 |         }
30 |         if(ans==-1) cout<<ans;
31 |         else for(auto x:res) cout<<x<<" ";
32 |         cout<<endl;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/1000/05.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1849/B
 2 | //Monsters
 3 | class cmp{
 4 | public: 
 5 |      bool operator()(pair<int,int> &p1,pair<int,int>&p2){
 6 |         int a = p1.first, b = p1.second;
 7 |         int c = p2.first, d = p2.second;
 8 |         if(a!=c) return a>c;
 9 |         else return b<d;
10 |         }
11 | };
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n,k;
17 |         cin>>n>>k;
18 |         vector<int> arr(n);
19 |         vector<pair<int,int> > p;
20 |         for(int i=0;i<n;i++){
21 |             cin>>arr[i];
22 |             if(arr[i]<k);
23 |             else if(arr[i]%k==0) arr[i] = k;
24 |             else arr[i]%=k;
25 |             p.push_back({arr[i],i});
26 |         } 
27 |         debug(p);
28 |         sort(p.begin(),p.end(),cmp());
29 |         for(auto c: p) cout<<c.second+1<<" ";
30 |         cout<<endl;        
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/1100/07.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1873/E
 2 | //Building an Aquarium
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int main() {
10 | 	int tc;
11 | 	cin>>tc;
12 | 	while(tc--){
13 |         ll n, x;
14 |         cin>>n>>x;
15 |         vector<ll> arr(n);
16 |         for(auto &a: arr) cin>>a;
17 |         ll lo = 0, hi = 1e10,mid;
18 |         ll ans = 0;
19 |         while(lo<=hi){
20 |             mid = lo+(hi-lo)/2;
21 |             ll w = 0;
22 |             for(int i=0;i<n;i++){
23 |                 ll h = max(1ll*0,(mid-arr[i]));
24 |                 w+=h;
25 |             }
26 |             if(w<=x){
27 |                 ans = mid;
28 |                 lo = mid+1;
29 |             }
30 |             else hi = mid-1;
31 |         }
32 |         cout<<ans<<endl;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/900/10.cpp:
--------------------------------------------------------------------------------
 1 | //Odd Queries
 2 | //https://codeforces.com/contest/1807/problem/D
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | int solve(){
 9 | }
10 | int main() {
11 | 	int tc;
12 | 	cin>>tc;
13 | 	while(tc--){
14 |         int n , q;
15 |         cin>>n>>q;
16 |         vector<int> arr(n), pre;
17 |         pre.push_back(0);
18 |         for(int i=0;i<n;i++){
19 |             cin>>arr[i];
20 |             pre.push_back((pre[i]+arr[i]));
21 |         }
22 |         while(q--){
23 |             int l,r,k;
24 |             cin>>l>>r>>k;
25 |             ll left = (ll)pre[l-1];
26 |             ll right = (ll)pre.back()-pre[r];
27 |             ll len = r-l+1; 
28 |             ll z = (ll)k*len;
29 |             ll sum = left+right+z;
30 |             cout<<((sum%2)?"YES":"NO");
31 |             cout<<"\n";
32 |         }
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/1000/10.cpp:
--------------------------------------------------------------------------------
 1 | //Traffic Light
 2 | //https://codeforces.com/problemset/problem/1744/C#include <bits/stdc++.h>
 3 | using namespace std;
 4 | #define ll long long 
 5 | #define gcd __gcd
 6 | #define ull unsigned long long
 7 | #define endl "\n"
 8 | 
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;char c;
16 |         cin>>n>>c;
17 |         string s;
18 |         cin>>s;
19 |         if(c=='g'){
20 |             cout<<0<<endl;
21 |             continue;
22 |         }
23 |         s+=s;
24 |         int ans = 0;
25 |         stack<int> st;
26 |         for(int i=0;i<s.size();i++){
27 |             if(s[i]=='g'){
28 |                 while(st.size()){
29 |                     int id = st.top();st.pop();
30 |                     ans = max(i-id,ans);
31 |                 }
32 |             }
33 |             else if(s[i]==c) st.push(i);
34 |         }
35 |         cout<<ans<<endl;
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/1000/08.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1791/problem/D
 2 | //Distinct Split
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n;
17 |         cin>>n;
18 |         string s;
19 |         cin>>s;
20 |         vector<int> left(n),right(n);
21 |         unordered_set<int> uniq;
22 |         for(int i=0;i<n;i++){
23 |             uniq.insert(s[i]);
24 |             left[i] = uniq.size();
25 |         }
26 |         uniq.clear();
27 |         for(int i=n-1;i>=0;i--){
28 |             uniq.insert(s[i]);
29 |             right[i] = uniq.size();
30 |         }
31 |         int ans = 0;
32 |         for(int i=0;i<n-1;i++){
33 |             ans = max((left[i]+right[i+1]),ans);
34 |         }
35 |         cout<<ans<<endl;
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/1000/20.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1567/problem/B
 2 | //MEXor Mixup
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll mex,x;
17 |         cin>>mex>>x;
18 |         ll c = 0;
19 |         int g = mex%4;
20 |         for(int i=mex-1;g>0;i--){
21 |             c^=i;
22 |             g--;
23 |         }
24 |         ll temp = c^x;
25 |         ll ans = 0;
26 |         if(c==x) ans = mex;
27 |         else if((c==0 and mex==x) or temp == mex) {
28 |             ans = mex+2;
29 |         }
30 |         else{ans = mex+1;}
31 |         cout<<ans<<endl;
32 | 	}
33 | }
34 | //general rule
35 | //     if (mex % 4 == 1) {c = a - 1;}
36 | //     else if (mex % 4 == 2) {c = 1;}
37 | //     else if (mex % 4 == 3) {c = a;}
38 | //     else {c = 0;}
39 | 


--------------------------------------------------------------------------------
/1000/02.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1883/problem/C
 2 | //Raspberries
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         debug(tc);
17 |         int n,k;
18 |         cin>>n>>k;
19 |         int mini = INT_MAX, op;
20 |         int eve = 0;
21 |         for(int i=0;i<n;i++){
22 |             int x;cin>>x;
23 |             if(x%2==0) eve++;
24 |             if(x%k==0){debug(i);mini = 0;}
25 |             int a = x/k;
26 |             op = (a+1)*k-x;
27 |             mini = min(op,mini);
28 |             debug(mini);
29 |         }
30 |         if(k==4){
31 |             if(eve==1) mini = mini = min(1,mini);
32 |             else if(eve>=2) mini = min(0,mini);
33 |             mini = min(2,mini);
34 |         }
35 |         cout<<mini<<endl;
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/1100/02.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1914/C
 2 | //Quests
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll n ; cin>>n; ll k ; cin>>k;
17 |         vector<ll> q(n),s(n);
18 |         for(ll i=0;i<n;i++) {
19 |             cin>>q[i];
20 |             if(i>0) q[i]+=q[i-1];
21 |         }
22 |         ll maxi = LLONG_MIN;
23 |         for(ll i=0;i<n;i++){
24 |             cin>>s[i];
25 |             maxi = max(maxi,s[i]);
26 |             s[i] = maxi;
27 |         }
28 |         ll idx = min(k-1,n-1); ll ans = 0;
29 |         while(idx>=0){
30 |             ll score = q[idx];
31 |             ll slot = k-1-idx;
32 |             ans = max(ans,score+slot*s[idx]);
33 |             idx--;
34 |         }
35 |         cout<<ans<<endl;
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | TLE CP-31 Sheet Solutions Repository
 2 | 
 3 | Description: This repository hosts my solutions/codes to TLE's CP-31 sheet curated by Priyansh Aggarwal.
 4 | The sheet is thoughtfully organized according to the difficulty levels of the problems, ranging from ratings 800 to 1600.
 5 | Within this repository, you will find meticulously crafted codes for each problem, categorized based on their respective ratings.
 6 | 
 7 | Link to the Sheet: [TLE CP-31 Sheet](https://www.tle-eliminators.com/cp-sheet)
 8 | 
 9 | This repository serves as a comprehensive resource for individuals seeking to start CP and Priyansh Sir's sheet is fabulous resource for beginners or individuals who are confused which questions to practice
10 | This sheet is  meticulously prepared by Priyansh Aggarwal. Organized by problem rating, ranging from 800 to 1200, the codes provided here offer reliability and insight into solving each problem effectively.
11 | 
12 | 
13 | [TLE Eliminators](https://www.tle-eliminators.com)
14 | 
15 | 


--------------------------------------------------------------------------------
/1100/22.cpp:
--------------------------------------------------------------------------------
 1 | // Kill Demodogs
 2 | //https://codeforces.com/problemset/problem/1731/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		    ll n;
32 |         cin>>n;
33 |         ll ans = (((n*(n+1)%mod)*(4*n-1))%mod*337)%mod;
34 |         cout<<ans<<endl;
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/1000/24.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1447/B
 2 | //Number box
 3 | #include <bits/stdc++.h>
 4 | #ifndef ONLINE_JUDGE
 5 | #include <D:\CP\debug_Template.cpp>
 6 | #else
 7 | #define debug(...)
 8 | #define debugArr(...)
 9 | #endif
10 | using namespace std;
11 | #define ll long long 
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | 
16 | int solve(){
17 | }
18 | int main() {
19 | 	int tc;
20 | 	cin>>tc;
21 | 	while(tc--){
22 |         int m,n; cin>>m>>n;
23 |         vector<int> arr(m*n);
24 |         int count = 0,sum = 0,mini = INT_MAX;
25 |         for(int i=0;i<m*n;i++){
26 |             cin>>arr[i];
27 |             if(arr[i]<=0) count++;
28 |             sum+=abs(arr[i]);
29 |             arr[i] = abs(arr[i]);
30 |             mini = min(mini,arr[i]);
31 |         }
32 |         if(count==0 or count%2==0){
33 |             cout<<sum<<endl;
34 |         }
35 |         else{
36 |             sum-=2*mini;
37 |             cout<<sum<<endl;
38 |         }
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/1000/03.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1876/problem/A
 2 | //Helmets in Night Light 
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll n,p;
17 |         cin>>n>>p;
18 |         vector<ll> a(n),b(n);
19 |         vector<pair<ll,ll>> v;
20 |         for(int i=0;i<n;i++)cin>>a[i];
21 |         for(int i=0;i<n;i++){
22 |             cin>>b[i];
23 |             v.push_back(make_pair((ll)b[i],(ll)a[i]));
24 |         }
25 |         sort(v.begin(),v.end());
26 |         ll k = n,i=0,cost = 0;
27 |         cost+=p;k--;
28 |         while(i<n){
29 |             if(k==0 or v[i].first>p) break;
30 |             int left = min(k,v[i].second);
31 |             cost+=(left)*v[i].first;
32 |             k-=left;
33 |             i++;
34 |         }
35 |         if(k>0) cost+=k*p;
36 |         cout<<cost<<endl;
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/1100/09.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1850/E
 2 | //Cardboard for Pictures
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ll unsigned long long
 8 | #define endl "\n"
 9 | 
10 | long long solve(){
11 | }
12 | int main() {
13 | 	long long tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll n,c; cin>>n>>c;
17 |         vector<ll> arr(n); ll ans;
18 |         for(auto &x : arr) cin>>x;
19 |         long long l = 1, r = 1e9;
20 |         while(l <= r) {
21 |         long long mid = l + (r - l) / 2;
22 |         long long sum = 0;
23 |         for(long long i = 0; i < n; ++i) {
24 |             sum += (arr[i] + 2*mid)*(arr[i]+2*mid);
25 |             if(sum > c) break;
26 |         }
27 |         if(sum == c) {
28 |             ans = mid;
29 |             break;
30 |         }
31 |         if(sum > c) {
32 |             r = mid - 1;
33 |         } else {
34 |             l = mid + 1;
35 |         }
36 |     }   
37 |         cout<<ans<<endl;
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/1100/04.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1899/C
 2 | //Yarik and Array
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int parity(int a, int b){
11 |     if(a%2 and b%2) return false;
12 |     if(a%2==0 and b%2==0) return false;
13 |     return true;
14 | }
15 | int main() {
16 | 	int tc;
17 | 	cin>>tc;
18 | 	while(tc--){
19 |         int n;
20 |         cin>>n;
21 |         int maxi = INT_MIN;
22 |         vector<int> arr(n);
23 |         for(int i=0;i<n;i++) cin>>arr[i];
24 |         maxi = max(arr[0],maxi);
25 |         int curr = arr[0];
26 |         for(int i=1;i<n;i++){
27 |             if(parity(arr[i-1],arr[i])){
28 |                 curr = max(arr[i], curr+arr[i]);
29 |                 maxi = max(curr,maxi);
30 |             }
31 |             else{
32 |                 curr = arr[i];
33 |                 maxi = max(curr,maxi);
34 |             }
35 |         }
36 |         cout<<maxi<<endl;
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/1000/11.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1725/B
 2 | //Basketball Together
 3 | #include <bits/stdc++.h>
 4 | #ifndef ONLINE_JUDGE
 5 | #include <D:\CP\debug_Template.cpp>
 6 | #else
 7 | #define debug(...)
 8 | #define debugArr(...)
 9 | #endif
10 | using namespace std;
11 | #define ll long long 
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | 
16 | int solve(){
17 | }
18 | int main() {
19 | 	int tc;
20 | 	//cin>>tc;
21 | 	//while(tc--){
22 |         int n,d;
23 |         cin>>n>>d;
24 |         vector<int> arr(n);
25 |         for(int i=0;i<n;i++){
26 |             cin>>arr[i];
27 |         }
28 |         sort(arr.begin(),arr.end());
29 |         int i=0,j=n-1; int ans = 0;
30 |         while(i<=j){
31 |             ll p = arr[j];
32 |             ll need = d/p;
33 |             if(need*p>d);
34 |             else need++;
35 |             i+=(need-1);
36 |             if(i<=j) ans++;
37 |             else break;
38 |             j--;
39 |         }
40 |         cout<<ans<<endl;
41 | 	}//50 60 70 80 90 100
42 | 
43 | //}
44 | 


--------------------------------------------------------------------------------
/1100/06.cpp:
--------------------------------------------------------------------------------
 1 | //Deja Vu
 2 | //https://codeforces.com/problemset/problem/1891/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 |     vector<ll> two(31,1);
16 |     for(int i=1;i<=30;i++){
17 |         two[i]=two[i-1]*2;
18 |     }
19 | 	while(tc--){
20 |         ll n,m; cin>>n>>m;
21 |         vector<ll> a(n),b(m);
22 |         for(auto &x: a) cin>>x;
23 |         for(auto &x: b) cin>>x;
24 |         ll max = INT_MAX;
25 |         vector<ll> p;
26 |         for(int i=0;i<m;i++){
27 |             if(b[i]<max){
28 |                 p.push_back(b[i]);
29 |                 max = b[i];
30 |             }
31 |         }
32 |         for(ll x: p){
33 |             ll y = two[x];
34 |             for(int i=0;i<a.size();i++){
35 |                 if(a[i]%y==0) a[i]+=two[x-1];
36 |             }
37 |         }
38 |         for(auto x: a) cout<<x<<" ";
39 |         cout<<endl;
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/1100/08.cpp:
--------------------------------------------------------------------------------
 1 | //2D Traveling
 2 | //https://codeforces.com/contest/1869/problem/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | ll solve(vector<vector<ll>> &v, ll s,ll k){
11 |     ll mini = LLONG_MAX/2; ll ans = -1;
12 |     for(int i=1;i<=k;i++){
13 |         ll dis = abs(v[i][0]-v[s][0])+abs(v[i][1]-v[s][1]);
14 |         if(dis<mini){
15 |             mini = dis;
16 |             ans = i;
17 |         }
18 |     }
19 |     return mini;
20 | }
21 | int main() {
22 |     int tc;
23 |     cin>>tc;
24 |     while(tc--){
25 |         ll n,k,s,d;
26 |         cin>>n>>k>>s>>d;
27 |         vector<vector<ll>> v(n+1);
28 |         for(int i=1;i<=n;i++){
29 |             ll x,y;
30 |             cin>>x>>y;
31 |             v[i] = {x,y};
32 |         }
33 |         ll real = abs(v[s][0]-v[d][0])+abs(v[s][1]-v[d][1]);
34 |         ll s_near = solve(v,s,k);
35 |         ll d_near = solve(v,d,k);
36 |         ll ans = min(real,s_near+d_near);
37 |         cout<<ans<<endl;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/900/16.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1666/D
 2 | //Deletive Editing
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         string word,res;
16 |         cin>>word>>res;
17 |         unordered_map<char,int> mp,req;
18 |         for(auto x: res) req[x]++;
19 |         bool flag = true;
20 |         int i=word.size()-1, j=res.size()-1;
21 |         while(j>=0 and i>=0){
22 |             mp[word[i]]++;
23 |             if(word[i]==res[j]){
24 |                 if(mp[word[i]]>req[word[i]]){
25 |                     flag = false; 
26 |                     break;
27 |                 }
28 |                 i--,j--;
29 |             }
30 |             else i--;
31 |         }
32 |         if(j>=0) flag = false;
33 |         for(auto c: res){
34 |             if(mp[c]<req[c]) flag = false;
35 |         }
36 |         if(flag) cout<<"YES"<<endl;
37 |         else cout<<"NO"<<endl;
38 | 	}
39 | }
40 | 


--------------------------------------------------------------------------------
/1100/03.cpp:
--------------------------------------------------------------------------------
 1 | //Collecting Game
 2 | //https://codeforces.com/problemset/problem/1904/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll n;cin>>n;
17 |         vector<ll> ans(n),pre(n);
18 |         vector<pair<ll,ll>>v(n);
19 |         for(int i=0;i<n;i++){
20 |             ll c; cin>>c;
21 |              v[i] = {c,i};
22 |         }
23 |         sort(v.begin(),v.end());
24 |         pre[0] = v[0].first;
25 |         for(int i=1;i<n;i++){
26 |             pre[i] = pre[i-1]+v[i].first;
27 |         }
28 |         ans[v[n-1].second] = n-1;
29 |         for(int i=n-2;i>=0;i--){
30 |             ll score = pre[i];
31 |             if(score>=v[i+1].first){
32 |                 ans[v[i].second] = ans[v[i+1].second];
33 |             }
34 |             else{
35 |                 ans[v[i].second] = i;
36 |             }
37 |         }
38 |         for(auto x: ans) cout<<x<<" ";
39 |         cout<<endl;
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/1000/12.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1715/B
 2 | //Beautiful Array
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         debug(tc);
17 |         ll n,k,b,s;
18 |         cin>>n>>k>>b>>s;
19 |         ll req = b*k;
20 |         if(s<req or(k==1 and s!=b)){
21 |             cout<<-1<<endl;
22 |             continue;
23 |         }
24 |         ll first = min(req+k-1,s),left = s-first;
25 |         ll zeroes = (k>1)?(left/(k-1))+(left%(k-1)!=0):0;
26 |         if(zeroes>n-1) {
27 |             cout<<-1<<endl;
28 |             continue;
29 |         }
30 |         cout<<first<<" ";
31 |         n--;
32 |         while(n--){
33 |             if(left>k-1) {
34 |                 cout<<k-1<<" ";
35 |                 left-=(k-1);
36 |             }
37 |             else {
38 |                 cout<<left<<" ";
39 |                 left = 0;
40 |             }
41 |         }
42 |         cout<<endl;
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/900/18.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1624/B
 2 | //Make AP
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int a,b,c;
16 |         cin>>a>>b>>c;
17 |         int d1 = b-a, d2 = c-b;
18 |         if(d1==d2) {
19 |             cout<<"YES"<<endl;
20 |             continue;
21 |         }
22 |         // middle
23 |         int d = (c-a)/2;
24 |         int x = a+d;
25 |         if(x%b==0 and (c-a)%2==0 and x!=0 and x>=b){
26 |             cout<<"YES"<<endl;
27 |             continue;
28 |         }
29 |         //last
30 |         d = b-a;
31 |         x = b+d;
32 |         if(x%c==0 and x!=0 and x>=c){
33 |             cout<<"YES"<<endl;
34 |             continue;
35 |         }
36 |         //first
37 |         d = c-b;
38 |         x = b-d;
39 |         if(x%a==0 and x!=0 and x>=a){
40 |             cout<<"YES"<<endl;
41 |             continue;
42 |         }
43 |         cout<<"NO"<<endl;
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/1100/13.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1826/B
 2 | //Lunatic Never Content
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | #define pp pair<int,int>
10 | #define ff first
11 | #define ss second
12 | #define mod 1000000007
13 | #define sort(v) sort(v.begin(),v.end())
14 | vector<int> read(int n){
15 | 	vector<int> arr(n);
16 | 	for(int i=0;i<n;i++) cin>>arr[i];
17 | 	return arr;
18 | }
19 | bool pal(vector<int> &v){
20 |     int i=0,j=v.size()-1;
21 |     while(i<=j){
22 |         if(v[i]!=v[j]) return false;
23 |         i++,j--;
24 |     }
25 |     return true;
26 | }
27 | int main() {
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n;
32 |         cin>>n;
33 |         vector<int> v = read(n);
34 |         int ans = 1;
35 |         int i=0,j=n-1,a = abs(v[0]-v.back());
36 |         while(i<=j){
37 |             int x = abs(v[i]-v[j]);
38 |             a = gcd(x,a);
39 |             i++,j--;
40 |         }
41 |         cout<<a<<endl;
42 | 
43 | 	}
44 | }// 4 15 1 2 0 10
45 | //6,15,0
46 | //4%k = 10%k 6
47 | //15%k = 0%k 15
48 | 


--------------------------------------------------------------------------------
/1100/11.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1832/B
 2 | //Maximum Sum
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         ll n,k; cin>>n>>k;
17 |         ll sum = 0;
18 |         vector<ll> a(n);
19 |         for(auto &x: a){ cin>>x;sum+=x;}
20 |         sort(a.begin(),a.end());
21 |         vector<ll> pre,suff;pre = a,suff = a;
22 |         for(int i=1;i<n;i++){
23 |             pre[i] = pre[i-1]+a[i];
24 |         }
25 |         for(int i=n-2;i>=0;i--){
26 |             suff[i] = suff[i+1]+a[i];
27 |         }
28 |         ll i=0,j=n-1; ll temp = sum,ans=-1;
29 |         for(int m = 0;m<=k;m++){
30 |             int id1 = 2*m-1;
31 |             int j = k-m;
32 |             int id2 = n-j;
33 |             if(id1>=0) temp-=pre[id1];
34 |             if(id2<n) temp-=suff[id2];
35 |             ans = max(temp,ans);
36 |             temp = sum;
37 |         }
38 |         cout<<ans<<endl;
39 |         //10 11 12 13 15 22
40 |         //1 2 5 6 10
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/1100/12.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1827/A
 2 | //Counting Orders
 3 | #include <bits/stdc++.h>
 4 | #ifndef ONLINE_JUDGE
 5 | #include <D:\CP\debug_Template.cpp>
 6 | #else
 7 | #define debug(...)
 8 | #define debugArr(...)
 9 | #endif
10 | using namespace std;
11 | #define ll long long 
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | vector<int> read(int n){
20 | 	vector<int> arr(n);
21 | 	for(int i=0;i<n;i++) cin>>arr[i];
22 | 	return arr;
23 | }
24 | int solve(){
25 | }
26 | int main() {
27 | 	int tc;
28 | 	cin>>tc;
29 | 	while(tc--){
30 | 		int n;
31 |         cin>>n;
32 |         vector<int> a = read(n);
33 |         vector<int> b = read(n);
34 |         sort(a.rbegin(),a.rend());
35 |         sort(b.rbegin(),b.rend());
36 |         int i = 0,j=0;
37 |         long long ans = 1;
38 |         while(i<n){
39 |             while(j<n and b[i]<a[j]){
40 |                 j++;
41 |             }
42 |             ans*=(j-i);
43 |             ans%=mod;
44 |             i++; 
45 |         }
46 |         cout<<ans<<endl;
47 | 	}
48 | }
49 | 
50 | 


--------------------------------------------------------------------------------
/800/17.cpp:
--------------------------------------------------------------------------------
 1 | //Forbidden Integer
 2 | //https://codeforces.com/contest/1845/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | int main() {
 6 |      int tc;
 7 |      cin>>tc;
 8 |      while(tc--){
 9 |         int n,k,x;
10 |         cin>>n>>k>>x;
11 |         if(n%2!=0){
12 |             if(x!=1){
13 |                 cout<<"YES"<<endl<<n<<endl;
14 |                 while(n-->0) cout<<1<<" ";
15 |             }
16 |             else if(k>2){
17 |                 cout<<"YES"<<endl;
18 |                 int m = (n-3)/2+1;
19 |                 cout<<m<<endl;
20 |                 cout<<3<<" ";
21 |                 for(int i=1;i<=m-1;i++) cout<<2<<" ";
22 |             }
23 |             else cout<<"NO"<<endl;
24 |         }
25 |         else{
26 |             if(x!=1){
27 |                 cout<<"YES"<<endl<<n<<endl;
28 |                 while(n-->0) cout<<1<<" ";
29 |             }
30 |             else if(x!=2 and k>=2){
31 |                 cout<<"YES"<<endl;
32 |                 cout<<n/2<<endl;
33 |                 for(int i=1;i<=n/2;i++) cout<<2<<" ";
34 |             }
35 |             else cout<<"NO"<<endl;
36 |         }
37 |         cout<<endl;
38 |     }
39 |         
40 | }
41 | 


--------------------------------------------------------------------------------
/900/12.cpp:
--------------------------------------------------------------------------------
 1 | // Mainak and Array
 2 | //https://codeforces.com/contest/1726/problem/A
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;
16 |         cin>>n;
17 |         int maxi = -1, mini = 9999;
18 |         int maxidx, mindx ; int arr[n];
19 |         for(int i=0;i<n;i++){
20 |             int x; cin>>x;
21 |             arr[i] = x;
22 |             if(x>maxi){
23 |                 maxi = x;
24 |                 maxidx = i;
25 |             }
26 |             if(x<mini){
27 |                 mini = x;
28 |                 mindx = i;
29 |             }
30 |         }
31 |         if(mindx == 0 or maxidx == n-1) cout<<maxi-mini<<endl;
32 |         else{
33 |             int a,b, diff,c=0;
34 |             a = maxi - arr[0];
35 |             b = arr[n-1] - mini;
36 |             for(int i=n-1;i>=1;i--){
37 |                 int diff = arr[i-1]-arr[i];
38 |                 c = max(c,diff);
39 |             }
40 |             cout<<max({a,b,c})<<endl;
41 |         }
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/1100/24.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1682/B
 2 | //AND Sorting
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n;
32 |         cin>>n;
33 |         vi arr(n);
34 |         read(arr,n);
35 |         vi x = arr;
36 |         srt(x);
37 |         int ans = INT_MAX;
38 |         for(int i=0;i<n;i++){
39 |             if(arr[i]!=x[i]){
40 |                 ans&=arr[i];
41 |             }
42 |         }
43 |         cout<<ans<<endl;
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/1100/28.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1631/B
 2 | //Fun with Even Subarrays
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n;cin>>n;
32 |         vi arr(n);
33 |         read(arr,n);
34 |         int i=n-1,op=0;
35 |         while(i>=0){
36 |             while(i>=0 and arr[i]==arr[n-1]) i--;
37 |             if(i<0) break;
38 |             int cnt = n-1-i;
39 |             i-=cnt;op++;
40 |         }
41 |         cout<<op<<endl;
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/1000/06.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1840/C
 2 | //Ski Resort
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n" 
 9 | 
10 | int solve(){ 
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n,k,t;
17 |         cin>>n>>k>>t;
18 |         vector<ll> arr(n);
19 |         for(int i=0;i<n;i++) cin>>arr[i];
20 |         ll ans = 0;ll days = 0;
21 |         for(int i=0;i<n;i++){
22 |             if(arr[i]<=t) days++;
23 |             else{
24 |                 debug(i);debug(days);
25 |                 if(days>=k){
26 |                     ll possible = (days*(days+1))/2;
27 | //(k-1)/2(2n-k+2)
28 |                     ll x = ((k-1)*(2*days-k+2))/2;
29 |                     debug(x);
30 |                     ans+=possible-x;
31 |                 }
32 |                 days= 0;
33 |             }
34 |         }
35 |         debug(days);
36 |         if(days>=k){
37 |             ll possible = (days*(days+1))/2;
38 |             ll x = ((k-1)*(2*days-k+2))/2;
39 |             ans+=possible-x;
40 |         }
41 |         cout<<ans<<endl;
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/1000/21.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1506/C
 2 | //Double-ended Strings
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         string a,b;
17 |         cin>>a>>b;
18 |         if(a==b) {cout<<0<<endl;continue;}
19 |         unordered_map<string,int> m1,m2;
20 |         for(int i=0;i<a.size();i++){
21 |             for(int len = 1;len<=a.size()-i;len++){
22 |                 string x = a.substr(i,len);
23 |                 m1[x] = i;
24 |             }
25 |         }
26 |         int ans = a.size()+b.size(), maxi = 0;
27 |         for(int i=0;i<b.size();i++){
28 |             for(int len = 1;len<=b.size()-i;len++){
29 |                 string x = b.substr(i,len);
30 |                 if(m1.find(x)!=m1.end()){
31 |                     int l = x.size();
32 |                     if(l>maxi){
33 |                         maxi = l;
34 |                         ans = a.size()-len+b.size()-len;
35 |                     }
36 |                 }
37 |                 m2[x] = i;
38 |             }
39 |         }
40 |         cout<<ans<<endl;
41 | 	}
42 | }
43 | 
44 | 


--------------------------------------------------------------------------------
/1100/26.cpp:
--------------------------------------------------------------------------------
 1 | //Eating Candies
 2 | //https://codeforces.com/contest/1669/problem/F
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n;cin>>n;
32 |         vi arr(n);
33 |         read(arr,n);
34 |         int i=0,j=n-1;
35 |         int a = 0, b = 0, ans = 0;
36 |         while(i<=j){
37 |             if(a==b){
38 |                 ans = n-1-j+i;
39 |                 a+=arr[i++];
40 |             }
41 |             else if(a<b) a+=arr[i++];
42 |             else b+=arr[j--];
43 |         }
44 |         if(a==b) ans = n-1-j+i;
45 |         cout<<ans<<endl;
46 | 	}
47 | }
48 | 


--------------------------------------------------------------------------------
/1000/04.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1859/B
 2 | //Olya and Game with Arrays
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | int solve(){
11 | }
12 | int main() {
13 | 	int tc;
14 | 	cin>>tc;
15 | 	while(tc--){
16 |         int n;
17 |         cin>>n;
18 |         int k = n;
19 |         vector<int> res;int mini = INT_MAX;
20 |         while(n--){
21 |             int m;
22 |             cin>>m;
23 |             vector<int> temp(m);
24 |             int fmin = INT_MAX,smin = INT_MAX;
25 |             for(int i=0;i<m;i++){
26 |                 cin>>temp[i];
27 |                 if(fmin>temp[i]){
28 |                     smin = fmin;
29 |                     fmin = temp[i];
30 |                 }
31 |                 else if(smin>temp[i]){
32 |                     smin = temp[i];
33 |                 }
34 |             }
35 |             mini = min(mini,fmin);
36 |             res.push_back(smin);
37 |         }
38 |         sort(res.begin(),res.end());
39 |         ll sum = 0;
40 |         sum+=mini;
41 |         int i = res.size()-1;
42 |         int cnt = 0;
43 |         while(cnt++<k-1){
44 |             sum+=res[i--];
45 |         }
46 |         cout<<sum<<endl;
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/1100/05.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1899/B
 2 | //250 Thousand Tons of TNT 
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | 
10 | vector<ll> div( ll &n){
11 |     vector<ll> ans;
12 |     for(ll i=1;i<=sqrt(n);i++){
13 |         if(n%i==0){
14 |             ans.push_back(i);
15 |             ans.push_back(n/i);
16 |         }
17 |     }
18 |     return ans;
19 | }
20 | int main() {
21 | 	int tc;
22 | 	cin>>tc;
23 | 	while(tc--){
24 |         ll n; cin>>n;
25 |         vector<ll> v = div(n);
26 |         vector<ll> arr(n);
27 |         for(int i=0;i<n;i++)cin>>arr[i];
28 | 
29 |         ll ans = 0;
30 |         for(auto c : v){
31 |             ll sum = 0;
32 |             ll mini = LLONG_MAX,maxi = LLONG_MIN;
33 |             if(c==n) continue;
34 |             for(int i=0;i<n;i++){
35 |                 if((i+1)%c==0){
36 |                     sum+=arr[i];
37 |                     maxi = max(sum,maxi);
38 |                     mini = min(sum,mini);
39 |                     sum = 0;
40 |                 }
41 |                 else sum+=arr[i];
42 |             }
43 |             debug(maxi);
44 |             ans = max(ans,maxi-mini);
45 |         }
46 |         cout<<ans<<endl;
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/1100/18.cpp:
--------------------------------------------------------------------------------
 1 | //Teleporters (Easy Version)
 2 | //https://codeforces.com/problemset/problem/1791/G1
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		ll n;cin>>n;
32 |         ll c;cin>>c;
33 |         vl v(n);
34 |         for(ll i=0;i<n;i++){
35 |             cin>>v[i];
36 |             v[i]+=(i+1);
37 |         }
38 |         srt(v);
39 |         ll count =0;
40 |         for(ll i=0;i<n;i++){
41 |             if(v[i]<=c){
42 |                 c-=v[i];
43 |                 count++;
44 |             }
45 |             else break;
46 |         }
47 |         cout<<count<<endl;
48 | 	}
49 | }
50 | 


--------------------------------------------------------------------------------
/1100/20.cpp:
--------------------------------------------------------------------------------
 1 | //GCD Partition
 2 | //https://codeforces.com/problemset/problem/1780/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define presum(x,y) for(ll i=1;i<x.size();i++) y[i]=y[i-1]+x[i]
 8 | #define pb(x) push_back(x)
 9 | #define vi vector<int>
10 | #define vl vector<ll>
11 | #define vvi vector<vector<int>>
12 | #define vvl vector<vector<ll>>
13 | #define gcd __gcd
14 | #define ull unsigned long long
15 | #define endl "\n"
16 | #define pp pair<int,int>
17 | #define ff first
18 | #define ss second
19 | #define mod 1000000007
20 | #define srt(v) sort(v.begin(),v.end())
21 | #define rsrt(v) sort(v.rbegin(),v.rend())
22 | #define rev(v) reverse(v.begin(),v.end())
23 | #define ump unordered_map
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n;
32 |         cin>>n;
33 |         vi v(n);
34 |         ll sum = 0;
35 |         for(int i=0;i<n;i++){
36 |             cin>>v[i];
37 |             sum+=v[i];
38 |         }
39 |         ll run = 0, ans = 1;
40 |         for(int i=0;i<n-1;i++){
41 |             run+=v[i];
42 |             sum-=v[i];
43 |             ans = max(gcd(run,sum),ans);  
44 |         }
45 |         cout<<ans<<endl;
46 |         
47 | 	}
48 | }
49 | 
50 | 


--------------------------------------------------------------------------------
/1000/19.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1614/B
 2 | // Divan and a New Project
 3 | #include <bits/stdc++.h>
 4 | #ifndef ONLINE_JUDGE
 5 | using namespace std;
 6 | #define ll long long 
 7 | #define gcd __gcd
 8 | #define ull unsigned long long
 9 | #define endl "\n"
10 | #define pp pair<int,int> 
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         int n;
16 |         cin>>n;
17 |         priority_queue<pp,vector<pp>,less<>> pq;
18 |         vector<int> visit(n) ;
19 |         for(int i=0;i<n;i++){
20 |             int x;cin>>x;
21 |             visit[i] = x;
22 |             pq.push({x,i});
23 |         }
24 |         ll l=0,r=0;bool right = true;
25 |         ll ans = 0;
26 |         while(pq.size()){
27 |             auto p = pq.top();pq.pop();
28 |             int v = p.first;
29 |             int idx   = p.second;
30 |             if(right){
31 |                 r++;
32 |                 ans+=(r)*visit[idx]*2;
33 |                 visit[idx] = r;
34 |                 right = false;
35 |             }
36 |             else{
37 |                 l--;
38 |                 ans+=abs(l)*visit[idx]*2;
39 |                 visit[idx] = l;
40 |                 right = true;
41 |             }
42 |         }
43 |         cout<<ans<<endl;
44 |         cout<<0<<" ";for(auto x: visit) cout<<x<<" ";
45 |         cout<<endl;
46 | 	}
47 | }
48 | 


--------------------------------------------------------------------------------
/1100/31.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1511/C
 2 | //Yet Another Card Deck
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	// int tc;
29 | 	// cin>>tc;
30 | 	//while(tc--){
31 | 		int n,k;cin>>n>>k;
32 |         ump<int,int> idx;
33 |         vi arr(n),q(k);
34 |         read(arr,n);
35 |         read(q,k);
36 |         for(int i=0;i<n;i++){
37 |             int x = arr[i];
38 |             if(idx.find(x)==idx.end()) idx[x] = i+1; 
39 |         }
40 |         for(int i=0;i<k;i++){
41 |             int c = q[i];
42 |             cout<<idx[c]<<" ";
43 |             for(auto &x: idx) {
44 |                 if(x.second<idx[c]) x.second+=1;
45 |             }
46 |             idx[c] = 1;
47 |         }
48 |         cout<<endl;
49 | 	}
50 | //}
51 | 


--------------------------------------------------------------------------------
/1100/14.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1821/problem/B
 2 | //Sort the Subarray
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | #define pp pair<int,int>
10 | #define ff first
11 | #define ss second
12 | #define vi vector<int>
13 | #define mod 1000000007
14 | #define sort(v) sort(v.begin(),v.end())
15 | vector<int> read(int n){
16 | 	vector<int> arr(n);
17 | 	for(int i=0;i<n;i++) cin>>arr[i];
18 | 	return arr;
19 | }
20 | int solve(){
21 | }
22 | int main() {
23 | 	int tc;
24 | 	cin>>tc;
25 | 	while(tc--){
26 | 		int n;
27 |         cin>>n;
28 |         vi a = read(n);
29 |         vi b = read(n);
30 |         int i=0,j=0;int l=1, r = n,len = 0;
31 |         while(j<n){
32 |             int count = 0;
33 |             while(j<n-1 and b[j]<=b[j+1]){
34 |                 if(a[j]!=b[j]) count++;
35 |                 j++;
36 |             }
37 |             if(count){
38 |                 int curr = j-i+1;
39 |                 if(curr>len){len = curr,l=i+1,r=j+1;}
40 |             }
41 |             while(i<=j){
42 |                 if(a[i]!=b[i]) count--;
43 |                 i++;
44 |                 if(count){
45 |                     int curr = j-i+1;
46 |                     if(curr>len){len = curr,l=i+1,r=j+1;}
47 |                 }
48 |             }
49 |             j++;
50 |         }
51 |         cout<<l<<" "<<r<<endl;
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/900/21.cpp:
--------------------------------------------------------------------------------
 1 | //Make it Divisible by 25
 2 | //https://codeforces.com/problemset/problem/1593/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | int solve(){
10 | }
11 | int main() {
12 | 	int tc;
13 | 	cin>>tc;
14 | 	while(tc--){
15 |         ll n;
16 |         cin>>n;
17 |         string s = to_string(n);
18 |         ll count = 0,ans = INT_MAX;
19 |         for(int i=s.size()-1;i>=0;i--){
20 |             if(s[i]=='0'){
21 |                 i--;
22 |                 while(i>=0 and( s[i]!='5' and s[i]!='0')){
23 |                     count++;
24 |                     i--;
25 |                 }
26 |                 if(i>=0 and (s[i]=='5' or s[i]=='0')){
27 |                     ans = min(ans,count);
28 |                 }
29 |                 break;
30 |             }
31 |             else count++;
32 |         }
33 |         count = 0;
34 |         for(int i=s.size()-1;i>=0;i--){
35 |             if(s[i]=='5'){
36 |                 i--;
37 |                 while(i>=0 and( s[i]!='2' and s[i]!='7')){
38 |                     count++;
39 |                     i--;
40 |                 }
41 |                 if(i>=0 and (s[i]=='2' or s[i]=='7')){
42 |                     ans = min(ans,count);
43 |                 }
44 |                 break;
45 |             }
46 |             else count++;
47 |         }
48 |         cout<<ans<<endl;
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/1000/07.cpp:
--------------------------------------------------------------------------------
 1 | // Array Merging
 2 | //https://codeforces.com/contest/1831/problem/B
 3 | #include <bits/stdc++.h>
 4 | #ifndef ONLINE_JUDGE
 5 | #include <D:\CP\debug_Template.cpp>
 6 | #else
 7 | #define debug(...)
 8 | #define debugArr(...)
 9 | #endif
10 | using namespace std;
11 | #define ll long long 
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | 
16 | int solve(){
17 | }
18 | int main() {
19 | 	int tc;
20 | 	cin>>tc;
21 | 	while(tc--){
22 |         int n; int ans=0;
23 |         cin>>n;
24 |         vector<int> a(n),b(n);
25 |         for(int i=0;i<n;i++)cin>>a[i];
26 |         for(int i=0;i<n;i++)cin>>b[i];
27 |         vector<int> freq1(n+n+1,0),freq2(n+n+1,0);
28 |         int s = 0 ,i=1;
29 |         for( i=1;i<n;i++){
30 |             if(a[i]!=a[i-1]){
31 |                 int len = i-s;
32 |                 freq1[a[i-1]] = max(freq1[a[i-1]],len);
33 |                 s = i;
34 |             }
35 |         }
36 |         freq1[a[i-1]] = max(freq1[a[i-1]],i-s);
37 |         s = 0;
38 |         for( i=1;i<n;i++){
39 |             if(b[i]!=b[i-1]){
40 |                 int len = i-s;
41 |                 freq2[b[i-1]] = max(freq2[b[i-1]],len);
42 |                 s = i;
43 |             }
44 |         }
45 |         freq2[b[n-1]] = max(freq2[b[n-1]],n-s);
46 | 
47 |         for(int i=0;i<freq1.size();i++){
48 |             ans = max(freq1[i]+freq2[i],ans);        
49 |         }
50 |         cout<<ans<<endl;
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/1100/29.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1618/C
 2 | //Paint the Array
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		ll n;cin>>n;
32 |         vl arr(n);
33 |         read(arr,n);
34 |         ll i = 0,j=1;
35 |         ll x=arr[0],y=arr[1];
36 |         while(i<n){
37 |             x=gcd(arr[i],x);
38 |             i+=2;
39 |         }
40 |         while(j<n){
41 |             y=gcd(arr[j],y);
42 |             j+=2;
43 |         }
44 |         for(int i=0;i<n;i++){
45 |             if(x!=0 and i%2==1 and arr[i]%x==0) x=0;
46 |             if(y!=0 and i%2==0 and arr[i]%y==0) y=0;
47 |         }
48 |         if(!x and !y) cout<<0<<endl;
49 |         else if(x) cout<<x<<endl;
50 |         else cout<<y<<endl;
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/1100/27.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1656/B
 2 | //Subtract Operation
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n,k;
32 |         cin>>n>>k;
33 |         vi v(n);
34 |         read(v,n);
35 |         srt(v);
36 |         bool f = false;
37 |         int left = 0, right = 1;
38 |         while (right < n) {
39 |             int diff=v[right]- v[left];
40 |             if(diff==k) {
41 |                 f = true;
42 |                 break;
43 |             }
44 |             else if (diff < k) right++;
45 |             else{
46 |                 left++;
47 |                 if (left==right) right++;
48 |             }
49 |         }
50 |         
51 |         if(f) cout<<"YES"<<endl;
52 |         else cout<<"NO"<<endl;
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/1100/21.cpp:
--------------------------------------------------------------------------------
 1 | //Coprime
 2 | //https://codeforces.com/contest/1742/problem/D
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n;
32 |         cin>>n;
33 |         vi v(n);
34 |         read(v,n);
35 |         int ans = -1;
36 |         vi arr;
37 |         ump<int,int> mp;
38 |         for(int i=0;i<n;i++){
39 |             if(mp.find(v[i])==mp.end()) arr.pb(v[i]);
40 |             mp[v[i]] = i+1;
41 |         }
42 |         for(int i=arr.size()-1;i>=0;i--){
43 |             for(int j=i;j>=0;j--){
44 |                 if(gcd(arr[i],arr[j])==1){
45 |                     ans = max(ans,mp[arr[i]]+mp[arr[j]]);
46 |                 }
47 |             }
48 |         }
49 |         cout<<ans<<endl;
50 | 	}
51 | }
52 | //1 3 5 7 7
53 | //2 4
54 | 
55 | //1 3 5
56 | //2 4
57 | 


--------------------------------------------------------------------------------
/1100/30.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1610/B
 2 | //Kalindrome Array
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | bool solve(vi &arr, int k){
25 |     vector<int> temp;
26 |     for(auto x: arr) if(x!=k) temp.pb(x);
27 |     int i=0,j=temp.size()-1;
28 |     while(i<=j){
29 |         if(temp[i]!=temp[j]) return false;
30 |         i++,j--;
31 |     }
32 |     return true;
33 | }
34 | int main() {
35 |     ios::sync_with_stdio(0); cin.tie(0);
36 | 	int tc;
37 | 	cin>>tc;
38 | 	while(tc--){
39 | 		int n;cin>>n;
40 |         vi arr(n);
41 |         read(arr,n);
42 |         int i=0,j=n-1;
43 |         bool f = true;
44 |         while(i<=j){
45 |             if(arr[i]!=arr[j]){
46 |                 f = (solve(arr,arr[i]) or solve(arr,arr[j]));
47 |                 break;
48 |             }
49 |             i++;j--;
50 |         }
51 |         if(f) cout<<"YES"<<endl;
52 |         else cout<<"NO"<<endl;
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/1100/23.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1708/B
 2 | //Difference of GCDs
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		ll n,l,r;
32 |         cin>>n>>l>>r;
33 |         vl arr(n+1);
34 |         bool flag = true;
35 |         for(int i=1;i<=n;i++){
36 |             if(l%i==0) arr[i]=l;
37 |             else{
38 |                 ll x = l%i;
39 |                 if((l+i-x)>r) {
40 |                     flag = false;
41 |                     break;
42 |                 }
43 |                 else if((l+i-x)<=r){
44 |                     arr[i] = l+i-x;
45 |                 }
46 |             }
47 |         }
48 |         if(flag){
49 |             cout<<"YES"<<endl;
50 |             for(int i=1;i<=n;i++) cout<<arr[i]<<" ";
51 |             cout<<endl;
52 |         }
53 |         else cout<<"NO"<<endl;
54 | 	}
55 | }
56 | 


--------------------------------------------------------------------------------
/1100/15.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1820/problem/B
 2 | //JoJo's Incredible Adventures
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define gcd __gcd
 7 | #define ull unsigned long long
 8 | #define endl "\n"
 9 | #define pp pair<int,int>
10 | #define ff first
11 | #define ss second
12 | #define mod 1000000007
13 | #define sort(v) sort(v.begin(),v.end())
14 | vector<int> read(int n){
15 | 	vector<int> arr(n);
16 | 	for(int i=0;i<n;i++) cin>>arr[i];
17 | 	return arr;
18 | }
19 | int solve(){
20 | }
21 | int main() {
22 | 	int tc;
23 | 	cin>>tc;
24 | 	while(tc--){
25 | 		string s; cin>>s;
26 |         ll n = s.size();
27 |         if(s.size()>1) s+=s;
28 |         ll count = 0, maxi =0;bool flag = false;
29 |         for(int i=0;i<s.size();i++){
30 |             if(s[i]=='0') flag = true;
31 |             if(s[i]=='1') count++;
32 |             else{
33 |                 maxi = max(count,maxi);
34 |                 count = 0;
35 |             }
36 |         }
37 |         ll x = n*n;
38 |         if(!flag) cout<<x<<endl;
39 |         else{
40 |             ll ans = 0;
41 |             ll a = maxi/2;
42 |             ans = (maxi-a)*(1+a);
43 |             cout<<ans<<endl;
44 |         }
45 |         
46 |         
47 | 	}
48 |     //1110
49 |     //0111
50 |     //1011
51 |     //1101
52 | 
53 |     //1101
54 |     //1110
55 |     //0111
56 |     //1011
57 |     //1101
58 | }
59 | /*
60 | 11011101111
61 | 11101110111
62 | 11110111011
63 | 11111011101
64 | 11111101110
65 | */
66 | //1110110110011111111000111
67 | //9*1.8*2.7*3.6*4.5*5*.4*6
68 | //4*1.3*2.2*3.1*4
69 | 


--------------------------------------------------------------------------------
/1100/16.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1807/G2
 2 | //Subsequence Addition (Hard Version)
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define vi vector<int>
 7 | #define vl vector<ll>
 8 | #define vvi vector<vector<int>>
 9 | #define vvl vector<vector<ll>>
10 | #define gcd __gcd
11 | #define ull unsigned long long
12 | #define endl "\n"
13 | #define pp pair<int,int>
14 | #define ff first
15 | #define ss second
16 | #define mod 1000000007
17 | #define srt(v) sort(v.begin(),v.end())
18 | #define rsrt(v) sort(v.rbegin(),v.rend())
19 | #define rev(v) reverse(v.begin(),v.end())
20 | #define ump unordered_map
21 | 
22 | vector<ll> read(int n){
23 | 	vector<ll> arr(n);
24 | 	for(int i=0;i<n;i++) cin>>arr[i];
25 | 	return arr;
26 | }
27 | int solve(){
28 | }
29 | int main() {
30 |     ios::sync_with_stdio(0); cin.tie(0);
31 | 	int tc;
32 | 	cin>>tc;
33 | 	while(tc--){
34 | 		ll n;
35 |         cin>>n;
36 |         vl v = read(n);
37 |         srt(v);
38 |         vl pre;
39 |         pre.push_back(v[0]);
40 |         for(int i=1;i<v.size();i++){
41 |             pre.push_back(pre.back()+v[i]);
42 |         }
43 |         if(pre[0]!=1){
44 |             cout<<"NO"<<endl;
45 |             continue;
46 |         }
47 |         bool flag = true;
48 |         for(int i=1;i<n;i++){
49 |             if(v[i]>pre[i-1]) {
50 |                 flag = false;
51 |                 break;
52 |             }
53 |         }
54 |         if(flag) cout<<"YES"<<endl;
55 |         else cout<<"NO"<<endl;
56 | 	}
57 | }
58 | /*
59 | 1 1 2 3 5 12
60 | 1 2 4 7 12 24
61 | 
62 | 1 1 2 5 7
63 | 1 2 4 9 16
64 | 
65 | 1 1 1 2 4
66 | 1 2 3 5 9
67 | */
68 | 


--------------------------------------------------------------------------------
/1100/25.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/contest/1673/problem/B
 2 | //A Perfectly Balanced String?
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		string s;
32 |         cin>>s; bool flag = true;
33 |         ump<char,int> mp;
34 |         for(auto c: s) mp[c]++;
35 |         int uniq = mp.size();
36 |         for(int i=0;i<26;i++){
37 |             if(mp['a'+i]<2) continue;
38 |             int j=0;
39 |             char key = 'a'+i;
40 |             int n = s.size();
41 |             while(j<n){
42 |                 int count = 0;
43 |                 while(j<n and s[j]!=key) j++;
44 |                 j++;
45 |                 while(j<n and s[j]!=key) j++,count++;
46 |                 if(j<n and uniq-count>1){
47 |                     flag = false;
48 |                     break;
49 |                 }
50 |                 
51 |             }
52 |             if(!flag) break;
53 |         }
54 |         cout<<((flag)?"YES":"NO")<<endl;
55 | 	}
56 | }
57 | //bacdb
58 | 


--------------------------------------------------------------------------------
/1200/01.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1914/D
 2 | //Three Activities
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define yes "YES"
 6 | #define no "NO"
 7 | #define ll long long 
 8 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 9 | #define pb(x) push_back(x)
10 | #define vi vector<int>
11 | #define vl vector<ll>
12 | #define vvi vector<vector<int>>
13 | #define vvl vector<vector<ll>>
14 | #define gcd __gcd
15 | #define ull unsigned long long
16 | #define endl "\n"
17 | #define pp pair<int,int>
18 | #define ff first
19 | #define ss second
20 | #define mod 1000000007
21 | #define srt(v) sort(v.begin(),v.end())
22 | #define rsrt(v) sort(v.rbegin(),v.rend())
23 | #define rev(v) reverse(v.begin(),v.end())
24 | #define ump unordered_map
25 | #define uset unordered_set
26 | #define setbits(x) __builtin_popcount(x)
27 | 
28 | vector<int> solve(vector<int>& arr) {
29 |     int n = arr.size();
30 |     int a=-1,b=-1,c=-1;
31 |     for (int i = 0; i < n; ++i) {
32 |         if (a==-1 or arr[i]>arr[a]) c=b,b=a,a=i;
33 |         else if (b==-1 or arr[i]>arr[b]) c=b,b=i;
34 |         else if (c==-1 or arr[i]>arr[c]) c = i;
35 |     }
36 |     return {a,b,c};
37 | }
38 | int main() {
39 |     ios::sync_with_stdio(0); cin.tie(0);
40 | 	int tc;
41 | 	cin>>tc;
42 | 	while(tc--){
43 | 		int n;cin>>n;
44 | 		vvi arr;
45 | 		for(int i=0;i<3;i++){
46 | 			vi temp(n);
47 | 			read(temp,n);
48 | 			arr.pb(temp);
49 | 		}
50 | 		int ans = 0, curr = 0;
51 | 		for(auto x : solve(arr[0])){
52 | 			for(auto y : solve(arr[1])){
53 | 				for(auto z: solve(arr[2])){
54 | 					if(x!=y and y!=z and z!=x){
55 | 						curr=arr[0][x]+arr[1][y]+arr[2][z];
56 | 						ans = max(curr,ans);
57 | 					}
58 | 				}
59 | 			}
60 | 		}
61 | 		cout<<ans<<endl;
62 | 	}
63 | }
64 | 


--------------------------------------------------------------------------------
/1100/17.cpp:
--------------------------------------------------------------------------------
 1 | //Li Hua and Pattern
 2 | //https://codeforces.com/problemset/problem/1797/B
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		int n,k;
32 |         cin>>n>>k;
33 |         vvi v;
34 |         for(int i=0;i<n;i++){
35 |             vi temp(n);
36 |             read(temp,n);
37 |             v.pb(temp);
38 |         }
39 |         int i=0, j=n-1;
40 |         while(i<j){
41 |             int id1 = 0, id2 = n-1;
42 |             while(id1<n){
43 |                 if(v[i][id1]!=v[j][id2]) k--;
44 |                 id1++;id2--;
45 |                 if(k<0) break;
46 |             }
47 |             if(k<0) break;
48 |             i++;
49 |             j--;
50 |         }
51 |         if(n>1 and n%2==1){
52 |             int row = n/2;
53 |             int i=0,j=n-1;
54 |             while(i<=j){
55 |                 if(v[row][i]!=v[row][j]) k--;
56 |                 i++;j--;
57 |             }
58 |         }
59 |         if(k>=0 and k%2==0) cout<<"YES"<<endl;
60 |         else if(k>=0 and n%2) cout<<"YES"<<endl;
61 |         else cout<<"NO"<<endl;
62 | 	}
63 | }
64 | //1 1 1 0 0 0
65 | //0 0 0 1 1 1
66 | 


--------------------------------------------------------------------------------
/1100/19.cpp:
--------------------------------------------------------------------------------
 1 | //https://codeforces.com/problemset/problem/1791/E
 2 | //Negatives and Positives
 3 | #include <bits/stdc++.h>
 4 | using namespace std;
 5 | #define ll long long 
 6 | #define read(arr,n) for(ll i=0;i<n;i++) cin>>arr[i]
 7 | #define pb(x) push_back(x)
 8 | #define vi vector<int>
 9 | #define vl vector<ll>
10 | #define vvi vector<vector<int>>
11 | #define vvl vector<vector<ll>>
12 | #define gcd __gcd
13 | #define ull unsigned long long
14 | #define endl "\n"
15 | #define pp pair<int,int>
16 | #define ff first
17 | #define ss second
18 | #define mod 1000000007
19 | #define srt(v) sort(v.begin(),v.end())
20 | #define rsrt(v) sort(v.rbegin(),v.rend())
21 | #define rev(v) reverse(v.begin(),v.end())
22 | #define ump unordered_map
23 | 
24 | int solve(){
25 | }
26 | int main() {
27 |     ios::sync_with_stdio(0); cin.tie(0);
28 | 	int tc;
29 | 	cin>>tc;
30 | 	while(tc--){
31 | 		ll n;
32 |         cin>>n;
33 |         vl v(n);ll sum = 0;
34 |         int count = 0;
35 |         vector<int> neg;
36 |         vector<int> pos;
37 |         for(int i=0;i<n;i++){
38 |             cin>>v[i];
39 |             if(v[i]<0) count++,neg.pb(v[i]);
40 |             else pos.pb(v[i]);
41 |         }
42 |         if(count%2==0){
43 |             for(auto x: v){
44 |                 sum+=abs(x);
45 |             }
46 |         }
47 |         else{
48 |             srt(neg);
49 |             srt(pos);
50 |             int i=0;
51 |             while(count>1){
52 |                 sum+=abs(neg[i]);
53 |                 count--;
54 |                 i++;
55 |             }
56 |             if(pos.size()){
57 |                 if(pos[0]<abs(neg.back())){
58 |                     sum+=abs(neg.back());
59 |                     sum-=pos[0];
60 |                     for(int i=1;i<pos.size();i++) sum+=pos[i];
61 |                 }
62 |                 else{
63 |                      sum+=neg.back();
64 |                      for(auto x: pos) sum+=x;
65 |                 }
66 |             }
67 |             else sum+=neg.back();
68 |         }
69 |         cout<<sum<<endl;
70 | 	}
71 | }
72 | 


--------------------------------------------------------------------------------