allcoding1_official

MOD = 10**9 + 7 def f(X, P, L, R): s = [(x, x + p) for x, p in zip(X, P)] s.sort() c = 0 i = 0 e = L f = L while e <= R: while i < len(s) and s[i][0] <= e: f = max(f, s[i][1]) i += 1 if f == e: return -1 c += 1 e = f + 1 return c def g(N, M, X, P, Q, Qs): t = 0 for L, R in Qs: r = f(X, P, L, R) t = (t + r) % MOD return t // Lighting lamp @allcoding1_official

def f(N, L, R, A): M = 10**9 + 7 dp = [0] * (N + 1) dp[0] = 1 # There's one way to partition an empty array for i in range(1, N + 1): xv = 0 for j in range(i, 0, -1): xv ^= A[j - 1] if L <= xv <= R: dp[i] = (dp[i] + dp[j - 1]) % M return dp[N] // divide the array @allcoding1_official

Maximum code are python

#include <iostream> #include <vector> #include <algorithm> using namespace std; void dfs(int node, int parent, const vector<vector<int>>& tree, const vector<int>& A, int depth, int& maxDepth) { maxDepth = max(maxDepth, depth); for (int child : tree[node]) { if (child != parent) { if ((A[node] ^ A[child]) < A[node] && (A[node] ^ A[child]) < A[child]) { dfs(child, node, tree, A, depth + 1, maxDepth); } } } } int main() { int N; cin >> N; vector<int> A(N + 1); vector<int> P(N + 1); vector<vector<int>> tree(N + 1); // Read values array for (int i = 1; i <= N; ++i) { cin >> A[i]; } // Read parent array and buildthe tree for (int i = 2; i <= N; ++i) { // P[1] is root with P[1] = 0, so start from 2 cin >> P[i]; tree[P[i]].push_back(i); tree[i].push_back(P[i]); } int maxDepth = 0; dfs(1, 0, tree, A, 1, maxDepth); cout << maxDepth << endl; return 0; }

#include <iostream> #include <vector> #include <algorithm> #include <cmath> using namespace std; const int MOD = 1000000007; int minLampsToLightRoad(int num_positions, int num_lamps, vector<int>& lamp_positions, vector<int>& left_reach, vector<int>& right_reach, vector<pair<int, int>>& queries) { // Step 1: Create intervals for each lamp vector<pair<int, int>> intervals; for (int i = 0; i < num_lamps; ++i) { intervals.push_back({lamp_positions[i] - left_reach[i], lamp_positions[i] + right_reach[i]}); } // Step 2: Sort intervals based on starting position sort(intervals.begin(), intervals.end()); // Precompute the farthest reach for each starting point vector<pair<int, int>> max_reach_from_start; int current_max_reach = -1; for (const auto& interval : intervals) { int start = interval.first; int end = interval.second; if (max_reach_from_start.empty() start > max_reach_from_start.back().first) { max_reach_from_start.push_back({start, end}); } current_max_reach = max(current_max_reach, end); max_reach_from_start.back().second = current_max_reach; } auto min_lamps_needed = [&](int query_left, int query_right) { int count = 0; int max_reach = query_left; while (max_reach <= query_right) { auto it = upper_bound(max_reach_from_start.begin(), max_reach_from_start.end(), make_pair(max_reach, INT_MAX)); if (it == max_reach_from_start.begin() prev(it)->first > max_reach) { return -1; } int next_max_reach = prev(it)->second; if (next_max_reach <= max_reach) { return -1; } max_reach = next_max_reach + 1; count++; if (max_reach > query_right) { break; } } return max_reach > query_right ? count : -1; }; // Step 3: Process each query and sum up the results int result_sum = 0; for (const auto& query : queries) { int result = min_lamps_needed(query.first, query.second); if (result != -1) { result_sum += result; result_sum %= MOD; } } return result_sum; } lightning lamp code , all cases are passing

