Let's have a value $$$a_i$$$ $$$(1 \le i \le n)$$$.

What if the $$$k'th$$$ $$$(0 \le k \le 16)$$$ bit of $$$a_i$$$ is $$$1$$$? It will contribute $$$2^k$$$ to the answer if the $$$k'th$$$ bit of $$$b_j$$$ $$$(1 \le j \le n)$$$ is $$$0$$$. Let's assume, $$$x$$$ $$$(1 \le x \le n)$$$ number of values are present in array $$$b$$$ where the $$$k'th$$$ bit is $$$0$$$. Then $$$a_i$$$ will contribute $$$x*2^k$$$ to the answer. If the $$$k'th$$$ bit is $$$0$$$ of $$$a_i$$$, it will contribute $$$(n-x)2^k$$$ to the answer. Now, compute the number of times $$$a_i$$$ will make a pair with $$$b_j$$$. It's $$$(n-1)!$$$.

So, the final result is the sum of $$$x*2^k(n-1)!$$$ if the $$$k'th$$$ bit is $$$1$$$ of $$$a_i$$$, $$$(n-x)2^k(n-1)!$$$ otherwise.

#include<bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int main() {
    ios_base::sync_with_stdio(false);cin.tie(NULL);
    int n; cin >> n;
    std::vector<int> v1(30);
    ll gun = 1, ans = 0;
    for(int i = 1; i < n; i++) {
        gun = (gun * i) % mod;
    } for(int i = 0; i < n; i++) {
        int a; cin >> a;
        for(int j = 0; j < 20; j++) {
            int a1 = (a >> j)&1;
            if(a1) v1[j]++;
        }
    } for(int i = 0; i < n; i++) {
        int a; cin >> a;
        for(int j = 0; j < 20; j++) {
            int a1 = (a >> j)&1;
            ll b1 = gun * ( 1 << j) % mod;
            if(a1) {
                ans += (n - v1[j]) * b1 % mod;
            } else {
                ans += v1[j] * b1 % mod;
            }
        }
    } cout << ans % mod << "\n";

}

Calculate the contribution of $$$k'th$$$ $$$(0 \le k \le 27)$$$ bit to the answer. Count the number of ways $$$x$$$, in which $$$k'th$$$ bit is $$$1$$$ within $$$n!$$$ permutations. Add $$$x*2^k$$$ to the answer.

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

const int mx = 16, mod = 1e9 + 7;
int n, a[mx], b[mx], d, dp[2][1 << mx];
int f(int i = 0, int mask = 0, int p = 0) {
    if(i >= n) {
        return p * (1 << d);
    }
    int &res = dp[p][mask]; if(~res) return res; res = 0;
    for(int j = 0; j < n; j++) {
        if(!(mask & (1 << j))) {
            res += f(i + 1, mask | (1 << j), p ^ (((a[j] + b[i]) >> d) & 1));
            if(res >= mod) res -= mod;
        }
    }
    return res;
}
int32_t main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    cin >> n;
    for(int i = 0; i < n; i++) cin >> a[i];    
    for(int i = 0; i < n; i++) cin >> b[i];
    int ans = 0;
    for(d = 0; d <= 27; d++) {
        memset(dp, -1, sizeof dp);
        ans = (ans + f()) % mod;
    }
    cout << ans << '\n';
    return 0;
}

Our intended solution was using Manachar algorithm.

From manacher algorithm, you can find every palindrome's start and end point. There can not have more than n palindrome (n = string-length).

Sort Reversely. Take the maximum length unused palindrome and still for those index not cover by any previous palindrome, cover it by the current palindrome length and erase those index as we find the maximum palindrome length for that specific index. Finally, print the index answer.

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

// l[2 * i] = len of palindrome centered at s[i]
// l[2*i+1] = len of palindrome centered at s[i], s[i+1]
vector<int> manacher(string &s) {
	int n = s.size(); vector<int> l(2 * n); 
	for (int i = 0, j = 0, k; i < n * 2; i += k, j = max(j - k, 0)) {
		while (i >= j && i + j + 1 < n * 2 && s[(i - j) / 2] == s[(i + j + 1) / 2]) ++j;
		l[i] = j;
		for (k = 1; i >= k && j >= k && l[i - k] != j - k; ++k) 
			l[i + k] = min(l[i - k], j - k);
	} return l;
}

