#include <iostream>
#include <vector>
#include <unordered_map>
#include <string>
using namespace std;

class Solution {
public:
long long modExp(long long base, long long exp, long long modVal) {
long long result = 1;
base %= modVal;
while(exp > 0){
if(exp & 1)
result = (result * base) % modVal;
base = (base * base) % modVal;
exp >>= 1;
}
return result;
}

long long countSubstrings(string s) {
int n = s.size();
vector<int> pre3(n+1, 0), pre9(n+1, 0);
pre3[0] = 0;
pre9[0] = 0;
for (int i = 0; i < n; i++) {
int digit = s[i]-'0';
pre3[i+1] = (pre3[i] + digit) % 3;
pre9[i+1] = (pre9[i] + digit) % 9;
}

vector<int> P7(n+1, 0);
P7[0] = 0;
for (int i = 0; i < n; i++) {
int digit = s[i]-'0';
P7[i+1] = (P7[i]*10 + digit) % 7;
}
vector<int> pow7(n+1, 0);
pow7[0] = 1;
for (int i = 1; i <= n; i++) {
pow7[i] = (pow7[i-1] * 10) % 7;
}
vector<int> invPow7(n+1, 0);
for (int i = 0; i <= n; i++) {
invPow7[i] = (int) modExp(pow7[i], 5, 7);
}
vector<int> Q(n+1, 0);
for (int i = 0; i <= n; i++) {
Q[i] = (P7[i] * invPow7[i]) % 7;
}

vector<int> f3(3, 0);
vector<int> f9(9, 0);
vector<int> f7(7, 0);

long long ans = 0;
for (int j = 0; j < n; j++) {
int d = s[j]-'0';
long long contr = 0;
if(d == 0) {
contr = 0;
}
else if(d == 1 d == 2 d == 5) { // TO‘G‘RI YOZILISH
contr = 1LL + j;
}
else if(d == 3 || d == 6) {
contr = 1LL + f3[ pre3[j] ];
}
else if(d == 9) {
contr = 1LL + f9[ pre9[j] ];
}
else if(d == 4) {
if(j >= 1 && ((s[j-1]-'0') % 2 == 0))
contr = 1LL + j;
else
contr = 1LL;
}
else if(d == 7) {
contr = 1LL + f7[ Q[j] ];
}
else if(d == 8) {
long long multi = 0;
if(j == 0) {
multi = 0;
}
else if(j == 1) {
multi = (((s[0]-'0') % 4) == 0 ? 1 : 0);
}
else {
if (((s[j-1]-'0') % 4) == 0)
multi += 1;
if ((((s[j-2]-'0')*10 + (s[j-1]-'0')) % 4) == 0)
multi += (j - 1);
}
contr = 1LL + multi;
}
ans += contr;

f3[ pre3[j] ]++;
f9[ pre9[j] ]++;
f7[ Q[j] ]++;
}

return ans;
}
};
©leetcode

thats correct for q3

one

two

three

@freefigmaui if u are figma designer )

@azamovme if u are mobile developer

follow me

if u want to get q4

answer

lets follow me

import java.util.*;

public class Solution {
public long minimalCost2(long v0, long v1) {
if (v0 <= 0 && v1 <= 0) return 0;
long cost = 1;
v0 -= 1;
if (v0 > 0 && v1 > 0) {
long k = Math.min(v0, v1);
cost += 2 * k;
v0 -= k;
v1 -= k;
}
if (v0 > 0) {
cost += 2 * v0;
v0 = 0;
}
if (v1 > 0) {
cost += 1;
v1 -= 1;
cost += 2 * v1;
v1 = 0;
}
return cost;
}

public long maxScoreForN3(int[] p, int m) {
boolean[][][][][] visited = new boolean[3][51][51][51][51];
long bestMinScore = 0;
Queue<int[]> q = new LinkedList<>();
q.offer(new int[]{0, 1, 1, 0, 0});

while (!q.isEmpty()) {
int[] st = q.poll();
int pos = st[0], moves = st[1], v0 = st[2], v1 = st[3], v2 = st[4];
long s0 = (long) v0 * p[0];
long s1 = (long) v1 * p[1];
long s2 = (long) v2 * p[2];
long mn = Math.min(s0, Math.min(s1, s2));
bestMinScore = Math.max(bestMinScore, mn);

if (moves < m) {
for (int delta = -1; delta <= 1; delta += 2) {
int newPos = pos + delta;
if (newPos >= 0 && newPos < 3) {
int[] newV = {v0, v1, v2};
newV[newPos]++;
if (!visited[newPos][moves + 1][newV[0]][newV[1]][newV[2]]) {
visited[newPos][moves + 1][newV[0]][newV[1]][newV[2]] = true;
q.offer(new int[]{newPos, moves + 1, newV[0], newV[1], newV[2]});
}
}
}
}
}
return bestMinScore;
}

public boolean canAchieveSinglePass(int[] points, long m, long X) {
long totalVisits = 0;
for (int p : points) {
if (X > 0) {
long need = (X + p - 1) / p;
totalVisits += need;
if (totalVisits > m + points.length + 1) return false;
}
}
long cost = 2 * totalVisits - (points.length + 1);
return cost <= m;
}

public long maxScore(int[] points, long m) {
int n = points.length;
if (m == 0) return 0;

if (n == 2) {
long left = 0, right = 1_000_000_000_000_000L, ans = 0;
while (left <= right) {
long mid = (left + right) / 2;
long v0 = (mid > 0) ? (mid + points[0] - 1) / points[0] : 0;
long v1 = (mid > 0) ? (mid + points[1] - 1) / points[1] : 0;
if (minimalCost2(v0, v1) <= m) {
ans = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
return ans;
}

long left = 0, right = 1_000_000_000_000_000L, ans = 0;
while (left <= right) {
long mid = (left + right) / 2;
if (canAchieveSinglePass(points, m, mid)) {
ans = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
return ans;
}
}

Thanks for all

@azamovme )

hello