#include <iostream> #include <vector> #include <unordered_map> #include <unordered_set> #include <queue> #include <algorithm> using namespace std; int maxTreeScore(int node_count, int edge_count, vector<pair<int, int>>& edges, vector<int>& colors) { // Step 1: Parse input and create adjacency list unordered_map<int, vector<int>> adjacency_list; for (const auto& edge : edges) { int start = edge.first; int end = edge.second; adjacency_list[start].push_back(end); adjacency_list[end].push_back(start); } // Step 2: Calculate depth of each node using BFS vector<int> node_depth(node_count + 1, -1); node_depth[1] = 0; queue<int> bfs_queue; bfs_queue.push(1); while (!bfs_queue.empty()) { int current_node = bfs_queue.front(); bfs_queue.pop(); int current_depth = node_depth[current_node]; for (int neighbor : adjacency_list[current_node]) { if (node_depth[neighbor] == -1) { // unvisited node_depth[neighbor] = current_depth + 1; bfs_queue.push(neighbor); } } } // Step 3: Group nodes by depth unordered_map<int, vector<int>> nodes_grouped_by_depth; for (int node = 1; node <= node_count; ++node) { nodes_grouped_by_depth[node_depth[node]].push_back(node); } // Step 4: Calculate distinct colors per depth unordered_map<int, int> distinct_colors_at_depth; for (const auto& pair : nodes_grouped_by_depth) { int depth = pair.first; const vector<int>& nodes = pair.second; unordered_set<int> unique_colors; for (int node : nodes) { unique_colors.insert(colors[node - 1]); } distinct_colors_at_depth[depth] = unique_colors.size(); } // Step 5: Dynamic programming to calculate max score int max_depth = max_element(nodes_grouped_by_depth.begin(), nodes_grouped_by_depth.end(), [](const auto& a, const auto& b) { return a.first < b.first; })->first; vector<int> dp_score(max_depth + 2, 0); for (int depth = max_depth; depth >= 0; --depth) { // Option 1: Move to the next depth without adding score dp_score[depth] = dp_score[depth + 1]; // Option 2: Add the distinct colors to score and move to depth depth + unique_colors_count if (distinct_colors_at_depth.find(depth) != distinct_colors_at_depth.end()) { int unique_colors_count = distinct_colors_at_depth[depth]; if (depth + unique_colors_count <= max_depth) { dp_score[depth] = max(dp_score[depth], dp_score[depth + unique_colors_count] + unique_colors_count); } else { dp_score[depth] = max(dp_score[depth], unique_colors_count); } } } return dp_score[0]; } diving in a tree , all test cases are passing

All codes are available To easily find out ur codes Once check it 👇👇 https://www.instagram.com/allcoding1_official?igsh=ZHJpNXdpeWh1d2No

Coins game

#include <iostream> #include <vector> #include <algorithm> using namespace std; void dfs(int node, int parent, const vector<vector<int>> &adj, const vector<int> &A, int length, int &maxLength) { maxLength = max(maxLength, length); for (int neighbor : adj[node]) { if (neighbor == parent) continue; if ((A[node] ^ A[neighbor]) < min(A[node], A[neighbor])) { dfs(neighbor, node, adj, A, length + 1, maxLength); } } } int main() { int N; cin >> N; vector<int> A(N), P(N); for (int i = 0; i < N; ++i) cin >> A[i]; for (int i = 1; i < N; ++i) cin >> P[i]; vector<vector<int>> adj(N); for (int i = 1; i < N; ++i) { int parent = P[i]; adj[parent].push_back(i); adj[i].push_back(parent); } int maxLength = 0; dfs(0, -1, adj, A, 1, maxLength); cout << maxLength << endl; return 0; } Nodes

Shortest string code in python Infosys

def get_answer(N, K, A, S):     from collections import Counter     def min_deletions_to_palindrome(piece):         count = Counter(piece)         odd_count = sum(1 for freq in count.values() if freq % 2 == 1)         return max(0, odd_count - 1)        start = 0     total_deletions = 0          for length in A:         piece = S[start:start + length]         total_deletions += min_deletions_to_palindrome(piece)         start += length          return total_deletions MINIMAL PALINDROME

Lighting lamp

Dividing array

Python periodic strings

All codes are available To easily find out ur codes Once check it 👇👇 https://www.instagram.com/allcoding1_official?igsh=ZHJpNXdpeWh1d2No

XR Forming code in python

Python

Code maximum python

///find largest swuare linked in public static int findLargestSquareSize(int[][] samples) { if (samples == null || samples.length == 0) return 0; int n = samples.length; int maxSize = 0; int[][] dp = new int[n][n]; for (int i = 0; i < n; i++) { dp[i][0] = samples[i][0]; dp[0][i] = samples[0][i]; maxSize = Math.max(maxSize, dp[i][0]); maxSize = Math.max(maxSize, dp[0][i]); } for (int i = 1; i < n; i++) { for (int j = 1; j < n; j++) { if (samples[i][j] == 1) { dp[i][j] = Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1; maxSize = Math.max(maxSize, dp[i][j]); } else { dp[i][j] = 0; } } } return maxSize; }