int32_t main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	int t; cin >> t; while(t--) {
		int n; cin >> n;
		vector<vector<int>> o(n + 1);
		string s; cin >> s;
		auto T = manacher(s);
		for(int i = 0; i < n; i++) {
			int val, l, r;
			val = T[i * 2], l = i - val / 2, r = i + val / 2, o[l].push_back(val), o[r + 1].push_back(-val);
			if(T[i * 2 + 1]) val = T[i * 2 + 1], l = i - val / 2 + 1, r = i + val / 2, o[l].push_back(val), o[r + 1].push_back(-val);
		}
		multiset<int> ms;
		for(int i = 0; i < n; i++) {
			for(int j: o[i]) {
				if(j < 0) {
					ms.erase(ms.find(-j));
				} else {
					ms.insert(j);
				}
			}
			cout << *ms.rbegin() << " \n"[i + 1 == n];
		}
	}	
	return 0;
}

Calculate all possible distinct subsequence sums using coin change dp and store them in array $$$x$$$. Also calculate the minimum possible and maximum subsequence sum. Relax your answer by $$$|2⋅x−(p+q)|$$$.

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

const int mx = 500 * 500 + 2;
int dp[mx * 2 + 4];
int32_t main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    dp[mx + 2] = 1;
    int n, p = 0, q = 0; cin >> n;
    for(int i = 0, x; i < n; i++) {
        cin >> x;
        if(x > 0) {
            p += x;
            for(int i = mx; i >= -mx; i--) if(i + x <= mx) dp[i + x + (mx + 2)] |= dp[i + (mx + 2)];
        } else {
            q += x;
            for(int i = -mx; i <= mx; i++) if(i + x >= -mx) dp[i + x + (mx + 2)] |= dp[i + (mx + 2)];
        }
    }
    int mi = INT_MAX;
    for(int i = -mx; i <= mx; i++) if(dp[i + (mx + 2)]) mi = min(mi, abs(2 * i - p - q));
    cout << mi << '\n';
    return 0;
}

You just have to implement the basic expected value equation. Let's think about a state, in which the first $$$q$$$ cities are not explored and $$$n-q$$$ cities are. $$$E(q)$$$ is the expected cost to explore the remaining q cities.

$$$E(q) = \frac{1}{n}{E(q-1)+a_1}+......+\frac{1}{n}{E(q-1)+a_q}+\frac{1}{n}{E(q)+a_{p+1}}+......+\frac{1}{n}{E(q)+a_n}$$$

$$$E(q) = \frac{q}{n}E(q-1)+\frac{n-q}{n}E(q)+\frac{1}{n}(a_1+a_2+......+a_n)$$$

$$$(1-\frac{n-q}{n})E(q)=\frac{q}{n}E(q-1)+\frac{1}{n}(a_1+a_2+......+a_n)$$$

$$$\frac{q}{n}E(q)=\frac{q}{n}E(q-1)+\frac{1}{n}(a_1+a_2+......+a_n)$$$

$$$E(q)=E(q-1)+\frac{1}{q}(a_1+a_2+......+a_n)$$$

Then

$$$E(q-1)=E(q-2)+\frac{1}{q-1}(a_1+a_2+......+a_n)$$$

So

$$$E(q)=E(q-2)+\frac{1}{q-1}(a_1+a_2+......+a_n)+\frac{1}{q}(a_1+a_2+......+a_n)$$$

$$$E(q)=E(q-2)+(\frac{1}{q}+\frac{1}{q-1})(a_1+a_2+......+a_n)$$$

As

$$$E(0)=0$$$

$$$E(q)=(\frac{1}{q}+\frac{1}{q-1}+......+\frac{1}{2}+1)(a_1+a_2+......+a_n)$$$

Initially, All of the n cities are not explored. So, the answer is $$$E(n)$$$, where

$$$E(n)=(\frac{1}{n}+\frac{1}{n-1}+......+\frac{1}{2}+1)(a_1+a_2+......+a_n)$$$

#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int power(long long a, long long b) {
	long long x = 1;
	while (b) {
		if (b & 1)x = x * a % mod;
		a = a * a % mod;
		b >>= 1;
	} return x;
}
int32_t main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	int n, s = 0, a = 0; cin >> n;
	for(int i = 1, x; i <= n; i++) {
		cin >> x;
		a = (a + x) % mod;
		s = (s + power(i, mod - 2)) % mod;
	}
	a = 1LL * a * s % mod;
	cout << a << '\n';
	return 0;
}

Save everything and solve query reversely. Can use DSU to merge two componentand and for update/max_value_find can use multiset.

Hint: Save all the query and solve offline.

Initially, merge all the edge as component using DSU which not deleted at all. Then,

1st query: just merge the edge.

2nd query: Find the vertex's parent and erase the previous value and insert the new one from that component. Here, can use multiset cause there can be duplicate value.

3rd query: Find the maximum value from the vertex parent's component and store it.

Finally print the stored value reversely, as we solved query reversely.

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

const int mx = 1e5 + 10;
int p[mx], type[mx], f[mx], s[mx], rs[mx], n, m, q, u[mx], v[mx], vis[mx], par[mx];
multiset<int> score[mx];

int find(int u) {return par[u] == u ? u: par[u] = find(par[u]);}
void add(int u, int v) {
    u = find(u);
    v = find(v);
    if(u != v) {
        if(score[u].size() > score[v].size()) swap(u, v);
        for(int x: score[u]) score[v].insert(x);
        par[u] = v;
    }
}
int32_t main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; i++) par[i] = i;
    for(int i = 1; i <= n; i++) cin >> p[i];
    for(int i = 1; i <= m; i++) cin >> u[i] >> v[i];
    cin >> q;
    for(int i = 1; i <= q; i++) {
        cin >> type[i];
        if(type[i] == 1) {
            cin >> f[i];
            vis[f[i]] = 1;
        } else if(type[i] == 2) {
            cin >> f[i] >> s[i];
            rs[i] = p[f[i]];
            p[f[i]] = s[i];
        } else if(type[i] == 3) {
            cin >> f[i];
        }
    }
    for(int i = 1; i <= n; i++) score[i].insert(p[i]);
    for(int i = 1; i <= m; i++) {
        if(!vis[i]) {
            add(u[i], v[i]);
        }
    }
    vector<int> ans;
    for(int i = q; i > 0; i--) {
        if(type[i] == 1) {
            add(u[f[i]], v[f[i]]);
        } else if(type[i] == 2) {
            int root = find(f[i]);
            score[root].erase(score[root].find(s[i]));
            score[root].insert(rs[i]);
        } else {
            int root = find(f[i]);
            ans.push_back(*score[root].rbegin());
        }
    }
    reverse(ans.begin(), ans.end());
    for(int x: ans) cout << x << '\n';
    return 0;
}

Find out minimum value $$$x_{min}$$$ and $$$x_{max}$$$ from the values of $$$x$$$ of all co-ordinates. Similarly find $$$y_{min}$$$ and $$$y_{max}$$$. Then, the answer is $$$(x_{max}-x_{min})(y_{max}-y_{min})$$$

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

int32_t main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	int t; cin >> t; while(t--) {
		int n, nx = INT_MAX, ny = INT_MAX, mx = INT_MIN, my = INT_MIN; cin >> n;
		for(int i = 0; i < n; i++) {
			int x, y; cin >> x >> y;
			nx = min(nx, x);
			mx = max(mx, x);
			ny = min(ny, y);
			my = max(my, y);
		}
		int a = max(mx - nx, my - ny);
		cout << 1LL * a * a << '\n';
	}
	return 0;
}

The answer is $$$max(a_{first_max}*a_{second_max}*a_{third_max},a_{first_max}*a_{first_min}*a_{second_min})$$$

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

int32_t main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	int t; cin >> t; while(t--) {
		int n; cin >> n;
		vector<int> v(n); for(int &i: v) cin >> i;
		sort(v.rbegin(), v.rend());
		long long ma = max(1LL * v[0] * v[1] * v[2], 1LL * v[0] * v[n - 2] * v[n - 1]);
		cout << ma << '\n';
	}
	return 0;
}

Let $$$d$$$ is a divisor of $$$a$$$. Then calculate two values $$$v$$$ and $$$m$$$ where $$$v=\frac{a^2}{d}$$$ and $$$m=v-d+1$$$. If $$$v$$$ $$$mod$$$ $$$2=d$$$ $$$mod$$$ $$$2$$$ and $$$\frac{m}{2} \ge a$$$, then there exists a pythagorean tuple in which $$$a$$$ is the minimum side. Count the number of $$$d$$$ for each possible $$$a$$$ $$$(1 \le a \le 10^5)$$$ and get the cummulative sum of them. Then answer each query in $$$O(1)$$$.

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

const int mx = 1e5 + 10;
int lpf[mx], dp[mx];
int p[10], c[10], ind;
int N, curr_ans = 0;
void backtrack(int i = 0, long long curr = 1) {
	if(i >= ind) {
		long long y = curr, x = 1LL * N * N / y;
		if((x & 1) == (y & 1) && x - y >= 2 * N) {
			curr_ans++;
		}
		return;
	}
	for(int j = 0; j <= c[i]; j++) {
		backtrack(i + 1, curr);
		curr *= p[i];
	}
}
int calculate(int n) {
	/*prime factorize*/
	ind = 0;
	int _n = n; while(_n != 1) {
		int P = lpf[_n], C = 0;
		while(lpf[_n] == P) _n /= P, C++;
		p[ind] = P; c[ind++] = C * 2; // as square
	}

	/*backtrack over all divisor*/
	N = n; curr_ans = 0;
	backtrack();
	return curr_ans;
}

int32_t main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	for(int i = 2; i < mx; i += 2) lpf[i] = 2;
	for(int i = 3; i * i < mx; i += 2) {
		if(lpf[i] == 0) {
			for(int j = i * i; j < mx; j += i << 1) {
				if(lpf[j] == 0) {
					lpf[j] = i;
				}
			}
		}
	}
	for(int i = 1; i < mx; i++) if(lpf[i] == 0) lpf[i] = i;

	for(int i = 1; i < mx; i++) {
		dp[i] = dp[i - 1] + calculate(i);
	}

	int t; cin >> t; while(t--) {
		int n; cin >> n;
		cout << dp[n] << '\n';
	}
	return 0;
}

Just print Team_Robust.

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

int32_t main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
	cout << "Team_Robust\n";
	return 0;
}

    for (int i = 2; i <= n; i++) { // will run O(log n) times at max
      if (__gcd(i, n - 1 - i) == 1) {
        cout << i << ' ' << n - 1 - i << ' ' << 1 << '\n';
        break;
      }
    }

There have $$$4$$$ sides. Side-0(East), side-1(South), side-2(West), side-3(North).

1. If we found '1', we have to move left, just decrement the side value. But for 'side-0', we have to move 'side-3'.
2. Otherwise we found '0', we have to move right, just increment the side value. But for 'side-3', we have to move 'side-0'.

Clearly, final side will be the answer.

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

#define ll long long int
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()

int main()
{
    int test,n;
    cin>>test;
    while(test--){
	string side="ESWN",p;
	cin>>n>>p;

	ll idx=0;
	for(ll i=0;i<n;i++){
		if(p[i]=='0') idx++;
		else idx--;
		if(idx==-1) idx=3;
		else if(idx==4) idx=0;
	}
	 cout<<side[idx]<<endl;
    }   
    return 0;
}

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

#define      PSB                 push_back
#define      ll                 long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll mod = 1e9  + 7;
const ll N=3e5+5;

int main(){
  FastIO
  
  int test;
  cin>>test;
  while(test--){
      ll cnt=0,n;
      string s;
      cin>>n>>s;
      for(ll i=0;i<n;i++){
        if(s[i]=='0') cnt++;
        else cnt--;
      }
      cnt%=4;
      if(cnt<0) cnt+=4;

      if(!cnt) cout<<"E"<<endl;
      else if(cnt==1) cout<<"S"<<endl;
      else if(cnt==2) cout<<"W"<<endl;
      else cout<<"N"<<endl;
  }

  return 0;
}

There are two cases.

• Case 1: There have only even number. In this case answer is "-1". Cause for making the even number odd by adding another number, we need a odd number (we can make even number odd by only adding a odd number with that even number)

• case 2: In this case there must have a odd number. Then for every even number, we can add a odd number with the target even number. And make every even number odd by one operation. Thus number of even number = minimum operation to make all odd.

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

#define      PSB         push_back
#define      ll          long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll mod = 1e9  + 7;
const ll N=3e6+5;

int main(){
  FastIO
  
  int test;
  cin>>test;
  while(test--){
      int n;
      cin>>n;
      vector<int> a(n);
      int cnt=0; bool ck=false;
      for(int i=0;i<n;i++){
        cin>>a[i];
        if(a[i]%2) ck=true;
        else cnt++;
      }

      if(!ck) cout<<"-1"<<endl;
      else cout<<cnt<<endl;
  }

  return 0;
}

A Team can be formed by two ways. By one student Or by two students.

• Way 1: For Those students skill at least k, every student can form a team.

• Way 2: Firstly take the student of maximum skill. Then take the student with minimum skill, as if (1st student skill + 2nd student skill)$$$ \geq k$$$. And Both students were not included in any team before.
  Continue this case to form as much team as possible.

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

#define      PSB         push_back
#define      ll          long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll mod = 1e9  + 7;
const ll N=3e6+5;

int main(){
  FastIO
  
  int test;
  cin>>test;
  while(test--){
      int n,k,team=0;
      cin>>n>>k;
      vector<int> a(n);
      for(int i=0;i<n;i++) cin>>a[i];
      sort(a.begin(),a.end());

      for(ll l=0,r=n-1;l<=r; ){
         if(a[r]>=k){
            ++team; --r;
         }
         else if(a[r]+a[l]>=k && l!=r){
            ++team; ++l; --r;
         }
         else l++;
      }
      cout<<team<<endl;
  }

  return 0;
}

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

#define      PSB         push_back
#define      ll          long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll mod = 1e9  + 7;
const ll N=3e6+5;


int main(){
  FastIO
  
  int test;
  cin>>test;
  while(test--){
      int n,m,a;
      cin>>n>>m;
      multiset<ll> st;
      for(ll i=0;i<n;i++){
        cin>>a;
        st.insert(a);
      }
      ll ans=0;

      for(ll i=n-1;i>=0;i--){
        ll bal=*st.rbegin();
        st.erase(--st.end());
        if(bal>=m){
            ans++; continue;
        }
        ll baki=m-bal;
        auto xx=st.lower_bound(baki);
        if(xx==st.end()) break;
        st.erase(xx);
        ans++;
        if(st.size()==0) break;
      }
      cout<<ans<<endl;
  }

  return 0;
}

For any two integers a, b. The maximum xor value is $$$(a+b)$$$. It can be found when there have not any common bit between 'a' and 'b'.

• Case 1: If Alice chosen two integer, produce the maximum xor value. Then Alice must be win.

• Case 2: In this case there must have some common bit between 'a' and 'b'. Then Bob can easily win, by choose two integer 'c' and 'd', where $$$(c \oplus d)$$$ = (a | b).
  And it is proven that if have some common bit between 'a' and 'b' then (a | b) must be greater than ($$$a \oplus b$$$).

#include <bits/stdc++.h>
using namespace std;
 
#define      PSB                 push_back
#define      ll                 long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll mod = 1e9  + 7;
const ll N=3e5+5;
 
int main(){
  FastIO
  
  int test;
  cin>>test;
  while(test--){
      int a,b;
      cin>>a>>b;
      if((a^b)==(a+b)) cout<<"No"<<endl;
      else cout<<"Yes"<<endl;
  }
  return 0;
}

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

#define ll long long int
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()

int main()
{	
    int test;
    cin>>test;
    read:
    while(test--){
        ll a,b;
        cin>>a>>b;

        while(a && b){
            if(a%2 && b%2){
                cout<<"Yes"<<endl;
                goto read;
            }
            a/=2;
            b/=2;
        }
        cout<<"No"<<endl;
    }
	return 0;
}

We can solve it by dynamic programming.

If some digit sequence already in decreasing order then answer is always "0".

We can write the transition of dp states like this:

$$$dp[i][digit]$$$ $$$ = \; $$$number of non-decreasing sequences end at $$$i$$$ and $$$s[i]=digit$$$.

Initially, all $$$dp[0][i]$$$ states are "1" $$$\; (1 \leq i \leq 9)$$$.

• Case of ($$$s[i]$$$ = "-") :
  $$$\qquad$$$ We can set any digit $$$(1-9)$$$ here. For this case ,
  $$$\qquad\quad$$$ $$$dp[i][digit] = dp[i-1][1] + dp[i-1][2] + \dots + dp[i-1][digit]$$$.

• Case of ($$$s[i]$$$ = '1' to '9') :
  $$$\qquad$$$ Then we must keep $$$s[i]$$$ as it is. For this case ,
  $$$\qquad\quad$$$ $$$dp[i][s_i] = dp[i−1][1] + dp[i−1][2] + \dots + dp[i−1][s_i]$$$.
  $$$\qquad$$$ For calculation help of the next states we can take the "Cumulative sums" $$$— dp[i][digit]$$$ += $$$d[i][digit−1]$$$ , $$$(2 \leq digit \leq 9)$$$

The final answer is $$$dp[len][9]$$$.

#include<bits/stdc++.h>

using namespace std;

const int N=1e5+5;
const int mod=1e9+7;

char s[N];
long long dp[N][10];

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);cout.tie(NULL);
    
    int test;
    cin>>test;
    while(test--){
        int i,j,l,n;
        cin >>n>> s+1;
        l=strlen(s+1);
        for(int i=0;i<=l;i++)
            for(int j=0;j<=10;j++)
              dp[i][j]=0;
        
        for(i=1;i<10;i++) dp[0][i]=1;
        for(i=1;i<=l;i++)
        {
            if(s[i] >= '1'  &&  s[i] <= '9')dp[i][s[i]-'0']=dp[i-1][s[i]-'0'];
            else
            {
                for(j=1;j<10;j++)dp[i][j]=dp[i-1][j];
            }
            for(j=2;j<10;j++)
            {
                dp[i][j]+=dp[i][j-1];
                dp[i][j]%=mod;
            }
        }
        cout << dp[l][9]<<endl;
    }
    return 0;
}

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

#define ll long long int
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()

int main()
{

    int test,n;
    cin>>test;
    read:
    while(test--){
        string s;
        cin>>n>>s;
        s='1'+s+'9';
        ll mod=1000000007LL,ans=1LL;

        for(ll i=0,j;i<(ll)s.size()-1;){
            for(j=i+1;j<(ll)s.size();j++)
                if(s[j]!='-') break;
            if(s[j]<s[i]){
                cout<<0<<endl;
                goto read;
            }
            ll diff=s[j]-s[i];
            ll d[10];
            for(ll k=0;k<10;k++) d[k]=1LL;

            for(ll k=i+1;k<j;k++){
                for(ll l=diff-1;l>=0;l--){
                    d[l]+=d[l+1];
                    d[l]%=mod;
                }
            }
            ans*=d[0];
            ans%=mod;
            i=j;
        }
        cout<<ans<<endl;
    }

	return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int mod=1e9+7;
const int mx=1e6+5;
int Pow(int a,int b){
	int res=1;
	while(b){
		if(b&1)res=(res*1LL*a)%mod;
		a=(a*1LL*a)%mod;
		b>>=1;
	}return res;
}
int f[mx];

inline int mul(int a,int b){return (a*1LL*b)%mod;}
inline int ncr(int n,int k){
	return mul(f[n],Pow(mul(f[k],f[n-k]),mod-2));
}

int main(){
	f[0]=1;
	for(int i=1;i<mx;i++){
		f[i]=(f[i-1]*1LL*i)%mod;
	}
	
    int test;
    cin>>test;
    read:
    while(test--){
        int ans=1,n;
        string s; cin>>n>>s; s="1"+s+"9";  n=s.size();
        for(int i=0,l=-1;i<n;i++){
            if(s[i]>='0' && s[i]<='9'){
                if(l==-1){
                    l=i;
                    continue;
                }
                int a=s[l]-'0',b=s[i]-'0',k=b-a;
                if(k<0){
                    cout<<0<<endl;
                    goto read;
                }
                int len=i-l-1;
                if(len==0){
                    l=i;
                    continue;
                }
                // cout<<len<<' '<<k<<' '<<i<<endl;
                int aa=0;
                for(int K=0;K<=k;K++){
                    aa+=ncr(len+K-1,K);
                    if(aa>=mod)aa-=mod;
                }
                ans=mul(ans,aa);
                l=i;
            }
        }cout<<ans<<endl;
    }
	return 0;
}

we can solve this problem by two pointer idea.

Every time, we fixed one left and right point and store the current frequency of every unique element between the left to right subsegment inclusively. And for those cases after buying all element between left to right subsegment inclusively, cost is not more than k, we have to find the maximum value of $$$(right-left+1)$$$.

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

#define      PSB         push_back
#define      ll          long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);
constexpr ll mod = 1e9  + 7;
const ll N=1e6+5;

int n, k;
int a[N], curf[N];

int main(){
    FastIO

    int test;
    cin>>test;
    while(test--){
        cin>>n>>k;
        vector<int> a(n);
        for(int i=0;i<n;i++) cin>>a[i],curf[a[i]]=0;

        int cost = 0, ans = 0;
        int l = 0;
        for(int r = 0; r < n; r++)
        {
            if(curf[a[r]] == 0)
                cost += a[r];
            curf[a[r]]++;
            while(cost > k)
            {
                curf[a[l]]--;
                if(curf[a[l]] == 0)
                    cost -= a[l];
                l++;
            }
            ans = max(ans, r - l + 1);
        }
        cout<<ans<<endl;
    }

  return 0;
}

//Author: AnandRaj doubleux
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef pair<ll,ll> pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pll> vpll; 

#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define test() int t;cin>>t;while(t--)
#define all(v) v.begin(),v.end()
#define prinp(p) cout<<p.first<<" "<<p.second<<endl
#define prinv(V) for(auto v:V) cout<<v<<" ";cout<<endl
#define take(V,f,n) for(int in=f;in<f+n;in++) cin>>V[in]
#define what(x) cerr<<#x<<" = "<<x<<endl
#define KStest() int t,t1;cin>>t;t1=t;while(t--)
#define KScout cout<<"Case #"<<t1-t<<": "
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1e9+7,MAX = 1e6+5;
const ll INF = 1e18+5;

int main()
{
    int test;
    cin>>test;
    while(test--){
        int n,k;
        cin>>n>>k;
        vi A(n);
        take(A,0,n);
        int ans = 0;
        int low = 0,high = n;
        while(low<=high)
        {
            int mid = low + (high-low)/2;
            bool can = false;
            ll sum = 0;
            vi M(MAX);
            for(int i = 0;i<mid;i++)
            {
                M[A[i]]++;
                if(M[A[i]]==1) sum+=A[i];
            }
            if(sum<=k)
            {
                ans = mid;
                low = mid+1;
            }
            else
            {
                for(int i=mid;i<n;i++)
                {
                    M[A[i-mid]]--;
                    if(M[A[i-mid]]==0) sum -= A[i-mid];
                    M[A[i]]++;
                    if(M[A[i]]==1) sum += A[i];

                    if(sum<=k) can=true;
                }
                if(can)
                {
                    ans = mid;
                    low = mid+1;
                }
                else high = mid-1;
            }
        }
        cout<<ans<<endl;
    }
}

• At first , we want to say sorry for our many mistakes. Please forgive us those mistakes like Bad statement ,capitalization , Bolding , Lack of latex/Pretty formating etc. we are totally unaware of those mistakes. Next time we will try to overcome those mistakes .
• Second one , Our B was match with one of codechef problem. But we are totally unaware of that. If we knew that we must be removed that problem .
• It was just a practice contest . So if you enjoy a little bit , it's out pleasure.

For a square-Field exclude the pillar we can choose any of four side of the pillar.. But answer will be the maximum one. Suppose think in a 5*5 Field a pillar on (4,3).

1. Right side you can choose max 1*1 field ( Blue Area ). Right = (L-x)*(L-x)
2. Upper side you can choose max 2*2 field (Yellow Area) . Upper = (y-1)*(y-1)
3. Left side you can choose max 3*3 field ( Green Area ) . Left = (x-1)*(x-1)
4. Down side you can choose max 2*2 field (Orange Area ) . Down = (L-y)*(L-y)

So Left one is the max .

mx = max( (L-x) , (y-1) , (x-1) , (L-y) )
answer = mx*mx = 3*3 = 9

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

int main()
{
    ll l;
    cin >> l;
    ll x, y;
    cin >> x >> y;
    ll mx=max(max(max(l-x,x-1LL),y-1LL),l-y);

    cout<<mx*mx<<endl;

    return 0;
}

Find the two subarray (s1, s2; |s1| >= |s2|) with maximum length and they are different(it is not allowed to choose an any index of the array for both subarray) where all elements are equal to 0.
At first |s1| = |s2| = 0

It is proved that other subarrays are unnecessary.
It is also proved that if((|s1| / 2) > |s2|) Alice will win. Otherwise Bob will win.

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

int a[1000005];

int main()
{
    int n, ct = 0;
    cin >> n;

    vector <int> ve;
    ve.push_back(ct);
    for(int i = 0; i < n; i++){
        cin >> a[i];
        if(a[i] == 0) ++ct;
        else{
            ve.push_back(ct);
            ct = 0;
        }
    }
    ve.push_back(ct);

    sort(ve.rbegin(), ve.rend());
    int alice = (ve[0] + 1) / 2;
    int bob = ve[0] / 2;
    bob = max(bob, ve[1]);

    if(bob >= alice) cout << "Bob" << endl;
    else cout << "Alice" << endl;

    return 0;
}

Here we can try for all , from 1 to string-length .
And for 1 , we will try to make no of appearence for all character is 1 from A to Z which are present .For this we will delete or insert as we need.
And for 2 , we will try to make no of appearence for all character is 2 from A to Z which are present .For this we will delete or insert as we need.
And for 3 , we will try to make no of appearence for all character is 3 from A to Z which are present .For this we will delete or insert as we need.
-----------
-----------
-----------
-----------

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

#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);

int cnt[26];

int main(){
    FastIO

    string s;
    cin>>s;
    long long len=s.length();

    for(int i=0;i<len;i++) cnt[s[i]-'A']++;

    long long ans = 1e18;
    for(int i=1;i<=len;i++){
        long long sum = 0;
        for(int j=0;j<26;j++){
            if(cnt[j]) sum += abs(cnt[j]-i)*1ll*(j+1);
        }
        ans = min(ans, sum);
    }
    cout<<ans<<endl;

    return 0;
}

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

ll ct[27];
int main()
{
    string st;
    cin >> st;

    for(int i = 0; i < st.size(); i++)
        ++ct[st[i] - 'A' + 1];

    ll ans = 1e17;
    for(ll i = 1; i <= 26; i++){
        ll c = 0;
        if(ct[i] > 0){
            for(int j = 1; j <= 26; j++){
                if(ct[j] != 0){
                    ll v = abs(ct[i] - ct[j]);
                    c += (v * j);
                }
            }

            ans = min(ans, c);
        }
    }

    cout << ans << endl;

    return 0;
}

Here we have make a team with x energy one with two other people greater than equal 3x energy as much as can. So its always optimal to get lowest n killed. Just sort the array .
Use two loop like below with two pointers .

  j=n+1;   
  for i=1 to i=n   
    for j=present_value to j=3*n     
       if(found two people geater than equal 3x eanergy than i-th people) ans++,j++,break;

#include<bits/stdc++.h>
using namespace std;
#define   ll        long long
#define   FastIO    ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);

int main()
{
    FastIO

    ll n;
    cin>>n;
    n*=3;
    vector<ll> a(n);
    for(ll i=0;i<n;i++) cin>>a[i];

    sort(a.begin(),a.end());

    ll ans = 0,j=n/3;
    for(ll i = 0; i < n/3; i++){
        ll cnt=0;
        for( ;j<n;j++){
            if(a[j]>=(3LL*a[i])) cnt++;
            if(cnt==2LL){
                j++,ans++; break;
            }
        }
    }

    cout << ans << endl;

    return 0;
}

Here we can solve it easily using k vaule . Cause max value of k is 10^3.

1. In the input can be contain with duplicate value but we don't need those .Cause we have to find unique pair.. So we just take the unique value by set . And store those value to a vector.Cause we can access vector index easily.
2. Then we use 2 loop.

   for i=1 to v.size()
      for j=i+1 to v.size()
         ll dif=v[j]-v[i] , if(dif>k) break, else if(dif%k==0) ans+=2;  // here we use +=2 cause if there have pair 
                                                       (1,5) then there have must be (5,1) pair and both are unique.

Here, the main tricks is ,, 2nd loop continue at most 10^3 time .Cause vector is sorted (we use set before) and there have not any duplicate value.. So,(v[j]-v[i]) > 10^3 before continue the 2nd loop for 10^3+1 times.
So, max complexity is(10^5 * 10^3 = 10^8) And it passed easily with time limit.

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

#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);

int main() {
	FastIO

	int n, k;
    cin >> n >> k;
	set<int> se;
	for (int i = 1; i <= n; i++) {
		int a; cin >> a;
		se.insert(a);
	}
	vector<int> v(se.begin(), se.end());
	n = v.size();
	long long ans = 0;
	for (int i = 0; i < n; i++) {
		for (int j = i + 1; j < n; j++) {
			int d = v[j] - v[i];
			if (d > k) break;
			if (k % d == 0) {
				ans += 2;
			}
		}
	}
	cout << ans << '\n';
    return 0;
}

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

vector <int> di;
void divisors(int x){
    for(int i = 1; i * i <= x; i++){
        if(x % i == 0){
            di.push_back(i);
            if(i * i != x) di.push_back(x / i);
        }
    }
    sort(di.begin(), di.end());
}

int main()
{
    int n, k;
    cin >> n >> k;
    divisors(k);

    vector <int> ve;
    map <int, int> mp;
    for(int i = 0; i < n; i++){
        int a;
        cin >> a;
        if(mp[a] == 0){
            ve.push_back(a);
            mp[a] = 1;
        }
    }

    sort(ve.begin(), ve.end());
    long long int ans = 0;
    for(int i = 0; i < ve.size(); i++){
        for(int j = 0; j < di.size(); j++){
            int v = ve[i] + di[j];
            if(mp[v] == 1) ++ans;
        }
    }

    cout << ans * 2 << endl;


    return 0;
}

We have to find the longest sorted minimum sub-sequence (LSMS) .
string ss[30] .
Here if s[i]='a' then ss[0] store from 0 to i LSMS string which last character is a.
if s[i]='b' then ss[1] store from 0 to i LSMS string which last character is b.
if s[i]='c' then ss[2] store from 0 to i LSMS string which last character is c.
-----------
-----------
-----------

suppose think s=abab..

1. For 1st index the LSMS is a. How can we find that, we can easily made a loop from ss[0] to ss[0] and find the maximum length one.Here longest sorted minimum one ss[0]=" " and then we add 'a' with that longest sorted minimum string . ss[0] = ss[0]+ 'a' = a.

2. For 2nd index The LSMS is ab.. we can easily made a loop from ss[0] to ss[1] and find the maximum length one..Here longest sorted minimum one ss[0]=a and then we add 'b' with thatlongest sorted minimum string . ss[1] = ss[0]+ 'b' = ab.

3. For 3rd index The LSMS is aa.. we can easily made a loop from ss[0] to ss[0] and find the maximum length one..Here longest sorted minimum one ss[0]=a and then we add 'a' with thatlongest sorted minimum string . ss[0] = ss[0]+ 'a' = aa.

4. For 4-th index The LSMS is aab.. we can easily made a loop from ss[0] to ss[1] and find the maximum length one..Here longest sorted minimum one ss[0]=aa and then we add 'b' with that longest sorted minimum string . ss[1] = ss[0]+ 'b' = aab.

Then just make a loop from 0 to 25 check ss[0] to ss[25] to find the longest sorted minimum sub-sequence .

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

#define      loser       return 0
#define      ll          long long
#define      FastIO      ios::sync_with_stdio(0);cin.tie(0); cout.tie(0);

string ss[30];

int main(){
   FastIO

   ll n;
   string s,answer;
   cin>>s;
   ll len=s.length();
   for(ll i=0;i<len;i++){
    ll ch=s[i]-'a';
    ll mx=0;
    string aux;
    for(ll j=0;j<=ch;j++){
        if((ss[j].size())>mx){
            aux=ss[j];
            mx=ss[j].size();
        }
    }
    ss[ch]=aux+s[i];
    if(ss[ch].size()>answer.size()) answer=ss[ch];
    else if(ss[ch].size()==answer.size()) answer=min(answer,ss[ch]);
   }
   cout<<answer.size()<<endl;
   cout<<answer<<endl;

  loser;
}